Configurare Monitoraggio di Azure per l'applicazione Python

Monitoraggio di Azure supporta la traccia distribuita, la raccolta delle metriche e la registrazione delle applicazioni Python.

La soluzione supportata da Microsoft per tenere traccia ed esportare i dati per le applicazioni Python è tramite OpenCensus Python SDK tramite gli utilità di esportazione di Monitoraggio di Azure.

Microsoft non consiglia di usare altri SDK di telemetria per Python come soluzione di telemetria perché non sono supportati.

OpenCensus sta convergendo in OpenTelemetry. Si continua a consigliare OpenCensus mentre OpenTelemetry si matura gradualmente.

Prerequisiti

È necessaria una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Introduzione a OpenCensus Python SDK

OpenCensus è un set di librerie open source che consentono la raccolta di dati di telemetria, metriche e traccia distribuita. Usando gli strumenti di esportazione di Monitoraggio di Azure, è possibile inviare i dati di telemetria raccolti ad Application Insights. Questo articolo illustra il processo di configurazione degli utilità di esportazione di OpenCensus e Monitoraggio di Azure per Python per inviare i dati di monitoraggio a Monitoraggio di Azure.

Instrumentare con OpenCensus Python SDK con gli esportatori di Monitoraggio di Azure

Installare le utilità di esportazione di Monitoraggio di Azure per OpenCensus:

python -m pip install opencensus-ext-azure

L'SDK usa tre utilità di esportazione di Monitoraggio di Azure per inviare diversi tipi di dati di telemetria a Monitoraggio di Azure. traceSono , metricse logs. Per altre informazioni su questi tipi di telemetria, vedere Panoramica della piattaforma dati. Usare le istruzioni seguenti per inviare questi tipi di dati di telemetria tramite le tre utilità di esportazione.

Mapping dei tipi di telemetria

OpenCensus esegue il mapping degli esportatori seguenti ai tipi di dati di telemetria visualizzati in Monitoraggio di Azure.

Registri

1. Prima di tutto, generare alcuni dati di log locali.

   
   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. Viene generata una voce di log per ogni numero nell'intervallo.

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

3. Si vogliono visualizzare questi dati di log in Monitoraggio di Azure. È possibile specificarlo in una variabile di ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. È anche possibile passare il connection_string direttamente in AzureLogHandler, ma i stringa di connessione non devono essere aggiunti al controllo della versione.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   È consigliabile usare il stringa di connessione per creare un'istanza degli esportatori usati per inviare dati di telemetria ad Application Insights. Modificare il codice del passaggio precedente in base all'esempio di codice seguente:

   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. L'utilità di esportazione invia i dati di log a Monitoraggio di Azure. È possibile trovare i dati in traces.

   In questo contesto, traces non è uguale tracinga . In questo caso, traces si riferisce al tipo di dati di telemetria visualizzati in Monitoraggio di Azure quando si usa AzureLogHandler. Ma tracing fa riferimento a un concetto in OpenCensus e si riferisce alla traccia distribuita.

   Nota

   Il logger radice è configurato con il livello di warning. Ciò significa che tutti i log inviati con minore gravità vengono ignorati e a loro volta non verranno inviati a Monitoraggio di Azure. Per altre informazioni, vedere La documentazione relativa alla registrazione.

5. È anche possibile aggiungere proprietà personalizzate ai messaggi di log nell'argomento extra parola chiave usando il custom_dimensions campo . Queste proprietà vengono visualizzate come coppie chiave-valore in customDimensions Monitoraggio di Azure.

   Nota

   Per consentire il funzionamento di questa funzionalità, è necessario passare un dizionario al custom_dimensions campo . Se si passano argomenti di qualsiasi altro tipo, il logger li 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)
   

Configurare la registrazione per le applicazioni Django

È possibile configurare la registrazione in modo esplicito nel codice dell'applicazione come quello precedente per le applicazioni Django oppure specificarla nella configurazione di registrazione di Django. Questo codice può essere inserito in qualsiasi file usato per la configurazione delle impostazioni del sito Django, in settings.pygenere .

Per informazioni su come configurare le impostazioni django, vedere Impostazioni django. Per altre informazioni su come configurare la registrazione, vedere Registrazione di 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"]},
    },
}

Assicurarsi di usare il logger con lo stesso nome di quello specificato nella configurazione.

# views.py

import logging
from django.shortcuts import request

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

Inviare eccezioni

OpenCensus Python non tiene traccia e invia exception automaticamente i dati di telemetria. Viene inviato AzureLogHandler tramite l'uso di eccezioni tramite la libreria di registrazione Python. È possibile aggiungere proprietà personalizzate come la registrazione normale.

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)

Poiché è necessario registrare le eccezioni in modo esplicito, è possibile registrare eccezioni non gestite. OpenCensus non applica restrizioni su come eseguire questa registrazione, ma è necessario registrare in modo esplicito i dati di telemetria delle eccezioni.

Inviare gli eventi

È possibile inviare customEvent dati di telemetria esattamente come si inviano trace i dati di telemetria, ad eccezione dell'uso di 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!')

Campionamento

Per informazioni sul campionamento in OpenCensus, vedere Campionamento in OpenCensus.

Correlazione dei registri

Per informazioni su come arricchire i log con i dati del contesto di traccia, vedere Integrazione dei log di Python OpenCensus.

Modificare la telemetria

Per informazioni su come modificare i dati di telemetria rilevati prima dell'invio a Monitoraggio di Azure, vedere Processori di telemetria Python OpenCensus.

Metrica

OpenCensus.stats supporta quattro metodi di aggregazione, ma offre supporto parziale per Monitoraggio di Azure:

• Conteggio: conteggio del numero di punti di misura. Il valore è cumulativo, può aumentare solo e reimpostare su 0 al riavvio.
• Somma: somma dei punti di misura. Il valore è cumulativo, può aumentare solo e reimpostare su 0 al riavvio.
• LastValue: mantiene l'ultimo valore registrato e rilascia tutto il resto.
• Distribuzione: l'utilità di esportazione di Azure non supporta la distribuzione istogramma dei punti di misura.

Esempio di aggregazione Count

1. Prima di tutto, generare alcuni dati di metrica locali. Viene creata una metrica per tenere traccia del numero di volte in cui l'utente seleziona la chiave INVIO .

   
   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. Le metriche vengono create per tenere traccia molte volte. Con ogni voce, il valore viene incrementato e le informazioni sulle metriche vengono visualizzate nella console. Le informazioni includono il valore corrente e il timestamp corrente al momento dell'aggiornamento della metrica.

   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. L'immissione di valori è utile a scopo dimostrativo, ma si vogliono generare i dati delle metriche in Monitoraggio di Azure. Passare il stringa di connessione direttamente all'utilità di esportazione. In alternativa, è possibile specificarlo in una variabile di ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. È consigliabile usare il stringa di connessione per creare un'istanza degli esportatori usati per inviare dati di telemetria ad Application Insights. Modificare il codice del passaggio precedente in base all'esempio di codice seguente:

   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. L'utilità di esportazione invia i dati delle metriche a Monitoraggio di Azure a intervalli fissi. È necessario impostare questo valore su 60 secondi perché il back-end di Application Insights presuppone l'aggregazione dei punti delle metriche in un intervallo di tempo di 60 secondi. Si sta monitorando una singola metrica, quindi questi dati delle metriche, con qualsiasi valore e timestamp che contiene, vengono inviati ogni intervallo. I dati sono cumulativi, possono aumentare solo e reimpostare su 0 al riavvio.

   È possibile trovare i dati in customMetrics, ma le customMetrics proprietà valueCount, , valueSumvalueMinvalueMax, e valueStdDev non vengono usate in modo efficace.

Impostare dimensioni personalizzate nelle metriche

OpenCensus Python SDK consente di aggiungere dimensioni personalizzate ai dati di telemetria delle metriche usando tags, come un dizionario di coppie chiave-valore.

1. Inserire i tag da usare nella mappa dei tag. La mappa tag funge da "pool" di tutti i tag disponibili che è possibile usare.

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

2. Per un oggetto specifico View, specificare i tag da usare quando si registrano le metriche con tale visualizzazione tramite la chiave del tag.

   ...
   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. Assicurarsi di usare la mappa tag durante la registrazione nella mappa di misurazione. Le chiavi di tag specificate in View devono essere trovate nella mappa tag usata per registrare.

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

4. customMetrics Nella tabella tutti i record delle metriche generati tramite prompt_view hanno dimensioni {"url":"http://example.com"}personalizzate.

5. Per produrre tag con valori diversi usando le stesse chiavi, creare nuove mappe tag per tali tag.

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

Contatori delle prestazioni

Per impostazione predefinita, l'utilità di esportazione delle metriche invia un set di contatori delle prestazioni a Monitoraggio di Azure. È possibile disabilitare questa funzionalità impostando il enable_standard_metrics flag su False nel costruttore dell'utilità di esportazione delle metriche.

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

I contatori delle prestazioni seguenti sono attualmente inviati:

• Memoria disponibile (byte)
• Tempo processore CPU (percentuale)
• Frequenza richieste in ingresso (al secondo)
• Tempo di esecuzione medio richieste in ingresso (millisecondi)
• Utilizzo CPU processi (percentuale)
• Byte privati processi (byte)

Dovrebbe essere possibile visualizzare queste metriche in performanceCounters. Per altre informazioni, vedere Contatori delle prestazioni.

Modificare la telemetria

Per informazioni su come modificare i dati di telemetria rilevati prima dell'invio a Monitoraggio di Azure, vedere Processori di telemetria Python OpenCensus.

Traccia

1. Prima di tutto, è necessario generare alcuni dati di traccia in locale. In Python IDLE o nell'editor preferito immettere il codice seguente:

   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 ogni voce, il valore viene stampato nella shell. Il modulo OpenCensus Python genera una parte corrispondente di SpanData. Nel progetto OpenCensus, una trace è un albero di span.

   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. La visualizzazione dell'output è utile a scopo dimostrativo, ma si vuole eseguire l'emissione SpanData in Monitoraggio di Azure. Passare il stringa di connessione direttamente all'utilità di esportazione. In alternativa, è possibile specificarlo in una variabile di ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. È consigliabile usare il stringa di connessione per creare un'istanza degli esportatori usati per inviare dati di telemetria ad Application Insights. Modificare il codice del passaggio precedente in base all'esempio di codice seguente:

   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. Ora, quando si esegue lo script Python, solo il valore viene stampato nella shell. Il creato SpanData viene inviato a Monitoraggio di Azure. È possibile trovare i dati di span emessi in dependencies.

   Per altre informazioni sulle richieste in uscita, vedere Dipendenze di OpenCensus Python. Per altre informazioni sulle richieste in ingresso, vedere Richieste Python OpenCensus.

Campionamento

Per informazioni sul campionamento in OpenCensus, vedere Campionamento in OpenCensus.

Correlazione delle tracce

Per altre informazioni sulla correlazione dei dati di telemetria nei dati di traccia, vedere Correlazione dei dati di telemetria di OpenCensus Python.

Modificare la telemetria

Per altre informazioni su come modificare i dati di telemetria rilevati prima dell'invio a Monitoraggio di Azure, vedere Processori di telemetria OpenCensus Python.

Configurare gli esportatori di Monitoraggio di Azure

Come illustrato, esistono tre diversi esportatori di Monitoraggio di Azure che supportano OpenCensus. Ognuno invia tipi diversi di dati di telemetria a Monitoraggio di Azure. Per visualizzare i tipi di dati di telemetria inviati da ogni utilità di esportazione, vedere la tabella seguente.

Ogni esportatore accetta gli stessi argomenti per la configurazione, passati attraverso i costruttori. Qui è possibile visualizzare informazioni su ognuna di esse:

Integrazione con Funzioni di Azure

Per acquisire dati di telemetria personalizzati in ambienti Funzioni di Azure, usare l'estensione Funzioni di Azure Python OpenCensus. Per altre informazioni, vedere la guida per sviluppatori Python Funzioni di Azure.

Autenticazione (anteprima)

Ogni utilità di esportazione di Monitoraggio di Azure supporta la configurazione dell'invio sicuro dei payload di telemetria tramite l'autenticazione OAuth con Azure Active Directory. Per altre informazioni, vedere la documentazione Autenticazione.

Visualizzare i dati usando query

È possibile visualizzare i dati di telemetria inviati dall'applicazione tramite la scheda Log (Analisi).

Nell'elenco sotto Attiva:

• Per i dati di telemetria inviati con l'utilità di esportazione log di Monitoraggio di Azure, le richieste in ingresso vengono visualizzate in requests. Le richieste in uscita o in elaborazione vengono visualizzate in dependencies.
• Per i dati di telemetria inviati con l'utilità di esportazione delle metriche di Monitoraggio di Azure, le metriche inviate vengono visualizzate in customMetrics.
• Per i dati di telemetria inviati con l'utilità di esportazione log di Monitoraggio di Azure, i log vengono visualizzati in traces. Le eccezioni vengono visualizzate in exceptions.

Per altre informazioni su come usare query e log, vedere Log in Monitoraggio di Azure.

Configurare e abilitare l'autenticazione basata su Microsoft Entra ID

Creare le credenziali appropriate e passarle al costruttore dell'utilità di esportazione di Monitoraggio di Azure. Assicurarsi che la stringa di connessione sia configurata con la chiave di strumentazione e l'endpoint di inserimento della risorsa.

Gli esportatori di Monitoraggio di Azure OpenCensus supportano questi tipi di autenticazione. È consigliabile usare le identità gestite negli ambienti di produzione.

Identità gestita assegnata dal 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)
)
...

Identità gestita assegnata dall'utente

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

Altre informazioni su OpenCensus per Python

• OpenCensus Python su GitHub
• Personalizzazione
• Utilità di esportazione di Monitoraggio di Azure in GitHub
• Integrazioni di OpenCensus
• Applicazioni di esempio di Monitoraggio di Azure

Risoluzione dei problemi

Testare la connettività tra l'host dell'applicazione e il servizio di inserimento

Gli SDK e gli agenti di Application Insights inviano dati di telemetria per l'inserimento come chiamate REST agli endpoint di inserimento. È possibile testare la connettività dal server Web o dal computer host dell'applicazione agli endpoint del servizio di inserimento usando client REST non elaborati da comandi PowerShell o curl. Vedere Risolvere i problemi di dati di telemetria delle applicazioni mancanti in Application Insights per Monitoraggio di Azure.

Note sulla versione

Per le note sulla versione più recenti, vedere Python Azure Monitor Exporter

Gli aggiornamenti del servizio riepilogano anche i principali miglioramenti di Application Insights.

Passaggi successivi

• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio utenti del Web o del browser
• Tenere traccia delle richieste in ingresso.
• Tenere traccia delle richieste in uscita.
• Vedere la mappa delle applicazioni.
• Informazioni su come eseguire il monitoraggio delle prestazioni end-to-end.

Avvisi

• Panoramica della disponibilità: creare test per assicurarsi che il sito sia visibile sul Web.
• Diagnostica intelligente: questi test vengono eseguiti automaticamente e non è quindi necessario effettuare alcuna operazione per configurarli. Se l'app ha una frequenza insolita di richieste non riuscite, verrà comunicato automaticamente.
• Avvisi delle metriche: impostare avvisi per avvisare se una metrica supera una soglia. È possibile impostarli nelle metriche personalizzate di cui si scrive il codice nell'app.