Freigeben über

Microsoft OpenTelemetry-Exporter für Azure Monitor

  • Artikel

Mit dem Exporter für Azure Monitor können Sie Daten mithilfe des OpenTelemetry SDK exportieren und Telemetriedaten für in Python geschriebene Anwendungen an Azure Monitor senden.

Quellcode | Paket (PyPi) | API-Referenzdokumentation | Produktdokumentation | Proben | Changelog

Erste Schritte

Installieren des Pakets

Installieren Sie den Microsoft OpenTelemetry-Exporter für Azure Monitor mit pip:

pip install azure-monitor-opentelemetry-exporter --pre

Voraussetzungen

Um dieses Paket verwenden zu können, benötigen Sie Folgendes:

Instanziieren des Clients

Die Interaktion mit dem Azure Monitor-Exporter beginnt mit einer instance der -Klasse für verteilte AzureMonitorTraceExporter Ablaufverfolgung, AzureMonitorLogExporter Protokollierung und AzureMonitorMetricExporter Metriken. Sie benötigen eine connection_string , um das Objekt zu instanziieren. In den unten verlinkten Beispielen wird veranschaulicht, wie Sie den Exporter mithilfe eines Verbindungszeichenfolge erstellen.

Protokollierung (experimentell)

HINWEIS: Das Protokollierungssignal für den AzureMonitorLogExporter befindet sich derzeit im EXPERIMENTAL-Zustand. Mögliche Breaking Changes können in Zukunft auftreten.

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

Metriken

from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

Ablaufverfolgung

from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
exporter = AzureMonitorTraceExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

Sie können den Exporter auch direkt über den Konstruktor instanziieren. In diesem Fall wird die Verbindungszeichenfolge automatisch aus der Umgebungsvariable APPLICATIONINSIGHTS_CONNECTION_STRING aufgefüllt.

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
exporter = AzureMonitorLogExporter()

from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter()

from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
exporter = AzureMonitorTraceExporter()

Wichtige Begriffe

Zu den wichtigsten Konzepten für den Azure Monitor-Exporter gehören:

  • OpenTelemetry: OpenTelemetry ist eine Reihe von Bibliotheken, die zum Sammeln und Exportieren von Telemetriedaten (Metriken, Protokolle und Ablaufverfolgungen) für die Analyse verwendet werden, um die Leistung und das Verhalten Ihrer Software zu verstehen.

  • Instrumentierung: Die Möglichkeit, die OpenTelemetry-API direkt von jeder Anwendung aufzurufen, wird durch Instrumentierung erleichtert. Eine Bibliothek, die OpenTelemetry-Beobachtbarkeit für eine andere Bibliothek ermöglicht, wird als Instrumentierungsbibliothek bezeichnet.

  • Protokoll: Protokoll bezieht sich auf die Erfassung von Protokollierung, Ausnahme und Ereignissen.

  • LogRecord: Stellt einen Protokolldatensatz dar, der von einer unterstützten Protokollierungsbibliothek ausgegeben wird.

  • Protokollierung: Konvertiert ein LogRecord in einen lesbaren LogDataund wird durch das SDK gepusht, um exportiert zu werden.

  • Protokollierungsanbieter: Stellt für die angegebene Instrumentierungsbibliothek einen bereit Logger .

  • LogRecordProcessor: Schnittstelle zum Einbinden des Protokolldatensatzes, der die Aktion aussendet.

  • LoggingHandler: Eine Handlerklasse, die Protokollierungsdatensätze im OpenTelemetry-Format aus der Python-Standardbibliothek logging schreibt.

  • AzureMonitorLogExporter: Dies ist die Klasse, die initialisiert wird, um protokollierungsbezogene Telemetriedaten an Azure Monitor zu senden.

  • Metrik: Metric bezieht sich auf die Aufzeichnung von Rohmessungen mit vordefinierter Aggregation und Attributsätzen für einen bestimmten Zeitraum.

  • Messung: Stellt einen Datenpunkt dar, der zu einem bestimmten Zeitpunkt aufgezeichnet wurde.

  • Instrument: Instrumente werden verwendet, um Berichte zu melden Measurement.

  • Meter: Der Meter ist für das Erstellen Instrumentsvon verantwortlich.

  • Meteranbieter: Stellt eine Meter für die angegebene Instrumentierungsbibliothek bereit.

  • Metrikleser: Ein SDK-Implementierungsobjekt, das die allgemeinen konfigurierbaren Aspekte des OpenTelemetry Metrics SDK wie Sammlung, Leerung und Herunterfahren bereitstellt.

  • AzureMonitorMetricExporter: Dies ist die Klasse, die zum Senden metrikbezogener Telemetriedaten an Azure Monitor initialisiert wird.

  • Ablaufverfolgung: Ablaufverfolgung bezieht sich auf die verteilte Ablaufverfolgung. Eine verteilte Ablaufverfolgung ist eine Reihe von Ereignissen, die als Ergebnis eines einzelnen logischen Vorgangs ausgelöst werden und über verschiedene Komponenten einer Anwendung konsolidiert werden. Insbesondere kann eine Ablaufverfolgung als ein gerichtetes azyklisches Diagramm (DAG) von Spans betrachtet werden, bei dem die Kanten zwischen Spans als übergeordnete/untergeordnete Beziehung definiert werden.

  • Span: Stellt einen einzelnen Vorgang innerhalb eines dar Trace. Kann geschachtelt werden, um eine Ablaufverfolgungsstruktur zu bilden. Jede Ablaufverfolgung enthält eine Stammspanne, die in der Regel den gesamten Vorgang und optional eine oder mehrere Unterspannen für seine Untervorgänge beschreibt.

  • Tracer: Verantwortlich für das Erstellen von Spans.

  • Ablaufverfolgungsanbieter: Stellt einen Tracer für die Verwendung durch die angegebene Instrumentierungsbibliothek bereit.

  • Span-Prozessor: Ein span-Prozessor ermöglicht Hooks für Start- und Endmethodenaufrufe des Span SDK. Folgen Sie dem Link für weitere Informationen.

  • AzureMonitorTraceExporter: Dies ist die Klasse, die initialisiert wird, um ablaufverfolgungsbezogene Telemetriedaten an Azure Monitor zu senden.

  • Sampling: Sampling ist ein Mechanismus zum Steuern des Rauschens und des Mehraufwands, der von OpenTelemetry eingeführt wird, indem die Anzahl der Stichproben der gesammelten und an das Back-End gesendeten Ablaufverfolgungen reduziert wird.

  • ApplicationInsightsSampler: Application Insights-spezifischer Sampler, der für konsistente Stichprobenentnahmen über Application Insights-SDKs und OpenTelemetry-basierte SDKs verwendet wird, die Daten an Application Insights senden. Dieser Sampler MUSS immer verwendet werden, wenn AzureMonitorTraceExporter er verwendet wird.

Weitere Informationen zu diesen Ressourcen finden Sie unter Was ist Azure Monitor?.

Konfiguration

Alle Konfigurationsoptionen können über die Konstruktoren von Exportern kwargsübergeben werden. Im Folgenden finden Sie eine Liste konfigurierbarer Optionen.

  • connection_string: Die Verbindungszeichenfolge, die für Ihre Application Insights-Ressource verwendet wird.
  • disable_offline_storage: Boolescher Wert, um zu bestimmen, ob das Speichern fehlerhafter Telemetriedatensätze für Wiederholungen deaktiviert werden soll. Der Standardwert lautet False.
  • storage_directory: Speicherverzeichnis, in dem Wiederholungsdateien gespeichert werden sollen. Wird standardmäßig auf <tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key> festgelegt.
  • credential: Tokenanmeldeinformationen, z. B. ManagedIdentityCredential oder ClientSecretCredential, die für die Authentifizierung von Azure Active Directory (AAD) verwendet werden. Der Standardwert ist „None“. Beispiele finden Sie in den Beispielen .

Beispiele

Protokollierung (experimentell)

HINWEIS: Das Protokollierungssignal für den AzureMonitorLogExporter befindet sich derzeit im EXPERIMENTAL-Zustand. Mögliche Breaking Changes können in Zukunft auftreten.

Die folgenden Abschnitte enthalten mehrere Codeausschnitte, die einige der gängigsten Aufgaben abdecken, einschließlich:

Lesen Sie das OpenTelemetry Logging SDK , um zu erfahren, wie Sie OpenTelemetry-Komponenten zum Sammeln von Protokollen verwenden.

Exportieren Hallo Welt Protokolls

"""
An example to show an application using Opentelemetry logging sdk. Logging calls to the standard Python
logging library are tracked and telemetry is exported to application insights with the AzureMonitorLogExporter.
"""
import os
import logging

from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()

# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)

logger = logging.getLogger(__name__)

logger.warning("Hello World!")

# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
logger_provider.force_flush()

Exportieren eines korrelierten Protokolls

"""
An example showing how to include context correlation information in logging telemetry.
"""
import os
import logging

from opentelemetry import trace
from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.trace import TracerProvider

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()

# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)

logger = logging.getLogger(__name__)

logger.info("INFO: Outside of span")
with tracer.start_as_current_span("foo"):
    logger.warning("WARNING: Inside of span")
logger.error("ERROR: After span")

Exportieren von Protokollen für benutzerdefinierte Eigenschaften

"""
An example showing how to add custom properties to logging telemetry.
"""
import os
import logging

from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)

logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()

# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)

logger = logging.getLogger(__name__)

# Custom properties
logger.debug("DEBUG: Debug with properties", extra={"debug": "true"})

Protokoll zum Exportieren von Ausnahmen

"""
An example showing how to export exception telemetry using the AzureMonitorLogExporter.
"""
import os
import logging

from opentelemetry._logs import (
    get_logger_provider,
    set_logger_provider,
)
from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

set_logger_provider(LoggerProvider())
exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
get_logger_provider().add_log_record_processor(BatchLogRecordProcessor(exporter))

# Attach LoggingHandler to namespaced logger
handler = LoggingHandler()
logger = logging.getLogger(__name__)
logger.addHandler(handler)
logger.setLevel(logging.NOTSET)

# The following code will generate two pieces of exception telemetry
# that are identical in nature
try:
    val = 1 / 0
    print(val)
except ZeroDivisionError:
    logger.exception("Error: Division by zero")

try:
    val = 1 / 0
    print(val)
except ZeroDivisionError:
    logger.error("Error: Division by zero", stack_info=True, exc_info=True)

Metriken

Die folgenden Abschnitte enthalten mehrere Codeausschnitte, die einige der gängigsten Aufgaben abdecken, einschließlich:

Lesen Sie das OpenTelemetry Metrics SDK , um zu erfahren, wie Sie OpenTelemetry-Komponenten zum Sammeln von Metriken verwenden.

Verwendung von Metrikinstrumenten

"""
An example to show an application using all instruments in the OpenTelemetry SDK. Metrics created
and recorded using the sdk are tracked and telemetry is exported to application insights with the
AzureMonitorMetricsExporter.
"""
import os
from typing import Iterable

from opentelemetry import metrics
from opentelemetry.metrics import CallbackOptions, Observation
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

exporter = AzureMonitorMetricExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))

# Create a namespaced meter
meter = metrics.get_meter_provider().get_meter("sample")

# Callback functions for observable instruments
def observable_counter_func(options: CallbackOptions) -> Iterable[Observation]:
    yield Observation(1, {})


def observable_up_down_counter_func(
    options: CallbackOptions,
) -> Iterable[Observation]:
    yield Observation(-10, {})


def observable_gauge_func(options: CallbackOptions) -> Iterable[Observation]:
    yield Observation(9, {})

# Counter
counter = meter.create_counter("counter")
counter.add(1)

# Async Counter
observable_counter = meter.create_observable_counter(
    "observable_counter", [observable_counter_func]
)

# UpDownCounter
up_down_counter = meter.create_up_down_counter("up_down_counter")
up_down_counter.add(1)
up_down_counter.add(-5)

# Async UpDownCounter
observable_up_down_counter = meter.create_observable_up_down_counter(
    "observable_up_down_counter", [observable_up_down_counter_func]
)

# Histogram
histogram = meter.create_histogram("histogram")
histogram.record(99.9)

# Async Gauge
gauge = meter.create_observable_gauge("gauge", [observable_gauge_func])

# Upon application exit, one last collection is made and telemetry records are
# flushed automatically. # If you would like to flush records manually yourself,
# you can call force_flush()
meter_provider.force_flush()

Benutzerdefinierte Metrikansichten

"""
This example shows how to customize the metrics that are output by the SDK using Views. Metrics created
and recorded using the sdk are tracked and telemetry is exported to application insights with the
AzureMonitorMetricsExporter.
"""
import os

from opentelemetry import metrics
from opentelemetry.sdk.metrics import Counter, MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import View

from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

exporter = AzureMonitorMetricExporter.from_connection_string(
    os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
# Create a view matching the counter instrument `my.counter`
# and configure the new name `my.counter.total` for the result metrics stream
change_metric_name_view = View(
    instrument_type=Counter,
    instrument_name="my.counter",
    name="my.counter.total",
)

reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
provider = MeterProvider(
    metric_readers=[
        reader,
    ],
    views=[
        change_metric_name_view,
    ],
)
metrics.set_meter_provider(provider)

meter = metrics.get_meter_provider().get_meter("view-name-change")
my_counter = meter.create_counter("my.counter")
my_counter.add(100)

Weitere Beispiele mit dem Metrik-SDK Views finden Sie hier.

Metrikdatensatzattribute

"""
An example to show an application using different attributes with instruments in the OpenTelemetry SDK.
Metrics created and recorded using the sdk are tracked and telemetry is exported to application insights
with the AzureMonitorMetricsExporter.
"""
import os

from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

exporter = AzureMonitorMetricExporter.from_connection_string(
    os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))

attribute_set1 = {
    "key1": "val1"
}
attribute_set2 = {
    "key2": "val2"
}
large_attribute_set = {}
for i in range(20):
    key = "key{}".format(i)
    val = "val{}".format(i)
    large_attribute_set[key] = val

meter = metrics.get_meter_provider().get_meter("sample")

# Counter
counter = meter.create_counter("attr1_counter")
counter.add(1, attribute_set1)

# Counter2
counter2 = meter.create_counter("attr2_counter")
counter2.add(10, attribute_set1)
counter2.add(30, attribute_set2)

# Counter3
counter3 = meter.create_counter("large_attr_counter")
counter3.add(100, attribute_set1)
counter3.add(200, large_attribute_set)

Ablaufverfolgung

Die folgenden Abschnitte enthalten mehrere Codeausschnitte, die einige der gängigsten Aufgaben abdecken, einschließlich:

Lesen Sie das OpenTelemetry Tracing SDK , um zu erfahren, wie Sie OpenTelemetry-Komponenten zum Sammeln von Protokollen verwenden.

Exportieren Hallo Welt Ablaufverfolgung

"""
An example to show an application using Opentelemetry tracing api and sdk. Custom dependencies are
tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)
# This is the exporter that sends data to Application Insights
exporter = AzureMonitorTraceExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

with tracer.start_as_current_span("hello"):
    print("Hello, World!")

# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
tracer_provider.force_flush()

Instrumentierung mit Anforderungsbibliothek

OpenTelemetry unterstützt auch mehrere Instrumentierungen, die die Instrumentierung mit Bibliotheken von Drittanbietern ermöglichen.

Eine Liste der in OpenTelemetry verfügbaren Instrumentierungen finden Sie in der contrib-Dokumentation.

In diesem Beispiel wird gezeigt, wie Sie mit der Anforderungsbibliothek instrumentieren.

  • Installieren Sie das Anforderungsinstrumentierungspaket mithilfe von pip install opentelemetry-instrumentation-requests.
"""
An example to show an application instrumented with the OpenTelemetry requests instrumentation.
Calls made with the requests library will be automatically tracked and telemetry is exported to 
application insights with the AzureMonitorTraceExporter.
See more info on the requests instrumentation here:
https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-requests
"""
import os
import requests
from opentelemetry import trace
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

# This line causes your calls made with the requests library to be tracked.
RequestsInstrumentor().instrument()

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
exporter = AzureMonitorTraceExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# This request will be traced
response = requests.get(url="https://azure.microsoft.com/")

Aktivieren der Stichprobenerstellung

Sie können die Stichprobenerstellung aktivieren, um die Menge der empfangenen Telemetriedatensätze zu begrenzen. Um die richtige Stichprobenerstellung in Application Insights zu aktivieren, verwenden Sie die ApplicationInsightsSampler wie unten gezeigt.

"""
An example to show an application using the ApplicationInsightsSampler to enable sampling for your telemetry.
Specify a sampling rate for the sampler to limit the amount of telemetry records you receive. Custom dependencies
 are tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import (
    ApplicationInsightsSampler,
    AzureMonitorTraceExporter,
)

# Sampler expects a sample rate of between 0 and 1 inclusive
# A rate of 0.75 means approximately 75% of your telemetry will be sent
sampler = ApplicationInsightsSampler(0.75)
trace.set_tracer_provider(TracerProvider(sampler=sampler))
tracer = trace.get_tracer(__name__)
exporter = AzureMonitorTraceExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

for i in range(100):
    # Approximately 25% of these spans should be sampled out
    with tracer.start_as_current_span("hello"):
        print("Hello, World!")

Leerungs-/Herunterfahren

Für alle Anwendungen, die mit OpenTelemetry SDK und Azure Monitor-Exportern eingerichtet wurden, werden Telemetriedaten beim Beenden der Anwendung automatisch geleert. Beachten Sie, dass dies nicht einschließt, wenn die Anwendung aufgrund einer nicht abgeschlossenen Ausnahme abrupt beendet wird oder abstürzt.

Problembehandlung

Der Exporter löst in Azure Core definierte Ausnahmen aus.

Nächste Schritte

Weiterer Beispielcode

Weitere Beispiele finden Sie im Beispielverzeichnis , das gängige Szenarien veranschaulicht.

Zusätzliche Dokumentation

Eine ausführlichere Dokumentation zum Azure Monitor-Dienst finden Sie in der Azure Monitor-Dokumentation auf docs.microsoft.com.

Eine detaillierte Übersicht über OpenTelemetry finden Sie auf der Übersichtsseite .

Die offizielle OpenTelemetry Python-Dokumentation und informationen zum Aktivieren anderer Telemetrieszenarien finden Sie auf der offiziellen OpenTelemetry-Website.

Weitere Informationen zur OpenTelemetry-Distro von Azure Monitor, bei der es sich um ein Bündel nützlicher, vormontierter Komponenten handelt (eine davon ist dieses aktuelle Paket), die Telemetrieszenarien mit Azure Monitor ermöglichen, finden Sie in der Infodatei.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Ausführliche Informationen finden Sie unter https://cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.