Nastavení Azure Monitor pro aplikaci PythonSet up Azure Monitor for your Python application

Azure Monitor podporuje distribuované trasování, shromažďování metrik a protokolování aplikací Pythonu prostřednictvím integrace s OpenCensus.Azure Monitor supports distributed tracing, metric collection, and logging of Python applications through integration with OpenCensus. Tento článek vás provede procesem nastavení OpenCensus pro Python a odeslání dat monitorování do Azure Monitor.This article walks you through the process of setting up OpenCensus for Python and sending your monitoring data to Azure Monitor.

PožadavkyPrerequisites

  • Předplatné Azure.An Azure subscription. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet.If you don't have an Azure subscription, create a free account before you begin.
  • Instalace PythonuPython installation. Tento článek používá Python 3.7.0, i když jiné verze budou nejspíš fungovat s menšími změnami.This article uses Python 3.7.0, although other versions will likely work with minor changes. Sada SDK podporuje pouze Python v 2.7 a v 3.4-v 3.7.The SDK only supports Python v2.7 and v3.4-v3.7.
  • Vytvořte prostředekApplication Insights.Create an Application Insights resource. K vašemu prostředku budete mít přiřazený vlastní klíč instrumentace (ikey).You'll be assigned your own instrumentation key (ikey) for your resource.

Instrumentace se sadou OpenCensus Python SDK pro Azure MonitorInstrument with OpenCensus Python SDK for Azure Monitor

Instalace OpenCensus Azure Monitor vývozců:Install the OpenCensus Azure Monitor exporters:

python -m pip install opencensus-ext-azure

Úplný seznam balíčků a integrací najdete v tématu OpenCensus Packages.For a full list of packages and integrations, see OpenCensus packages.

Poznámka

python -m pip install opencensus-ext-azurePříkaz předpokládá, že máte PATH nastavenou proměnnou prostředí pro instalaci Pythonu.The python -m pip install opencensus-ext-azure command assumes that you have a PATH environment variable set for your Python installation. Pokud jste tuto proměnnou nenakonfigurovali, musíte zadat úplnou cestu k adresáři, kde se nachází spustitelný soubor Pythonu.If you haven't configured this variable, you need to give the full directory path to where your Python executable is located. Výsledkem je příkaz podobný tomuto: C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe -m pip install opencensus-ext-azure .The result is a command like this: C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe -m pip install opencensus-ext-azure.

Sada SDK používá tři Azure Monitor vývozců k posílání různých typů telemetrie do Azure Monitor.The SDK uses three Azure Monitor exporters to send different types of telemetry to Azure Monitor. Jedná se o trasování, metriky a protokoly.They're trace, metrics, and logs. Další informace o těchto typech telemetrie najdete v tématu Přehled datové platformy.For more information on these telemetry types, see the data platform overview. Pomocí následujících pokynů můžete odeslat tyto typy telemetrie prostřednictvím tří vývozců.Use the following instructions to send these telemetry types via the three exporters.

Mapování typů telemetrieTelemetry type mappings

Tady jsou vývozci, kteří OpenCensus poskytují mapování na typy telemetrie, které vidíte v Azure Monitor.Here are the exporters that OpenCensus provides mapped to the types of telemetry that you see in Azure Monitor.

Pilíř pro pozorováníPillar of observability Typ telemetrie v Azure MonitorTelemetry type in Azure Monitor VysvětleníExplanation
ProtokolyLogs Trasování, výjimky, customEventsTraces, exceptions, customEvents Telemetrie protokolů, telemetrie výjimek, telemetrie událostíLog telemetry, exception telemetry, event telemetry
MetrikyMetrics customMetrics, čítače výkonucustomMetrics, performanceCounters Čítače výkonu vlastních metrikCustom metrics performance counters
TrasováníTracing Požadavky na závislostiRequests dependencies Příchozí požadavky, odchozí požadavkyIncoming requests, outgoing requests

ProtokolyLogs

  1. Nejdřív vygenerujeme některá místní data protokolu.First, let's generate some local log data.

    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. Kód průběžně žádá o zadání hodnoty.The code continuously asks for a value to be entered. Záznam protokolu je vygenerován pro každou zadanou hodnotu.A log entry is emitted for every entered value.

    Enter a value: 24
    24
    Enter a value: 55
    55
    Enter a value: 123
    123
    Enter a value: 90
    90
    
  3. I když zadáním hodnot je užitečné pro demonstrační účely, nakonec chceme vygenerovat data protokolu pro Azure Monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit the log data to Azure Monitor. Předání připojovacího řetězce přímo do vývozce.Pass your connection string directly into the exporter. Nebo ji můžete zadat v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING .Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Upravte kód z předchozího kroku na základě následujícího příkladu kódu:Modify your code from the previous step based on the following code sample:

    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')
    )
    
    def valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  4. Exportér odesílá data protokolu do Azure Monitor.The exporter sends log data to Azure Monitor. Data můžete najít v části traces .You can find the data under traces.

    Poznámka

    V tomto kontextu traces není stejný jako tracing .In this context, traces isn't the same as tracing. Tady traces odkazuje na typ telemetrie, který se zobrazí v Azure monitor při využití AzureLogHandler .Here, traces refers to the type of telemetry that you'll see in Azure Monitor when you utilize AzureLogHandler. Ale tracing odkazuje na koncept v OpenCensus a vztahuje se na distribuované trasování.But tracing refers to a concept in OpenCensus and relates to distributed tracing.

    Poznámka

    Kořenový protokolovací nástroj je nakonfigurovaný s úrovní upozornění.The root logger is configured with the level of WARNING. To znamená, že všechny protokoly, které odesíláte méně závažnosti, se ignorují a pak se nebudou odesílat do Azure Monitor.That means any logs that you send that have less of a severity are ignored, and in turn, won't be sent to Azure Monitor. Další informace najdete v dokumentaci.For more information, see documentation.

  5. Pomocí pole custom_dimensions můžete do svých zpráv protokolu přidat také vlastní vlastnosti v argumentu klíčového slova extra .You can also add custom properties to your log messages in the extra keyword argument by using the custom_dimensions field. Tyto vlastnosti se zobrazí jako páry klíč-hodnota v customDimensions v Azure monitor.These properties appear as key-value pairs in customDimensions in Azure Monitor.

    Poznámka

    Aby tato funkce fungovala, musíte do pole custom_dimensions předat slovník.For this feature to work, you need to pass a dictionary to the custom_dimensions field. Pokud předáte argumenty jiného typu, protokolovací nástroj je ignoruje.If you pass arguments of any other type, the logger ignores them.

    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)
    

Konfigurace protokolování pro aplikace DjangoConfigure logging for Django applications

Protokolování můžete nakonfigurovat explicitně v kódu aplikace, jak je uvedeno výše pro aplikace Django, nebo můžete zadat v konfiguraci protokolování Django.You can configure logging explicitly in your application code like above for your Django applications, or you can specify it in Django's logging configuration. Tento kód může přejít do libovolného souboru, který používáte pro konfiguraci nastavení Django.This code can go into whatever file you use for Django settings configuration. Postup konfigurace nastavení Django najdete v tématu Nastavení Django.For how to configure Django settings, see Django settings. Další informace o konfiguraci protokolování najdete v tématu protokolování Django.For more information on configuring logging, see Django logging.

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

Ujistěte se, že používáte protokolovací nástroj se stejným názvem, jaký je zadaný ve vaší konfiguraci.Be sure you use the logger with the same name as the one specified in your configuration.

import logging

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

Odeslat výjimkySend exceptions

OpenCensus Python automaticky nesleduje a neposílá exception telemetrii.OpenCensus Python doesn't automatically track and send exception telemetry. Odesílají se prostřednictvím AzureLogHandler pomocí výjimek prostřednictvím knihovny protokolování Pythonu.They're sent through AzureLogHandler by using exceptions through the Python logging library. Vlastní vlastnosti můžete přidat stejně jako u normálního protokolování.You can add custom properties just like with normal logging.

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)

Vzhledem k tomu, že je nutné výjimky protokolovat explicitně, je až uživateli, jak chce protokolovat neošetřené výjimky.Because you must log exceptions explicitly, it's up to the user how they want to log unhandled exceptions. OpenCensus neumísťuje omezení na to, jak to uživatel chce udělat, pokud explicitně protokolují telemetrii výjimek.OpenCensus doesn't place restrictions on how a user wants to do this, as long as they explicitly log an exception telemetry.

Odesílání událostíSend events

Telemetrii můžete poslat customEvent přesně stejným způsobem jako trace telemetrii, s výjimkou použití AzureEventHandler místo toho.You can send customEvent telemetry in exactly the same way that you send trace telemetry except by using AzureEventHandler instead.

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

VzorkováníSampling

Informace o vzorkování v OpenCensus se podíváme na vzorkování v OpenCensus.For information on sampling in OpenCensus, take a look at sampling in OpenCensus.

Korelace protokolůLog correlation

Podrobnosti o tom, jak rozšířit protokoly pomocí dat kontextu trasování, najdete v tématu OpenCensus Python logs Integration.For details on how to enrich your logs with trace context data, see OpenCensus Python logs integration.

Úprava telemetrieModify telemetry

Podrobnosti o tom, jak upravit sledovanou telemetrii před odesláním do Azure Monitor, najdete v tématu OpenCensus Python telemetrie.For details on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

MetrikyMetrics

  1. Nejdřív vygenerujeme některá místní data metriky.First, let's generate some local metric data. Vytvoříme jednoduchou metriku pro sledování počtu, kolikrát uživatel vybere klíč ENTER .We'll create a simple metric to track the number of times the user selects the Enter key.

    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. Spuštění kódu opakovaně vyzve k výběru ENTER.Running the code repeatedly prompts you to select Enter. Vytvoří se metrika, která sleduje počet vybraných časů zadání .A metric is created to track the number of times Enter is selected. U každé položky se hodnota zvýší a v konzole se zobrazí informace o metrikách.With each entry, the value is incremented and the metric information appears in the console. Informace obsahují aktuální hodnotu a aktuální časové razítko při aktualizaci metriky.The information includes the current value and the current time stamp when the metric was updated.

    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. I když zadáním hodnot je užitečné pro demonstrační účely, nakonec chceme vygenerovat data metriky pro Azure Monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit the metric data to Azure Monitor. Předání připojovacího řetězce přímo do vývozce.Pass your connection string directly into the exporter. Nebo ji můžete zadat v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING .Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Upravte kód z předchozího kroku na základě následujícího příkladu kódu:Modify your code from the previous step based on the following code sample:

    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')
    
    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. Exportér posílá data metriky Azure Monitor v pevném intervalu.The exporter sends metric data to Azure Monitor at a fixed interval. Výchozí hodnota je každých 15 sekund.The default is every 15 seconds. Sledujeme jednu metriku, takže tato data metriky s libovolným hodnotou a časovým razítkem, které obsahuje, se odesílají každý interval.We're tracking a single metric, so this metric data, with whatever value and time stamp it contains, is sent every interval. Data můžete najít v části customMetrics .You can find the data under customMetrics.

Čítače výkonuPerformance counters

Ve výchozím nastavení odesílá Exportér metrik sadu čítačů výkonu pro Azure Monitor.By default, the metrics exporter sends a set of performance counters to Azure Monitor. Tuto možnost můžete zakázat nastavením enable_standard_metrics příznaku na False v konstruktoru pro exportéra metrik.You can disable this by setting the enable_standard_metrics flag to False in the constructor of the metrics exporter.

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

V současné době jsou odesílány tyto čítače výkonu:These performance counters are currently sent:

  • Dostupná paměť (bajty)Available Memory (bytes)
  • Čas procesoru procesoru (v procentech)CPU Processor Time (percentage)
  • Míra příchozích požadavků (za sekundu)Incoming Request Rate (per second)
  • Průměrná doba provádění příchozího požadavku (milisekundy)Incoming Request Average Execution Time (milliseconds)
  • Využití procesoru procesem (procento)Process CPU Usage (percentage)
  • Zpracovat soukromé bajty (bajty)Process Private Bytes (bytes)

Tyto metriky byste měli být schopní zobrazit v performanceCounters .You should be able to see these metrics in performanceCounters. Další informace najdete v tématu čítače výkonu.For more information, see performance counters.

Úprava telemetrieModify telemetry

Informace o tom, jak upravit sledovanou telemetrii před odesláním do Azure Monitor, najdete v tématu OpenCensus telemetriePython.For information on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

TrasováníTracing

Poznámka

V OpenCensus tracing odkazuje na distribuované trasování.In OpenCensus, tracing refers to distributed tracing. AzureExporterOdeslání requests a dependency telemetrie Azure monitor.The AzureExporter sends requests and dependency telemetry to Azure Monitor.

  1. Nejdřív vygenerujte data trasování místně.First, let's generate some trace data locally. V Pythonu nečinné nebo v editoru podle vlastního výběru zadejte následující kód:In Python IDLE, or your editor of choice, enter the following code:

    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. Spuštění kódu opakovaně vyzve k zadání hodnoty.Running the code repeatedly prompts you to enter a value. U každé položky se hodnota vytiskne do prostředí.With each entry, the value is printed to the shell. Modul Python OpenCensus vygeneruje odpovídající část SpanData .The OpenCensus Python Module generates a corresponding piece of SpanData. Projekt OpenCensus definuje trasování jako strom rozpětí.The OpenCensus project defines a trace as a tree of spans.

    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. I když je zadání hodnot užitečné pro demonstrační účely, nakonec chceme vygenerovat SpanData Azure monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit SpanData to Azure Monitor. Předání připojovacího řetězce přímo do vývozce.Pass your connection string directly into the exporter. Nebo ji můžete zadat v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING .Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Upravte kód z předchozího kroku na základě následujícího příkladu kódu:Modify your code from the previous step based on the following code sample:

    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),
    )
    
    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. Když teď spouštíte skript Pythonu, měli byste být pořád vyzváni k zadání hodnot, ale v prostředí se tiskne jenom hodnota.Now when you run the Python script, you should still be prompted to enter values, but only the value is being printed in the shell. Vytvořená SpanData je odeslána do Azure monitor.The created SpanData is sent to Azure Monitor. Data emitovaného rozsahu najdete v části dependencies .You can find the emitted span data under dependencies. Další informace o odchozích žádostech najdete v tématu OpenCensus v Pythonu.For more information about outgoing requests, see OpenCensus Python dependencies. Další informace o příchozích požadavcích naleznete v tématu OpenCensus Python requests.For more information on incoming requests, see OpenCensus Python requests.

VzorkováníSampling

Informace o vzorkování v OpenCensus se podíváme na vzorkování v OpenCensus.For information on sampling in OpenCensus, take a look at sampling in OpenCensus.

Korelace trasováníTrace correlation

Další informace o korelaci telemetrie v datech trasování najdete v OpenCensus korelace telemetriePythonu.For more information on telemetry correlation in your trace data, take a look at OpenCensus Python telemetry correlation.

Úprava telemetrieModify telemetry

Další informace o tom, jak upravit sledovanou telemetrii před odesláním do Azure Monitor, najdete v tématu OpenCensus Python telemetrie.For more information on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

Konfigurace Azure Monitor vývozcůConfigure Azure Monitor exporters

Jak je znázorněno, existují tři různé Azure Monitor vývozců, kteří podporují OpenCensus.As shown, there are three different Azure Monitor exporters that support OpenCensus. Každé z nich odesílá různé typy telemetrie Azure Monitor.Each one sends different types of telemetry to Azure Monitor. Chcete-li zjistit, jaké typy telemetrie každý vývozce odesílá, přečtěte si následující seznam.To see what types of telemetry each exporter sends, see the following list.

Každý vývozce přijímá stejné argumenty pro konfiguraci a předává je prostřednictvím konstruktorů.Each exporter accepts the same arguments for configuration, passed through the constructors. Podrobnosti o každé z nich můžete zobrazit tady:You can see details about each one here:

  • connection_string: Připojovací řetězec, který se používá pro připojení k vašemu Azure Monitor prostředku.connection_string: The connection string used to connect to your Azure Monitor resource. Má přednost před instrumentation_key .Takes priority over instrumentation_key.
  • enable_standard_metrics: Používá se pro AzureMetricsExporter .enable_standard_metrics: Used for AzureMetricsExporter. Signalizuje, že vývozce automaticky pošle metriky čítače výkonu Azure monitor.Signals the exporter to send performance counter metrics automatically to Azure Monitor. Výchozí hodnota je True .Defaults to True.
  • export_interval: Používá se k určení frekvence v sekundách exportu.export_interval: Used to specify the frequency in seconds of exporting.
  • instrumentation_key: Klíč instrumentace, který se používá pro připojení k vašemu Azure Monitor prostředku.instrumentation_key: The instrumentation key used to connect to your Azure Monitor resource.
  • logging_sampling_rate: Používá se pro AzureLogHandler .logging_sampling_rate: Used for AzureLogHandler. Poskytuje vzorkovací frekvenci [0, 1,0] pro export protokolů.Provides a sampling rate [0,1.0] for exporting logs. Výchozí hodnota je 1,0.Defaults to 1.0.
  • max_batch_size: Určuje maximální velikost telemetrie, která je exportována najednou.max_batch_size: Specifies the maximum size of telemetry that's exported at once.
  • proxies: Určuje sekvenci proxy serverů, které se mají použít k odesílání dat do Azure Monitor.proxies: Specifies a sequence of proxies to use for sending data to Azure Monitor. Další informace najdete v tématu proxy.For more information, see proxies.
  • storage_path: Cesta k umístění místní složky úložiště (neodeslané telemetrie).storage_path: A path to where the local storage folder exists (unsent telemetry). Jako opencensus-ext-azure v 1.0.3 je výchozí cesta dočasným adresářem operačního systému + opencensus-python + your-ikey .As of opencensus-ext-azure v1.0.3, the default path is the OS temp directory + opencensus-python + your-ikey. Před až v 1.0.3 je výchozí cesta $USER + .opencensus + .azure + python-file-name .Prior to v1.0.3, the default path is $USER + .opencensus + .azure + python-file-name.

Zobrazení dat pomocí dotazůView your data with queries

Data telemetrie, která byla odeslána z vaší aplikace, můžete zobrazit prostřednictvím karty protokoly (Analytics) .You can view the telemetry data that was sent from your application through the Logs (Analytics) tab.

Snímek obrazovky s podoknem přehled se zvolenými možnostmi protokoly (Analytics) v červeném poli

V seznamu pod položkou aktivní:In the list under Active:

  • U telemetrie odeslaných pomocí Azure Monitorho vývozce trasování se příchozí požadavky zobrazí v části requests .For telemetry sent with the Azure Monitor trace exporter, incoming requests appear under requests. Odchozí nebo vnitroprocesové požadavky se zobrazí v části dependencies .Outgoing or in-process requests appear under dependencies.
  • U telemetrie odesílaných pomocí Azure Monitorch metriky se v části zobrazuje metrika customMetrics .For telemetry sent with the Azure Monitor metrics exporter, sent metrics appear under customMetrics.
  • U telemetrie odesílaných pomocí nástroje Azure Monitorch protokolů se zobrazí protokoly v části traces .For telemetry sent with the Azure Monitor logs exporter, logs appear under traces. Výjimky se zobrazí v části exceptions .Exceptions appear under exceptions.

Podrobnější informace o používání dotazů a protokolů najdete v tématu protokoly v Azure monitor.For more detailed information about how to use queries and logs, see Logs in Azure Monitor.

Další informace o OpenCensus pro PythonLearn more about OpenCensus for Python

Další krokyNext steps

VýstrahyAlerts

  • Testy dostupnosti: Vytvářejte testy, abyste ověřili viditelnost svého webu na internetu.Availability tests: Create tests to make sure your site is visible on the web.
  • Inteligentní diagnostika: Tyto testy se spouštějí automaticky, takže je nemusíte nijak nastavovat.Smart diagnostics: These tests run automatically, so you don't have to do anything to set them up. Upozorní vás, pokud má aplikace nezvykle velký podíl neúspěšných požadavků.They tell you if your app has an unusual rate of failed requests.
  • Výstrahy metriky: Nastavte výstrahy, které vás upozorní, pokud metrika překračuje prahovou hodnotu.Metric alerts: Set alerts to warn you if a metric crosses a threshold. Upozornění můžete nastavit u vlastních metrik, které v aplikaci naprogramujete.You can set them on custom metrics that you code into your app.