Konfigurera Azure Monitor för ditt Python-program

Azure Monitor stöder distribuerad spårning, måttinsamling och loggning av Python-program.

Microsofts lösning som stöds för att spåra och exportera data för dina Python-program är via OpenCensus Python SDK via Azure Monitor-exportörerna.

Microsoft rekommenderar inte att du använder andra telemetri-SDK:er för Python som en telemetrilösning eftersom de inte stöds.

OpenCensus konvergerar till OpenTelemetry. Vi fortsätter att rekommendera OpenCensus medan OpenTelemetry gradvis mognar.

Förutsättningar

Du behöver en Azure-prenumerationen. Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Introduktion till OpenCensus Python SDK

OpenCensus är en uppsättning bibliotek med öppen källkod som tillåter insamling av distribuerad spårning, mått och loggningstelemetri. Genom att använda Azure Monitor-exportörer kan du skicka den här insamlade telemetrin till Application Insights. Den här artikeln beskriver hur du konfigurerar OpenCensus- och Azure Monitor-exportörer för Python för att skicka dina övervakningsdata till Azure Monitor.

Instrument med OpenCensus Python SDK med Azure Monitor-exportörer

Installera OpenCensus Azure Monitor-exportörerna:

python -m pip install opencensus-ext-azure

SDK använder tre Azure Monitor-exportörer för att skicka olika typer av telemetri till Azure Monitor. De är trace, metricsoch logs. Mer information om dessa telemetrityper finns i översikten över dataplattformen. Använd följande instruktioner för att skicka dessa telemetrityper via de tre exportörerna.

Mappningar av telemetrityp

OpenCensus mappar följande exportörer till de typer av telemetri som du ser i Azure Monitor.

Loggar

1. Först ska vi generera lokala loggdata.

   
   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. En loggpost genereras för varje tal i intervallet.

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

3. Vi vill se loggdata till Azure Monitor. Du kan ange den i en miljövariabel, APPLICATIONINSIGHTS_CONNECTION_STRING. Du kan också skicka connection_string direkt till AzureLogHandler, men anslutningssträng bör inte läggas till i versionskontrollen.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Vi rekommenderar att du använder anslutningssträng för att instansiera de exportörer som används för att skicka telemetri till Application Insights. Ändra koden från föregående steg baserat på följande kodexempel:

   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. Exportören skickar loggdata till Azure Monitor. Du hittar data under traces.

   I det här sammanhanget traces är inte samma som tracing. traces Här refererar till den typ av telemetri som du ser i Azure Monitor när du använder AzureLogHandler. Men tracing refererar till ett begrepp i OpenCensus och relaterar till distribuerad spårning.

   Kommentar

   Rotloggaren har konfigurerats med nivån warning. Det innebär att alla loggar som du skickar som har mindre allvarlighetsgrad ignoreras och i sin tur inte skickas till Azure Monitor. Mer information finns i loggningsdokumentationen.

5. Du kan också lägga till anpassade egenskaper i dina loggmeddelanden i nyckelordsargumentet extra med hjälp av fältet custom_dimensions . De här egenskaperna visas som nyckel/värde-par i customDimensions Azure Monitor.

   Kommentar

   För att den här funktionen ska fungera måste du skicka en ordlista till fältet custom_dimensions . Om du skickar argument av någon annan typ ignorerar loggaren dem.

   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)
   

Konfigurera loggning för Django-program

Du kan konfigurera loggning explicit i programkoden som föregående för dina Django-program, eller så kan du ange den i Djangos loggningskonfiguration. Den här koden kan gå till den fil som du använder för Django-webbplatsens inställningskonfiguration, vanligtvis settings.py.

Information om hur du konfigurerar Django-inställningar finns i Django-inställningar. Mer information om hur du konfigurerar loggning finns i Django-loggning.

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

Se till att du använder loggaren med samma namn som den som anges i konfigurationen.

# views.py

import logging
from django.shortcuts import request

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

Skicka undantag

OpenCensus Python spårar och skickar exception inte telemetri automatiskt. Det skickas via AzureLogHandler med undantag via Python-loggningsbiblioteket. Du kan lägga till anpassade egenskaper som du gör med normal loggning.

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)

Eftersom du måste logga undantag explicit är det upp till dig hur du loggar ohanterade undantag. OpenCensus har inga begränsningar för hur den här loggningen ska utföras, men du måste uttryckligen logga undantagstelemetri.

Skicka händelser

Du kan skicka customEvent telemetri på exakt samma sätt som du skickar trace telemetri, förutom genom att använda AzureEventHandler i stället.

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

Sampling

Information om sampling i OpenCensus finns i Sampling i OpenCensus.

Loggkorrelation

Information om hur du utökar dina loggar med spårningskontextdata finns i Integrering av OpenCensus Python-loggar.

Ändra telemetri

Information om hur du ändrar spårad telemetri innan den skickas till Azure Monitor finns i OpenCensus Python-telemetriprocessorer.

Mått

OpenCensus.stats stöder fyra aggregeringsmetoder men ger delvis stöd för Azure Monitor:

• Antal: Antalet mätpunkter. Värdet är kumulativt, kan bara öka och återställs till 0 vid omstart.
• Summa: En summering av mätpunkterna. Värdet är kumulativt, kan bara öka och återställs till 0 vid omstart.
• LastValue: Behåller det senast registrerade värdet och släpper allt annat.
• Distribution: Azure-exportören stöder inte histogramfördelningen för mätpunkterna.

Exempel på antal sammansättningar

1. Först ska vi generera några lokala måttdata. Vi skapar ett mått för att spåra hur många gånger användaren väljer returnyckeln.

   
   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. Mått skapas för att spåra många gånger. För varje post ökas värdet och måttinformationen visas i konsolen. Informationen innehåller det aktuella värdet och den aktuella tidsstämpeln när måttet uppdaterades.

   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. Att ange värden är användbart i demonstrationssyfte, men vi vill skicka måttdata till Azure Monitor. Skicka anslutningssträng direkt till exportören. Eller så kan du ange den i en miljövariabel, APPLICATIONINSIGHTS_CONNECTION_STRING. Vi rekommenderar att du använder anslutningssträng för att instansiera de exportörer som används för att skicka telemetri till Application Insights. Ändra koden från föregående steg baserat på följande kodexempel:

   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. Exportören skickar måttdata till Azure Monitor med ett fast intervall. Du måste ange det här värdet till 60 sekunder eftersom Application Insights-serverdelen förutsätter aggregering av måttpunkter med ett tidsintervall på 60 sekunder. Vi spårar ett enda mått, så dessa måttdata, oavsett värde och tidsstämpel, skickas varje intervall. Data är kumulativa, kan bara öka och återställs till 0 vid omstart.

   Du hittar data under customMetrics, men customMetrics egenskaperna valueCount, valueSum, valueMin, valueMaxoch valueStdDev används inte effektivt.

Ange anpassade dimensioner i mått

Med OpenCensus Python SDK kan du lägga till anpassade dimensioner i din måtttelemetri med hjälp tagsav , som är som en ordlista med nyckel/värde-par.

1. Infoga de taggar som du vill använda i taggkartan. Taggkartan fungerar som en slags "pool" av alla tillgängliga taggar som du kan använda.

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

2. För en specifik Viewanger du de taggar som du vill använda när du registrerar mått med den vyn via taggnyckeln.

   ...
   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. Se till att använda taggkartan när du registrerar på måttkartan. Taggnycklarna som anges i View måste hittas i taggkartan som används för att registrera.

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

4. Under tabellen customMetrics har alla måttposter som genereras med hjälp prompt_view av anpassade dimensioner {"url":"http://example.com"}.

5. Skapa nya taggkartor för dem om du vill skapa taggar med olika värden med samma nycklar.

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

Prestandaräknare

Som standard skickar måttexportören en uppsättning prestandaräknare till Azure Monitor. Du kan inaktivera den här funktionen genom att ange enable_standard_metrics flaggan till False i konstruktorn för måttexportören.

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

Följande prestandaräknare skickas för närvarande:

• Tillgängligt minne (byte)
• Processortid (procent)
• Inkommande begärandefrekvens (per sekund)
• Genomsnittlig körningstid för inkommande begäran (millisekunder)
• Bearbeta CPU-användning (procent)
• Bearbeta privata byte (byte)

Du bör kunna se dessa mått i performanceCounters. Mer information finns i Prestandaräknare.

Ändra telemetri

Information om hur du ändrar spårad telemetri innan den skickas till Azure Monitor finns i OpenCensus Python-telemetriprocessorer.

Spårning

1. Först ska vi generera spårningsdata lokalt. I Python IDLE, eller valfri redigerare, anger du följande kod:

   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. För varje post skrivs värdet ut till gränssnittet. Modulen OpenCensus Python genererar en motsvarande del av SpanData. OpenCensus-projektet definierar en spårning som ett intervallträd.

   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. Det är användbart att visa utdata i demonstrationssyfte, men vi vill skicka SpanData dem till Azure Monitor. Skicka anslutningssträng direkt till exportören. Eller så kan du ange den i en miljövariabel, APPLICATIONINSIGHTS_CONNECTION_STRING. Vi rekommenderar att du använder anslutningssträng för att instansiera de exportörer som används för att skicka telemetri till Application Insights. Ändra koden från föregående steg baserat på följande kodexempel:

   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. Nu när du kör Python-skriptet skrivs bara värdet ut i gränssnittet. Den skapade SpanData skickas till Azure Monitor. Du hittar utsända span-data under dependencies.

   Mer information om utgående begäranden finns i OpenCensus Python-beroenden. Mer information om inkommande begäranden finns i OpenCensus Python-begäranden.

Sampling

Information om sampling i OpenCensus finns i Sampling i OpenCensus.

Spårningskorrelation

Mer information om telemetrikorrelation i spårningsdata finns i OpenCensus Python-telemetrikorrelation.

Ändra telemetri

Mer information om hur du ändrar spårad telemetri innan den skickas till Azure Monitor finns i OpenCensus Python-telemetriprocessorer.

Konfigurera Azure Monitor-exportörer

Som du ser finns det tre olika Azure Monitor-exportörer som stöder OpenCensus. Var och en skickar olika typer av telemetri till Azure Monitor. Information om vilka typer av telemetri som varje exportör skickar finns i följande tabell.

Varje exportör accepterar samma argument för konfigurationen som skickas genom konstruktorerna. Du kan se information om var och en här:

Integrera med Azure Functions

Om du vill samla in anpassad telemetri i Azure Functions-miljöer använder du Azure Functions-tillägget OpenCensus Python. Mer information finns i utvecklarhandboken för Azure Functions Python.

Autentisering (förhandsversion)

Var och en av Azure Monitor-exportörerna stöder konfiguration av säker sändning av telemetrinyttolaster via OAuth-autentisering med Azure Active Directory. Mer information finns i dokumentationen om autentisering.

Visa dina data med frågor

Du kan visa telemetridata som skickades från ditt program via fliken Loggar (Analys).

I listan under Aktiv:

• För telemetri som skickas med Azure Monitor-spårningsexportören visas inkommande begäranden under requests. Utgående begäranden eller pågående begäranden visas under dependencies.
• För telemetri som skickas med Azure Monitor-måttexportören visas skickade mått under customMetrics.
• För telemetri som skickas med Azure Monitor-loggexportören visas loggarna under traces. Undantag visas under exceptions.

Mer information om hur du använder frågor och loggar finns i Loggar i Azure Monitor.

Konfigurera och aktivera Microsoft Entra ID-baserad autentisering

Skapa lämpliga autentiseringsuppgifter och skicka dem till konstruktorn för Azure Monitor-exportören. Kontrollera att din anslutningssträng har konfigurerats med instrumentationsnyckeln och inmatningsslutpunkten för resursen.

OpenCensus Azure Monitor-exportörerna stöder dessa autentiseringstyper. Vi rekommenderar att du använder hanterade identiteter i produktionsmiljöer.

Systemtilldelad hanterad identitet

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

Användartilldelad hanterad identitet

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

Läs mer om OpenCensus för Python

• OpenCensus Python på GitHub
• Anpassning
• Azure Monitor-exportörer på GitHub
• OpenCensus-integreringar
• Azure Monitor-exempelprogram

Felsökning

Testa anslutningen mellan programvärden och inmatningstjänsten

Application Insights SDK:er och agenter skickar telemetri för att matas in som REST-anrop till våra inmatningsslutpunkter. Du kan testa anslutningen från webbservern eller programvärddatorn till slutpunkterna för inmatningstjänsten med hjälp av råa REST-klienter från PowerShell- eller curl-kommandon. Se Felsöka programtelemetri som saknas i Azure Monitor Application Insights.

Viktig information

De senaste viktig information finns i Python Azure Monitor Exporter

Våra tjänstuppdateringar sammanfattar även större Förbättringar av Application Insights.

Nästa steg

• Aktivera webb- eller webbläsaranvändarövervakning för att aktivera användningsupplevelser
• Spåra inkommande begäranden.
• Spåra utgående begäranden.
• Kolla in programkartan.
• Lär dig hur du utför prestandaövervakning från slutpunkt till slutpunkt.

Aviseringar

• Tillgänglighetsöversikt: Skapa tester för att se till att webbplatsen är synlig på webben.
• Smart diagnostik: De här testerna körs automatiskt, så du behöver inte göra något för att konfigurera dem. De berättar om din app har ett ovanligt antal misslyckade begäranden.
• Måttaviseringar: Ange aviseringar för att varna dig om ett mått överskrider ett tröskelvärde. Du kan ställa in dem för anpassade mätningar som du kodar i din app.