Nastavení Služby Azure Monitor pro aplikaci v Pythonu

Poznámka

Sada OpenCensus Python SDK je zastaralá, ale Microsoft ji podporuje až do vyřazení 30. září 2024. Nyní doporučujeme nabídku Pythonu založenou na OpenTelemetry a poskytujeme pokyny k migraci.

Azure Monitor podporuje distribuované trasování, shromažďování metrik a protokolování aplikací v Pythonu.

Podporované řešení Microsoftu pro sledování a export dat pro aplikace Pythonu je prostřednictvím sady OpenCensus Python SDK prostřednictvím nástrojů pro exporty azure monitoru.

Microsoft nedoporučuje jako řešení telemetrie používat žádné jiné sady SDK pro telemetrii pro Python, protože nejsou podporované.

OpenCensus konverguje do OpenTelemetry. I nadále doporučujeme OpenCensus, zatímco OpenTelemetry postupně zraje.

Požadavky

Potřebujete předplatné Azure. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet.

Poznámka

Podpora příjmu dat založeného na instrumentačním klíči skončí 31. března 2025. Příjem dat instrumentačního klíče bude dál fungovat, ale už nebudeme pro tuto funkci poskytovat aktualizace ani podporu. Přejděte na připojovací řetězce , abyste mohli využívat nové možnosti.

Představení sady OpenCensus Python SDK

OpenCensus je sada opensourcových knihoven, které umožňují shromažďování distribuovaných trasování, metrik a protokolování telemetrie. Pomocí exportérů služby Azure Monitor můžete tuto shromážděnou telemetrii odeslat do Application Insights. Tento článek vás provede procesem nastavení exportérů OpenCensus a Azure Monitoru pro Python pro odesílání dat monitorování do služby Azure Monitor.

Instrumentace s OpenCensus Python SDK s využitím exportérů Azure Monitoru

Nainstalujte exportéry OpenCensus pro Azure Monitor:

python -m pip install opencensus-ext-azure

Sada SDK používá k odesílání různých typů telemetrie do služby Azure Monitor tři exportéry služby Azure Monitor. Jsou to trace, metricsa logs. Další informace o těchto typech telemetrie najdete v tématu Přehled datové platformy. Pomocí následujících pokynů odešlete tyto typy telemetrie prostřednictvím tří exportérů.

Mapování typů telemetrie

OpenCensus mapuje následující exportéry na typy telemetrie, které vidíte ve službě Azure Monitor.

Pilíř pozorovatelnosti	Typ telemetrie ve službě Azure Monitor	Vysvětlení
Protokoly	Trasování, výjimky, customEvents	Telemetrie protokolů, telemetrie výjimek, telemetrie událostí
Metriky	customMetrics, performanceCounters	Čítače výkonu vlastních metrik
Trasování	Závislosti požadavků	Příchozí požadavky, odchozí žádosti

Protokoly

1. Nejprve vygenerujme data místního protokolu.

   
   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. Pro každé číslo v rozsahu se vygeneruje položka protokolu.

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

3. Chceme, aby se tato data protokolů zobrazovala ve službě Azure Monitor. Můžete ho zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . Můžete také předat connection_string přímo do AzureLogHandler, ale připojovací řetězce by se neměly přidávat do správy verzí.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   K vytvoření instance exportérů, které se používají k odesílání telemetrie do Application Insights, doporučujeme použít připojovací řetězec. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   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. Exportér odesílá data protokolu do služby Azure Monitor. Data najdete v části traces.

   V tomto kontextu traces není totéž jako tracing. Tady odkazuje na typ telemetrie, traces která se zobrazí ve službě Azure Monitor, když využíváte AzureLogHandler. Ale tracing odkazuje na koncept v OpenCensus a souvisí s distribuovaným trasováním.

   Poznámka

   Kořenový protokolovací nástroj je nakonfigurovaný s úrovní warning. To znamená, že všechny protokoly, které odešlete a které mají menší závažnost, se ignorují a nebudou odesílány do služby Azure Monitor. Další informace najdete v dokumentaci k protokolování.

5. Pomocí pole můžete také přidat vlastní vlastnosti do zpráv protokolu v argumentu extra klíčového custom_dimensions slova. Tyto vlastnosti se ve customDimensions službě Azure Monitor zobrazují jako páry klíč-hodnota.

   Poznámka

   Aby tato funkce fungovala, musíte do custom_dimensions pole předat slovník. Pokud předáte argumenty jakéhokoli jiného typu, protokolovací nástroj 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)
   

Poznámka

V rámci instrumentace Application Insights shromažďujeme a odesíláme diagnostická data do Microsoftu. Tato data nám pomáhají spouštět a vylepšovat Application Insights. Máte možnost zakázat shromažďování dat, která nejsou nezbytná. Další informace najdete v tématu Statsbeat v Application Insights.

Konfigurace protokolování pro aplikace Django

Protokolování můžete nakonfigurovat explicitně v kódu aplikace jako v předchozím příkladu pro aplikace Django, nebo ho můžete zadat v konfiguraci protokolování Django. Tento kód může jít do libovolného souboru, který používáte pro konfiguraci nastavení webu Django, obvykle settings.py.

Informace o konfiguraci nastavení Django najdete v tématu Nastavení Django. Další informace o konfiguraci protokolování najdete v tématu Protokolování 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"]},
    },
}

Ujistěte se, že používáte protokolovací nástroj se stejným názvem, jaký jste zadali ve vaší konfiguraci.

# views.py

import logging
from django.shortcuts import request

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

Odesílání výjimek

OpenCensus Python nesleduje a neodesílá exception telemetrii automaticky. Odesílá se prostřednictvím AzureLogHandler výjimek prostřednictvím knihovny protokolování Pythonu. Vlastní vlastnosti můžete přidat stejně jako u běžného protokolování.

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)

Vzhledem k tomu, že výjimky musíte protokolovat explicitně, je na vás, jak protokolovat neošetřené výjimky. OpenCensus neuvádí omezení, jak toto protokolování provést, ale musíte explicitně protokolovat telemetrii výjimek.

Odesílání událostí

Telemetrii můžete posílat customEvent úplně stejným způsobem, jakým odesíláte trace telemetrická data, s tím rozdílem, že místo toho použijete příkaz 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!')

Vzorkování

Informace o vzorkování v OpenCensus najdete v tématu Vzorkování v OpenCensus.

Korelace protokolů

Informace o tom, jak rozšířit protokoly o kontextová data trasování, najdete v tématu Integrace protokolů Pythonu OpenCensus.

Úprava telemetrie

Informace o tom, jak upravit sledované telemetrie před jejím odesláním do služby Azure Monitor, najdete v tématu Procesory telemetrie Python OpenCensus.

Metriky

OpenCensus.stats podporuje čtyři metody agregace, ale poskytuje částečnou podporu pro Azure Monitor:

• Počet: Počet bodů měření. Hodnota je kumulativní, může se pouze zvýšit a při restartování se resetuje na 0.
• Součet: Součet měrných bodů. Hodnota je kumulativní, může se pouze zvýšit a při restartování se resetuje na 0.
• LastValue: Zachová poslední zaznamenanou hodnotu a zahodí všechno ostatní.
• Distribuce: Exportér Azure nepodporuje histogramy rozdělení měrných bodů.

Příklad agregace počtu

1. Nejprve vygenerujme data místních metrik. Vytvoříme metriku, která sleduje, kolikrát uživatel vybral klávesu 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. Metriky se vytvářejí pro sledování mnohokrát. S každou položkou se hodnota navyšuje a informace o metrikách se zobrazí v konzole nástroje . Informace zahrnují aktuální hodnotu a aktuální časové razítko, kdy byla metrika aktualizována.

   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. Zadávání hodnot je užitečné pro demonstrační účely, ale chceme generovat data metrik do služby Azure Monitor. Předejte připojovací řetězec přímo do exportéru. Nebo ho můžete zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . K vytvoření instance exportérů, které se používají k odesílání telemetrie do Application Insights, doporučujeme použít připojovací řetězec. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   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. Exportér odesílá data metrik do služby Azure Monitor v pevně stanoveném intervalu. Tuto hodnotu musíte nastavit na 60 sekund, protože back-end Application Insights předpokládá agregaci bodů metrik v 60sekundovém časovém intervalu. Sledujeme jednu metriku, takže tato data metriky s libovolnou hodnotou a časovým razítkem, která obsahují, se odesílají v každém intervalu. Data jsou kumulativní, můžou se pouze zvýšit a při restartování se resetují na 0.

   Data najdete v části customMetrics, ale customMetrics vlastnosti valueCount, valueSum, valueMin, valueMaxa valueStdDev se efektivně nepoužívají.

Nastavení vlastních dimenzí v metrikách

OpenCensus Python SDK umožňuje přidat do telemetrie metrik vlastní dimenze pomocí tags, které se podobají slovníku párů klíč-hodnota.

1. Vložte značky, které chcete použít, do mapy značek. Mapa značek funguje jako druh "fondu" všech dostupných značek, které můžete použít.

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

2. U konkrétního Viewparametru zadejte značky, které chcete použít při záznamu metrik s tímto zobrazením, a to prostřednictvím klíče značky.

   ...
   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. Při záznamu do mapy měření nezapomeňte použít mapu značek. Klíče značek zadané v View souboru musí být nalezeny v mapě značek použité k záznamu.

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

4. customMetrics V tabulce mají všechny záznamy metrik generované pomocí prompt_view vlastní dimenze {"url":"http://example.com"}.

5. Pokud chcete vytvořit značky s různými hodnotami pomocí stejných klíčů, vytvořte pro ně nové mapy značek.

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

Čítače výkonu

Ve výchozím nastavení exportér metrik odesílá sadu čítačů výkonu do služby Azure Monitor. Tuto možnost můžete zakázat tak, že enable_standard_metrics v konstruktoru exportéru metrik nastavíte příznak na False .

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

Aktuálně se odesílají následující čítače výkonu:

• Dostupná paměť (bajty)
• Čas procesoru CPU (procento)
• Frekvence příchozích požadavků (za sekundu)
• Průměrná doba provádění příchozích požadavků (milisekundy)
• Využití procesoru procesu (procento)
• Zpracování privátních bajtů (bajtů)

Tyto metriky byste měli vidět v performanceCounters. Další informace najdete v tématu Čítače výkonu.

Úprava telemetrie

Informace o tom, jak upravit sledované telemetrie před jejím odesláním do služby Azure Monitor, najdete v tématu Procesory telemetrie Python OpenCensus.

Trasování

Poznámka

V OpenCensus tracing odkazuje na distribuované trasování. Parametr AzureExporter odesílá requestsdependency telemetrii do služby Azure Monitor.

1. Nejprve vygenerujme nějaká data trasování místně. Do pole Python IDLE nebo editoru podle vašeho výběru zadejte následující kód:

   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. S každou položkou se hodnota vytiskne do prostředí. Modul OpenCensus Python vygeneruje odpovídající část souboru SpanData. Projekt OpenCensus definuje trasování jako strom 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. Zobrazení výstupu je užitečné pro demonstrační účely, ale chceme vygenerovat SpanData výstup do služby Azure Monitor. Předejte připojovací řetězec přímo do exportéru. Nebo ho můžete zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . K vytvoření instance exportérů, které se používají k odesílání telemetrie do Application Insights, doporučujeme použít připojovací řetězec. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   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. Když teď spustíte skript Pythonu, vytiskne se v prostředí jenom hodnota. Vytvořený SpanData soubor se odešle do Služby Azure Monitor. Vygenerované údaje o rozsahu najdete v části dependencies.

   Další informace o odchozích požadavcích najdete v tématu Závislosti Pythonu openCensus. Další informace o příchozích požadavcích najdete v tématu Žádosti Pythonu o OpenCensus.

Vzorkování

Informace o vzorkování v OpenCensus najdete v tématu Vzorkování v OpenCensus.

Korelace trasování

Další informace o korelaci telemetrie v datech trasování najdete v tématu Korelace telemetrie OpenCensus v Pythonu.

Úprava telemetrie

Další informace o tom, jak upravit sledovanou telemetrii před jejím odesláním do služby Azure Monitor, najdete v tématu Procesory telemetrie Pythonu OpenCensus.

Konfigurace exportérů azure monitoru

Jak je znázorněno, existují tři různé exportéry služby Azure Monitor, které podporují OpenCensus. Každý z nich odesílá do Azure Monitoru různé typy telemetrie. Pokud chcete zjistit, jaké typy telemetrie jednotlivé exportéry odesílají, podívejte se do následující tabulky.

Každý exportér přijímá stejné argumenty pro konfiguraci, které se předávají prostřednictvím konstruktorů. Informace o každé z nich najdete tady:

Telemetrie exportu	Description
connection_string	Připojovací řetězec použitý k připojení k vašemu prostředku služby Azure Monitor. Má přednost před instrumentation_key.
credential	Třída credential používaná ověřováním Azure Active Directory. Projděte si část Ověřování, která následuje.
enable_standard_metrics	Používá se pro AzureMetricsExporter. Signalizuje exportéru, aby automaticky odeslal metriky čítače výkonu do služby Azure Monitor. Výchozí hodnota je True.
export_interval	Slouží k určení frekvence exportu v sekundách. Výchozí hodnota je 15s. U metrik musíte nastavit 60 sekund, jinak agregace metrik nebudou v Průzkumníku metrik dávat smysl.
grace_period	Slouží k určení časového limitu pro vypnutí vývozců v sekundách. Výchozí hodnota je 5s.
instrumentation_key	Instrumentační klíč použitý k připojení k prostředku služby Azure Monitor.
logging_sampling_rate	Používá se pro AzureLogHandler a AzureEventHandler. Poskytuje vzorkovací frekvenci [0,1.0] pro export protokolů nebo událostí. Výchozí hodnota je 1.0.
max_batch_size	Určuje maximální velikost telemetrie, která se exportuje najednou.
proxies	Určuje posloupnost proxy serverů, které se mají použít k odesílání dat do služby Azure Monitor. Další informace najdete v tématu proxy.
storage_path	Cesta k místu, kde existuje složka místního úložiště (neodpojovaná telemetrie). Od verze opencensus-ext-azure 1.0.3 je výchozí cestou dočasný adresář operačního systému + + opencensus-pythonyour-ikey . Výchozí cesta před verzí 1.0.3 je $USER.azure + python-file-name.opencensus + + .
timeout	Určuje časový limit sítě pro odesílání telemetrie do služby příjmu dat v sekundách. Výchozí hodnota je 10s.

Integrace s Azure Functions

Pokud chcete zachytit vlastní telemetrii v Azure Functions prostředích, použijte rozšíření OpenCensus Python Azure Functions. Další informace najdete v příručce pro vývojáře Azure Functions Pythonu.

Ověřování (Preview)

Poznámka

Funkce ověřování je dostupná od opencensus-ext-azure verze 1.1b0.

Každý z exportérů služby Azure Monitor podporuje konfiguraci zabezpečeného odesílání datových částí telemetrie prostřednictvím ověřování OAuth pomocí Azure Active Directory. Další informace najdete v dokumentaci k ověřování.

Zobrazení dat pomocí dotazů

Telemetrická data odeslaná z vaší aplikace můžete zobrazit na kartě Protokoly (Analytics).

V seznamu v části Aktivní:

• Pro telemetrii odeslanou pomocí exportéru trasování Služby Azure Monitor se příchozí požadavky zobrazí v části requests. Odchozí nebo procesní požadavky se zobrazí v části dependencies.
• Pro telemetrii odeslanou exportérem metrik Azure Monitoru se odeslané metriky zobrazí v části customMetrics.
• V případě telemetrie odesílané pomocí exportéru protokolů služby Azure Monitor se protokoly zobrazí v části traces. Výjimky se zobrazí v části exceptions.

Další informace o používání dotazů a protokolů najdete v tématu Protokoly ve službě Azure Monitor.

Další informace o OpenCensus pro Python

• OpenCensus Python na GitHubu
• Přizpůsobení
• Exportéři služby Azure Monitor na GitHubu
• Integrace OpenCensus
• Ukázkové aplikace Azure Monitoru

Poradce při potížích

Testování připojení mezi hostitelem aplikace a službou příjmu dat

Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovaly jako volání REST do našich koncových bodů příjmu dat. Připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby příjmu dat můžete otestovat pomocí nezpracovaných klientů REST z PowerShellu nebo příkazů curl. Viz Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.

Zpráva k vydání verze

Nejnovější poznámky k verzi najdete v tématu Exportér služby Azure Monitor v Pythonu.

Naše Aktualizace služeb také shrnuje hlavní vylepšení Application Insights.

Další kroky

• Pokud chcete povolit používání, povolte monitorování uživatelů webu nebo prohlížeče.
• Sledujte příchozí požadavky.
• Sledování odchozích požadavků
• Podívejte se na mapu aplikace.
• Přečtěte si, jak provádět komplexní monitorování výkonu.

Výstrahy

• Přehled dostupnosti: Vytvořte testy, abyste měli jistotu, že je váš web viditelný na webu.
• Inteligentní diagnostika: Tyto testy se spouštějí automaticky, takže je nemusíte nijak nastavovat. Upozorní vás, pokud má aplikace nezvykle velký podíl neúspěšných požadavků.
• Upozornění na metriky: Nastavte upozornění, která vás upozorní, pokud metrika překročí prahovou hodnotu. Upozornění můžete nastavit u vlastních metrik, které v aplikaci naprogramujete.