Configuración de Azure Monitor para la aplicación de PythonSet up Azure Monitor for your Python application

Azure Monitor admite seguimiento distribuido, recopilación de métricas y registro de aplicaciones de Python gracias a la integración con OpenCensus.Azure Monitor supports distributed tracing, metric collection, and logging of Python applications through integration with OpenCensus. En este artículo, encontrará instrucciones para configurar OpenCensus para Python y enviar los datos de supervisión a Azure Monitor.This article walks you through the process of setting up OpenCensus for Python and sending your monitoring data to Azure Monitor.

Requisitos previosPrerequisites

  • Suscripción a Azure.An Azure subscription. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.If you don't have an Azure subscription, create a free account before you begin.
  • Instalación de Python.Python installation. En este artículo se usa Python 3.7.0, aunque es probable que las versiones anteriores funcionen con cambios menores.This article uses Python 3.7.0, although other versions will likely work with minor changes. El SDK solo admite Python v2.7 y v3.4-v3.7.The SDK only supports Python v2.7 and v3.4-v3.7.
  • Cree un recurso de Application Insights.Create an Application Insights resource. Se le asignará su propia clave de instrumentación (iKey) para el recurso.You'll be assigned your own instrumentation key (ikey) for your resource.

Instrumentación con el SDK de Python para OpenCensus en Azure MonitorInstrument with OpenCensus Python SDK for Azure Monitor

Instale los exportadores de Azure Monitor de OpenCensus:Install the OpenCensus Azure Monitor exporters:

python -m pip install opencensus-ext-azure

Nota

El comando python -m pip install opencensus-ext-azure supone que tiene una variable de entorno PATH establecida para la instalación de Python.The python -m pip install opencensus-ext-azure command assumes that you have a PATH environment variable set for your Python installation. Si no ha configurado esta variable, deberá proporcionar la ruta de acceso completa del directorio a la ubicación del archivo ejecutable de Python.If you haven't configured this variable, you need to give the full directory path to where your Python executable is located. El resultado es un comando como el siguiente: 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.

El SDK emplea tres exportadores de Azure Monitor para enviar distintos tipos de telemetría a Azure Monitor.The SDK uses three Azure Monitor exporters to send different types of telemetry to Azure Monitor. Son seguimiento, métricas y registros.They're trace, metrics, and logs. Para obtener más información sobre estos tipos de telemetría, consulte la información general sobre la plataforma de datos.For more information on these telemetry types, see the data platform overview. Utilice las instrucciones siguientes para enviar estos tipos de telemetría a través de los tres exportadores.Use the following instructions to send these telemetry types via the three exporters.

Asignaciones de tipos de telemetríaTelemetry type mappings

Estos son los exportadores que proporciona OpenCensus asignados a los tipos de telemetría que se ven en Azure Monitor.Here are the exporters that OpenCensus provides mapped to the types of telemetry that you see in Azure Monitor.

Pilar de observabilidadPillar of observability Tipo de telemetría en Azure Monitor.Telemetry type in Azure Monitor ExplicaciónExplanation
RegistrosLogs Seguimientos, excepciones, customEventsTraces, exceptions, customEvents Telemetría de registro, telemetría de excepciones, telemetría de eventosLog telemetry, exception telemetry, event telemetry
MétricasMetrics customMetrics, performanceCounterscustomMetrics, performanceCounters Contadores de rendimiento de métricas personalizadasCustom metrics performance counters
SeguimientoTracing Dependencias de solicitudesRequests dependencies Solicitudes entrantes, solicitudes salientesIncoming requests, outgoing requests

RegistrosLogs

  1. Primero, se van a generar algunos datos de registro locales.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. El código pedirá continuamente que se escriba un valor.The code continuously asks for a value to be entered. Se emite una entrada de registro para cada valor especificado.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. Aunque introducir valores es útil con fines de demostración, la finalidad básica es emitir los datos del registro a Azure Monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit the log data to Azure Monitor. Pase la cadena de conexión directamente al exportador.Pass your connection string directly into the exporter. O bien, puede especificarlo en una variable de entorno APPLICATIONINSIGHTS_CONNECTION_STRING.Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Modifique el código del paso anterior en función del ejemplo de código siguiente: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. El exportador envía los datos de registro a Azure Monitor.The exporter sends log data to Azure Monitor. Puede encontrar los datos en traces.You can find the data under traces.

    Nota

    En este contexto, traces no es lo mismo que tracing.In this context, traces isn't the same as tracing. Aquí, traces hace referencia al tipo de telemetría que verá en Azure Monitor al usar AzureLogHandler.Here, traces refers to the type of telemetry that you'll see in Azure Monitor when you utilize AzureLogHandler. Pero tracing hace referencia a un concepto de OpenCensus y se relaciona con el seguimiento distribuido.But tracing refers to a concept in OpenCensus and relates to distributed tracing.

    Nota

    El registrador raíz se configura con el nivel de advertencia.The root logger is configured with the level of WARNING. Esto significa que los registros que se envían con menos de una gravedad se omiten y, a su vez, no se enviarán a 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. Para obtener más información, vea la documentación.For more information, see documentation.

  5. También puede agregar propiedades personalizadas a los mensajes de registro del argumento de palabra clave extra mediante el campo custom_dimensions.You can also add custom properties to your log messages in the extra keyword argument by using the custom_dimensions field. Estas propiedades aparecen como pares de valor clave en el customDimensions de Azure Monitor.These properties appear as key-value pairs in customDimensions in Azure Monitor.

    Nota

    Para que esta característica funcione, debe pasar un diccionario al campo custom_dimensions.For this feature to work, you need to pass a dictionary to the custom_dimensions field. Si se pasan argumentos de cualquier otro tipo, el registrador los omitirá.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)
    

Configuración del registro para aplicaciones de Django.Configure logging for Django applications

Puede configurar el registro de forma explícita en su código de aplicación, como en el caso de las aplicaciones de Django, o puede especificarlo en la configuración de registro de 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. Este código puede entrar en cualquier archivo que use para la configuración de los valores de Django.This code can go into whatever file you use for Django settings configuration. Para ver cómo configurar los valores de Django, consulte valores de Django.For how to configure Django settings, see Django settings. Para más información sobre la configuración del registro para Log4j, consulte registro de 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"]},
    },
}

Asegúrese de usar el registrador con el mismo nombre que el especificado en su configuración.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")

Enviar excepcionesSend exceptions

OpenCensus Python no realiza de forma automática el seguimiento y el envío de la telemetría de exception.OpenCensus Python doesn't automatically track and send exception telemetry. Se envían mediante AzureLogHandler por medio de excepciones a través de la biblioteca de registro de Python.They're sent through AzureLogHandler by using exceptions through the Python logging library. Puede agregar propiedades personalizadas de la misma manera que con el registro normal.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)

Es decisión del usuario cómo quiere registrar las excepciones no controladas, ya que debe registrar las excepciones de manera explícita.Because you must log exceptions explicitly, it's up to the user how they want to log unhandled exceptions. OpenCensus no impone restricciones en el modo en que un usuario quiera hacerlo, siempre y cuando registre explícitamente una telemetría de excepciones.OpenCensus doesn't place restrictions on how a user wants to do this, as long as they explicitly log an exception telemetry.

Envío de eventosSend events

Puede enviar la telemetría de customEvent exactamente del mismo modo que envía la telemetría de trace, excepto mediante el uso de AzureEventHandler en su lugar.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!')

muestreoSampling

Para información sobre el muestreo en OpenCensus, eche un vistazo al muestreo en OpenCensus.For information on sampling in OpenCensus, take a look at sampling in OpenCensus.

Correlación de registrosLog correlation

Para más información sobre cómo enriquecer los registros con los datos de contexto de seguimiento, vea la integración de registros de Python para OpenCensus.For details on how to enrich your logs with trace context data, see OpenCensus Python logs integration.

Modificación de la telemetríaModify telemetry

Para obtener detalles sobre cómo modificar la telemetría sometida a seguimiento antes de enviarla a Azure Monitor, vea los procesadores de telemetría de Python para OpenCensus.For details on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

MétricasMetrics

  1. Primero, se van a generar algunos datos de métrica locales.First, let's generate some local metric data. Se creará una métrica sencilla para realizar el seguimiento del número de veces que el usuario selecciona la tecla Entrar.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. Al ejecutar el código varias veces, se le pedirá que seleccione Entrar.Running the code repeatedly prompts you to select Enter. Se crea una métrica para realizar el seguimiento del número de veces que se presiona la tecla Entrar.A metric is created to track the number of times Enter is selected. Con cada entrada, el valor se incrementará y la información de la métrica se mostrará en la consola.With each entry, the value is incremented and the metric information appears in the console. La información incluye el valor actual y la marca de tiempo actual en el momento en que se actualizó la métrica.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. Aunque introducir valores es útil con fines de demostración, la finalidad básica es emitir los datos de la métrica a Azure Monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit the metric data to Azure Monitor. Pase la cadena de conexión directamente al exportador.Pass your connection string directly into the exporter. O bien, puede especificarlo en una variable de entorno APPLICATIONINSIGHTS_CONNECTION_STRING.Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Modifique el código del paso anterior en función del ejemplo de código siguiente: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. El exportador envía los datos de métricas a Azure Monitor según un intervalo fijo.The exporter sends metric data to Azure Monitor at a fixed interval. El valor predeterminado es cada 15 segundos.The default is every 15 seconds. Se está realizando el seguimiento de una sola métrica. Por lo tanto, los datos de esta métrica se envían en cada intervalo con el valor y la marca de tiempo que contengan.We're tracking a single metric, so this metric data, with whatever value and time stamp it contains, is sent every interval. Puede encontrar los datos en customMetrics.You can find the data under customMetrics.

Contadores de rendimientoPerformance counters

De forma predeterminada, el exportador de métricas envía un conjunto de contadores de rendimiento a Azure Monitor.By default, the metrics exporter sends a set of performance counters to Azure Monitor. Puede deshabilitar este comportamiento si establece la marca enable_standard_metrics en False en el constructor del exportador de métricas.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>')
...

Estos contadores de rendimiento se envían actualmente:These performance counters are currently sent:

  • Memoria disponible (bytes)Available Memory (bytes)
  • Tiempo de procesador de CPU (porcentaje)CPU Processor Time (percentage)
  • Tasa de solicitudes entrantes (por segundo)Incoming Request Rate (per second)
  • Tiempo de ejecución promedio de solicitudes entrantes (milisegundos)Incoming Request Average Execution Time (milliseconds)
  • Uso de CPU de proceso (porcentaje)Process CPU Usage (percentage)
  • Bytes privados del proceso (bytes)Process Private Bytes (bytes)

Debería poder ver estas métricas en performanceCounters.You should be able to see these metrics in performanceCounters. Para más información, consulte Contadores de rendimiento.For more information, see performance counters.

Modificación de la telemetríaModify telemetry

Para obtener detalles sobre cómo modificar la telemetría sometida a seguimiento antes de enviarla a Azure Monitor, vea los procesadores de telemetría de Python para OpenCensus.For information on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

SeguimientoTracing

Nota

En OpenCensus, tracing hace referencia al seguimiento distribuido.In OpenCensus, tracing refers to distributed tracing. AzureExporter envía datos de telemetría de requests y dependency a Azure Monitor.The AzureExporter sends requests and dependency telemetry to Azure Monitor.

  1. En primer lugar, vamos a generar algunos datos de seguimiento localmente.First, let's generate some trace data locally. En Python IDLE, o en el editor que prefiera, escriba el código siguiente: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. Al ejecutar el código varias veces, se le pedirá que introduzca un valor.Running the code repeatedly prompts you to enter a value. Con cada entrada, el valor se imprime en el shell.With each entry, the value is printed to the shell. El módulo de Python para OpenCensus genera una parte correspondiente de SpanData.The OpenCensus Python Module generates a corresponding piece of SpanData. El proyecto OpenCensus define un seguimiento como un árbol de intervalos.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. Aunque introducir valores es útil con fines de demostración, la finalidad básica es emitir SpanData a Azure Monitor.Although entering values is helpful for demonstration purposes, ultimately we want to emit SpanData to Azure Monitor. Pase la cadena de conexión directamente al exportador.Pass your connection string directly into the exporter. O bien, puede especificarlo en una variable de entorno APPLICATIONINSIGHTS_CONNECTION_STRING.Or, you can specify it in an environment variable, APPLICATIONINSIGHTS_CONNECTION_STRING. Modifique el código del paso anterior en función del ejemplo de código siguiente: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. Ahora, al ejecutar el script de Python, todavía se le seguirá pidiendo que especifique los valores, pero en el shell solo se imprime el valor.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. El valor de SpanData creado se envía a Azure Monitor.The created SpanData is sent to Azure Monitor. Puede encontrar los datos del intervalo emitidos en dependencies.You can find the emitted span data under dependencies. Para obtener más información sobre las solicitudes de salida, vea las dependencias de Python para OpenCensus.For more information about outgoing requests, see OpenCensus Python dependencies. Para obtener más información sobre las solicitudes de entrada, vea las solicitudes de Python para OpenCensus.For more information on incoming requests, see OpenCensus Python requests.

muestreoSampling

Para información sobre el muestreo en OpenCensus, eche un vistazo al muestreo en OpenCensus.For information on sampling in OpenCensus, take a look at sampling in OpenCensus.

Correlación de seguimientoTrace correlation

Para obtener más información sobre la correlación de telemetría de los datos de seguimiento, eche un vistazo a la correlación de telemetría de Python para OpenCensus.For more information on telemetry correlation in your trace data, take a look at OpenCensus Python telemetry correlation.

Modificación de la telemetríaModify telemetry

Para obtener más información sobre cómo modificar la telemetría sometida a seguimiento antes de enviarla a Azure Monitor, vea los procesadores de telemetría de Python para OpenCensus.For more information on how to modify tracked telemetry before it's sent to Azure Monitor, see OpenCensus Python telemetry processors.

Configuración de los exportadores de Azure MonitorConfigure Azure Monitor exporters

Como se muestra, hay tres exportadores de Azure Monitor diferentes que admiten OpenCensus.As shown, there are three different Azure Monitor exporters that support OpenCensus. Cada uno envía distintos tipos de telemetría a Azure Monitor.Each one sends different types of telemetry to Azure Monitor. Para ver qué tipos de telemetría envía cada exportador, consulte la lista siguiente.To see what types of telemetry each exporter sends, see the following list.

Cada exportador acepta los mismos argumentos para la configuración, que se pasan a través de los constructores.Each exporter accepts the same arguments for configuration, passed through the constructors. Aquí puede ver los detalles de cada uno de ellos:You can see details about each one here:

  • connection_string: La cadena de conexión usada para conectarse a su recurso de Azure Monitor.connection_string: The connection string used to connect to your Azure Monitor resource. Tiene prioridad sobre instrumentation_key.Takes priority over instrumentation_key.
  • enable_standard_metrics: Usado para AzureMetricsExporter.enable_standard_metrics: Used for AzureMetricsExporter. Indica al exportador que envíe las métricas de los contadores de rendimiento de forma automática a Azure Monitor.Signals the exporter to send performance counter metrics automatically to Azure Monitor. Su valor predeterminado es True.Defaults to True.
  • export_interval: Se utiliza para especificar la frecuencia en segundos de exportación.export_interval: Used to specify the frequency in seconds of exporting.
  • instrumentation_key: La clave de instrumentación utilizada para conectarse al recurso de Azure Monitor.instrumentation_key: The instrumentation key used to connect to your Azure Monitor resource.
  • logging_sampling_rate: Usado para AzureLogHandler.logging_sampling_rate: Used for AzureLogHandler. Proporciona una frecuencia de muestreo [0, 1.0] para exportar registros.Provides a sampling rate [0,1.0] for exporting logs. Su valor predeterminado es 1.0.Defaults to 1.0.
  • max_batch_size: Especifica el tamaño máximo de la telemetría que se exporta a la vez.max_batch_size: Specifies the maximum size of telemetry that's exported at once.
  • proxies: Especifica una secuencia de servidores proxy que se va a usar para enviar datos a Azure Monitor.proxies: Specifies a sequence of proxies to use for sending data to Azure Monitor. Para obtener más información, consulte las proxies.For more information, see proxies.
  • storage_path: Una ruta de acceso a la ubicación de la carpeta de almacenamiento local (telemetría sin enviar).storage_path: A path to where the local storage folder exists (unsent telemetry). A partir del v1.0.3 de opencensus-ext-azure, la ruta de acceso predeterminada es el directorio temporal del sistema operativo + opencensus-python + your-ikey.As of opencensus-ext-azure v1.0.3, the default path is the OS temp directory + opencensus-python + your-ikey. Antes de v1.0.3, la ruta de acceso predeterminada es $USER + .opencensus + .azure + python-file-name.Prior to v1.0.3, the default path is $USER + .opencensus + .azure + python-file-name.

Visualización de los datos con consultasView your data with queries

Puede ver los datos de telemetría que se enviaron desde la aplicación mediante la pestaña Registros (Analytics) .You can view the telemetry data that was sent from your application through the Logs (Analytics) tab.

Captura de pantalla del panel de información general con la pestaña "Registros (Analytics)" seleccionada en el cuadro rojo.

En la lista de Activo:In the list under Active:

  • En el caso de la telemetría enviada con el exportador de seguimiento de Azure Monitor, las solicitudes entrantes se muestran en requests.For telemetry sent with the Azure Monitor trace exporter, incoming requests appear under requests. Las solicitudes salientes o en proceso se muestran en dependencies.Outgoing or in-process requests appear under dependencies.
  • En el caso de la telemetría enviada con el exportador de métricas de Azure Monitor, las métricas enviadas se muestran en customMetrics.For telemetry sent with the Azure Monitor metrics exporter, sent metrics appear under customMetrics.
  • En el caso de la telemetría enviada con el exportador de registros de Azure Monitor, los registros se muestran en traces.For telemetry sent with the Azure Monitor logs exporter, logs appear under traces. Las excepciones aparecen en exceptions.Exceptions appear under exceptions.

Para obtener información más detallada sobre cómo usar las consultas y los registros, consulte Registros en Azure Monitor.For more detailed information about how to use queries and logs, see Logs in Azure Monitor.

Más información sobre OpenCensus para PythonLearn more about OpenCensus for Python

Pasos siguientesNext steps

AlertasAlerts

  • Pruebas de disponibilidad: cree pruebas para asegurarse de que el sitio sea visible en la Web.Availability tests: Create tests to make sure your site is visible on the web.
  • Diagnósticos inteligentes: estas pruebas se realizan automáticamente, por lo que no es preciso hacer nada para configurarlas.Smart diagnostics: These tests run automatically, so you don't have to do anything to set them up. Le indican si la aplicación tiene una tasa de solicitudes con error inusual.They tell you if your app has an unusual rate of failed requests.
  • Alertas de métricas: Establezca alertas que le adviertan si una métrica supera un umbral.Metric alerts: Set alerts to warn you if a metric crosses a threshold. Puede establecerlas en las métricas personalizadas que codifique en la aplicación.You can set them on custom metrics that you code into your app.