Konfigurowanie usługi Azure Monitor dla aplikacji języka Python

Uwaga

Zestaw OpenCensus Python SDK jest przestarzały, ale firma Microsoft obsługuje go do wycofania 30 września 2024 r. Teraz 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 openCensus, podczas gdy openTelemetry stopniowo dojrzałe.

Wymagania wstępne

Potrzebujesz subskrypcji 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 parametrów połączenia w celu skorzystania z nowych możliwości.

Wprowadzenie do zestawu OpenCensus Python SDK

OpenCensus to zestaw bibliotek typu open source, który umożliwia zbieranie rozproszonych danych telemetrycznych, metryk i rejestrowania. Za pomocą eksporterów usługi Azure Monitor można 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 OpenCensus Python SDK 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. Są to trace, 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 telemetrii za pośrednictwem trzech eksporterów.

Mapowania typów telemetrii

Narzędzie 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, niestandardowe elementy	Dane telemetryczne dzienników, dane telemetryczne 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 APPLICATIONINSIGHTS_CONNECTION_STRINGśrodowiskowej . Można również przekazać connection_string bezpośrednio do AzureLogHandlerelementu , ale parametry połączenia nie powinny być dodawane do kontroli wersji.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Zalecamy użycie parametrów 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 odnosi się do typu danych telemetrycznych wyświetlanych w usłudze Azure Monitor podczas korzystania z usługi AzureLogHandler. Odnosi się jednak tracing do koncepcji w rozwiązaniu OpenCensus i odnosi się do śledzenia rozproszonego.

   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ę rejestrowania.

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

   Uwaga

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

   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. Możesz wyłączyć zbieranie danych, które nie są niezbędne. Aby dowiedzieć się więcej, zobacz Statystykibeat w usłudze Application Insights.

Konfigurowanie rejestrowania dla aplikacji Django

Rejestrowanie można skonfigurować jawnie w kodzie aplikacji, tak jak poprzednio 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ń 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 takiej samej nazwie jak określona 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 jest automatycznie śledzony i wysyła dane telemetryczne exception . Jest ona wysyłana przy AzureLogHandler użyciu 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ż wyjątki należy rejestrować jawnie, należy zarejestrować nieobsługiwane wyjątki. Funkcja OpenCensus nie nakłada ograniczeń dotyczących sposobu rejestrowania, ale należy jawnie rejestrować dane telemetryczne wyjątków.

Wysyłanie zdarzeń

Dane telemetryczne można wysyłać customEvent w taki sam sposób, jak dane trace 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 pliku 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 programem OpenCensus.

Modyfikowanie danych telemetrycznych

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

Funkcja 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 tylko zwiększyć i resetuje wartość 0 po ponownym uruchomieniu.
• Suma: suma punktów pomiaru. Wartość jest skumulowana, może tylko zwiększyć 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 zliczaj

1. Najpierw wygenerujmy dane metryk lokalnych. Tworzymy metrykę, aby śledzić liczbę razy, po których użytkownik wybierze klawisz 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. Po każdym wpisie 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 parametrów 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. Tę wartość należy ustawić na 60 sekund, ponieważ zaplecze usługi Application Insights zakłada agregację punktów metryk w 60-sekundowym interwale czasu. Śledzimy jedną 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 niestandardowych wymiarów 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. W przypadku 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 miary. 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 prompt_view mają niestandardowe wymiary {"url":"http://example.com"}.

5. Aby wygenerować tagi o różnych wartościach 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 (procent)
• Częstotliwość żądań przychodzących (na sekundę)
• Średni czas wykonania żądania przychodzącego (milisekundy)
• Przetwarzanie użycia procesora CPU (procent)
• Przetwarzanie bajtów prywatnych (bajtów)

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

Modyfikowanie danych telemetrycznych

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 pliku tracing OpenCensus odnosi się do śledzenia rozproszonego. Parametr AzureExporter wysyła requests i dependency telemetria do usługi Azure Monitor.

1. Najpierw wygenerujmy dane śledzenia lokalnie. W języku Python IDLE lub 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. Po 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 w celach demonstracyjnych, ale chcemy emitować dane do SpanData 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 parametrów 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 SpanData element jest wysyłany do usługi Azure Monitor. Emitowane dane 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 języka Python OpenCensus).

Próbkowanie

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

Korelacja śledzenia

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

Modyfikowanie danych telemetrycznych

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 eksportery usługi Azure Monitor, które 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żdej z nich można wyświetlić tutaj:

Telemetria eksportera	Opis
connection_string	Parametry połączenia używane do nawiązywania połączenia z zasobem usługi Azure Monitor. Przejmie 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	Służy do obsługi AzureMetricsExporter. Wysyła sygnały eksportera do automatycznego wysyłania 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 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żywany dla 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 danych telemetrycznych eksportowanych 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 (niesprawne dane telemetryczne). opencensus-ext-azure Od wersji 1.0.3 domyślna ścieżka to katalog tymczasowy systemu operacyjnego + + opencensus-pythonyour-ikey . Przed 1.0.3 domyślną ścieżką jest $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 Azure Functions

Aby przechwytywać niestandardowe dane telemetryczne w środowiskach Azure Functions, użyj rozszerzenia OpenCensus Python Azure Functions. Aby uzyskać więcej informacji, zobacz przewodnik dewelopera Azure Functions Python.

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 telemetrycznych 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ć za pomocą karty 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 procesie są wyświetlane w obszarze dependencies.
• W przypadku telemetrii wysłanej za pomocą eksportera metryk usługi Azure Monitor 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.

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 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 nieprzetworzonych 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.

Uwagi do wersji

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

Nasza usługa Aktualizacje również podsumować główne ulepszenia usługi Application Insights.

Następne kroki

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

Alerty

• Omówienie 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.