Towards observability with (RDF) trace stream processing

Distributed software systems and cloud-based micro-service solutions are getting momentum. Although this paradigm-shift foster scalability, it is making architectures too complicated to maintain using traditional techniques. How to supervise such complex systems is not apparent, and industry is investigating the subject under the observability umbrella. In this thesis, we investigate observability as a research problem. First, we provide a definition that clarifies the scientific boundaries. Then we investigate the following research questions: how to expose and how to make sense of the system behaviour at runtime. In particular, in order to expose the system behaviour: (i) we employ event as a unifying data model for metrics, logs, and trace data, (ii) we explain how to map existing data formats to the proposed model, and (iii) we discuss the benefits of a unified abstraction for observability. Moreover, in order to make sense of the system behaviour: (i) we elicit a set of requirements, and (ii) we build a proof-of-concept implementing a stream processing solution that satisfies them. Notably, since the state-of-the-art already provides a stream processing solution that makes sense of metrics and logs, we focus on trace stream processing. We followed the Design Science framework to realise our proof-of-concept. I.e., we design and implement an artifact (Kaiju, a Trace Stream Processor) and we study its interactions in the addressed context (Rim, a reproducible environment capable of emulating a distributed system and its typical issues). We provide evidence of the artifact validity comparing it with state-of-the-art distributed tracing tools, and against the typical use cases for such systems recreated in Rim. Last but not least, we discuss the benefits of processing together metrics, logs and trace data. Since stream processing solutions cannot tame the heterogeneity of metrics, logs, and trace data, we employed a stream reasoning approach. In this direction, we propose an ontology to model trace data, and we report an explorative analysis of an RSP engine consuming this type of data.

Sistemi software distribuiti e soluzioni a micro-servizi basate sulle tecnologie del cloud presentano una crescente adozione. Sebbene questo cambio di paradigma favorisca la scalabilità, al contempo sta rendendo le architetture troppo complicate per essere gestite attraverso le tecniche tradizionali. Determinare come supervisionare sistemi così complessi non è scontato, e per questo motivo il mondo dell'industria sta approfondendo questa tematica definendola con il nome di observability. In questa tesi affrontiamo l'observability come un problema di ricerca. Per prima cosa forniamo una definizione che chiarisca il termine da un punto di vista scientifico. Poi affrontiamo le seguenti domande di ricerca: come esporre e come dare significato al comportamento del sistema a runtime. Per esporre il comportamento del sistema: (i) utilizziamo l'evento come modello dei dati unificante per metriche, logs e tracce, (ii) mostriamo come stabilire una corrispondenza tra i formati dei dati esistenti e il modello proposto, e (iii) discutiamo i benefici di un'astrazione unificante per l'observability. Per dare significato al comportamento del sistema: (i) elicitiamo un insieme di requisiti, e (ii) realizziamo un proof-of-concept che implementi una soluzione di stream processing rispettando i requisiti. Poiché lo stato dell'arte fornisce già una soluzione di stream processing per metriche e logs, ci concentriamo sullo stream processing applicato alle tracce. In questo lavoro ci atteniamo al framework Design Science per realizzare il nostro proof-of-concept, i.e., progettiamo ed implementiamo un artefatto (Kaiju, un Trace Stream Processor) e studiamo le sue interazioni nel contesto affrontato (Rim, un ambiente riproducibile che emuli un sistema distribuito e le sue principali problematiche). Dimostriamo la validità dell'artefatto comparandolo con gli strumenti correntemente utilizzati per il tracing distribuito e in relazione ai casi d'uso tipici di questi sistemi ricreati mediante Rim. In conclusione, consideriamo i benefici nel processare insieme metriche, logs e dati delle tracce. Poiché soluzioni di stream processing non possono contrastare efficacemente l'eterogeneità  di metriche, logs e tracce, consideriamo un approccio stream reasoning. In questa direzione, proponiamo un'ontologia per modellare le tracce e riportiamo un'analisi esplorativa di un RSP engine che consumi questo tipo di dato.