Configurare Monitoraggio di Azure per l'applicazione Python

Nota

OpenCensus Python SDK è deprecato, ma Microsoft lo supporta fino al ritiro il 30 settembre 2024. È ora consigliabile usare l'offerta Python basata su OpenTelemetry e fornire indicazioni sulla migrazione.

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 strumenti 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 matura gradualmente.

Prerequisiti

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

Nota

Il 31 marzo 2025, il supporto per l'inserimento delle chiavi di strumentazione terminerà. L'inserimento delle chiavi di strumentazione continuerà a funzionare, ma non fornirà più aggiornamenti o supporto per la funzionalità. Transizione alle stringhe di connessione per sfruttare le nuove funzionalità.

Introduzione a OpenCensus Python SDK

OpenCensus è un set di librerie open source per consentire la raccolta di dati di telemetria, metriche e di traccia distribuiti. Usando gli strumenti di esportazione di Monitoraggio di Azure, è possibile inviare questi dati di telemetria raccolti ad Application Insights. Questo articolo illustra il processo di configurazione degli strumenti 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 strumenti di esportazione 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.

Pilastro dell'osservabilità	Tipo di telemetria in Monitoraggio di Azure	Spiegazione
Log	Tracce, eccezioni, eventi personalizzati	Telemetria dei log, telemetria delle eccezioni, telemetria degli eventi
Metriche	customMetrics, performanceCounters	Contatori delle prestazioni delle metriche personalizzate
Traccia	Richieste di dipendenze	Richieste in ingresso, richieste in uscita

Log

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 le stringhe di connessione non devono essere aggiunte al controllo della versione.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   È consigliabile usare la stringa di connessione per creare un'istanza degli strumenti di esportazione 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'esportatore 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 una gravità inferiore vengono ignorati e, a sua volta, non verranno inviati a Monitoraggio di Azure. Per altre informazioni, vedere Documentazione sulla 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)
   

Nota

Nell'ambito dell'uso della strumentazione di Application Insights, vengono raccolti e inviati dati di diagnostica a Microsoft. Questi dati consentono di eseguire e migliorare Application Insights. È possibile disabilitare la raccolta dati non essenziale. Per altre informazioni, vedere Statsbeat in Application Insights.

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 genere settings.py.

Per informazioni su come configurare le impostazioni di 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 le 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 eventi

È possibile inviare customEvent dati di telemetria esattamente allo stesso modo in cui si inviano trace dati di telemetria, ad eccezione dell'uso AzureEventHandler di .

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 log

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

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.

Metriche

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

• Count: 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 sulla metrica 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 la stringa di connessione direttamente all'utilità di esportazione. In alternativa, è possibile specificarlo in una variabile di ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. È consigliabile usare la stringa di connessione per creare un'istanza degli strumenti di esportazione 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 un intervallo fisso. È 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 tiene traccia di 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 reimpostarli su 0 al riavvio.

   È possibile trovare i dati in customMetrics, ma le customMetrics proprietà valueCount, , valueSumvalueMin, valueMaxe 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 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 delle misurazioni. 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

Nota

In OpenCensus tracing fa riferimento alla traccia distribuita. Il AzureExporter parametro invia requests e dependency telemetria a Monitoraggio di Azure.

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 generare SpanData in Monitoraggio di Azure. Passare la stringa di connessione direttamente all'utilità di esportazione. In alternativa, è possibile specificarlo in una variabile di ambiente, APPLICATIONINSIGHTS_CONNECTION_STRING. È consigliabile usare la stringa di connessione per creare un'istanza degli strumenti di esportazione 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. L'oggetto 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 Python OpenCensus. 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 Python OpenCensus.

Configurare gli strumenti di esportazione di Monitoraggio di Azure

Come illustrato, esistono tre diversi esportatori di Monitoraggio di Azure che supportano OpenCensus. Ognuno invia diversi tipi 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. È possibile visualizzare le informazioni su ognuna di esse qui:

Telemetria dell'utilità di esportazione	Descrizione
connection_string	Stringa di connessione usata per connettersi alla risorsa di Monitoraggio di Azure. Assume la priorità su instrumentation_key.
credential	Classe Credential usata dall'autenticazione di Azure Active Directory. Vedere la sezione "Autenticazione" riportata di seguito.
enable_standard_metrics	Utilizzato per AzureMetricsExporter. Segnala all'utilità di esportazione di inviare automaticamente le metriche del contatore delle prestazioni a Monitoraggio di Azure. Il valore predefinito è True.
export_interval	Consente di specificare la frequenza in secondi di esportazione. Il valore predefinito è 15s. Per le metriche, è NECESSARIO impostarlo su 60 secondi oppure le aggregazioni delle metriche non hanno senso in Esplora metriche.
grace_period	Utilizzato per specificare il timeout per l'arresto degli esportatori in secondi. Il valore predefinito è 5s.
instrumentation_key	Chiave di strumentazione usata per connettersi alla risorsa di Monitoraggio di Azure.
logging_sampling_rate	Usato per AzureLogHandler e AzureEventHandler. Fornisce una frequenza di campionamento [0,1,0] per l'esportazione di log/eventi. Il valore predefinito è 1.0.
max_batch_size	Specifica le dimensioni massime dei dati di telemetria esportati contemporaneamente.
proxies	Specifica una sequenza di proxy da usare per l'invio di dati a Monitoraggio di Azure. Per altre informazioni, vedere proxy.
storage_path	Percorso in cui è presente la cartella di archiviazione locale (dati di telemetria non inviati). opencensus-ext-azure A partire dalla versione 1.0.3, il percorso predefinito è la directory temporanea del sistema operativo + + opencensus-pythonyour-ikey . Prima della versione 1.0.3, il percorso predefinito è $USER.azure + python-file-name.opencensus + + .
timeout	Specifica il timeout di rete per inviare i dati di telemetria al servizio di inserimento in secondi. Il valore predefinito è 10s.

Integrazione con Funzioni di Azure

Per acquisire dati di telemetria personalizzati negli 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)

Nota

La funzionalità di autenticazione è disponibile a partire dalla opencensus-ext-azure versione 1.1b0.

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 relativa all'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.

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 essere inseriti 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 PowerShell o comandi curl. Vedere Risolvere i problemi di telemetria delle applicazioni mancanti in Application Insights per Monitoraggio di Azure.

Note sulla versione

Per le note sulla versione più recenti, vedere Utilità di esportazione di Monitoraggio di Azure python

Il servizio Aggiornamenti riepiloga anche i principali miglioramenti di Application Insights.

Passaggi successivi

• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio degli utenti del Web o del browser
• Tenere traccia delle richieste in ingresso.
• Tenere traccia delle richieste in uscita.
• Vedere la mappa dell'applicazione.
• 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 essere avvertiti se una metrica supera una soglia. È possibile impostarli nelle metriche personalizzate di cui si scrive il codice nell'app.