Configurar Azure Monitor para seu aplicativo Python

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

A solução com suporte da Microsoft para acompanhar e exportar dados para seus aplicativos Python é por meio do SDK do Python Opencensus por meio dos exportadores do Azure Monitor.

Outros SDKs de telemetria para Python não são compatíveis e NÃO são recomendados pela Microsoft para serem usados como uma solução de telemetria.

Talvez você tenha observado que OpenCensus está convergindo para OpenTelemetry. No entanto, continuamos recomendando o OpenCensus enquanto a OpenTelemetry se desenvolve gradualmente.

Observação

Uma versão prévia da oferta do Python baseada em OpenTelemetry está disponível. Saiba mais.

Pré-requisitos

  • Uma assinatura do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
  • Instalação do Python. Este artigo usa o Python 3.7.0, embora outras versões provavelmente funcionem com pequenas alterações. O SDK do Python Opencensus dá suporte apenas ao Python v2.7 e v3.4+.
  • Crie um recurso Application Insights. Você receberá sua própria chave de instrumentação (iKey) para seu recurso.

Introdução ao SDK Opencensus do Python

O OpenCensus é um conjunto de bibliotecas de código aberto para permitir a coleta de rastreamento distribuído, métricas e telemetria de log. Usando os exportadores do Azure Monitor, você poderá enviar essa telemetria coletada para o Application Insights. Este artigo orientará você pelo processo de configuração do OpenCensus e dos Exportadores do Azure Monitor para Python a fim de enviar dados de monitoramento para o 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

Observação

O comando python -m pip install opencensus-ext-azure pressupõe que você tenha uma variável de ambiente PATH definida para sua instalação do Python. Se você não tiver configurado essa variável, precisará fornecer o caminho completo do diretório para o local em que o executável do Python está localizado. Execute um comando como este: C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe -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 rastreamento, métricas e logs. Para obter mais informações sobre esses tipos de telemetria, consulte 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

Aqui estão os exportadores que o OpenCensus fornece mapeados para os tipos de telemetria que você verá 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, 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 valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  2. O código solicitara continuamente um valor a ser inserido. Uma entrada de log é emitida para cada valor inserido.

    Enter a value: 24
    24
    Enter a value: 55
    55
    Enter a value: 123
    123
    Enter a value: 90
    90
    
  3. Embora a inserção de valores seja útil para fins de demonstração, na realidade, desejamos emitir os dados de log para o Azure Monitor. Passe sua cadeia de conexão diretamente no exportador. Ou você pode especificá-lo em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. 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__)
    
    # 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. O exportador envia dados de log para o Azure Monitor. Você pode encontrar os dados em traces.

    Observação

    Nesse contexto, traces não é o mesmo que tracing. Aqui, traces refere-se ao tipo de telemetria que você verá no Azure Monitor ao utilizar o 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 aviso. Isso significa que todos os logs que você enviar com menos de uma severidade serão ignorados e, por sua vez, não serão enviados para o Azure Monitor. Para obter mais informações, consulte a documentação.

  5. Você também pode adicionar propriedades personalizadas às suas 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 esse recurso funcione, você precisa passar 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__)
    # 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)
    

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. Saiba mais.

Configurar o log para aplicativos Django

Você pode configurar o registro em log explicitamente no código do aplicativo, como acima, para seus aplicativos Django, ou pode especificá-lo na configuração de log do Django. Esse código pode entrar em qualquer arquivo que você usar para a configuração de configurações do Django. Para saber como definir as configurações de Django, consulte configurações de Django. Para obter mais informações sobre como configurar o registro em log, consulte registro em do Django.

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

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

import logging

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. Eles são enviados por AzureLogHandler usando exceções por meio da biblioteca de log do Python. Você pode adicionar propriedades personalizadas, assim como com o log normal.

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)

Como você deve registrar as exceções explicitamente, cabe ao usuário como ele deseja registrar as exceções sem tratamento. O OpenCensus não coloca restrições sobre como um usuário deseja fazer isso, desde que registre explicitamente uma telemetria de exceção.

Enviar eventos

Você pode enviar customEvent a telemetria exatamente da mesma maneira que envia a trace telemetria, exceto usando o AzureEventHandler em vez disso.

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

amostragem

Para obter informações sobre amostragem no OpenCensus, dê uma olhada em amostragem no OpenCensus.

Correlação de logs

Para obter detalhes sobre como enriquecer seus logs com dados de contexto de rastreamento, consulte a integração de logs do OpenCensus Python.

Modificar telemetria

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

Métricas

O OpenCensus. stats dá suporte a 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 redefinir como 0 na reinicialização.
  • Soma: uma soma dos pontos de medida. O valor é cumulativo, só pode aumentar e redefinir como 0 na reinicialização.
  • Últimovalue: mantém o último valor gravado, descarta todo o resto.
  • Distribuição: distribuição de histograma dos pontos de medida. Esse método não há suporte pelo exportador do Azure.

Exemplo de agregação de contagem

  1. Primeiro vamos gerar alguns dados métricos locais. Criaremos uma métrica simples para acompanhar o número de vezes que o usuário seleciona a t 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 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. Executar o código repetidamente solicita que você selecione Enter. Uma métrica é criada para rastrear o número de vezes que Enter é selecionada. 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.

    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. Embora a inserção de valores seja útil para fins de demonstração, na realidade, desejamos emitir os dados de métrica para o Azure Monitor. Passe sua cadeia de conexão diretamente no exportador. Ou você pode especificá-lo em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. 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()
    
    # 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. O exportador envia dados de métrica para o Azure Monitor em um intervalo fixo. O padrão é a cada 15 segundos. 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 redefinir como 0 na reinicialização. Você pode encontrar os dados em customMetrics, mas customMetrics as propriedades ValueCount, valueal, ValueMin, ValueMax e valueStdDev não são usadas com eficiência.

Configurando dimensões personalizadas em métricas

O SDK Opencensus do Python permite adicionar dimensões personalizadas à telemetria de métricas por meio de tags, que são essencialmente 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 distinto, especifique as marcas que você deseja usar ao registrar métricas com essa exibição por meio da chave de marca.

    ...
    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 usar o mapa de marca ao gravar no mapa de medida. 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 usando prompt_view terão dimensões personalizadas {"url":"http://example.com"}.

  5. Para produzir marcas com valores diferentes usando as mesmas chaves, crie novos mapas de marca 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. Você pode desabilitar isso 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,
  connection_string='InstrumentationKey=<your-instrumentation-key-here>')
...

Esses contadores de desempenho são enviados no momento:

  • 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 obter mais informações, consulte 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 AzureExporter envia a telemetria requests e dependency para o 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 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. Executar o código repetidamente solicita que você insira um valor. Com cada entrada, o valor é impresso no Shell. O módulo OpenCensus Python gera uma parte correspondente do SpanData. O projeto OpenCensus define um rastreamento como uma árvore de 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. Embora a inserção de valores seja útil para fins de demonstração, na realidade, desejamos emitir SpanData para o Azure Monitor. Passe sua cadeia de conexão diretamente no exportador. Ou você pode especificá-lo em uma variável de ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. 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
    
    # 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. Agora, quando você executa o script Python, ainda deve ser solicitado a inserir valores, mas apenas o valor que está sendo 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 obter informações sobre amostragem no OpenCensus, dê uma olhada em amostragem no OpenCensus.

Correlação de rastreamento

Para obter mais informações sobre a correlação de telemetria em seus dados de rastreamento, confira a correlação de telemetria do OpenCensus Python.

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 cada exportador envia, consulte a lista a seguir.

Cada exportador aceita os mesmos argumentos para configuração, passados pelos construtores. Você pode ver detalhes sobre cada um aqui:

  • connection_string: a cadeia de conexão usada para se conectar ao recurso de Azure Monitor. Tem prioridade instrumentation_key.
  • enable_standard_metrics: usada paraAzureMetricsExporter. 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 a frequência em segundos de exportação.
  • instrumentation_key: a chave de instrumentação usada para se conectar ao recurso de Azure Monitor.
  • logging_sampling_rate: usada paraAzureLogHandler. Fornece uma taxa de amostragem [0,1,0] para exportar logs. O valor padrão é 1.0.
  • max_batch_size: especifica o tamanho máximo da telemetria que é exportada de uma vez.
  • proxies: especifica uma sequência de proxies a serem usados para enviar dados para o Azure Monitor. Para obter mais informações, consulte proxies.
  • storage_path: um caminho para onde a pasta de armazenamento local existe (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 do v 1.0.3, o caminho padrão é $USER + .opencensus + .azure + python-file-name.

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

Observação

O recurso de autenticação está disponível começando no 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 de autenticação OAuth com o AAD (Azure Active Directory). Para saber mais, confira a documentação da 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) .

Captura de tela do painel Visão geral com "Logs (Análise)" selecionado em uma caixa vermelha

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 obter informações mais detalhadas sobre como usar consultas e logs, consulte Logs no Azure Monitor.

Saiba mais sobre o OpenCensus para Python

Próximas etapas

Alertas

  • Testes de disponibilidade: Crie testes para garantir que o site esteja 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.