Konfigurowanie Azure Monitor dla aplikacji w języku Python

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 twoich aplikacji w języku Python jest dostępne za pośrednictwem zestawu SDK Opencensus dla języka Python za pośrednictwem Azure Monitor eksportowych.

Wszystkie inne zestawy SDK telemetrii dla języka Python nie są OBSŁUGIWANE i FIRMA Microsoft NIE zaleca używania ich jako rozwiązania do telemetrii.

Być może zauważyliśmy, że opencensus jest zbieżny z openTelemetry. Jednak nadal zalecamy korzystanie z openCensus, gdy openTelemetry stopniowo się dojrzeje.

Uwaga

Dostępna jest wersja zapoznawcza języka Python oparta na języku OpenTelemetry. Dowiedz się więcej.

Wymagania wstępne

  • Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • Instalacja języka Python. W tym artykule jest używany język Python 3.7.0,chociaż inne wersje prawdopodobnie będą działać z niewielkimi zmianami. Zestaw Opencensus Python SDK obsługuje tylko język Python w wersjach 2.7 i 3.4 lub więcej.
  • Utwórz zasób Szczegółowe informacje aplikacji. Do zasobu zostanie przypisany własny klucz instrumentacji (ikey).

Wprowadzenie do zestawu Opencensus Python SDK

OpenCensus to zestaw bibliotek open source, które umożliwiają zbieranie rozproszonych danych telemetrycznych śledzenia, metryk i rejestrowania. Dzięki użyciu Azure Monitor będziemożna wysłać zebrane dane telemetryczne do usługi Application Insights. W tym artykule opracowywuje się proces konfigurowania środowisk OpenCensus i Azure Monitor w języku Python w celu wysyłania danych monitorowania do Azure Monitor.

Instrument with OpenCensus Python SDK with Azure Monitor exporters (Instrument with OpenCensus Python SDK with Azure Monitor(Instrument with OpenCensus Python SDK with Azure Monitor(Instrument with Open

Zainstaluj eksporterów opencensus Azure Monitor:

python -m pip install opencensus-ext-azure

Uwaga

W python -m pip install opencensus-ext-azure poleceniu przyjęto założenie, że dla instalacji PATH języka Python jest ustawiona zmienna środowiskowa. Jeśli ta zmienna nie została skonfigurowana, musisz podać pełną ścieżkę katalogu do miejsca, w którym znajduje się plik wykonywalny języka Python. Wynikiem jest polecenie podobne do tego: C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe -m pip install opencensus-ext-azure .

Zestaw SDK używa trzech Azure Monitor do wysyłania różnych typów danych telemetrycznych do Azure Monitor. Są to ślady, metryki i dzienniki. Aby uzyskać więcej informacji na temat tych typów telemetrii, zobacz omówienie platformy danych. Użyj poniższych instrukcji, aby wysłać te typy danych telemetrycznych za pośrednictwem trzech eksporterów.

Mapowania typu telemetrii

Oto eksporterzy udostępniani przez OpenCensus zamapowane na typy danych telemetrycznych, które są Azure Monitor.

Filar możliwości obserwacji Typ telemetrii w Azure Monitor Wyjaśnienie
Dzienniki Ślady, wyjątki, customEvents Telemetria dziennika, telemetria wyjątków, telemetria zdarzeń
Metryki customMetrics, performanceCounters Liczniki wydajności metryk niestandardowych
Śledzenie Żąda zależności Żądania przychodzące, żądania wychodzące

Dzienniki

  1. Najpierw wygenerujmy dane dziennika lokalnego.

    import logging
    
    logger = logging.getLogger(__name__)
    
    def valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  2. Kod stale pyta o wartość, która ma zostać wprowadzona. Wpis dziennika jest emitowany dla każdej wprowadzonej wartości.

    Enter a value: 24
    24
    Enter a value: 55
    55
    Enter a value: 123
    123
    Enter a value: 90
    90
    
  3. Chociaż wprowadzanie wartości jest przydatne w celach demonstracyjnych, ostatecznie chcemy emitować dane dziennika do Azure Monitor. Przekaż swoje ciągi połączenia bezpośrednio do eksportera. Można też określić ją w zmiennej środowiskowej APPLICATIONINSIGHTS_CONNECTION_STRING . Zalecamy użycie parametrów połączenia do wystąpienia eksporterów, którzy są używani do wysyłania danych telemetrycznych do usługi Application Szczegółowe informacje. Zmodyfikuj kod z poprzedniego kroku, bazując na następującym przykładzie kodu:

    import logging
    from opencensus.ext.azure.log_exporter import AzureLogHandler
    
    logger = logging.getLogger(__name__)
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    logger.addHandler(AzureLogHandler(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    )
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # logger.addHandler(AzureLogHandler())
    
    def valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  4. Eksport wysyła dane dziennika do Azure Monitor. Dane można znaleźć w obszarze traces .

    Uwaga

    W tym kontekście traces nie jest tożsamy z . tracing W tym traces miejscu odnosi się do typu telemetrii, która będzie Azure Monitor podczas korzystania z usługi AzureLogHandler . Jednak tracing odnosi się do koncepcji w opencensus i odnosi się do tracing.

    Uwaga

    Główny rejestrator jest skonfigurowany z poziomem OSTRZEŻENIE. Oznacza to, że wszystkie wysyłane dzienniki o mniejszej ważności są ignorowane i z kolei nie są wysyłane do Azure Monitor. Aby uzyskać więcej informacji, zobacz dokumentację.

  5. Możesz również dodać właściwości niestandardowe do komunikatów dziennika w argumentze dodatkowego słowa kluczowego, używając custom_dimensions pola. Te właściwości są wyświetlane jako pary klucz-wartość w customDimensions Azure Monitor.

    Uwaga

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

    import logging
    
    from opencensus.ext.azure.log_exporter import AzureLogHandler
    
    logger = logging.getLogger(__name__)
    # TODO: replace the all-zero GUID with your instrumentation key.
    logger.addHandler(AzureLogHandler(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    )
    
    properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}
    
    # Use properties in logging statements
    logger.warning('action', extra=properties)
    

Uwaga

W ramach korzystania z usługi Application Szczegółowe informacje instrumentacji danych zbieramy i wysyłamy dane diagnostyczne do firmy Microsoft. Te dane pomagają nam uruchamiać i ulepszać funkcje Szczegółowe informacje. Możesz wyłączyć zbieranie danych innych niż niezbędne. Dowiedz się więcej.

Konfigurowanie rejestrowania dla aplikacji Django

Możesz jawnie skonfigurować rejestrowanie w kodzie aplikacji, tak jak powyżej, dla aplikacji Django lub określić je w konfiguracji rejestrowania django. Ten kod może trafić do dowolnego pliku, który jest częścią konfiguracji ustawień Django. Aby dowiedzieć się, jak skonfigurować ustawienia 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",
            "instrumentation_key": "<your-ikey-here>",
         },
        "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.

import logging

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

Wysyłanie wyjątków

Język OpenCensus Python nie śledzi i nie wysyła automatycznie danych exception telemetrycznych. Są one wysyłane przy użyciu AzureLogHandler wyjątków za pośrednictwem biblioteki rejestrowania języka Python. Właściwości niestandardowe można dodawać tak samo jak w przypadku normalnego rejestrowania.

import logging

from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)
# TODO: replace the all-zero GUID with your instrumentation key.
logger.addHandler(AzureLogHandler(
    connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
)

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, to od użytkownika należy sposób, w jaki użytkownik chce rejestrować nieobsługiwane wyjątki. OpenCensus nie nakłada ograniczeń na sposób, w jaki użytkownik chce to zrobić, o ile jawnie rejestruje telemetrię wyjątku.

Wysyłanie zdarzeń

Telemetrię można wysłać dokładnie w taki sam sposób, jak w przypadku wysyłania customEventtrace danych telemetrycznych, z wyjątkiem AzureEventHandler użycia.

import logging

from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler(connection_string='InstrumentationKey=<your-instrumentation_key-here>'))
logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Próbkowanie

Aby uzyskać informacje na temat próbkowania w opencensus, zobacz próbkowanie w opencensus.

Korelacja dzienników

Aby uzyskać szczegółowe informacje na temat wzbogacania dzienników o dane kontekstu śledzenia, zobacz Integracja dzienników OpenCensus językaPython .

Modyfikowanie telemetrii

Aby uzyskać szczegółowe informacje na temat modyfikowania śledzone dane telemetryczne przed ich wysłaniem do usługi Azure Monitor, zobacz OpenCensus Python telemetry processors(Procesory telemetrii języka Python w języku OpenCensus).

Metryki

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

  • Liczba: Liczba punktów pomiarów. Wartość jest kumulowana, można ją zwiększyć i zresetować do wartości 0 tylko po ponownym uruchomieniu.
  • Suma: Suma punktów pomiarów. Wartość jest skumulowana, można ją zwiększyć i zresetować do wartości 0 po ponownym uruchomieniu.
  • LastValue: Zachowuje ostatnią zanotowane wartość, porzuca wszystkie inne.
  • Dystrybucji: Rozkład histogramu punktów pomiarów. Ta metoda NIE jest obsługiwana przez eksportera platformy Azure.

Przykład agregacji liczby

  1. Najpierw wygenerujmy kilka lokalnych danych metryk. Utworzymy prostą metrykę, aby śledzić, ile razy 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 prompt():
        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])
    
    def main():
        while True:
            prompt()
    
    if __name__ == "__main__":
        main()
    
  2. Uruchomienie kodu wielokrotnie monituje o wybranie klawisza Enter. Metryka jest tworzona w celu śledzenia, ile razy wybrano klawisz Enter. W przypadku każdego wpisu wartość jest zwiększana, a informacje o metrykach są wyświetlane w konsoli programu . Informacje obejmują bieżącą wartość i bieżący znacznik czasu, gdy metryka została zaktualizowana.

    Press enter.
    Point(value=ValueLong(5), timestamp=2019-10-09 20:58:04.930426)
    Press enter.
    Point(value=ValueLong(6), timestamp=2019-10-09 20:58:06.570167)
    Press enter.
    Point(value=ValueLong(7), timestamp=2019-10-09 20:58:07.138614)
    
  3. Chociaż wprowadzanie wartości jest przydatne w celach demonstracyjnych, ostatecznie chcemy emitować dane metryk do Azure Monitor. Przekaż swoje ciągi 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 do wystąpienia eksporterów, którzy są używani do wysyłania danych telemetrycznych do usługi Application Szczegółowe informacje. 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()
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    exporter = metrics_exporter.new_metrics_exporter(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # exporter = metrics_exporter.new_metrics_exporter()
    
    view_manager.register_exporter(exporter)
    
    def prompt():
        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])
    
    def main():
        while True:
            prompt()
    
    if __name__ == "__main__":
        main()
    
  4. Eksporter wysyła dane metryk do Azure Monitor w ustalonym interwale. Wartość domyślna to co 15 sekund. Śledzimy pojedynczą metrykę, więc te dane metryki, niezależnie od ich wartości i sygnatury czasowej, są wysyłane co interwał. Wartość jest skumulowana, można ją zwiększyć i zresetować do wartości 0 po ponownym uruchomieniu. Dane można znaleźć w obszarze , ale właściwości customMetricscustomMetrics valueCount, valueSum, valueMin, valueMax i valueStdDev nie są efektywnie używane.

Ustawianie wymiarów niestandardowych w metrykach

Zestaw SDK Opencensus dla języka Python umożliwia dodawanie wymiarów niestandardowych do telemetrii metryk za pomocą parametru , który zasadniczo jest słownikiem par tags 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 parametru określ tagi, które mają być używane podczas rejestrowania metryk w View tym widoku za pośrednictwem 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 pomiarów. Klucze tagów określone w pliku View muszą znajdować się na mapie tagów używanej do nagrywania.

    ...
    mmap = stats_recorder.new_measurement_map()
    mmap.measure_int_put(prompt_measure, 1)
    mmap.record(tmap) # <-- pass the tag map in here
    ...
    
  4. W tabeli wszystkie rekordy metryk emitowane przy użyciu funkcji customMetrics będą mieć wymiary niestandardowe prompt_view{"url":"http://example.com"} .

  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 Azure Monitor. Można to wyłączyć, ustawiając enable_standard_metrics flagę na False w konstruktorze eksportera metryk.

...
exporter = metrics_exporter.new_metrics_exporter(
  enable_standard_metrics=False,
  connection_string='InstrumentationKey=<your-instrumentation-key-here>')
...

Te liczniki wydajności są obecnie wysyłane:

  • Dostępna pamięć (w bajtach)
  • Czas procesora CPU (wartość procentowa)
  • Szybkość żądań przychodzących (na sekundę)
  • Średni czas wykonywania żądania przychodzącego (w milisekundach)
  • Użycie procesora CPU procesu (wartość procentowa)
  • Przetwarzanie bajtów prywatnych (w bajtach)

Te metryki powinny być dostępne w programie performanceCounters . Aby uzyskać więcej informacji, zobacz liczniki wydajności.

Modyfikowanie telemetrii

Aby uzyskać informacje na temat modyfikowania śledzone dane telemetryczne przed ich wysłaniiem do usługi Azure Monitor, zobacz Procesory telemetrii Języka Python w języku OpenCensus.

Śledzenie

Uwaga

W openCensus tracing odnosi się do tracing. Wysyła AzureExporter dane requestsdependency telemetryczne do Azure Monitor.

  1. Najpierw wygenerujmy lokalnie dane śledzenia. W środowisku IDLE języka Python lub w 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 valuePrompt():
        with tracer.span(name="test") as span:
            line = input("Enter a value: ")
            print(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  2. Uruchomienie kodu wielokrotnie monituje o wprowadzenie wartości. Przy każdym wpisie wartość jest drukowana w powłokie. Moduł OpenCensus języka Python generuje odpowiedni element SpanData . Projekt OpenCensus definiuje ślad jako drzewo zakresów.

    Enter a value: 4
    4
    [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)]
    Enter a value: 25
    25
    [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)]
    Enter a value: 100
    100
    [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. Chociaż wprowadzanie wartości jest przydatne w celach demonstracyjnych, ostatecznie chcemy emitować SpanData Azure Monitor. Przekaż swoje ciągi 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 do wystąpienia eksporterów, którzy są używani do wysyłania danych telemetrycznych do usługi Application Szczegółowe informacje. 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
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    tracer = Tracer(
        exporter=AzureExporter(
            connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000'),
        sampler=ProbabilitySampler(1.0),
    )
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # exporter = AzureExporter()
    
    def valuePrompt():
        with tracer.span(name="test") as span:
            line = input("Enter a value: ")
            print(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  4. Teraz po uruchomieniu skryptu języka Python nadal powinien zostać wyświetlony monit o wprowadzenie wartości, ale tylko wartość jest drukowana w powłoki. Utworzone zostaną SpanData wysłane do Azure Monitor. Emitowane dane zakresu 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 w językuOpenCensus). Aby uzyskać więcej informacji na temat żądań przychodzących, zobacz OpenCensus Python requests (Żądania OpenCensus w językuPython).

Próbkowanie

Aby uzyskać informacje na temat próbkowania w OpenCensus, zobacz próbkowanie w OpenCensus.

Korelacja śledzenia

Aby uzyskać więcej informacji na temat korelacji telemetrii w danych śledzenia, zobacz OpenCensus Python telemetry correlation(Korelacja telemetrii języka Python w języku OpenCensus).

Modyfikowanie telemetrii

Aby uzyskać więcej informacji na temat modyfikowania śledzone dane telemetryczne przed ich wysłaniiem do usługi Azure Monitor, zobacz Procesory telemetrii Języka Python w języku OpenCensus.

Konfigurowanie Azure Monitor eksportu

Jak pokazano, istnieją trzy różne Azure Monitor, które obsługują OpenCensus. Każdy z nich wysyła różne typy danych telemetrycznych do Azure Monitor. Aby zobaczyć, jakie typy danych telemetrycznych wysyła każdy eksporter, zobacz następującą listę.

Każdy eksporter akceptuje te same argumenty dla konfiguracji przekazywane przez konstruktory. Szczegółowe informacje o każdym z nich można znaleźć tutaj:

  • connection_string: ciąg połączenia używany do nawiązywania połączenia z Azure Monitor zasobem. Ma priorytet nad instrumentation_key .
  • enable_standard_metrics: używany AzureMetricsExporter dla . Sygnalizuje eksporterowi automatyczne wysyłanie metryk liczników wydajności do Azure Monitor. Wartość domyślna to True .
  • export_interval: służy do określania częstotliwości eksportowania w sekundach.
  • instrumentation_key: klucz instrumentacji używany do nawiązywania połączenia Azure Monitor zasobem.
  • logging_sampling_rate: używany AzureLogHandler dla . Udostępnia częstotliwość próbkowania [0,1.0] dla eksportowania dzienników. Wartość domyślna to 1.0.
  • max_batch_size: określa maksymalny rozmiar danych telemetrycznych, które są eksportowane jednocześnie.
  • proxies: określa sekwencję serwerów proxy do użycia w celu wysyłania danych do Azure Monitor. Aby uzyskać więcej informacji, zobacz proxy.
  • storage_path: ścieżka do lokalizacji, w której znajduje się folder magazynu lokalnego (niezasyłana telemetria). Od wersji opencensus-ext-azure 1.0.3 domyślną ścieżką jest katalog tymczasowy systemu operacyjnego + opencensus-python + your-ikey . W wersjach wcześniejszych niż 1.0.3 ścieżka domyślna to $USER + .opencensus + .azure + python-file-name .

Uwierzytelnianie (wersja zapoznawcza)

Uwaga

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

Każdy z Azure Monitor obsługuje konfigurację bezpiecznego wysyłania ładunków telemetrycznych za pośrednictwem uwierzytelniania OAuth za pomocą Azure Active Directory (AAD). Aby uzyskać więcej informacji, zapoznaj się z dokumentacją dotyczącą uwierzytelniania.

Wyświetlanie danych za pomocą zapytań

Dane telemetryczne wysłane z aplikacji można wyświetlić za pomocą karty Dzienniki (analiza).

Zrzut ekranu przedstawiający okienko przeglądu z wybraną czerwoną oknie

Na liście w obszarze Aktywne:

  • W przypadku telemetrii wysyłanej Azure Monitor danych śledzenia żądania przychodzące są wyświetlane w obszarze requests . Żądania wychodzące lub w trakcie przetwarzania są wyświetlane w obszarze dependencies .
  • W przypadku telemetrii wysyłanej z Azure Monitor metryki metryki są wyświetlane w obszarze customMetrics .
  • W przypadku telemetrii wysyłanej Azure Monitor eksportu dzienniki są wyświetlane w obszarze traces . Wyjątki są wyświetlane w obszarze exceptions .

Aby uzyskać bardziej szczegółowe informacje na temat używania zapytań i dzienników, zobacz Dzienniki w Azure Monitor.

Dowiedz się więcej o środowisku OpenCensus for Python

Następne kroki

Alerty

  • Testy dostępności: Utwórz testy, aby upewnić się, że Twoja witryna jest widoczna w sieci Web.
  • 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ącemetryk: ustaw alerty, aby ostrzec, jeśli metryka przekroczy próg. Możesz je ustawić dla metryk niestandardowych, które zakodujesz w aplikacji.