Configurar Azure Monitor para seu aplicativo Python

Cuidado

O SDK do OpenCensus Python foi desativado. Recomendamos a oferta do Python baseada em OpenTelemetry e fornecemos diretrizes de migração.

O Azure Monitor permite o rastreamento distribuído, a coleta de métricas e o log de aplicativos Python.

A solução compatível da Microsoft para acompanhar e exportar dados para aplicativos Python ocorre por meio do SDK do Python do OpenCensus através dos exportadores do Azure Monitor.

A Microsoft não recomenda o uso de nenhum outro SDK de telemetria para Python como uma solução de telemetria porque não há suporte para isso.

O OpenCensus está convergindo para OpenTelemetry. No entanto, ele continua sendo recomendado enquanto o OpenTelemetry é gradualmente desenvolvido.

Pré-requisitos

É necessária uma assinatura do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

Observação

Em 31 de março de 31, 2025, o suporte à ingestão de chave de instrumentação será encerrado. A ingestão de chave de instrumentação continuará funcionando, mas não forneceremos mais atualizações ou suporte para o recurso. Faça a transição para cadeias de conexão para aproveitar as novas funcionalidades.

Introdução ao SDK do Python do Opencensus

O OpenCensus é um conjunto de bibliotecas de código aberto que permite a coleta de rastreamentos distribuídos, métricas e telemetria de registro em log. Com os exportadores do Azure Monitor, é possível enviar ao Application Insights essa telemetria coletada. Este artigo explica o processo de configuração do OpenCensus e dos exportadores do Azure Monitor para Python a fim de enviar dados de monitoramento ao Azure Monitor.

Instrumentar com SDK do Python OpenCensus e exportadores do Azure Monitor

Instale exportadores OpenCensus Azure Monitor:

python -m pip install opencensus-ext-azure

O SDK usa três exportadores Azure Monitor para enviar tipos diferentes de telemetria para o Azure Monitor. Eles são os seguintes: trace, metrics e logs. Para saber mais sobre esses tipos de telemetria, confira Visão geral da plataforma de dados. Use as instruções a seguir para enviar esses tipos de telemetria por meio dos três exportadores.

Mapeamentos do tipo de telemetria

O OpenCensus mapeia os exportadores a seguir para os tipos de telemetria que você vê no Azure Monitor.

Pilar da observação	Tipo de telemetria no Azure Monitor	Explicação
Logs	Rastreamentos, exceções, customEvents	Telemetria de log, telemetria de exceção e telemetria de eventos
Métricas	customMetrics, performanceCounters	Contadores de desempenho de métricas personalizadas
Rastreamento	Dependências de solicitações	Solicitações de entrada, solicitações de saída

Logs

1. Primeiro vamos gerar alguns dados de log locais.

   
   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. Uma entrada de log é emitida para cada número no intervalo.

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

3. A intenção é ver esses dados de log no Azure Monitor. É possível especificá-los em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Também é possível transmitir connection_string diretamente para AzureLogHandler, mas as cadeias de conexão não devem ser adicionadas ao controle de versão.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Recomendamos usar a cadeia de conexão para criar uma instância dos exportadores que são usados para enviar a telemetria ao Application Insights. Modifique seu código da etapa anterior com base no seguinte exemplo de código:

   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. O exportador envia dados de log para o Azure Monitor. Você pode encontrar os dados em traces.

   Nesse contexto, traces não é o mesmo que tracing. Aqui, traces refere-se ao tipo de telemetria exibida no Azure Monitor ao utilizar AzureLogHandler. Mas tracing refere-se a um conceito em OpenCensus e está relacionado ao rastreamento distribuído.

   Observação

   O agente raiz é configurado com o nível de warning. Isso significa que todos os logs enviados com menos severidade serão ignorados e não serão enviados ao Azure Monitor. Para saber mais, confira a documentação do registro em log.

5. Também é possível adicionar propriedades personalizadas às mensagens de log no argumento de palavra-chave extra usando o campo custom_dimensions. Essas propriedades aparecem como pares de chave-valor em customDimensions no Azure Monitor.

   Observação

   Para que o recurso funcione, você precisa transmitir um dicionário para o campo custom_dimensions. Se você passar argumentos de qualquer outro tipo, o agente os ignora.

   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)
   

Observação

Como parte do uso da instrumentação do Application Insights, coletamos e enviamos dados de diagnóstico para a Microsoft. Esses dados nos ajudam a executar e a aprimorar o Application Insights. Você tem a opção de desabilitar a coleta de dados não essenciais. Para saber mais, confira Statsbeat no Application Insights.

Configurar o log para aplicativos Django

É possível configurar o registro em log explicitamente no código do aplicativo, como acima, para os aplicativos Django ou especificá-lo na configuração de registro em log do Django. Esse código pode ser incluído em qualquer arquivo usado para a definição das configurações do site do Django, normalmente, settings.py.

Para saber como definir as configurações do Django, confira Configurações do Django. Para saber como configurar o registro em log, confira Registro em log do 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"]},
    },
}

Certifique-se de usar o agente de log com o mesmo nome que o especificado em sua configuração.

# views.py

import logging
from django.shortcuts import request

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

Enviar exceções

O OpenCensus Python não rastreia e envia automaticamente a telemetria de exception. Ela é enviada por meio de AzureLogHandler usando exceções através da biblioteca de registro em log do Python. É possível adicionar propriedades personalizadas, assim como no registro em log 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)

Como as exceções devem ser registradas explicitamente, cabe a você decidir como registrar exceções sem tratamento. O OpenCensus não impõe restrições sobre esse registro, mas você deve registrar explicitamente a telemetria de exceção.

Enviar eventos

É possível enviar a telemetria customEvent exatamente da mesma maneira que a telemetria trace, mas usando AzureEventHandler como alternativa.

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

amostragem

Para saber mais sobre a amostragem no OpenCensus, confira Amostragem no OpenCensus.

Correlação de logs

Para saber como enriquecer os logs com dados de contexto de rastreamento, confira a integração de logs do Python do OpenCensus.

Modificar telemetria

Para obter informações sobre como modificar a telemetria acompanhada antes de enviá-la para o Azure Monitor, consulte os processadores de telemetria do OpenCensus Python.

Métricas

O OpenCensus.stats é compatível com quatro métodos de agregação, mas dá suporte parcial ao Azure Monitor:

• Contagem: a contagem de pontos de medida. O valor é cumulativo, só pode aumentar e é redefinido para 0 na reinicialização.
• Soma: uma soma dos pontos de medida. O valor é cumulativo, só pode aumentar e é redefinido para 0 na reinicialização.
• LastValue: mantém o último valor registrado e remove todo o resto.
• Distribuição: o exportador do Azure não dá suporte à distribuição de histogramas dos pontos de medição.

Exemplo de agregação de contagem

1. Primeiro vamos gerar alguns dados métricos locais. Você criará uma métrica para acompanhar a frequência de pressionamento da tecla Enter pelo usuário.

   
   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. As métricas são criadas para acompanhar essa frequência. Com cada entrada, o valor é incrementado e as informações de métrica aparece no console. As informações incluem o valor atual e o carimbo de data/hora atual quando a métrica foi atualizada.

   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. Embora a inserção de valores seja útil para fins de demonstração, o objetivo é emitir os dados de métrica para o Azure Monitor. Passe sua cadeia de conexão diretamente no exportador. Também é possível especificá-la em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Recomendamos usar a cadeia de conexão para criar uma instância dos exportadores que são usados para enviar a telemetria ao Application Insights. Modifique seu código da etapa anterior com base no seguinte exemplo de código:

   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. O exportador envia dados de métrica para o Azure Monitor em um intervalo fixo. Defina esse valor como 60 segundos, pois o back-end do Application Insights assume a agregação de pontos de métricas nesse intervalo. Estamos acompanhando uma única métrica, portanto, esses dados de métrica, com qualquer valor e carimbo de data/hora que ele contém, são enviados a cada intervalo. O valor é cumulativo, só pode aumentar e redefine como 0 na reinicialização.

   É possível encontrar os dados em customMetrics, mas as propriedades valueCount, valueSum, valueMin, valueMax e valueStdDev de customMetrics não são usadas efetivamente.

Configurar dimensões personalizadas em métricas

O SDK do Python do OpenCensus permite adicionar dimensões personalizadas à telemetria de métricas por meio de tags, que são como um dicionário de pares de chave/valor.

1. Insira as marcas que você deseja usar no mapa de marcas. O mapa de marca atua como um tipo de "pool" de todas as marcas disponíveis que você pode usar.

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

2. Para um View específico, utilize a chave de marca a fim de determinar as marcas que serão usadas ao registrar métricas com essa exibição.

   ...
   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. Use o mapa de marcas ao realizar gravações no mapa de medidas. As chaves de marca especificadas no View devem ser encontradas no mapa de marca usado para registro.

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

4. Na tabela customMetrics, todos os registros de métrica emitidos por meio de prompt_view terão dimensões {"url":"http://example.com"} personalizadas.

5. Para produzir marcas com valores diferentes usando as mesmas chaves, crie mapas de marcas para elas.

   ...
   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 desempenho

Por padrão, o exportador de métricas envia um conjunto de contadores de desempenho para o Azure Monitor. Isso pode ser desabilitado definindo o sinalizador enable_standard_metrics como False no construtor do exportador de métricas.

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

No momento, os seguintes contadores de desempenho são enviados:

• Memória disponível (bytes)
• Tempo do processador da CPU (percentual)
• Taxa de solicitação de entrada (por segundo)
• Tempo médio de execução da solicitação de entrada (milissegundos)
• Uso da CPU do processo (percentual)
• Bytes privados do processo (bytes)

Você deve ser capaz de ver essas métricas em performanceCounters. Para saber mais, confira Contadores de desempenho.

Modificar telemetria

Para obter informações sobre como modificar a telemetria acompanhada antes de enviá-la para o Azure Monitor, consulte os processadores de telemetria do OpenCensus Python.

Rastreamento

Observação

NO OpenCensus, tracing refere-se a rastreamento distribuído. O parâmetro AzureExporter envia a telemetria de requests e dependency ao Azure Monitor.

1. Primeiro vamos gerar alguns dados de rastreamento localmente. No Python IDLE, ou seu editor preferencial, digite o seguinte código:

   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. Com cada entrada, o valor é impresso no Shell. O módulo do Python do OpenCensus gera uma parte correspondente de SpanData. O projeto OpenCensus define um rastreamento como uma árvore de spans.

   0
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='15ac5123ac1f6847', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:22.805429Z', end_time='2019-06-27T18:21:44.933405Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   1
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='2e512f846ba342de', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:44.933405Z', end_time='2019-06-27T18:21:46.156787Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   2
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='f3f9f9ee6db4740a', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:46.157732Z', end_time='2019-06-27T18:21:47.269583Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   

3. Embora a exibição da saída seja útil para fins de demonstração, emita SpanData para o Azure Monitor. Passe sua cadeia de conexão diretamente no exportador. Também é possível especificá-la em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Recomendamos usar a cadeia de conexão para criar uma instância dos exportadores que são usados para enviar a telemetria ao Application Insights. Modifique seu código da etapa anterior com base no seguinte exemplo de código:

   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. Agora, quando você executar o script Python, apenas o valor será impresso no shell. O SpanData criado é enviado para o Azure Monitor. Você pode encontrar os dados de span emitidos em dependencies.

   Para obter mais informações sobre as solicitações de saída, consulte as dependências de OpenCensus Python. Para obter mais informações sobre as solicitações de chegada, consulte as solicitações de OpenCensus Python.

amostragem

Para saber mais sobre a amostragem no OpenCensus, confira Amostragem no OpenCensus.

Correlação de rastreamento

Para saber mais sobre a correlação de telemetria em dados de rastreamento, confira a correlação de telemetria do Python do OpenCensus.

Modificar telemetria

Para obter mais informações sobre como modificar a telemetria acompanhada antes de enviá-la para Azure Monitor, consulte os processadores de telemetria do OpenCensus Python.

Configurar exportadores de Azure Monitor

Como mostrado, há três exportadores de Azure Monitor diferentes que dão suporte a OpenCensus. Cada uma envia tipos diferentes de telemetria para o Azure Monitor. Para ver quais tipos de telemetria são enviados por cada exportador, confira a tabela a seguir.

Cada exportador aceita os mesmos argumentos para configuração, passados pelos construtores. É possível ver detalhes sobre cada um aqui:

Telemetria do exportador	Descrição
connection_string	A cadeia de conexão usada para se conectar ao recurso do Azure Monitor. Tem prioridade instrumentation_key.
credential	Classe de credencial usada pela autenticação do Azure Active Directory. Confira a seção "Autenticação" a seguir.
enable_standard_metrics	Usado para AzureMetricsExporter. Sinaliza o exportador para enviar as métricas do contador de desempenho automaticamente para o Azure Monitor. Assume o padrão de True.
export_interval	Usado para especificar, em segundos, a frequência de exportação. Assume o padrão de 15s. No caso das métricas, defina a configuração como 60 segundos, caso contrário, as agregações de métricas não farão sentido no gerenciador de métricas.
grace_period	Usado para especificar, em segundos, o tempo limite até o desligamento dos exportadores. Assume o padrão de 5s.
instrumentation_key	A chave de instrumentação usada para se conectar ao recurso do Azure Monitor.
logging_sampling_rate	Usado para AzureLogHandler e AzureEventHandler. Fornece uma taxa de amostragem [0,1.0] para exportar logs/eventos. Assume o padrão de 1.0.
max_batch_size	Especifica o tamanho máximo da telemetria exportada de uma vez.
proxies	Especifica uma sequência de proxies a serem usados no envio de dados ao Azure Monitor. Para obter mais informações, consulte proxies.
storage_path	Um caminho para a pasta de armazenamento local (telemetria não enviada). A partir de opencensus-ext-azure v 1.0.3, o caminho padrão é o diretório Temp do sistema operacional + opencensus-python + your-ikey. Antes da v 1.0.3, o caminho padrão é $USER + .opencensus + .azure + python-file-name.
timeout	Especifica o tempo limite de rede, em segundos, para o envio da telemetria ao serviço de ingestão. Assume o padrão de 10s.

Integração com o Azure Functions

Para capturar a telemetria personalizada em ambientes do Azure Functions, use a extensão do Python do OpenCensus para Azure Functions. Para saber mais, confira o Guia do desenvolvedor de Python do Azure Functions.

Autenticação (versão prévia)

Observação

O recurso de autenticação está disponível a partir do opencensus-ext-azure v1.1b0.

Cada um dos exportadores do Azure Monitor dá suporte à configuração do envio seguro de cargas de telemetria por meio da autenticação OAuth com o Azure Active Directory. Para saber mais, confira a documentação sobre a autenticação.

Visualização dos seus dados com consultas

Você pode exibir os dados de telemetria que foram enviados do seu aplicativo por meio da guia Logs (Análise) .

Na lista em Ativo:

• Para a telemetria enviada com o exportador de rastreamento do Azure Monitor, as solicitações de entrada aparecem em requests. As solicitações de saída ou em andamento aparecem em dependencies.
• Para a telemetria enviada com o exportador de métricas do Azure Monitor, as métricas enviadas aparecem em customMetrics.
• Para a telemetria enviada com o exportador de logs do Azure Monitor, os logs aparecem em traces. As exceções aparecem em exceptions.

Para saber como usar consultas e logs, confira Logs no Azure Monitor.

Configurar e habilitar a autenticação baseada em ID do Microsoft Entra

Observação

A autenticação do Microsoft Entra está disponível somente para Python v2.7, v3.6 e v3.7. O suporte ao Microsoft Entra ID no SDK do Application Insights para OpenCensus Python está incluído a partir da versão beta opencensus-ext-azure 1.1b0.

Observação

O SDK do Python do OpenCensus foi preterido, mas a Microsoft dá suporte a ele até a desativação em 30 de setembro de 2024. Agora, recomendamos a oferta do Python baseada no OpenTelemetry e fornecemos diretrizes de migração.

Construa as credenciais apropriadas e passe-as para o construtor do exportador do Azure Monitor. Verifique se a cadeia de conexão está configurada com a chave de instrumentação e o ponto de extremidade de ingestão de seu recurso.

Os exportadores do Azure Monitor OpenCensus dão suporte para esses tipos de autenticação. Identidades gerenciadas são recomendadas para ambientes de produção.

Identidade gerenciada atribuída pelo 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)
)
...

Identidade gerenciada atribuída pelo usuário

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)
)
...

Saiba mais sobre o OpenCensus para Python

• OpenCensus Python no GitHub
• Personalização
• Exportadores do Azure Monitor no GitHub
• Integrações do OpenCensus
• Aplicativos de exemplo do Azure Monitor

Solução de problemas

Testar a conectividade entre o host do aplicativo e o serviço de ingestão

Os SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST para nossos pontos de extremidade de ingestão. Você pode testar a conectividade do servidor Web ou do computador host do aplicativo para os pontos de extremidade do serviço de ingestão usando clientes REST brutos do PowerShell ou comandos curl. Confira Solucionar problemas de telemetria de aplicativo ausente no Application Insights do Azure Monitor.

Notas de versão

Para obter as notas de versão mais recentes, consulte Exportador Python do Azure Monitor

Nossas Atualizações de Serviço também resumem as principais melhorias do Application Insights.

Próximas etapas

• Para habilitar experiências de uso, habilite o monitoramento de usuários da Web ou do navegador
• Rastrear as solicitações recebidas.
• Rastrear as solicitações de saída.
• Confira o Mapa do aplicativo.
• Saiba como fazer o Monitoramento de desempenho de ponta a ponta.

Alertas

• Testes de disponibilidade: criar testes para verificar se seu site está visível na web.
• Diagnóstico inteligente: Esses testes são executados automaticamente, portanto, nenhuma configuração adicional será necessária. Eles informam se o aplicativo tem uma taxa incomum de solicitações com falha.
• Alertas de métrica: Definir alertas para avisar se uma métrica ultrapassar um limite. Você pode defini-los em métricas personalizadas que você codifica em seu aplicativo.