Configurar o Azure Monitor para a sua aplicação Python

Nota

O SDK Python do OpenCensus foi preterido, mas a Microsoft suporta-o até à descontinuação a 30 de setembro de 2024. Agora, recomendamos a oferta python baseada em OpenTelemetry e fornecemos orientações de migração.

O Azure Monitor suporta rastreio distribuído, recolha de métricas e registo de aplicações Python.

A solução suportada pela Microsoft para controlar e exportar dados para as suas aplicações Python é através do SDK Python do OpenCensus através dos exportadores do Azure Monitor.

A Microsoft não recomenda a utilização de outros SDKs de telemetria para Python como uma solução de telemetria porque não são suportados.

O OpenCensus está a convergir para OpenTelemetry. Continuamos a recomendar o OpenCensus enquanto o OpenTelemetry amadurece gradualmente.

Pré-requisitos

Precisa de uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

Nota

A 31 de março de 2025, o suporte da ingestão de chaves de instrumentação terminará. A ingestão de chaves de instrumentação continuará a funcionar, mas deixaremos de fornecer atualizações ou suporte para a funcionalidade. Transição para cadeias de ligação para tirar partido das novas capacidades.

Introdução ao SDK Python do OpenCensus

O OpenCensus é um conjunto de bibliotecas open source para permitir a recolha de telemetria de rastreio distribuído, métricas e registo. Ao utilizar os exportadores do Azure Monitor, pode enviar esta telemetria recolhida para o Application Insights. Este artigo explica-lhe o processo de configuração do OpenCensus e dos exportadores do Azure Monitor para Python para enviar os seus dados de monitorização para o Azure Monitor.

Instrumentar com o SDK Python do OpenCensus com exportadores do Azure Monitor

Instale os exportadores do Azure Monitor do OpenCensus:

python -m pip install opencensus-ext-azure

O SDK utiliza três exportadores do Azure Monitor para enviar diferentes tipos de telemetria para o Azure Monitor. traceSão , metricse logs. Para obter mais informações sobre estes tipos de telemetria, veja Descrição geral da plataforma de dados. Utilize as seguintes instruções para enviar estes tipos de telemetria através dos três exportadores.

Mapeamentos de tipos de telemetria

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

Pilar da observabilidade	Tipo de telemetria no Azure Monitor	Explicação
Registos	Rastreios, exceções, customEvents	Telemetria de registo, telemetria de exceção, telemetria de eventos
Métricas	customMetrics, performanceCounters	Contadores de desempenho de métricas personalizadas
Rastreio	Dependências de pedidos	Pedidos recebidos, pedidos de saída

Registos

1. Primeiro, vamos gerar alguns dados de registo 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. É emitida uma entrada de registo para cada número no intervalo.

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

3. Queremos ver estes dados de registo no Azure Monitor. Pode especificá-lo numa variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Também pode transmitir o connection_string diretamente para o AzureLogHandler, mas as cadeias de ligação não devem ser adicionadas ao controlo de versões.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Recomendamos que utilize a cadeia de ligação para instanciar os exportadores que são utilizados para enviar telemetria para o Application Insights. Modifique o código do passo 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 registo para o Azure Monitor. Pode encontrar os dados em traces.

   Neste contexto, traces não é o mesmo que tracing. Aqui, traces refere-se ao tipo de telemetria que vê no Azure Monitor quando utiliza AzureLogHandler. Mas tracing refere-se a um conceito no OpenCensus e está relacionado com o rastreio distribuído.

   Nota

   O logger de raiz está configurado com o nível de warning. Isto significa que quaisquer registos enviados com menos gravidade são ignorados e, por sua vez, não serão enviados para o Azure Monitor. Para obter mais informações, veja Documentação de registo.

5. Também pode adicionar propriedades personalizadas às suas mensagens de registo no extra argumento de palavra-chave com o custom_dimensions campo . Estas propriedades são apresentadas como pares chave-valor no customDimensions Azure Monitor.

   Nota

   Para que esta funcionalidade funcione, tem de transmitir um dicionário para o custom_dimensions campo. Se transmitir argumentos de qualquer outro tipo, o logger ignora-os.

   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 da utilização da instrumentação do Application Insights, recolhemos e enviamos dados de diagnóstico para a Microsoft. Estes dados ajudam-nos a executar e melhorar o Application Insights. Tem a opção de desativar a recolha de dados não essenciais. Para saber mais, veja Statsbeat no Application Insights.

Configurar o registo para aplicações Django

Pode configurar o registo explicitamente no código da aplicação, como o anterior para as suas aplicações Django, ou pode especificá-lo na configuração de registo do Django. Este código pode entrar em qualquer ficheiro que utilize para a configuração de definições do site Django, normalmente settings.py.

Para obter informações sobre como configurar as definições do Django, consulte Definições do Django. Para obter mais informações sobre como configurar o registo, veja Registo 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 que utiliza o logger com o mesmo nome que o especificado na 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 Python openCensus não controla e envia exception telemetria automaticamente. É enviado através AzureLogHandler de exceções através da biblioteca de registos do Python. Pode adicionar propriedades personalizadas, como faz com o registo 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)

Uma vez que tem de registar exceções explicitamente, cabe-lhe a si registar exceções não processadas. O OpenCensus não coloca restrições sobre como efetuar este registo, mas tem de registar explicitamente a telemetria da exceção.

Enviar eventos

Pode enviar customEvent telemetria exatamente da mesma forma que envia trace telemetria, exceto ao utilizar AzureEventHandler .

import logging
from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler())
# Alternatively manually pass in the connection_string
# logger.addHandler(AzureEventHandler(connection_string=<appinsights-connection-string>))

logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Amostragem

Para obter informações sobre a amostragem no OpenCensus, veja Amostragem no OpenCensus.

Correlação de registos

Para obter informações sobre como enriquecer os seus registos com dados de contexto de rastreio, veja Integração de registos python do OpenCensus.

Modificar telemetria

Para obter informações sobre como modificar a telemetria controlada antes de ser enviada para o Azure Monitor, veja Processadores de telemetria Python do OpenCensus.

Métricas

O OpenCensus.stats suporta quatro métodos de agregação, mas fornece suporte parcial para o Azure Monitor:

• Contagem: a contagem do número de pontos de medida. O valor é cumulativo, só pode aumentar e é reposto para 0 no reinício.
• Soma: uma soma dos pontos de medição. O valor é cumulativo, só pode aumentar e é reposto para 0 no reinício.
• LastValue: mantém o último valor registado e remove tudo o resto.
• Distribuição: o exportador do Azure não suporta a distribuição de histogramas dos pontos de medição.

Exemplo de agregação de contagem

1. Primeiro, vamos gerar alguns dados de métricas locais. Criamos uma métrica para controlar o número de vezes que o utilizador seleciona a chave Enter .

   
   from datetime import datetime
   from opencensus.stats import aggregation as aggregation_module
   from opencensus.stats import measure as measure_module
   from opencensus.stats import stats as stats_module
   from opencensus.stats import view as view_module
   from opencensus.tags import tag_map as tag_map_module
   
   stats = stats_module.stats
   view_manager = stats.view_manager
   stats_recorder = stats.stats_recorder
   
   prompt_measure = measure_module.MeasureInt("prompts",
                                              "number of prompts",
                                              "prompts")
   prompt_view = view_module.View("prompt view",
                                  "number of prompts",
                                  [],
                                  prompt_measure,
                                  aggregation_module.CountAggregation())
   view_manager.register_view(prompt_view)
   mmap = stats_recorder.new_measurement_map()
   tmap = tag_map_module.TagMap()
   
   def main():
       for _ in range(4):
           mmap.measure_int_put(prompt_measure, 1)
           mmap.record(tmap)
           metrics = list(mmap.measure_to_view_map.get_metrics(datetime.utcnow()))
           print(metrics[0].time_series[0].points[0])
   
   if __name__ == "__main__":
       main()
   

2. As métricas são criadas para controlar muitas vezes. Com cada entrada, o valor é incrementado e as informações das métricas são apresentadas na consola do . 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. A introdução de valores é útil para fins de demonstração, mas queremos emitir os dados de métricas para o Azure Monitor. Transmita a cadeia de ligação diretamente para o exportador. Em alternativa, pode especificá-la numa variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Recomendamos que utilize a cadeia de ligação para instanciar os exportadores que são utilizados para enviar telemetria para o Application Insights. Modifique o código do passo 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étricas para o Azure Monitor num intervalo fixo. Tem de definir este valor para 60 segundos, uma vez que o back-end do Application Insights pressupõe a agregação de pontos de métricas num intervalo de tempo de 60 segundos. Estamos a controlar uma única métrica, pelo que estes dados de métricas, com qualquer valor e carimbo de data/hora que contém, são enviados a cada intervalo. Os dados são cumulativos, só podem aumentar e são repostos para 0 no reinício.

   Pode encontrar os dados em customMetrics, mas as customMetrics propriedades valueCount, valueSum, valueMin, valueMaxe valueStdDev não são efetivamente utilizadas.

Definir dimensões personalizadas em métricas

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

1. Insira as etiquetas que pretende utilizar no mapa de etiquetas. O mapa de etiquetas funciona como uma espécie de "conjunto" de todas as etiquetas disponíveis que pode utilizar.

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

2. Para um específico View, especifique as etiquetas que pretende utilizar quando estiver a gravar métricas com essa vista através da chave 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. Certifique-se de que utiliza o mapa de etiquetas quando estiver a gravar no mapa de medidas. As chaves de etiqueta especificadas no View têm de ser encontradas no mapa de etiquetas utilizado para registar.

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

4. customMetrics Na tabela, todos os registos de métricas emitidos com prompt_view têm dimensões personalizadas {"url":"http://example.com"}.

5. Para produzir etiquetas com valores diferentes com as mesmas chaves, crie novos mapas de etiquetas para as mesmas.

   ...
   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 predefinição, o exportador de métricas envia um conjunto de contadores de desempenho para o Azure Monitor. Pode desativar esta capacidade ao definir o enable_standard_metrics sinalizador False como no construtor do exportador de métricas.

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

Os seguintes contadores de desempenho são atualmente enviados:

• Memória Disponível (bytes)
• Tempo do Processador da CPU (percentagem)
• Taxa de Pedidos Recebidos (por segundo)
• Tempo médio de execução do pedido recebido (milissegundos)
• Processar Utilização da CPU (percentagem)
• Processar Bytes Privados (bytes)

Deverá conseguir ver estas métricas no performanceCounters. Para obter mais informações, veja Contadores de desempenho.

Modificar telemetria

Para obter informações sobre como modificar a telemetria controlada antes de ser enviada para o Azure Monitor, veja Processadores de telemetria Python do OpenCensus.

Rastreio

Nota

No OpenCensus, tracing refere-se ao rastreio distribuído. O AzureExporter parâmetro envia requests e dependency telemetria para o Azure Monitor.

1. Primeiro, vamos gerar alguns dados de rastreio localmente. Em Python IDLE ou no editor escolhido, introduza 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 na shell. O módulo Python do OpenCensus gera uma parte correspondente de SpanData. O projeto OpenCensus define um rastreio 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. Ver a saída é útil para fins de demonstração, mas queremos emitir SpanData para o Azure Monitor. Transmita a cadeia de ligação diretamente para o exportador. Em alternativa, pode especificá-la numa variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. Recomendamos que utilize a cadeia de ligação para instanciar os exportadores que são utilizados para enviar telemetria para o Application Insights. Modifique o código do passo 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 executa o script de Python, apenas o valor está a ser impresso na shell. A criação SpanData é enviada para o Azure Monitor. Pode encontrar os dados dependenciesde span emitidos em .

   Para obter mais informações sobre pedidos de saída, veja Dependências do Python do OpenCensus. Para obter mais informações sobre pedidos recebidos, veja Pedidos do Python do OpenCensus.

Amostragem

Para obter informações sobre a amostragem no OpenCensus, veja Amostragem no OpenCensus.

Correlação de rastreio

Para obter mais informações sobre a correlação de telemetria nos dados de rastreio, veja Correlação de telemetria do Python do OpenCensus.

Modificar telemetria

Para obter mais informações sobre como modificar a telemetria controlada antes de ser enviada para o Azure Monitor, veja Processadores de telemetria Python do OpenCensus.

Configurar exportadores do Azure Monitor

Como mostrado, existem três exportadores diferentes do Azure Monitor que suportam o OpenCensus. Cada um deles envia diferentes tipos de telemetria para o Azure Monitor. Para ver que tipos de telemetria cada exportador envia, veja a tabela seguinte.

Cada exportador aceita os mesmos argumentos para a configuração, transmitidos pelos construtores. Pode ver informações sobre cada uma aqui:

Telemetria do exportador	Description
connection_string	A cadeia de ligação utilizada para ligar ao recurso do Azure Monitor. Tem prioridade sobre instrumentation_key.
credential	Classe de credenciais utilizada pela autenticação do Azure Active Directory. Veja a secção "Autenticação" que se segue.
enable_standard_metrics	Utilizado para AzureMetricsExporter. Sinaliza o exportador para enviar automaticamente métricas do contador de desempenho para o Azure Monitor. A predefinição é True.
export_interval	Utilizado para especificar a frequência em segundos de exportação. A predefinição é 15s. Para as métricas, tem de o definir como 60 segundos ou, caso contrário, as agregações de métricas não fazem sentido no explorador de métricas.
grace_period	Utilizado para especificar o tempo limite para o encerramento dos exportadores em segundos. A predefinição é 5s.
instrumentation_key	A chave de instrumentação utilizada para ligar ao recurso do Azure Monitor.
logging_sampling_rate	Utilizado para AzureLogHandler e AzureEventHandler. Fornece uma taxa de amostragem [0,1,0] para exportar registos/eventos. A predefinição é 1.0.
max_batch_size	Especifica o tamanho máximo da telemetria exportada ao mesmo tempo.
proxies	Especifica uma sequência de proxies a utilizar para enviar dados para o Azure Monitor. Para obter mais informações, veja proxies.
storage_path	Um caminho para onde existe a pasta de armazenamento local (telemetria não enviada). A partir da opencensus-ext-azure v1.0.3, o caminho predefinido é o diretório temp do SO + + opencensus-pythonyour-ikey . Antes da v1.0.3, o caminho predefinido é $USER.azure + python-file-name.opencensus + + .
timeout	Especifica o tempo limite da rede para enviar telemetria para o serviço de ingestão em segundos. A predefinição é 10s.

Integrar com Funções do Azure

Para capturar telemetria personalizada em ambientes Funções do Azure, utilize a extensão openCensus Python Funções do Azure. Para obter mais informações, veja o guia para programadores do Python Funções do Azure.

Autenticação (pré-visualização)

Nota

A funcionalidade de autenticação está disponível a partir da opencensus-ext-azure v1.1b0.

Cada um dos exportadores do Azure Monitor suporta a configuração do envio seguro de payloads de telemetria através da autenticação OAuth com o Azure Active Directory. Para obter mais informações, veja a Documentação de autenticação.

Ver os seus dados com consultas

Pode ver os dados telemétricos que foram enviados da sua aplicação através do separador Registos (Análise ).

Na lista em Ativo:

• Para a telemetria enviada com o exportador de rastreio do Azure Monitor, os pedidos recebidos são apresentados em requests. Os pedidos de saída ou em processo são apresentados dependenciesem .
• Para a telemetria enviada com o exportador de métricas do Azure Monitor, as métricas enviadas são apresentadas em customMetrics.
• Para a telemetria enviada com o exportador de registos do Azure Monitor, os registos são apresentados em traces. As exceções são apresentadas em exceptions.

Para obter mais informações sobre como utilizar consultas e registos, veja Registos no Azure Monitor.

Saiba mais sobre o OpenCensus para Python

• OpenCensus Python no GitHub
• Personalização
• Exportadores do Azure Monitor no GitHub
• Integrações do OpenCensus
• Azure Monitor sample applications (Aplicações de exemplo do Azure Monitor)

Resolução de problemas

Testar a conectividade entre o anfitrião da aplicação e o serviço de ingestão

Os SDKs e os agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST para os nossos pontos finais de ingestão. Pode testar a conectividade do servidor Web ou do computador anfitrião da aplicação para os pontos finais do serviço de ingestão ao utilizar clientes REST não processados do PowerShell ou comandos curl. Veja Resolver problemas de telemetria de aplicações em falta no Application Insights do Azure Monitor.

Notas de Versão

Para obter as notas de versão mais recentes, veja Python Azure Monitor Exporter (Exportador do Azure Monitor do Python)

O nosso Serviço Atualizações também resumir as principais melhorias do Application Insights.

Passos seguintes

• Para ativar as experiências de utilização, ative a monitorização de utilizadores da Web ou do browser
• Controlar pedidos recebidos.
• Controlar pedidos de saída.
• Veja o Mapa da aplicação.
• Saiba como fazer a monitorização de desempenho ponto a ponto.

Alertas

• Descrição geral da disponibilidade: crie testes para se certificar de que o seu site está visível na Web.
• Diagnóstico inteligente: Estes testes são executados automaticamente, pelo que não precisa de fazer nada para os configurar. Estes indicam se a aplicação tem uma taxa de pedidos com falha fora do normal.
• Alertas de métricas: defina alertas para o avisar se uma métrica ultrapassar um limiar. Pode defini-los em métricas personalizadas que introduz no código da sua aplicação.