Konfigurowanie usługi Azure Monitor dla aplikacji w języku Python

Uwaga

Zestaw SDK języka Python openCensus został wycofany. Zalecamy ofertę języka Python opartą na protokole OpenTelemetry i udostępniamy wskazówki dotyczące migracji.

Usługa Azure Monitor obsługuje śledzenie rozproszone, zbieranie metryk i rejestrowanie aplikacji języka Python.

Obsługiwane przez firmę Microsoft rozwiązanie do śledzenia i eksportowania danych dla aplikacji języka Python odbywa się za pośrednictwem zestawu SDK języka Python OpenCensus za pośrednictwem eksporterów usługi Azure Monitor.

Firma Microsoft nie zaleca używania innych zestawów SDK telemetrii dla języka Python jako rozwiązania telemetrycznego, ponieważ nie są one obsługiwane.

Interfejs OpenCensus jest zbieżny z funkcją OpenTelemetry. Nadal zalecamy rozszerzenie OpenCensus, podczas gdy funkcja OpenTelemetry stopniowo dojrzała.

Wymagania wstępne

Wymagana jest subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

Uwaga

31 marca 2025 r. zostanie zakończone świadczenie pomocy technicznej dla pozyskiwania klucza instrumentacji. Pozyskiwanie klucza instrumentacji będzie nadal działać, ale nie udostępnimy już aktualizacji ani obsługi funkcji. Przejście do parametry połączenia w celu skorzystania z nowych funkcji.

Wprowadzenie do zestawu OpenCensus python SDK

OpenCensus to zestaw bibliotek typu open source umożliwiający zbieranie rozproszonego śledzenia, metryk i rejestrowania danych telemetrycznych. Korzystając z eksporterów usługi Azure Monitor, możesz wysłać te zebrane dane telemetryczne do usługi Application Insights. W tym artykule przedstawiono proces konfigurowania eksporterów openCensus i Azure Monitor dla języka Python w celu wysyłania danych monitorowania do usługi Azure Monitor.

Instrumentowanie za pomocą zestawu Sdk języka Python OpenCensus za pomocą eksporterów usługi Azure Monitor

Zainstaluj eksporterów usługi Azure Monitor OpenCensus:

python -m pip install opencensus-ext-azure

Zestaw SDK używa trzech eksporterów usługi Azure Monitor do wysyłania różnych typów danych telemetrycznych do usługi Azure Monitor. traceSą to , metricsi logs. Aby uzyskać więcej informacji na temat tych typów telemetrii, zobacz Omówienie platformy danych. Skorzystaj z poniższych instrukcji, aby wysłać te typy danych telemetrycznych za pośrednictwem trzech eksporterów.

Mapowania typów telemetrii

OpenCensus mapuje następujących eksporterów na typy telemetrii widoczne w usłudze Azure Monitor.

Filar obserwacji	Typ telemetrii w usłudze Azure Monitor	Wyjaśnienie
Dzienniki	Ślady, wyjątki, customEvents	Dane telemetryczne dziennika, telemetria wyjątków, telemetria zdarzeń
Metryki	customMetrics, performanceCounters	Niestandardowe liczniki wydajności metryk
Śledzenie	Zależności żądań	Żądania przychodzące, żądania wychodzące

Dzienniki

1. Najpierw wygenerujmy dane dziennika lokalnego.

   
   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. Wpis dziennika jest emitowany dla każdej liczby w zakresie.

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

3. Chcemy zobaczyć te dane dziennika w usłudze Azure Monitor. Można go określić w zmiennej środowiskowej . APPLICATIONINSIGHTS_CONNECTION_STRING Możesz również przekazać connection_string bezpośrednio do AzureLogHandlerelementu , ale parametry połączenia nie należy dodawać do kontroli wersji.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Zalecamy użycie parametry połączenia w celu utworzenia wystąpienia eksporterów używanych do wysyłania danych telemetrycznych do usługi Application Insights. Zmodyfikuj kod z poprzedniego kroku na podstawie następującego przykładu kodu:

   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. Eksporter wysyła dane dziennika do usługi Azure Monitor. Dane można znaleźć w obszarze traces.

   W tym kontekście traces nie jest to samo co tracing. traces W tym miejscu odwołuje się do typu telemetrii widocznej w usłudze Azure Monitor podczas korzystania z usługi AzureLogHandler. Jednak tracing odnosi się do koncepcji w technologii OpenCensus i odnosi się do rozproszonego śledzenia.

   Uwaga

   Główny rejestrator jest skonfigurowany z poziomem warning. Oznacza to, że wszystkie wysyłane dzienniki o mniejszej ważności są ignorowane, a z kolei nie będą wysyłane do usługi Azure Monitor. Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą rejestrowania.

5. Możesz również dodać właściwości niestandardowe do komunikatów dziennika w argumencie słowa kluczowego extra custom_dimensions przy użyciu pola . Te właściwości są wyświetlane jako pary klucz-wartość w usłudze customDimensions Azure Monitor.

   Uwaga

   Aby ta funkcja działała, należy przekazać słownik do custom_dimensions pola. Jeśli przekażesz argumenty dowolnego innego typu, rejestrator je zignoruje.

   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)
   

Uwaga

W ramach instrumentacji usługi Application Insights zbieramy i wysyłamy dane diagnostyczne do firmy Microsoft. Te dane pomagają nam uruchamiać i ulepszać usługę Application Insights. Istnieje możliwość wyłączenia zbierania danych innych niż podstawowe. Aby dowiedzieć się więcej, zobacz Statsbeat in Application Insights (Statystyki w usłudze Application Insights).

Konfigurowanie rejestrowania dla aplikacji Django

Rejestrowanie można skonfigurować jawnie w kodzie aplikacji, tak jak poprzednie dla aplikacji Django, lub określić je w konfiguracji rejestrowania Django. Ten kod może przejść do dowolnego pliku używanego do konfiguracji ustawień witryny Django, zazwyczaj settings.py.

Aby uzyskać informacje na temat konfigurowania ustawień platformy Django, zobacz Ustawienia Django. Aby uzyskać więcej informacji na temat konfigurowania rejestrowania, zobacz Rejestrowanie Django.

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"]},
    },
}

Upewnij się, że używasz rejestratora o tej samej nazwie co ten określony w konfiguracji.

# views.py

import logging
from django.shortcuts import request

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

Wysyłanie wyjątków

Język OpenCensus w języku Python nie śledzi automatycznie i wysyła exception danych telemetrycznych. Jest ona wysyłana AzureLogHandler za pomocą wyjątków za pośrednictwem biblioteki rejestrowania języka Python. Możesz dodać właściwości niestandardowe, takie jak w przypadku normalnego rejestrowania.

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)

Ponieważ należy jawnie rejestrować wyjątki, należy rejestrować nieobsługiwane wyjątki. Funkcja OpenCensus nie nakłada ograniczeń dotyczących sposobu wykonywania tego rejestrowania, ale należy jawnie rejestrować dane telemetryczne wyjątków.

Wysyłanie zdarzeń

Dane telemetryczne można wysyłać customEvent w dokładnie taki sam sposób, w jaki wysyłasz trace dane telemetryczne, z wyjątkiem użycia AzureEventHandler .

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!')

Próbkowanie

Aby uzyskać informacje na temat próbkowania w usłudze OpenCensus, zobacz Próbkowanie w usłudze OpenCensus.

Korelacja dzienników

Aby uzyskać informacje na temat wzbogacania dzienników przy użyciu danych kontekstowych śledzenia, zobacz Integracja dzienników języka Python z biblioteką OpenCensus.

Modyfikowanie telemetrii

Aby uzyskać informacje na temat modyfikowania śledzonych danych telemetrycznych przed wysłaniem ich do usługi Azure Monitor, zobacz OpenCensus Python telemetrii procesorów.

Metryki

Biblioteka OpenCensus.stats obsługuje cztery metody agregacji, ale zapewnia częściową obsługę usługi Azure Monitor:

• Liczba: liczba punktów pomiaru. Wartość jest skumulowana, może zwiększać się tylko i resetuje wartość 0 po ponownym uruchomieniu.
• Suma: suma punktów pomiaru. Wartość jest skumulowana, może zwiększać się tylko i resetuje wartość 0 po ponownym uruchomieniu.
• LastValue: Utrzymuje ostatnią zarejestrowaną wartość i spada wszystkie inne elementy.
• Dystrybucja: Eksporter platformy Azure nie obsługuje rozkładu histogramu punktów pomiaru.

Przykład agregacji zlicz

1. Najpierw wygenerujmy dane metryk lokalnych. Tworzymy metrykę, aby śledzić liczbę prób wybrania przez użytkownika Enter .

   
   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. Metryki są tworzone w celu śledzenia wiele razy. W przypadku każdego wpisu wartość jest zwiększana, a informacje o metryce są wyświetlane w konsoli programu . Informacje obejmują bieżącą wartość i bieżącą sygnaturę czasową po zaktualizowaniu metryki.

   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. Wprowadzanie wartości jest przydatne w celach demonstracyjnych, ale chcemy emitować dane metryk do usługi Azure Monitor. Przekaż parametry połączenia bezpośrednio do eksportera. Możesz też określić ją w zmiennej środowiskowej . APPLICATIONINSIGHTS_CONNECTION_STRING Zalecamy użycie parametry połączenia w celu utworzenia wystąpienia eksporterów używanych do wysyłania danych telemetrycznych do usługi Application Insights. Zmodyfikuj kod z poprzedniego kroku na podstawie następującego przykładu kodu:

   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. Eksporter wysyła dane metryk do usługi Azure Monitor w stałym interwale. Należy ustawić tę wartość na 60 sekund, ponieważ zaplecze usługi Application Insights zakłada agregację punktów metryk w 60-sekundowym interwale czasu. Śledzimy pojedynczą metrykę, więc te dane metryk, z dowolną wartością i sygnaturą czasową, która zawiera, są wysyłane co interwał. Dane są skumulowane, mogą tylko zwiększać się i resetować do wartości 0 po ponownym uruchomieniu.

   Dane można znaleźć w obszarze customMetrics, ale customMetrics właściwości valueCount, valueSum, valueMin, valueMaxi valueStdDev nie są skutecznie używane.

Ustawianie wymiarów niestandardowych w metrykach

Zestaw SDK języka Python OpenCensus umożliwia dodawanie wymiarów niestandardowych do telemetrii metryk przy użyciu polecenia tags, które są jak słownik par klucz-wartość.

1. Wstaw tagi, których chcesz użyć do mapy tagów. Mapa tagów działa jak rodzaj "puli" wszystkich dostępnych tagów, których można użyć.

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

2. Dla określonego Viewelementu określ tagi, których chcesz użyć podczas rejestrowania metryk w tym widoku za pomocą klucza tagu.

   ...
   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. Pamiętaj, aby użyć mapy tagów podczas rejestrowania na mapie miar. Klucze tagów określone w elemecie View muszą znajdować się na mapie tagów używanej do rejestrowania.

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

4. customMetrics W tabeli wszystkie rekordy metryk emitowane przy użyciu mają prompt_view wymiary {"url":"http://example.com"}niestandardowe .

5. Aby utworzyć tagi z różnymi wartościami przy użyciu tych samych kluczy, utwórz dla nich nowe mapy tagów.

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

Liczniki wydajności

Domyślnie eksporter metryk wysyła zestaw liczników wydajności do usługi Azure Monitor. Tę funkcję można wyłączyć, ustawiając flagę enable_standard_metrics na False w konstruktorze eksportera metryk.

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

Obecnie są wysyłane następujące liczniki wydajności:

• Dostępna pamięć (bajty)
• Czas procesora CPU (wartość procentowa)
• Szybkość żądań przychodzących (na sekundę)
• Średni czas wykonywania żądania przychodzącego (milisekundy)
• Przetwarzanie użycia procesora CPU (wartość procentowa)
• Przetwarzanie bajtów prywatnych (bajtów)

Te metryki powinny być widoczne w pliku performanceCounters. Aby uzyskać więcej informacji, zobacz Liczniki wydajności.

Modyfikowanie telemetrii

Aby uzyskać informacje na temat modyfikowania śledzonych danych telemetrycznych przed wysłaniem ich do usługi Azure Monitor, zobacz OpenCensus Python telemetrii procesorów.

Śledzenie

Uwaga

W narzędziu OpenCensus tracing odwołuje się do śledzenia rozproszonego. Parametr AzureExporter wysyła dane telemetryczne requests i dependency do usługi Azure Monitor.

1. Najpierw wygenerujmy dane śledzenia lokalnie. W pliku IDLE języka Python lub w wybranym edytorze wprowadź następujący kod:

   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. Przy każdym wpisie wartość jest drukowana w powłoce. Moduł OpenCensus języka Python generuje odpowiedni element .SpanData Projekt OpenCensus definiuje ślad jako drzewo rozpiętości.

   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. Wyświetlanie danych wyjściowych jest przydatne do celów demonstracyjnych, ale chcemy emitować SpanData dane do usługi Azure Monitor. Przekaż parametry połączenia bezpośrednio do eksportera. Możesz też określić ją w zmiennej środowiskowej . APPLICATIONINSIGHTS_CONNECTION_STRING Zalecamy użycie parametry połączenia w celu utworzenia wystąpienia eksporterów używanych do wysyłania danych telemetrycznych do usługi Application Insights. Zmodyfikuj kod z poprzedniego kroku na podstawie następującego przykładu kodu:

   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. Teraz po uruchomieniu skryptu języka Python tylko wartość jest drukowana w powłoce. Utworzony element SpanData jest wysyłany do usługi Azure Monitor. Emitowany zakres danych można znaleźć w obszarze dependencies.

   Aby uzyskać więcej informacji na temat żądań wychodzących, zobacz OpenCensus Python dependencies (Zależności języka Python openCensus). Aby uzyskać więcej informacji na temat żądań przychodzących, zobacz OpenCensus Python requests (Żądania openCensus języka Python).

Próbkowanie

Aby uzyskać informacje na temat próbkowania w usłudze OpenCensus, zobacz Próbkowanie w usłudze OpenCensus.

Korelacja śledzenia

Aby uzyskać więcej informacji na temat korelacji telemetrii w danych śledzenia, zobacz OpenCensus Python telemetria korelacji.

Modyfikowanie telemetrii

Aby uzyskać więcej informacji na temat modyfikowania śledzonych danych telemetrycznych przed wysłaniem ich do usługi Azure Monitor, zobacz OpenCensus Python telemetrii procesorów.

Konfigurowanie eksporterów usługi Azure Monitor

Jak pokazano, istnieją trzy różne eksporterzy usługi Azure Monitor, którzy obsługują usługę OpenCensus. Każdy z nich wysyła różne typy danych telemetrycznych do usługi Azure Monitor. Aby zobaczyć, jakie typy telemetrii wysyła każdy eksporter, zobacz poniższą tabelę.

Każdy eksporter akceptuje te same argumenty konfiguracji, przekazywane przez konstruktory. Informacje o każdym z nich można zobaczyć tutaj:

Telemetria eksportera	opis
connection_string	Parametry połączenia używany do nawiązywania połączenia z zasobem usługi Azure Monitor. Przejmuje priorytet nad instrumentation_key.
credential	Klasa poświadczeń używana przez uwierzytelnianie usługi Azure Active Directory. Zobacz sekcję "Uwierzytelnianie", która jest poniżej.
enable_standard_metrics	Używany dla elementu AzureMetricsExporter. Sygnalizuje eksporterowi automatyczne wysyłanie metryk licznika wydajności do usługi Azure Monitor. Wartość domyślna to True.
export_interval	Służy do określania częstotliwości eksportowania w sekundach. Wartość domyślna to 15s. W przypadku metryk musisz ustawić ją na 60 sekund lub inne agregacje metryk nie mają sensu w Eksploratorze metryk.
grace_period	Służy do określania limitu czasu zamknięcia eksporterów w sekundach. Wartość domyślna to 5s.
instrumentation_key	Klucz instrumentacji używany do nawiązywania połączenia z zasobem usługi Azure Monitor.
logging_sampling_rate	Używane w systemach AzureLogHandler i AzureEventHandler. Zapewnia częstotliwość próbkowania [0,1.0] na potrzeby eksportowania dzienników/zdarzeń. Wartość domyślna to 1.0.
max_batch_size	Określa maksymalny rozmiar telemetrii eksportowanej jednocześnie.
proxies	Określa sekwencję serwerów proxy do użycia do wysyłania danych do usługi Azure Monitor. Aby uzyskać więcej informacji, zobacz serwery proxy.
storage_path	Ścieżka do miejsca, w którym istnieje lokalny folder magazynu (niesymetryczne dane telemetryczne). Od wersji opencensus-ext-azure 1.0.3 domyślna ścieżka to katalog tymczasowy systemu operacyjnego + + opencensus-pythonyour-ikey . Przed wersją 1.0.3 domyślna ścieżka to $USER.azure + python-file-name.opencensus + + .
timeout	Określa limit czasu sieci do wysyłania danych telemetrycznych do usługi pozyskiwania w sekundach. Wartość domyślna to 10s.

Integracja z usługą Azure Functions

Aby przechwycić niestandardowe dane telemetryczne w środowiskach usługi Azure Functions, użyj rozszerzenia OpenCensus python usługi Azure Functions. Aby uzyskać więcej informacji, zobacz Przewodnik dla deweloperów języka Python usługi Azure Functions.

Uwierzytelnianie (wersja zapoznawcza)

Uwaga

Funkcja uwierzytelniania jest dostępna od opencensus-ext-azure wersji 1.1b0.

Każdy eksporter usługi Azure Monitor obsługuje konfigurację bezpiecznego wysyłania ładunków telemetrii za pośrednictwem uwierzytelniania OAuth w usłudze Azure Active Directory. Aby uzyskać więcej informacji, zobacz dokumentację uwierzytelniania.

Wyświetlanie danych za pomocą zapytań

Dane telemetryczne wysyłane z aplikacji można wyświetlić na karcie Dzienniki (Analiza).

Na liście w obszarze Aktywne:

• W przypadku danych telemetrycznych wysyłanych za pomocą eksportera śledzenia usługi Azure Monitor żądania przychodzące są wyświetlane w obszarze requests. Żądania wychodzące lub w trakcie przetwarzania są wyświetlane w obszarze dependencies.
• W przypadku danych telemetrycznych wysłanych za pomocą eksportera metryk usługi Azure Monitor wysłane metryki są wyświetlane w obszarze customMetrics.
• W przypadku danych telemetrycznych wysyłanych za pomocą eksportera dzienników usługi Azure Monitor dzienniki są wyświetlane w obszarze traces. Wyjątki są wyświetlane w obszarze exceptions.

Aby uzyskać więcej informacji na temat używania zapytań i dzienników, zobacz Dzienniki w usłudze Azure Monitor.

Konfigurowanie i włączanie uwierzytelniania opartego na identyfikatorze Entra firmy Microsoft

Uwaga

Uwierzytelnianie Entra firmy Microsoft jest dostępne tylko dla języków Python w wersji 2.7, 3.6 i 3.7. Obsługa identyfikatora Entra firmy Microsoft w zestawie SDK języka Python usługi Application Insights jest dostępna od wersji beta opencensus-ext-azure 1.1b0.

Uwaga

Zestaw OPENCensus Python SDK jest przestarzały, ale firma Microsoft obsługuje go do wycofania 30 września 2024 r. Zalecamy teraz ofertę języka Python opartą na protokole OpenTelemetry i udostępniamy wskazówki dotyczące migracji.

Skonstruuj odpowiednie poświadczenia i przekaż je do konstruktora eksportera usługi Azure Monitor. Upewnij się, że parametry połączenia został skonfigurowany przy użyciu klucza instrumentacji i punktu końcowego pozyskiwania zasobu.

OpenCensus Eksporterzy usługi Azure Monitor obsługują te typy uwierzytelniania. Zalecamy używanie tożsamości zarządzanych w środowiskach produkcyjnych.

Tożsamość zarządzana przypisana przez system

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential()
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Tożsamość zarządzana przypisana przez użytkownika

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential(client_id="<client-id>")
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Dowiedz się więcej o usłudze OpenCensus dla języka Python

• OpenCensus Python w witrynie GitHub
• Dostosowywanie
• Eksporterzy usługi Azure Monitor w usłudze GitHub
• Integracje biblioteki OpenCensus
• Przykładowe aplikacje usługi Azure Monitor

Rozwiązywanie problemów

Testowanie łączności między hostem aplikacji a usługą pozyskiwania

Zestawy SDK usługi Application Insights i agenci wysyłają dane telemetryczne, aby uzyskać pozyskane jako wywołania REST do naszych punktów końcowych pozyskiwania. Możesz przetestować łączność z serwera internetowego lub maszyny hosta aplikacji do punktów końcowych usługi pozyskiwania przy użyciu pierwotnych klientów REST z poziomu programu PowerShell lub poleceń curl. Zobacz Rozwiązywanie problemów z brakującą telemetrią aplikacji w usłudze Azure Monitor Application Insights.

Informacje o wersji

Aby uzyskać najnowsze informacje o wersji, zobacz Python Azure Monitor Exporter (Eksporter usługi Azure Monitor w języku Python)

Nasze aktualizacje usługi również podsumowują główne ulepszenia usługi Application Insights.

Następne kroki

• Aby włączyć środowiska użycia, włącz monitorowanie użytkowników w sieci Web lub przeglądarce
• Śledzenie żądań przychodzących.
• Śledzenie żądań wychodzących.
• Zapoznaj się z mapą aplikacji.
• Dowiedz się, jak wykonywać kompleksowe monitorowanie wydajności.

Alerty

• Przegląd dostępności: tworzenie testów w celu upewnienia się, że witryna jest widoczna w Internecie.
• Inteligentne diagnostyki: Te testy są uruchamiane automatycznie, więc nie trzeba wykonywać żadnych czynności, aby je skonfigurować. Ta funkcja powiadomi Cię, jeśli w aplikacji występuje nietypowa liczba nieudanych żądań.
• Alerty dotyczące metryk: ustaw alerty, aby wyświetlić ostrzeżenie, jeśli metryka przekroczy próg. Możesz je ustawić dla metryk niestandardowych, które zakodujesz w aplikacji.