Der Zweck dieses Tutorials besteht darin, eine praktische und leicht verständliche Anleitung zu Span-Links in OpenTelemetry bereitzustellen.
Es zielt darauf ab, Entwicklern, insbesondere denen, die mit komplexen und asynchronen Systemen arbeiten, zu helfen, zu verstehen, was Span-Links sind, wie sie sich von herkömmlichen Eltern-Kind-Beziehungen bei der Ablaufverfolgung unterscheiden und warum sie für eine bessere Ablaufverfolgungskorrelation wertvoll sind.
Am Ende dieses Leitfadens erwerben Sie die erforderlichen Fähigkeiten, um Span-Links effektiv zu nutzen, um Interaktionen innerhalb verteilter Systeme zu verfolgen, was zu einer verbesserten Beobachtbarkeit und Fehlersuche führt.
In der Vergangenheit waren Anwendungen typischerweise monolithisch, was bedeutete, dass jeder Prozess oder jede Funktion als einzelne Einheit auf einem Server ausgeführt wurde. Die Überwachung solcher Anwendungen war unkompliziert.
Zum Beispiel: Wenn etwas schief gelaufen ist, können Sie sich die Protokolle dieses Servers ansehen, um das Problem zu identifizieren. Der Aufstieg von Microservices hat diese Einfachheit jedoch verändert.
Moderne Anwendungen bestehen heute oft aus Dutzenden oder sogar Hunderten kleinerer, unabhängiger Dienste, die zusammenarbeiten. Wenn Sie beispielsweise eine mobile App verwenden, um eine Bestellung aufzugeben, gibt es möglicherweise separate Dienste für die Benutzerauthentifizierung, die Zahlungsabwicklung, die Bestandsverwaltung und den Versand von Bestätigungs-E-Mails.
Diese Dienste befinden sich nicht immer auf demselben Server und können sogar über das Internet kommunizieren, was die Verfolgung dessen, was passiert, wenn Sie mit einer Anwendung interagieren, komplexer macht.
Hier kommt die verteilte Ablaufverfolgung ins Spiel. Stellen Sie sich die verteilte Ablaufverfolgung als eine Möglichkeit vor, eine einzelne Anfrage auf ihrem Weg durch verschiedene Dienste in einer komplexen Anwendung zu verfolgen. Es verfolgt den Weg einer Anfrage durch ein komplexes System.
In modernen Anwendungen durchlaufen Anfragen häufig mehrere Dienste, die jeweils auf unterschiedlichen Maschinen ausgeführt werden. Die verteilte Nachverfolgung hilft uns, diese Reise zu visualisieren und erleichtert so die Identifizierung von Engpässen und Fehlern.
Es ist wie eine Detektivkarte, die die Punkte zwischen den einzelnen Schritten des Prozesses verbindet und Ihnen zeigt, wie lange jeder Teil gedauert hat und wo Probleme aufgetreten sind. Wenn Sie sich eine Ablaufverfolgung ansehen, sehen Sie eine Zeitleiste darüber, wie Ihre Anfrage verschiedene Dienste durchlaufen hat, sodass Sie Verlangsamungen, Fehler oder Ausfälle leichter erkennen können.
Code Repo
Hier ist das Code-Repo für dieses Tutorial:
[https://github.com/Noibisjunior/Span-Links-in-OpenTelemetry]
OpenTelemetry spielt eine Schlüsselrolle bei der Ermöglichung dieser Art von Sichtbarkeit. Es handelt sich um ein Open-Source-Observability-Framework, das es Entwicklern ermöglicht, Daten wie Protokolle, Metriken und Traces aus ihren Anwendungen zu sammeln. Es dient als Toolset zum Erfassen detaillierter Informationen darüber, was in Ihren Diensten passiert.
In der Welt der modernen Observability hilft Ihnen OpenTelemetry, die Leistung und den Zustand Ihrer verteilten Anwendungen zu verstehen. Es fungiert wie eine Brücke, die Daten von verschiedenen Diensten sammelt und an Tools wie SigNoz sendet, wo Sie visualisieren können, was vor sich geht. Dadurch ist OpenTelemetry von unschätzbarem Wert, wenn es darum geht, Engpässe zu identifizieren, Fehler aufzuspüren und sicherzustellen, dass Ihre Anwendungen reibungslos laufen.
Durch die Verwendung von OpenTelemetry mit verteilter Ablaufverfolgung können Sie sich ein vollständiges Bild vom Verhalten Ihrer Anwendungen machen, was die Diagnose von Problemen erleichtert und die Benutzererfahrung verbessert.
Da Software, insbesondere verteilte Systeme, immer komplexer wird, wird das Verständnis ihres Innenlebens zu einer herausfordernden Aufgabe. Hier kommen die Spans von OpenTelemetry ins Spiel, um die Herausforderung einfach zu lösen.
Eine Spanne ist eine grundlegende Arbeitseinheit im Ablaufverfolgungssystem von OpenTelemetry. Es handelt sich um einen einzelnen Vorgang oder ein einzelnes Ereignis, das in Ihrer Anwendung auftritt.
Es erfasst, was während dieses Vorgangs passiert ist, wie lange es gedauert hat und alle relevanten Details, z. B. ob der Vorgang erfolgreich war oder fehlgeschlagen ist.
Stellen Sie sich zum Beispiel vor, Ihre Anwendung verarbeitet eine Benutzeranfrage:
Schlüsselattribute einer Spanne:
Einzeln sind Spans nützlich, aber sie sind effektiv, wenn sie zusammenarbeiten, um eine Spur zu bilden.
Eine Ablaufverfolgung ist eine Sammlung von Spannen, die den gesamten Verlauf einer Anfrage oder eines Vorgangs darstellt, während diese durch Ihr System fließt.
Kehren wir zu unserem Beispiel für eine Benutzeranfrage zurück:
Der Trace beginnt, wenn die Anforderung das System betritt, und ein Root-Span wird erstellt. Wenn die Anforderung die Datenbankabfrage auslöst, wird der Datenbank-Interaktions-Span mit dem Root-Span verknüpft, was zeigt, dass er Teil desselben Prozesses ist.
Zusätzliche Spans zum Aufrufen anderer Dienste werden dem Trace hinzugefügt. Wenn Sie sich diesen Trace ansehen, können Sie sich einen Überblick darüber verschaffen, wie die Anfrage verschiedene Teile Ihres Systems durchlaufen hat. Es hilft Ihnen nicht nur zu verstehen, was passiert ist, sondern auch, wie verschiedene Teile Ihrer Anwendung miteinander verbunden sind.
Probleme lokalisieren: Spans helfen Ihnen dabei, genauer zu erkennen, wo etwas schief geht. Wenn eine Anfrage langsam ist, können Spans Ihnen sagen, ob die Datenbankabfrage, der Netzwerkaufruf oder ein anderer Teil des Prozesses die Verzögerung verursacht. Sie können sehen, welche Zeitspanne länger als erwartet gedauert hat, sodass Sie Engpässe leichter finden können.
Gebäudekontext: Jeder Bereich enthält Kontextinformationen wie Startzeit, Endzeit und benutzerdefinierte Beschriftungen (Attribute). Diese Daten bieten Einblicke in das, was zu einem bestimmten Zeitpunkt in Ihrem System passiert ist, z. B. die spezifische Benutzer-ID, die an einer Anfrage beteiligt war, oder die ausgeführte Abfrage.
Beziehungen erstellen: Spans haben Beziehungen zueinander, oft in einer Eltern-Kind-Struktur. Der Root-Span ist der übergeordnete Bereich und nachfolgende Spans sind seine untergeordneten Bereiche. Mithilfe dieser Struktur können Sie die Reihenfolge erkennen, in der Ereignisse aufgetreten sind, und wie sie voneinander abhängen. Es ist, als würde man in Ihrer App einen Stammbaum der Operationen betrachten.
Debuggen verteilter Systeme: Für Anwendungen mit Microservices (bei denen verschiedene Services unterschiedliche Teile einer Anfrage bearbeiten) sind Spans besonders wichtig. Sie helfen Ihnen dabei, eine Anforderung zu verfolgen, während sie zwischen Diensten übertragen wird, selbst wenn diese Dienste auf unterschiedlichen Servern oder in unterschiedlichen Rechenzentren ausgeführt werden. Dies ist der Schlüssel zum Verständnis komplexer Interaktionen zwischen Diensten.
Was sind Span-Links?
In der Welt der verteilten Systeme, in der mehrere Dienste zusammenarbeiten, um eine Benutzeranfrage zu bearbeiten, ist die Nachverfolgung wie eine Detektivkarte: Sie zeigt den Weg an, den eine Anfrage nimmt, während sie diese Dienste durchläuft. Jede Aktivität auf dieser Reise wird als Spanne bezeichnet, und eine vollständige Reise wird als Spur bezeichnet.
Traditionell werden Spannen über Eltern-Kind-Beziehungen verbunden. Stellen Sie sich diese wie einen Stammbaum vor: Ein übergeordneter Bereich initiiert einen Prozess (z. B. das Senden einer Anfrage an einen anderen Dienst), und untergeordnete Bereiche stellen die Aktivitäten dar, die als Ergebnis stattfinden (z. B. der Dienst, der die Anfrage verarbeitet). Dies ist eine einfache Möglichkeit, den Ablauf einer Anfrage darzustellen.
Aber was passiert, wenn zwei Bereiche miteinander verbunden sind, sie aber nicht perfekt in die Eltern-Kind-Hierarchie passen? Hier kommen Span-Links ins Spiel.
Ein Span-Link ermöglicht es Ihnen, zwei Spans zu verbinden, die zwar miteinander verbunden sind, aber keine direkte Eltern-Kind-Beziehung haben. Es ist wie eine „Referenz“ oder „Abkürzung“ zwischen zwei Aktivitäten in einem verteilten System.
Angenommen, ein Benutzer stellt eine Anfrage, die mehrere unabhängige Prozesse auslöst, z. B. das Senden einer E-Mail und das Schreiben in eine Datenbank. Diese Prozesse sind keine untergeordneten Aktivitäten voneinander; sie geschehen nebeneinander. Mithilfe eines Span-Links können Sie angeben, dass der E-Mail-Sende-Span und der Datenbank-Schreib-Span mit derselben anfänglichen Benutzeranfrage zusammenhängen, auch wenn sie im Eltern-Kind-Konzept nicht direkt miteinander verbunden sind.
Eltern-Kind-Beziehung: Es handelt sich um eine unkomplizierte Kette von Ereignissen. Ein Benutzer sendet eine Anfrage (übergeordnetes Element), die die Erstellung eines Datensatzes in einer Datenbank (untergeordnetes Element) auslöst. Die untergeordnete Spanne würde ohne die übergeordnete Spanne nicht existieren, was eine direkte Konsequenz wäre.
Span Links: Diese ähneln eher dem Zeichnen gepunkteter Linien zwischen Aktivitäten, die in einem bestimmten Kontext zusammenhängen, aber keiner direkten Aktionskette folgen. Sie bieten eine Möglichkeit zu sagen: „Diese Dinge hängen zusammen, auch wenn das eine nicht direkt das andere verursacht hat.“ Span-Links eignen sich ideal zur Darstellung paralleler Aktivitäten oder Ereignisse, die interagieren, aber nicht streng hierarchisch sind.
Bedeutung von Span-Links in komplexen und asynchronen Systemen
Span-Links sind besonders wertvoll in komplexen und asynchronen Systemen, in denen der Ereignisfluss nicht immer einem klaren Eltern-Kind-Pfad folgt. Hier sind einige Szenarien, wie es praktisch eingesetzt werden kann;
Asynchrone Arbeitsabläufe:
Stellen Sie sich eine Benutzeranfrage vor, die mit einem Hintergrundjob beginnt (z. B. dem Erstellen eines Berichts). Die erste Anfrage wird beendet, aber die Berichterstellung wird im Hintergrund fortgesetzt.
Mit der Implementierung von Span-Links können Sie den anfänglichen Anforderungs-Span mit dem Hintergrund-Job-Span in Beziehung setzen, auch wenn diese keinem direkten Eltern-Kind-Muster folgen.
Microservice-Kommunikation:
In einer Microservices-Architektur kommunizieren Dienste häufig auf nicht streng hierarchische Weise miteinander.
Zum Beispiel könnte eine Benutzeraktion mehrere Dienste auslösen, um verschiedene Teile der Daten gleichzeitig zu verarbeiten. Mit Span-Links können Sie diese unabhängigen und verwandten Spans als Teil eines umfassenderen Workflows verfolgen.
Stapelverarbeitung: Wenn Sie Datenstapel verarbeiten, bei denen jedes Element im Stapel seine eigenen Bereiche generiert, können Sie Span-Links verwenden, um diese Bereiche wieder mit dem ursprünglichen Stapelprozess zu verbinden.
Dadurch ist es einfacher, den gesamten Lebenszyklus einer Charge zu verfolgen und zu verstehen, wie sich einzelne Artikel auf den Hauptprozess beziehen.
Es fungiert als Brücke zwischen Ihrem Code und Observability-Systemen und ermöglicht es, detaillierte Informationen darüber zu sammeln, wie Ihre Anwendung ausgeführt wird.
Stellen Sie sich OpenTelemetry als eine „Kamera“ vor, die Schnappschüsse der Vorgänge Ihrer Anwendung aufnimmt. Durch die Integration des SDK in Ihre App positionieren Sie diese Kamera so, dass sie aufzeichnet, was hinter den Kulissen passiert.
Sie müssen das SDK in der Programmiersprache Ihrer Anwendung installieren (z. B. Python, Java, JavaScript).
(2) SigNoz-Setup: SigNoz ist ein Open-Source-Observability-Tool, mit dem Sie die mit OpenTelemetry gesammelten Daten visualisieren und analysieren können.
Stellen Sie sich SigNoz als den „Kontrollraum“ vor, in dem Sie das von Ihrem OpenTelemetry-Setup erfasste Filmmaterial ansehen. Hier erhalten Sie ein klares Bild der Spuren und Metriken in Ihrer Anwendung.
Sie müssen eine SigNoz-Instanz einrichten, was die Bereitstellung auf Ihrem lokalen Computer oder auf einem Server umfasst, normalerweise mit Docker oder Kubernetes.
SigNoz hilft dabei, die Rohdaten in Visualisierungen wie Grafiken und Diagramme umzuwandeln, sodass Sie leichter verstehen, was in Ihrer Anwendung passiert.
Spuren:
Einfach ausgedrückt ist ein Trace wie eine „Geschichte“ darüber, was passiert, wenn ein Benutzer oder eine Anfrage mit Ihrer Anwendung interagiert. Es erfasst alle Aktionen, die als Ergebnis dieser Interaktion stattfinden, von der ersten Anfrage bis hin zu allen Diensten und Datenbanken, die möglicherweise beteiligt sind.
Stellen Sie sich vor, ein Benutzer klickt auf eine Schaltfläche auf Ihrer Website. Ein Trace würde jeden Schritt aufzeichnen, was als nächstes passiert.
Bereiche:
Spans sind die „Kapitel“ innerhalb der Geschichte einer Spur. Jeder Bereich stellt einen bestimmten Vorgang oder eine bestimmte Aufgabe dar, die als Teil einer Ablaufverfolgung stattfindet.
Wenn der Trace beispielsweise den gesamten Prozess einer Benutzeranforderung erfasst, könnte ein Span einen einzelnen Schritt darstellen, wie etwa das Abfragen der Datenbank oder den Aufruf einer externen API.
Jede Spanne hat eine Start- und Endzeit, sodass Sie genaue Angaben dazu erhalten, wie lange jeder Schritt gedauert hat. Dies macht es einfacher, etwaige Verlangsamungen oder Fehler zu lokalisieren.
Code mit OpenTelemetry instrumentieren:
Instrumentierung ist der Prozess des Hinzufügens von Code zu Ihrer Anwendung, um Beobachtbarkeitsdaten zu sammeln. Wenn Sie Ihren Code mit OpenTelemetry instrumentieren, müssen Sie in der Regel einige Codezeilen an den Stellen hinzufügen, an denen Sie Traces und Spans erstellen möchten.
Sie könnten beispielsweise eine Datenbankabfrage instrumentieren, um zu sehen, wie lange es dauert, oder einen Benutzeranmeldevorgang instrumentieren, um seine Leistung zu verfolgen.
Das OpenTelemetry SDK erleichtert dies, indem es Bibliotheken und Funktionen bereitstellt, die Sie direkt in Ihren Code integrieren können. Stellen Sie sich das so vor, als würden Sie Tracker an Teilen einer Maschine anbringen, um deren Zusammenarbeit zu überwachen.
Schauen wir uns ein einfaches Beispiel in Python an. Wir verwenden das OpenTelemetry SDK, um zwei Spans zu erstellen und sie miteinander zu verknüpfen.
from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter
# Set up the tracer provider and span exporter
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)
# Create the first span, simulating some work being done
with tracer.start_as_current_span("span_one") as span_one:
span_one.add_event("Processing order")
order_id = "12345" # Imagine this as an order ID we're processing
# Create a second span with a link to the first span
with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
span_two.add_event("Updating order status")
# Simulate some additional work here
print("Order ID: {order_id} has been updated.")
print("Tracing complete")
Erklärung des obigen Python-Codeausschnitts
Tracer-Anbieter einrichten:
Der obige Codeausschnitt beginnt mit einem Tracer-Anbieter, der die Erstellung von Spans verwaltet.
Dies ist für OpenTelemetry wichtig, um zu wissen, wie mit Spans umgegangen wird. Wir konfigurieren außerdem einen SimpleSpanProcessor und einen ConsoleSpanExporter, um Span-Daten auf der Konsole zu drucken. Dies hilft uns zu sehen, welche Art von Spans erstellt werden und wie sie verknüpft sind
.
(2) Erstellen Sie den ersten Span (span_one):
Mit der Methode „tracer.start_as_current_span“ erstellen wir einen Span namens span_one. Dies kann eine beliebige Aktion darstellen, beispielsweise die Bearbeitung einer Bestellung.
Innerhalb dieser Zeitspanne fügen wir eine Ereignisverarbeitungsreihenfolge hinzu, um anzugeben, was zu diesem bestimmten Zeitpunkt passiert.
Wir simulieren auch eine Bestell-ID (order_id = „12345“), die im nächsten Bereich verwendet werden würde.
(3) Erstellen Sie den zweiten Span mit einem Link (span_two):
Hier haben wir einen weiteren Span namens span_two initiiert, um eine andere, aber verwandte Aktion darzustellen – wie zum Beispiel das Aktualisieren des Status der Bestellung.
Beachten Sie den Links-Parameter. Wir verwenden Link(span_one.get_span_context()), um einen Link zwischen span_two und span_one zu erstellen.
Dadurch wird OpenTelemetry mitgeteilt: „Obwohl diese Aktionen keine Eltern-Kind-Aktionen sind, hängen sie zusammen.“
In span_two haben wir ein weiteres Ereignis hinzugefügt, den Bestellstatus aktualisieren, und einige Aufgaben wie die Aktualisierung eines Bestellstatus in einer Datenbank simulieren.
(4) Ausgabe:
Wenn Sie diesen Code ausführen, sehen Sie in der Konsole eine Ausgabe des ConsoleSpanExporter, die beide Spans zusammen mit der Verknüpfung zwischen ihnen zeigt. Dadurch lässt sich visualisieren, wie diese beiden Bereiche in einer Spur zueinander in Beziehung stehen.
(1) Fehlende Span-Kontexte:
Fehler: Wenn Sie versuchen, einen Link zu erstellen, ohne span_one.get_span_context() aufzurufen, erhalten Sie eine Fehlermeldung, da OpenTelemetry einen gültigen Span-Kontext benötigt, um einen Link zu erstellen.
Lösung: Stellen Sie immer sicher, dass Sie beim Erstellen eines Links einen Span-Kontext übergeben. Verwenden Sie die Methode .get_span_context() eines aktiven Spans.
(2) Verknüpfen nicht gestarteter oder beendeter Spans:
Fehler: Wenn Sie versuchen, einen Link zu einem Span zu erstellen, der noch nicht gestartet oder bereits beendet wurde, kann es zu Problemen kommen, bei denen der Link nicht erkannt wird.
Lösung: Stellen Sie sicher, dass der Span, auf den Sie verlinken, aktiv ist, wenn Sie den Link erstellen. Das Erstellen von Links mit bereits beendeten Spans kann zu unerwartetem Verhalten bei der Anzeige von Ablaufverfolgungen führen.
(3) Leistungsüberlegungen:
Leistungsproblem: Das Verknüpfen zu vieler Spans kann den Overhead der Trace-Daten erhöhen und zu Leistungseinbußen in Systemen mit hohem Datenverkehr führen.
Lösung: Links gezielt einsetzen. Verknüpfen Sie Spannen nur dann, wenn eine sinnvolle Beziehung besteht, die Sie visualisieren oder analysieren müssen. In Umgebungen mit hohem Datenverkehr können Sie die Sampling-Optionen von OpenTelemetry verwenden, um die Menge der erfassten Trace-Daten zu reduzieren.
Bei der Arbeit mit verteilten Systemen ist es entscheidend zu verstehen, wie verschiedene Teile Ihres Systems kommunizieren. Span-Links in OpenTelemetry spielen eine wichtige Rolle bei der Verbindung von Traces, die möglicherweise keine direkte Eltern-Kind-Beziehung haben, und liefern ein klareres Bild davon, wie Anfragen durch Ihre Dienste fließen.
Warum die Visualisierung von Span-Links wichtig ist
Stellen Sie sich vor, Ihre Anwendung verfügt über einen Zahlungsdienst, der einen Benachrichtigungsdienst auslöst, wenn eine Zahlung erfolgreich ist. Obwohl diese Dienste interagieren, besteht möglicherweise keine direkte Eltern-Kind-Beziehung.
Mit Span-Links können Sie diese Interaktionen in Beziehung setzen und so zeigen, dass die Zahlung die Benachrichtigung ausgelöst hat. Durch die Visualisierung dieser Links können Sie das Gesamtbild der Korrelation unabhängiger Dienste in Echtzeit erkennen.
Indem Sie SigNoz für die Visualisierung dieser Span-Links einrichten, können Sie tiefere Einblicke in das Verhalten Ihrer Anwendung gewinnen.
So können Sie SigNoz für die Erfassung und Anzeige von Span-Links konfigurieren
Schritt 1: Stellen Sie sicher, dass SigNoz ordnungsgemäß installiert ist
Schritt 2: Konfigurieren Sie das OpenTelemetry SDK so, dass es Ihre Span-Links einschließt
Der nächste Schritt besteht darin, sicherzustellen, dass Ihr OpenTelemetry SDK so konfiguriert ist, dass es Span-Link-Daten an SigNoz sendet. Im Code Ihrer Anwendung müssen Sie Span-Links als Teil Ihrer Tracing-Logik hinzufügen.
Hier ist ein Codeausschnitt in der Programmiersprache Python:
from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter
# Set up the tracer provider and span exporter
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)
# Create the first span, simulating some work being done
with tracer.start_as_current_span("span_one") as span_one:
span_one.add_event("Processing order")
order_id = "12345" # Imagine this as an order ID we're processing
# Create a second span with a link to the first span
with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
span_two.add_event("Updating order status")
# Simulate some additional work here
print("Order ID: {order_id} has been updated.")
print("Tracing complete")
Erklärung des obigen Python-Codeausschnitts
Wir begannen damit, den TracerProvider für die Ablaufverfolgung in unserer Anwendung zu konfigurieren und einen Span-Prozessor einzurichten.
Der OTLPSpanExporter wird verwendet, um Spans mithilfe des OTLP-Protokolls an das Backend von SigNoz zu senden.
Ersetzen Sie http://localhost:4317 durch den entsprechenden SigNoz-Endpunkt, wenn Sie SigNoz nicht lokal ausführen.
Zweitens: Spans und Links erstellen:
Der parent_span wird zuerst erstellt und stellt einen ersten Vorgang dar (z. B. eine Benutzeranfrage). Wir extrahieren den Kontext des parent_span mit get_span_context(), was es uns ermöglicht, einen anderen Span damit zu verknüpfen.
Der „linked_span“ wird dann erstellt und ein Link hinzugefügt, um auf den Kontext des „parent_span“ zu verweisen. Dies bedeutet, dass „linked_span“ zwar kein direktes untergeordnetes Element von „parent_span“ ist, aber mit diesem verknüpft ist.
Zuletzt Daten an SigNoz senden:
Die Span-Daten werden mit dem BatchSpanProcessor verarbeitet, der sicherstellt, dass die Span-Daten effizient an SigNoz gesendet werden.
trace.get_tracer_provider().shutdown() wird am Ende aufgerufen, um sicherzustellen, dass alle verbleibenden Spans geleert und exportiert werden, bevor das Programm beendet wird.
Schritt 3: SigNoz-Konfiguration für Tracing-Daten aktualisieren
from opentelemetry import trace
from opentelemetry.trace import SpanKind, Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
# Set up the tracer provider and add a span processor
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
# Configure the exporter to send spans to SigNoz using the OTLP exporter
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Create two spans, linking the second span to the context of the first
with tracer.start_as_current_span("parent_span") as parent_span:
# Simulate some logic for the parent_span
print("Parent span is active")
# Get the context of the parent span
parent_context = parent_span.get_span_context()
# Create a linked span and add a link to the parent span's context
with tracer.start_as_current_span(
"linked_span",
links=[Link(parent_context)]
) as linked_span:
# Simulate some logic for the linked_span
print("Linked span is active")
# Ensure all spans are flushed before exiting the application
trace.get_tracer_provider().shutdown()
Schritt 4: Span-Links in SignNoz visualisieren
Sobald Ihre Anwendung Trace-Daten mit Span-Links an SigNoz sendet, können Sie diese Links wie folgt visualisieren:
Schritt 5: Passen Sie Ihre Ansicht an, um Klarheit zu schaffen
Um eine perfekte Visualisierung zu erhalten, müssen Sie Folgendes beachten:
Nächste Schritte
In diesem Tutorial haben wir gelernt, wie man Span-Links verwendet, um Interaktionen innerhalb verteilter Systeme zu verfolgen
Im nächsten Tutorial lernen wir die Best Practices für die Verwendung von Span-Links und erweiterten Anwendungsfällen kennen
Das obige ist der detaillierte Inhalt vonBeherrschen der Trace-Analyse mit Span-Links mithilfe von OpenTelemetry und Signoz (Ein praktischer Leitfaden). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
