Configuración de Azure Monitor para la aplicación de Python

Precaución

El SDK de Python de OpenCensus se retira. Se recomienda la oferta de Python basada en OpenTelemetry y proporcionar instrucciones de migración.

Azure Monitor admite seguimiento distribuido, recopilación de métricas y registro de aplicaciones de Python.

La solución compatible con Microsoft para el seguimiento y la exportación de datos de las aplicaciones de Python es con el SDK de Python para OpenCensus mediante los exportadores de Azure Monitor.

Microsoft no recomienda usar ningún otro SDK de telemetría para Python como solución de telemetría, ya que no tienen soporte técnico.

OpenCensus se converge en OpenTelemetry. Pero seguimos recomendando OpenCensus mientras OpenTelemetry madura gradualmente.

Prerrequisitos

Necesita una suscripción de Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Nota

El 31 de marzo de 2025 finalizará la compatibilidad con la ingesta de claves de instrumentación. La ingesta de claves de instrumentación seguirá funcionando, pero la característica ya no recibirá actualizaciones ni soporte técnico. Transición a las cadenas de conexión para aprovechar las nuevas funcionalidades.

Introducción al SDK de Python para OpenCensus

OpenCensus es un conjunto de bibliotecas de código abierto que permite la recopilación de seguimiento distribuido, métricas y telemetría de registro. Mediante el uso de exportadores de Azure Monitor, puede enviar esta telemetría recopilada a Application Insights. En este artículo, encontrará instrucciones para configurar OpenCensus y los exportadores de Azure Monitor para Python, a fin de enviar los datos de supervisión a Azure Monitor.

Instrumentación con el SDK de Python para OpenCensus mediante los exportadores de Azure Monitor

Instale los exportadores de Azure Monitor de OpenCensus:

python -m pip install opencensus-ext-azure

El SDK emplea tres exportadores de Azure Monitor para enviar distintos tipos de telemetría a Azure Monitor. Son trace, metrics y logs. Para obtener más información sobre estos tipos de telemetría, vea la información general sobre la plataforma de datos. Utilice las instrucciones siguientes para enviar estos tipos de telemetría a través de los tres exportadores.

Asignaciones de tipos de telemetría

OpenCensus asigna los exportadores siguientes a los tipos de telemetría que se ven en Azure Monitor.

Pilar de observabilidad	Tipo de telemetría en Azure Monitor.	Explicación
Registros	Seguimientos, excepciones, customEvents	Telemetría de registro, telemetría de excepciones, telemetría de eventos
Métricas	customMetrics, performanceCounters	Contadores de rendimiento de métricas personalizadas
Seguimiento	Dependencias de solicitudes	Solicitudes entrantes, solicitudes salientes

Registros

1. Primero, se van a generar algunos datos de registro locales.

   
   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. Se emite una entrada de registro para cada número del intervalo.

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

3. Queremos ver estos datos de registro en Azure Monitor. Puede especificarlo en una variable de entorno, APPLICATIONINSIGHTS_CONNECTION_STRING. También puede pasar connection_string directamente a AzureLogHandler, pero las cadenas de conexión no se deben agregar al control de versiones.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Se recomienda usar la cadena de conexión para crear instancias de los exportadores que se usan para enviar telemetría a Application Insights. Modifique el código del paso anterior en función del ejemplo de código siguiente:

   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. El exportador envía los datos de registro a Azure Monitor. Puede encontrar los datos en traces.

   En este contexto, traces no es lo mismo que tracing. Aquí, traces hace referencia al tipo de telemetría que verá en Azure Monitor al usar AzureLogHandler. Pero tracing hace referencia a un concepto de OpenCensus y se relaciona con el seguimiento distribuido.

   Nota

   El registrador raíz se configura con el nivel de warning. Esto significa que los registros que se envían con una gravedad menor se omiten y, a su vez, no se enviarán a Azure Monitor. Para obtener más información, vea la Documentación de registro.

5. También puede agregar propiedades personalizadas a los mensajes de registro del argumento de palabra clave extra mediante el campo custom_dimensions. Estas propiedades aparecen como pares de valor clave en el customDimensions de Azure Monitor.

   Nota

   Para que esta característica funcione, debe pasar un diccionario al campo custom_dimensions. Si se pasan argumentos de cualquier otro tipo, el registrador los omitirá.

   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)
   

Nota

Como parte del uso de la instrumentación de Application Insights, se recopilan y envían datos de diagnóstico a Microsoft. Estos datos ayudan a ejecutar y mejorar Application Insights. Tiene la opción de deshabilitar la recopilación de datos no esenciales. Para obtener más información, vea Statsbeat en Application Insights.

Configuración del registro para aplicaciones de Django.

Puede configurar el registro de forma explícita en su código de aplicación, como en el caso anterior de las aplicaciones de Django, o bien puede especificarlo en la configuración de registro de Django. Este código puede entrar en cualquier archivo que use para la configuración de los valores del sitio de Django, normalmente, settings.py.

Para obtener información sobre cómo configurar los valores de Django, vea Configuración de Django. Para obtener más información sobre cómo configurar el registro, vea Registro de 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"]},
    },
}

Asegúrese de usar el registrador con el mismo nombre que el especificado en su configuración.

# views.py

import logging
from django.shortcuts import request

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

Enviar excepciones

OpenCensus Python no realiza de forma automática el seguimiento y el envío de la telemetría de exception. Se envían mediante AzureLogHandler por medio de excepciones mediante la biblioteca de registro de Python. Puede agregar propiedades personalizadas de la misma manera que con el registro normal.

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)

Es decisión suya cómo quiere registrar las excepciones no controladas, ya que debe registrar las excepciones de manera explícita. OpenCensus no aplica restricciones sobre cómo realizar este registro, pero debe registrar explícitamente la telemetría de excepciones.

Envío de eventos

Puede enviar la telemetría de customEvent exactamente del mismo modo que envía la telemetría de trace, excepto que se usa AzureEventHandler en su lugar.

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

muestreo

Para obtener información sobre el muestreo en OpenCensus, vea Muestreo en OpenCensus.

Correlación de registros

Para obtener 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.

Modificación de la telemetría

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.

Métricas

OpenCensus.stats admite cuatro métodos de agregación, pero proporciona compatibilidad parcial para Azure Monitor:

• Count; recuento del número de puntos de medida. El valor es acumulado, solo puede aumentar y volver a establecerse en 0 al reiniciar.
• Sum: suma de los puntos de medida. El valor es acumulado, solo puede aumentar y volver a establecerse en 0 al reiniciar.
• LastValue: mantiene el último valor registrado y quita todo lo demás.
• Distribución: el exportador de Azure no admite la distribución del histograma de los puntos de medida.

Ejemplo de agregación de recuento

1. Primero, se van a generar algunos datos de métrica locales. Se crea una métrica para realizar el seguimiento del número de veces que el usuario selecciona la tecla Entrar.

   
   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. Las métricas se crean para realizar el seguimiento muchas veces. Con cada entrada, el valor se incrementará y la información de la métrica se mostrará en la consola. La información incluye el valor actual y la marca de tiempo actual en el momento en que se actualizó la métrica.

   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. 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. Pase la cadena de conexión directamente al exportador. O bien puede especificarlo en una variable de entorno APPLICATIONINSIGHTS_CONNECTION_STRING. Se recomienda usar la cadena de conexión para crear instancias de los exportadores que se usan para enviar telemetría a Application Insights. Modifique el código del paso anterior en función del ejemplo de código siguiente:

   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. El exportador envía los datos de métricas a Azure Monitor según un intervalo fijo. Debe establecer este valor en 60 segundos, ya que el back-end de Application Insights asume la agregación de puntos de métricas en un intervalo de tiempo de 60 segundos. 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. El dato es acumulado, solo puede aumentar y volver a establecerse en 0 al reiniciar.

   Puede encontrar los datos en customMetrics, pero las propiedades customMetrics, valueCount, valueSum, valueMin, valueMax y valueStdDev no se usan de forma eficaz.

Establecimiento de dimensiones personalizadas en métricas

El SDK de Python para OpenCensus permite agregar dimensiones personalizadas a la telemetría de métricas mediante tags, que es básicamente un diccionario de pares clave-valor.

1. Inserte las etiquetas que quiere usar en el mapa de etiquetas. El mapa de etiquetas actúa como una especie de "grupo" de todas las etiquetas disponibles que puede usar.

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

2. Para un elemento View específico, indique las etiquetas que quiere usar al grabar métricas con esa vista mediante la clave de etiqueta.

   ...
   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. Asegúrese de usar el mapa de etiquetas al grabar en el mapa de medida. Las claves de etiqueta especificadas en la View deben encontrarse en el mapa de etiquetas que se usa para registrar.

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

4. En la tabla customMetrics, todos los registros de métrica emitidos mediante prompt_view tendrán dimensiones personalizadas {"url":"http://example.com"}.

5. Para generar etiquetas con valores diferentes con las mismas claves, cree asignaciones de etiquetas para ellas.

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

Contadores de rendimiento

De forma predeterminada, el exportador de métricas envía un conjunto de contadores de rendimiento a Azure Monitor. Puede deshabilitar esta capacidad si establece la marca enable_standard_metrics en False en el constructor del exportador de métricas.

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

Actualmente se envían los contadores de rendimiento siguientes:

• Memoria disponible (bytes)
• Tiempo de procesador de CPU (porcentaje)
• Tasa de solicitudes entrantes (por segundo)
• Tiempo de ejecución promedio de solicitudes entrantes (milisegundos)
• Uso de CPU de proceso (porcentaje)
• Bytes privados del proceso (bytes)

Debería poder ver estas métricas en performanceCounters. Para obtener más información, vea Contadores de rendimiento.

Modificación de la telemetría

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.

Seguimiento

Nota

En OpenCensus, tracing hace referencia al seguimiento distribuido. El parámetro AzureExporter envía la telemetría de requests y dependency a Azure Monitor.

1. En primer lugar, vamos a generar algunos datos de seguimiento localmente. En Python IDLE, o en el editor que prefiera, escriba el código siguiente:

   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. Con cada entrada, el valor se imprime en el shell. El módulo de Python para OpenCensus genera una parte correspondiente de SpanData. El proyecto OpenCensus define un seguimiento como un árbol de intervalos.

   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. Aunque ver la salida resulta útil para la demostración, la finalidad básica es emitir SpanData a Azure Monitor. Pase la cadena de conexión directamente al exportador. O bien puede especificarlo en una variable de entorno APPLICATIONINSIGHTS_CONNECTION_STRING. Se recomienda usar la cadena de conexión para crear instancias de los exportadores que se usan para enviar telemetría a Application Insights. Modifique el código del paso anterior en función del ejemplo de código siguiente:

   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. Ahora, cuando ejecuta el script de Python, solo se imprime en el shell el valor. El valor de SpanData creado se envía a Azure Monitor. Puede encontrar los datos del intervalo emitidos en dependencies.

   Para obtener más información sobre las solicitudes de salida, vea las dependencias de Python para OpenCensus. Para obtener más información sobre las solicitudes de entrada, vea las solicitudes de Python para OpenCensus.

muestreo

Para obtener información sobre el muestreo en OpenCensus, vea Muestreo en OpenCensus.

Correlación de seguimiento

Para obtener más información sobre la correlación de telemetría de los datos de seguimiento, vea la correlación de telemetría de Python para OpenCensus.

Modificación de la telemetría

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.

Configuración de los exportadores de Azure Monitor

Como se muestra, hay tres exportadores de Azure Monitor diferentes que admiten OpenCensus. Cada uno envía distintos tipos de telemetría a Azure Monitor. Para ver qué tipos de telemetría envía cada exportador, vea la tabla siguiente.

Cada exportador acepta los mismos argumentos para la configuración, que se pasan a través de los constructores. Aquí puede ver la información de cada uno de ellos:

Telemetría del exportador	Descripción
connection_string	La cadena de conexión usada para conectarse a su recurso de Azure Monitor. Tiene prioridad sobre instrumentation_key.
credential	Clase de credencial que usa la autenticación de Azure Active Directory. Vea la sección "Autenticación" que se muestra a continuación.
enable_standard_metrics	Se utiliza para AzureMetricsExporter. Indica al exportador que envíe las métricas de los contadores de rendimiento de forma automática a Azure Monitor. Su valor predeterminado es True.
export_interval	Se utiliza para especificar la frecuencia en segundos de exportación. Tiene como valor predeterminado 15s. Para las métricas, DEBE establecer esto en 60 segundos o, de lo contrario, las agregaciones de métricas no tendrán sentido en el explorador de métricas.
grace_period	Se utiliza a fin de especificar el tiempo de espera para el apagado de los exportadores en segundos. Tiene como valor predeterminado 5s.
instrumentation_key	La clave de instrumentación utilizada para conectarse al recurso de Azure Monitor.
logging_sampling_rate	Se utiliza para AzureLogHandler y AzureEventHandler. Proporciona una frecuencia de muestreo [0,1.0] para exportar registros y eventos. Tiene como valor predeterminado 1.0.
max_batch_size	Especifica el tamaño máximo de la telemetría que se exporta a la vez.
proxies	Especifica una secuencia de servidores proxy que se va a usar para enviar datos a Azure Monitor. Para obtener más información, consulte las proxies.
storage_path	Una ruta de acceso a la ubicación de la carpeta de almacenamiento local (telemetría sin enviar). 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. En las versiones anteriores a la 1.0.3, la ruta de acceso predeterminada es $USER + .opencensus + .azure + python-file-name.
timeout	Especifica el tiempo de espera de red para enviar telemetría al servicio de ingesta en segundos. Tiene como valor predeterminado 10s.

Integración con Azure Functions

Para capturar telemetría personalizada en entornos de Azure Functions, use la extensión de Azure Functions de Python para OpenCensus. Para obtener más información, vea la Guía de Azure Functions para desarrolladores de Python.

Autenticación (versión preliminar)

Nota

La característica de autenticación está disponible a partir de opencensus-ext-azure v1.1b0.

Cada uno de los exportadores de Azure Monitor admite la configuración de envío seguro de cargas de telemetría mediante autenticación de OAuth con Azure Active Directory. Para obtener más información, vea la documentación de Autenticación.

Visualización de los datos con consultas

Puede ver los datos de telemetría que se enviaron desde la aplicación mediante la pestaña Registros (Analytics) .

En la lista de Activo:

• En el caso de la telemetría enviada con el exportador de seguimiento de Azure Monitor, las solicitudes entrantes se muestran en requests. Las solicitudes salientes o en proceso se muestran en 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.
• En el caso de la telemetría enviada con el exportador de registros de Azure Monitor, los registros se muestran en traces. Las excepciones aparecen en exceptions.

Para obtener más información sobre cómo usar las consultas y los registros, vea Registros en Azure Monitor.

Configuración y habilitación de la autenticación basada en Microsoft Entra ID

Nota:

La autenticación de Microsoft Entra solo está disponible para Python v2.7, v3.6 y v3.7. La compatibilidad con Microsoft Entra ID en el SDK de Python de OpenCensus para Application Insights se incluye a partir de la versión beta opencensus-ext-azure 1.1b0.

Nota:

El SDK de OpenCensus para Python está en desuso, pero Microsoft lo admite hasta la retirada el 30 de septiembre de 2024. Ahora se recomienda la oferta de Python basada en OpenTelemetry y se proporcionan instrucciones de migración.

Construya las credenciales adecuadas y páselas al constructor del exportador de Azure Monitor. Asegúrese de que la cadena de conexión está configurada con la clave de instrumentación y el punto de conexión de ingesta del recurso.

Los OpenCensusexportadores de Azure Monitor admiten estos tipos de autenticación. Se recomienda usar identidades administradas en entornos de producción.

Identidad administrada asignada por el sistema

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential()
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Identidad administrada asignada por el usuario

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential(client_id="<client-id>")
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Más información sobre OpenCensus para Python

• Python de OpenCensus en GitHub
• Personalización
• Exportadores de Azure Monitor en GitHub
• Integraciones de OpenCensus
• Aplicaciones de ejemplo de Azure Monitor

Solución de problemas

Prueba de la conectividad entre el host de la aplicación y el servicio de ingesta

Los SDK y agentes de Application Insights envían telemetría para ingerirse como llamadas REST a nuestros puntos de conexión de ingesta. Puede probar la conectividad desde el servidor web o la máquina host de la aplicación a los puntos de conexión del servicio de ingesta mediante clientes REST sin procesar con comandos de PowerShell o curl. Consulte Solución de problemas de telemetría de aplicaciones que faltan en Azure Monitor Application Insights.

Notas de la versión

Para obtener las notas de la versión más recientes, consulte Exportador de Azure Monitor para Python.

Nuestras actualizaciones del servicio también resumen las principales mejoras de Application Insights.

Pasos siguientes

• Habilite la supervisión de usuarios web o de explorador para habilitar las experiencias de uso.
• Seguimiento de las solicitudes entrantes.
• Seguimiento de las solicitudes salientes.
• Consulte el Mapa de aplicación.
• Aprende a hacer supervisión de rendimiento de un extremo a otro.

Alertas

• Información general de disponibilidad: cree estas pruebas para asegurarse de que el sitio se ve en la web.
• Diagnósticos inteligentes: estas pruebas se realizan automáticamente, por lo que no es preciso hacer nada para configurarlas. Le indican si la aplicación tiene una tasa de solicitudes con error inusual.
• Alertas de métricas: Establezca alertas que le adviertan si una métrica supera un umbral. Puede establecerlas en las métricas personalizadas que codifique en la aplicación.