Einrichten von Azure Monitor für Ihre Python-Anwendung

Hinweis

Das OpenCensus Python-SDK ist veraltet, aber Microsoft unterstützt es bis zur Einstellung am 30. September 2024. Wir empfehlen jetzt das auf OpenTelemetry basierende Python-Angebot und bieten Migrationsanleitungen.

Azure Monitor unterstützt verteilte Ablaufverfolgung, Metrikerfassung und Protokollierung für Python-Anwendungen.

Die von Microsoft unterstützte Lösung zum Nachverfolgen und Exportieren von Daten für Ihre Python-Anwendungen ist das OpenCensus Python SDK über die Azure Monitor-Exportprogramme.

Microsoft rät davon ab, andere Telemetrie-SDKs für Python als Telemetrielösung zu verwenden, da diese nicht unterstützt werden.

OpenCensus wird mit OpenTelemetry zusammengeführt. Wir empfehlen jedoch weiterhin OpenCensus, bis OpenTelemetry ausgereifter ist.

Voraussetzungen

Sie benötigen ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Hinweis

Am 31. März 2025 wird der Support für die auf Instrumentierungsschlüsseln basierende Erfassung eingestellt. Die Erfassung von Instrumentierungsschlüsseln funktioniert zwar weiterhin, wir stellen jedoch keine Updates und keinen Support mehr für das Feature bereit. Wechseln Sie zu Verbindungszeichenfolgen, damit Sie neue Funktionen nutzen können.

Einführung in das OpenCensus Python SDK

OpenCensus besteht aus einer Reihe von Open-Source-Bibliotheken, die die Erfassung von verteilter Ablaufverfolgung, Metriken und Protokollierungstelemetrie ermöglichen. Mithilfe von Azure Monitor-Exportprogrammen können Sie diese gesammelte Telemetrie an Application Insights senden. In diesem Artikel werden der Prozess zur Einrichtung von OpenCensus und Azure Monitor-Exportprogrammen für Python und das Senden Ihrer Überwachungsdaten an Azure Monitor beschrieben.

Instrumentieren mit dem OpenCensus Python SDK mit Azure Monitor-Exportprogrammen

Installieren Sie OpenCensus Azure Monitor Exporters:

python -m pip install opencensus-ext-azure

Das SDK verwendet drei Azure Monitor-Exportprogramme, um unterschiedliche Arten von Telemetriedaten an Azure Monitor zu senden. Dies sind trace, metrics und logs. Weitere Informationen zu diesen Telemetrietypen finden Sie in der Übersicht über die Datenplattform. Befolgen Sie die nachstehenden Anweisungen, um diese Telemetrietypen über die drei Exportprogramme zu senden.

Zuordnungen von Telemetriedatentypen

OpenCensus ordnet den verschiedenen Telemetriedaten in Azure Monitor die folgenden Exportprogramme zu.

Basis für Einblicke	Telemetriedatentyp in Azure Monitor	Erklärung
Protokolle	traces, exceptions, customEvents	Protokolltelemetrie, Ausnahmentelemetrie, Ereignistelemetrie
Metriken	customMetrics, performanceCounters	Benutzerdefinierte Metriken, Leistungsindikatoren
Ablaufverfolgung	requests, dependencies	Eingehende Anforderungen, ausgehende Anforderungen

Protokolle

1. Zuerst generieren wir einige lokale Protokolldaten.

   
   import logging
   
   logger = logging.getLogger(__name__)
   
   def main():
       """Generate random log data."""
       for num in range(5):
           logger.warning(f"Log Entry - {num}")
   
   if __name__ == "__main__":
       main()
   

2. Für jede Zahl im Bereich wird ein Protokolleintrag ausgegeben.

   Log Entry - 0
   Log Entry - 1
   Log Entry - 2
   Log Entry - 3
   Log Entry - 4
   

3. Diese Protokolldaten sollen in Azure Monitor angezeigt werden. Sie können sie in einer Umgebungsvariablen (APPLICATIONINSIGHTS_CONNECTION_STRING) angeben. Alternativ können Sie die Verbindungszeichenfolge auch direkt an AzureLogHandler übergeben. Verbindungszeichenfolgen sollten aber nicht zur Versionskontrolle hinzugefügt werden.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Es wird empfohlen, die Verbindungszeichenfolge zu verwenden, um die Exportprogramme zu instanziieren, die zum Senden von Telemetriedaten an Application Insights verwendet werden. Ändern Sie Ihren Code aus dem vorherigen Schritt basierend auf dem folgenden Codebeispiel:

   import logging
   from opencensus.ext.azure.log_exporter import AzureLogHandler
   
   logger = logging.getLogger(__name__)
   logger.addHandler(AzureLogHandler())
   
   # Alternatively manually pass in the connection_string
   # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))
   
   """Generate random log data."""
   for num in range(5):
       logger.warning(f"Log Entry - {num}")
   

4. Das Exportprogramm sendet Protokolldaten an Azure Monitor. Sie finden die Daten unter traces.

   In diesem Kontext ist traces nicht mit tracing identisch. Hier bezieht sich traces auf die Art der Telemetrie, die bei Verwendung von AzureLogHandler in Azure Monitor angezeigt wird. tracing bezieht sich jedoch auf ein Konzept in OpenCensus und betrifft die verteilte Ablaufverfolgung.

   Hinweis

   Die Stammprotokollierung wird mit dem Schweregrad warning konfiguriert. Das bedeutet, dass alle von Ihnen gesendeten Protokolle mit einem niedrigeren Schweregrad ignoriert und daher nicht an Azure Monitor gesendet werden. Weitere Informationen finden Sie in der Dokumentation zur Protokollierung.

5. Sie können Ihren Protokollnachrichten auch benutzerdefinierte Eigenschaften im Schlüsselwortargument extra hinzufügen, indem Sie das Feld custom_dimensions verwenden. Diese Eigenschaften werden als Schlüssel-Wert-Paare in customDimensions in Azure Monitor angezeigt.

   Hinweis

   Damit dieses Feature funktioniert, müssen Sie im Feld custom_dimensions ein Wörterbuch übergeben. Wenn Sie Argumente eines anderen Typs übergeben, werden diese von der Protokollierung ignoriert.

   import logging
   
   from opencensus.ext.azure.log_exporter import AzureLogHandler
   
   logger = logging.getLogger(__name__)
   logger.addHandler(AzureLogHandler())
   # Alternatively manually pass in the connection_string
   # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))
   
   properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}
   
   # Use properties in logging statements
   logger.warning('action', extra=properties)
   

Hinweis

Im Rahmen der Verwendung der Application Insights-Instrumentierung sammeln und senden wir Diagnosedaten an Microsoft. Diese Daten helfen uns, Application Insights auszuführen und zu verbessern. Sie haben die Möglichkeit, die Sammlung nicht wesentlicher Daten zu deaktivieren. Weitere Informationen finden Sie unter Statsbeat in Application Insights.

Konfigurieren der Protokollierung für Django-Anwendungen

Sie können die Protokollierung wie zuvor beschrieben explizit im Anwendungscode für Ihre Django-Anwendungen konfigurieren. Alternativ können Sie sie auch in der Protokollierungskonfiguration von Django angeben. Dieser Code kann in eine beliebige Datei eingefügt werden, die Sie für die Konfiguration der Einstellungen der Django-Website verwenden (üblicherweise settings.py).

Weitere Informationen zum Konfigurieren von Django-Einstellungen finden Sie unter Django-Einstellungen. Weitere Informationen zum Konfigurieren der Protokollierung finden Sie unter Django-Protokollierung.

LOGGING = {
    "handlers": {
        "azure": {
            "level": "DEBUG",
            "class": "opencensus.ext.azure.log_exporter.AzureLogHandler",
            "connection_string": "<appinsights-connection-string>",
        },
        "console": {
            "level": "DEBUG",
            "class": "logging.StreamHandler",
            "stream": sys.stdout,
        },
      },
    "loggers": {
        "logger_name": {"handlers": ["azure", "console"]},
    },
}

Stellen Sie sicher, dass Sie die Protokollierung mit demselben Namen verwenden, der in der Konfiguration angegeben ist.

# views.py

import logging
from django.shortcuts import request

logger = logging.getLogger("logger_name")
logger.warning("this will be tracked")

Senden von Ausnahmen

Telemetriedaten vom Typ exception werden von OpenCensus Python nicht automatisch nachverfolgt und gesendet. Sie werden per AzureLogHandler unter Verwendung von Ausnahmen über die Python-Protokollierungsbibliothek gesendet. Genau wie bei der gewöhnlichen Protokollierung können benutzerdefinierte Eigenschaften hinzugefügt werden.

import logging

from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureLogHandler())
# Alternatively, manually pass in the connection_string
# logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}

# Use properties in exception logs
try:
    result = 1 / 0  # generate a ZeroDivisionError
except Exception:
    logger.exception('Captured an exception.', extra=properties)

Da Ausnahmen explizit protokolliert werden müssen, müssen Sie entscheiden, wie Ausnahmefehler protokolliert werden. OpenCensus hat keine Einschränkungen für die Art der Protokollierung, doch Sie müssen Ausnahmetelemetriedaten explizit protokollieren.

Senden von Ereignisse

Sie können Telemetriedaten vom Typ customEvent genauso wie Telemetriedaten vom Typ trace senden, außer dass Sie stattdessen AzureEventHandler verwenden.

import logging
from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler())
# Alternatively manually pass in the connection_string
# logger.addHandler(AzureEventHandler(connection_string=<appinsights-connection-string>))

logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Stichproben

Informationen zur Stichprobenentnahme in OpenCensus finden Sie unter Stichprobenentnahme in OpenCensus.

Protokollkorrelation

Ausführliche Informationen dazu, wie Sie die Protokolle mit Daten aus dem Ablaufverfolgungskontext anreichern können, finden Sie unter Integration von Protokollen für OpenCensus Python.

Ändern der Telemetrie

Informationen dazu, wie Sie nachverfolgte Telemetrie ändern können, bevor sie an Azure Monitor gesendet wird, finden Sie unter OpenCensus Python-Telemetrieprozessoren.

Metriken

„OpenCensus.stats“ unterstützt vier Aggregationsmethoden, unterstützt Azure Monitor jedoch teilweise:

• Count: Die Anzahl der Messpunkte. Der Wert ist kumulativ. Er kann nur erhöht werden und wird beim Neustart auf 0 zurückgesetzt.
• Sum: Die Summe der Messpunkte. Der Wert ist kumulativ. Er kann nur erhöht werden und wird beim Neustart auf 0 zurückgesetzt.
• LastValue: Behält den zuletzt aufgezeichneten Wert bei und löscht alle übrigen Werte
• Distribution: Die Histogrammverteilung der Messpunkte wird vom Azure-Exportprogramm nicht unterstützt.

Beispiel für die Aggregation von „Count“

1. Zuerst generieren wir einige lokale Metrikdaten. Wir erstellen eine Metrik, um nachzuverfolgen, wie häufig Benutzer die EINGABETASTE drücken.

   
   from datetime import datetime
   from opencensus.stats import aggregation as aggregation_module
   from opencensus.stats import measure as measure_module
   from opencensus.stats import stats as stats_module
   from opencensus.stats import view as view_module
   from opencensus.tags import tag_map as tag_map_module
   
   stats = stats_module.stats
   view_manager = stats.view_manager
   stats_recorder = stats.stats_recorder
   
   prompt_measure = measure_module.MeasureInt("prompts",
                                              "number of prompts",
                                              "prompts")
   prompt_view = view_module.View("prompt view",
                                  "number of prompts",
                                  [],
                                  prompt_measure,
                                  aggregation_module.CountAggregation())
   view_manager.register_view(prompt_view)
   mmap = stats_recorder.new_measurement_map()
   tmap = tag_map_module.TagMap()
   
   def main():
       for _ in range(4):
           mmap.measure_int_put(prompt_measure, 1)
           mmap.record(tmap)
           metrics = list(mmap.measure_to_view_map.get_metrics(datetime.utcnow()))
           print(metrics[0].time_series[0].points[0])
   
   if __name__ == "__main__":
       main()
   

2. Metriken werden erstellt, um viele Male nachzuverfolgen. Bei jedem Eintrag wird der Wert erhöht, und die Metrikinformationen werden in der Konsole angezeigt. Die Informationen umfassen den aktuellen Wert und den aktuellen Zeitstempel für den Aktualisierungszeitpunkt der Metrik.

   Point(value=ValueLong(5), timestamp=2019-10-09 20:58:04.930426)
   Point(value=ValueLong(6), timestamp=2019-10-09 20:58:05.170167)
   Point(value=ValueLong(7), timestamp=2019-10-09 20:58:05.438614)
   Point(value=ValueLong(7), timestamp=2019-10-09 20:58:05.834216)
   

3. Das Eingeben von Werten ist zu Demonstrationszwecken hilfreich, doch wir möchten die Metrikdaten an Azure Monitor ausgeben. Übergeben Sie die Verbindungszeichenfolge direkt an das Exportprogramm. Sie können sie auch in einer Umgebungsvariablen (APPLICATIONINSIGHTS_CONNECTION_STRING) angeben. Es wird empfohlen, die Verbindungszeichenfolge zu verwenden, um die Exportprogramme zu instanziieren, die zum Senden von Telemetriedaten an Application Insights verwendet werden. Ändern Sie Ihren Code aus dem vorherigen Schritt basierend auf dem folgenden Codebeispiel:

   from datetime import datetime
   from opencensus.ext.azure import metrics_exporter
   from opencensus.stats import aggregation as aggregation_module
   from opencensus.stats import measure as measure_module
   from opencensus.stats import stats as stats_module
   from opencensus.stats import view as view_module
   from opencensus.tags import tag_map as tag_map_module
   
   stats = stats_module.stats
   view_manager = stats.view_manager
   stats_recorder = stats.stats_recorder
   
   prompt_measure = measure_module.MeasureInt("prompts",
                                              "number of prompts",
                                              "prompts")
   prompt_view = view_module.View("prompt view",
                                  "number of prompts",
                                  [],
                                  prompt_measure,
                                  aggregation_module.CountAggregation())
   view_manager.register_view(prompt_view)
   mmap = stats_recorder.new_measurement_map()
   tmap = tag_map_module.TagMap()
   
   exporter = metrics_exporter.new_metrics_exporter()
   # Alternatively manually pass in the connection_string
   # exporter = metrics_exporter.new_metrics_exporter(connection_string='<appinsights-connection-string>')
   
   view_manager.register_exporter(exporter)
   
   def main():
       for _ in range(10):
           input("Press enter.")
           mmap.measure_int_put(prompt_measure, 1)
           mmap.record(tmap)
           metrics = list(mmap.measure_to_view_map.get_metrics(datetime.utcnow()))
           print(metrics[0].time_series[0].points[0])
   
   if __name__ == "__main__":
       main()
   

4. Das Exportprogramm sendet die Metrikdaten in einem festen Intervall an Azure Monitor. Dieser Wert muss auf 60 Sekunden festgelegt werden, da das Application Insights-Back-End von einer Aggregation von Metrikpunkten in einem Zeitintervall von 60 Sekunden ausgeht. Wir verfolgen nur eine einzelne Metrik. Diese Metrikdaten werden also mit dem jeweiligen Wert und Zeitstempel in jedem Intervall gesendet. Der Wert ist kumulativ. Er kann nur erhöht werden und wird beim Neustart auf 0 zurückgesetzt.

   Sie finden die Daten unter customMetrics, doch die customMetrics-Eigenschaften valueCount, valueSum, valueMin, valueMax und valueStdDev werden effektiv nicht verwendet.

Festlegen benutzerdefinierter Dimensionen in Metriken

Mit dem OpenCensus Python SDK können Sie Ihrer Metriktelemetrie mithilfe von tags benutzerdefinierte Dimensionen hinzufügen. Bei diesen handelt es sich im Grunde genommen um ein Wörterbuch aus Schlüssel-Wert-Paaren.

1. Fügen Sie die Tags, die Sie verwenden möchten, in die Tagzuordnung ein. Die Tagzuordnung fungiert als eine Art „Pool“ aller verfügbaren Tags, die Sie verwenden können.

   ...
   tmap = tag_map_module.TagMap()
   tmap.insert("url", "http://example.com")
   ...
   

2. Geben Sie für ein bestimmtes View-Objekt die Tags an, die Sie beim Aufzeichnen von Metriken mit dieser Ansicht über den Tagschlüssel verwenden möchten.

   ...
   prompt_view = view_module.View("prompt view",
                               "number of prompts",
                               ["url"], # <-- A sequence of tag keys used to specify which tag key/value to use from the tag map
                               prompt_measure,
                               aggregation_module.CountAggregation())
   ...
   

3. Achten Sie darauf, die Tagzuordnung bei der Aufzeichnung in der Messzuordnung zu verwenden. Die in der View angegebenen Tagschlüssel müssen in der Tagzuordnung enthalten sein, die für die Aufzeichnung verwendet wird.

   ...
   mmap = stats_recorder.new_measurement_map()
   mmap.measure_int_put(prompt_measure, 1)
   mmap.record(tmap) # <-- pass the tag map in here
   ...
   

4. Unterhalb der Tabelle customMetrics verfügen alle Metrikdatensätze, die mithilfe von prompt_view ausgegeben werden, über benutzerdefinierte Dimensionen: {"url":"http://example.com"}.

5. Um Tags mit unterschiedlichen Werten unter Verwendung derselben Schlüssel zu generieren, erstellen Sie neue Tagzuordnungen für diese.

   ...
   tmap = tag_map_module.TagMap()
   tmap2 = tag_map_module.TagMap()
   tmap.insert("url", "http://example.com")
   tmap2.insert("url", "https://www.wikipedia.org/wiki/")
   ...
   

Leistungsindikatoren

Standardmäßig sendet das Exportprogramm für Metriken eine Reihe von Leistungsindikatoren an Azure Monitor. Sie können diese Funktion deaktivieren, indem Sie das Flag enable_standard_metrics im Konstruktor des Exportprogramms für Metriken auf False festlegen.

...
exporter = metrics_exporter.new_metrics_exporter(
  enable_standard_metrics=False,
  )
...

Die folgenden Leistungsindikatoren werden derzeit gesendet:

• Verfügbarer Arbeitsspeicher (Bytes)
• CPU – Prozessorzeit (%)
• Rate eingehender Anforderungen (pro Sekunde)
• Durchschnittliche Ausführungsdauer eingehender Anforderungen (Millisekunden)
• Prozess – CPU-Auslastung (%)
• Prozess – Private Bytes (Bytes)

Diese Metriken sollten in performanceCounters angezeigt werden. Weitere Informationen finden Sie unter Leistungsindikatoren.

Ändern der Telemetrie

Informationen dazu, wie Sie nachverfolgte Telemetrie ändern können, bevor sie an Azure Monitor gesendet wird, finden Sie unter OpenCensus Python-Telemetrieprozessoren.

Ablaufverfolgung

Hinweis

In OpenCensus bezieht sich tracing auf die verteilte Ablaufverfolgung. Der Parameter AzureExporter sendet Telemetriedaten zu requests und dependency an Azure Monitor.

1. Zuerst generieren wir lokal einige Ablaufverfolgungsdaten. Geben Sie in Python IDLE oder einem Editor Ihrer Wahl den folgenden Code ein:

   from opencensus.trace.samplers import ProbabilitySampler
   from opencensus.trace.tracer import Tracer
   
   tracer = Tracer(sampler=ProbabilitySampler(1.0))
   
   def main():
       with tracer.span(name="test") as span:
           for value in range(5):
               print(value)
   
   
   if __name__ == "__main__":
       main()
   

2. Mit jedem Eintrag wird der Wert in die Shell gedruckt. Das OpenCensus Python-Modul generiert ein entsprechendes SpanData-Element. Das OpenCensus-Projekt definiert eine Ablaufverfolgung als Struktur von Spannen (Spans).

   0
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='15ac5123ac1f6847', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:22.805429Z', end_time='2019-06-27T18:21:44.933405Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   1
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='2e512f846ba342de', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:44.933405Z', end_time='2019-06-27T18:21:46.156787Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   2
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='f3f9f9ee6db4740a', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:46.157732Z', end_time='2019-06-27T18:21:47.269583Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   

3. Die Betrachtung der Ausgabe ist zwar zu Demonstrationszwecken hilfreich, SpanData soll jedoch an Azure Monitor ausgegeben werden. Übergeben Sie die Verbindungszeichenfolge direkt an das Exportprogramm. Sie können sie auch in einer Umgebungsvariablen (APPLICATIONINSIGHTS_CONNECTION_STRING) angeben. Es wird empfohlen, die Verbindungszeichenfolge zu verwenden, um die Exportprogramme zu instanziieren, die zum Senden von Telemetriedaten an Application Insights verwendet werden. Ändern Sie Ihren Code aus dem vorherigen Schritt basierend auf dem folgenden Codebeispiel:

   from opencensus.ext.azure.trace_exporter import AzureExporter
   from opencensus.trace.samplers import ProbabilitySampler
   from opencensus.trace.tracer import Tracer
   
   tracer = Tracer(
       exporter=AzureExporter(),
       sampler=ProbabilitySampler(1.0),
   )
   # Alternatively manually pass in the connection_string
   # exporter = AzureExporter(
   #   connection_string='<appinsights-connection-string>',
   #   ...
   # )
   
   def main():
       with tracer.span(name="test") as span:
           for value in range(5):
               print(value)
   
   if __name__ == "__main__":
       main()
   

4. Wenn Sie das Python-Skript jetzt ausführen, wird nur der Wert in der Shell ausgegeben. Das erstellte SpanData-Element wird an Azure Monitor gesendet. Sie finden die ausgegebenen Span-Daten unter dependencies.

   Weitere Informationen zu ausgehenden Anforderungen finden Sie unter Nachverfolgen von Abhängigkeiten mit OpenCensus Python. Weitere Informationen zu eingehenden Anforderungen finden Sie unter Nachverfolgen eingehender Anforderungen mit OpenCensus Python.

Stichproben

Informationen zur Stichprobenentnahme in OpenCensus finden Sie unter Stichprobenentnahme in OpenCensus.

Korrelation der Ablaufverfolgung

Weitere Informationen zur Telemetriekorrelation in den Ablaufverfolgungsdaten finden Sie unter Telemetriekorrelation in OpenCensus Python.

Ändern der Telemetrie

Weitere Informationen dazu, wie Sie nachverfolgte Telemetrie ändern können, bevor sie an Azure Monitor gesendet wird, finden Sie unter OpenCensus Python-Telemetrieprozessoren.

Konfigurieren von Azure Monitor-Exportprogrammen

Wie bereits gezeigt, gibt es drei unterschiedliche Azure Monitor-Exportprogramme, die OpenCensus unterstützen. Jedes Programm sendet andere Arten von Telemetriedaten an Azure Monitor. Weitere Informationen dazu, welche Arten von Telemetriedaten vom jeweiligen Exportprogramm gesendet werden, finden Sie in der folgenden Tabelle.

Alle Exportprogramme akzeptieren dieselben Argumente für die Konfiguration, die über die Konstruktoren übergeben werden. Hier finden Sie Informationen zu den einzelnen Telemetrien:

Exportprogrammtelemetrie	BESCHREIBUNG
connection_string	Die Verbindungszeichenfolge, mit der eine Verbindung mit der Azure Monitor-Ressource hergestellt wird. Dies hat Vorrang vor instrumentation_key.
credential	Diese Klasse mit Anmeldeinformationen wird von der Azure Active Directory-Authentifizierung verwendet. Weitere Informationen finden Sie im nachfolgenden Abschnitt „Authentifizierung“.
enable_standard_metrics	Wird für AzureMetricsExporter verwendet. Signalisiert dem Exportprogramm, dass Leistungsindikatormetriken automatisch an Azure Monitor gesendet werden sollen. Der Standardwert lautet True.
export_interval	Wird verwendet, um die Häufigkeit in Sekunden für den Export anzugeben. Wird standardmäßig auf 15s festgelegt. Für Metriken MUSS dieser Wert auf 60 Sekunden festgelegt werden, da Ihre Metrikaggregationen im Metrik-Explorer ansonsten keinen Sinn ergeben.
grace_period	Wird verwendet, um das Timeout für das Herunterfahren von Exportprogrammen anzugeben (in Sekunden). Wird standardmäßig auf 5s festgelegt.
instrumentation_key	Der Instrumentierungsschlüssel, mit dem eine Verbindung mit der Azure Monitor-Ressource hergestellt wird.
logging_sampling_rate	Wird für AzureLogHandler und AzureEventHandler verwendet. Gibt eine Stichprobenrate [0,1.0] für das Exportieren von Protokollen/Ereignissen an. Wird standardmäßig auf 1.0 festgelegt.
max_batch_size	Gibt die maximale Größe der Telemetriedaten an, die gleichzeitig exportiert werden.
proxies	Gibt eine Folge von Proxys an, die zum Senden von Daten an Azure Monitor verwendet werden sollen. Weitere Informationen finden Sie unter Proxys.
storage_path	Ein Pfad zum Speicherort des lokalen Speicherordners (nicht gesendete Telemetrie). Ab opencensus-ext-azure v1.0.3 ist der Standardpfad das temporäre Verzeichnis des Betriebssystems + opencensus-python + your-ikey. Bei früheren Versionen als 1.0.3 lautet der Standardpfad $USER + .opencensus + .azure + python-file-name.
timeout	Gibt das Netzwerktimeout für das Senden von Telemetriedaten an den Erfassungsdienst an (in Sekunden). Wird standardmäßig auf 10s festgelegt.

Integration mit Azure Functions

Um die benutzerdefinierte Telemetriedaten in Azure Functions-Umgebungen zu erfassen, wird die Verwendung der Azure Functions-Erweiterung für OpenCensus Python empfohlen. Weitere Informationen finden Sie im Python-Entwicklerhandbuch für Azure Functions.

Authentifizierung (Vorschau)

Hinweis

Das Authentifizierungsfeature ist ab opencensus-ext-azure 1.1b0 verfügbar.

Jedes der Azure Monitor-Exportprogramme unterstützt die Konfiguration des sicheren Sendens von Telemetrienutzdaten über die OAuth-Authentifizierung mit Azure Active Directory. Weitere Informationen finden Sie in der Dokumentation zur Authentifizierung.

Anzeigen Ihrer Daten mit Abfragen

Sie können die von Ihrer Anwendung gesendeten Telemetriedaten über die Registerkarte Protokolle (Analytics) anzeigen.

In der Liste unter Aktiv ist Folgendes angegeben:

• Für Telemetriedaten, die mit dem Exportprogramm der Azure Monitor-Ablaufverfolgung gesendet werden, werden eingehende Anforderungen unter requests angezeigt. Ausgehende bzw. in Bearbeitung befindliche Anforderungen werden unter dependencies angezeigt.
• Für Telemetriedaten, die mit dem Exportprogramm für Azure Monitor-Metriken gesendet werden, werden die gesendeten Metriken unter customMetrics angezeigt.
• Für Telemetriedaten, die mit dem Exportprogramm für Azure Monitor-Protokolle gesendet werden, werden die Protokolle unter traces angezeigt. Ausnahmen werden unter exceptions angezeigt.

Weitere Informationen zur Verwendung von Abfragen und Protokollen finden Sie unter Protokolle in Azure Monitor.

Weitere Informationen zu OpenCensus für Python

• OpenCensus Python auf GitHub
• Anpassung
• Azure Monitor-Exportprogramme auf GitHub
• OpenCensus-Integrationen
• Azure Monitor-Beispielanwendungen

Problembehandlung

Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Sie können die Konnektivität Ihres Webservers oder Anwendungshostcomputers mit den Endpunkten des Erfassungsdiensts testen, indem Sie unformatierte REST-Clients über PowerShell- oder cURL-Befehle verwenden. Weitere Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Versionshinweise

Die neuesten Versionshinweise finden Sie unter Python Azure Monitor Exporter.

Unser Dienstupdates fassen auch wichtige Application Insights-Verbesserungen zusammen.

Nächste Schritte

• Um Nutzungserfahrungen zu aktivieren, aktivieren Sie die Web- oder Browserbenutzerüberwachung.
• Verfolgen von eingehenden Anforderungen
• Verfolgen von ausgehenden Anforderungen
• Überprüfen der Anwendungszuordnung
• Erfahren Sie, wie Sie die End-to-End-Leistungsüberwachung durchführen.

Alerts

• Verfügbarkeitsübersicht: Erstellen Sie Tests, um sicherzustellen, dass Ihre Website im Web sichtbar ist.
• Intelligente Diagnose: Diese Tests werden automatisch ausgeführt, sodass Sie keinerlei Einrichtungsschritte ausführen müssen. Sie werden darüber benachrichtigt, ob für Ihre App eine ungewöhnlich hohe Zahl von Anforderungen mit Fehlern vorliegt.
• Metrikwarnungen: Richten Sie Warnungen ein, damit Sie gewarnt werden, wenn für eine Metrik ein Schwellenwert überschritten wird. Sie können diese für benutzerdefinierte Metriken festlegen, die Sie in Ihrer App codieren.