Konfigurera Azure Monitor för ditt Python-program

Kommentar

OpenCensus Python SDK är inaktuellt, men Microsoft stöder det tills den upphör den 30 september 2024. Nu rekommenderar vi det OpenTelemetry-baserade Python-erbjudandet och ger migreringsvägledning.

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.

Kommentar

Stödet för inmatning av instrumentationsnycklar upphör den 31 mars 2025. Inmatningen av instrumenteringsnyckeln fortsätter att fungera, men vi kommer inte längre att tillhandahålla uppdateringar eller stöd för funktionen. Övergå till niska veze för att dra nytta av nya funktioner.

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.

Grundpelare för observerbarhet	Telemetrityp i Azure Monitor	Förklaring
Loggar	Spårningar, undantag, customEvents	Loggtelemetri, undantagstelemetri, händelsetelemetri
Mått	customMetrics, performanceCounters	Prestandaräknare för anpassade mått
Spårning	Begär beroenden	Inkommande begäranden, utgående begäranden

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 niska veze bör inte läggas till i versionskontroll.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Vi rekommenderar att du använder niska veze 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)
   

Kommentar

Som en del av användningen av Application Insights-instrumentation samlar vi in och skickar diagnostikdata till Microsoft. Dessa data hjälper oss att köra och förbättra Application Insights. Du kan inaktivera icke-nödvändig datainsamling. Mer information finns i Statsbeat i Application Insights.

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 niska veze direkt till exportören. Eller så kan du ange den i en miljövariabel, APPLICATIONINSIGHTS_CONNECTION_STRING. Vi rekommenderar att du använder niska veze 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

Kommentar

I OpenCensus tracing refererar till distribuerad spårning. Parametern AzureExporter skickar requests och dependency telemetri till Azure Monitor.

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 niska veze direkt till exportören. Eller så kan du ange den i en miljövariabel, APPLICATIONINSIGHTS_CONNECTION_STRING. Vi rekommenderar att du använder niska veze 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:

Telemetri för exportör	beskrivning
connection_string	Den niska veze som används för att ansluta till din Azure Monitor-resurs. Prioriterar över instrumentation_key.
credential	Autentiseringsklass som används av Azure Active Directory-autentisering. Se avsnittet "Autentisering" som följer.
enable_standard_metrics	Används för AzureMetricsExporter. Signalerar exportören att automatiskt skicka mått för prestandaräknare till Azure Monitor. Standardvärdet är True.
export_interval	Används för att ange frekvensen i sekunder efter export. Standardvärdet är 15s. För mått måste du ange det till 60 sekunder, annars är måttaggregeringarna inte meningsfulla i måttutforskaren.
grace_period	Används för att ange tidsgränsen för avstängning av exportörer i sekunder. Standardvärdet är 5s.
instrumentation_key	Instrumentationsnyckeln som används för att ansluta till din Azure Monitor-resurs.
logging_sampling_rate	Används för AzureLogHandler och AzureEventHandler. Tillhandahåller en samplingsfrekvens [0,1.0] för export av loggar/händelser. Standardvärdet är 1.0.
max_batch_size	Anger den maximala storleken på telemetri som exporteras samtidigt.
proxies	Anger en sekvens med proxyservrar som ska användas för att skicka data till Azure Monitor. Mer information finns i proxyservrar.
storage_path	En sökväg till platsen där den lokala lagringsmappen finns (ej använda telemetri). opencensus-ext-azure Från och med v1.0.3 är standardsökvägen operativsystemets temporära katalog + + opencensus-pythonyour-ikey . Före v1.0.3 är $USER.azurepython-file-name + .opencensus + + standardsökvägen .
timeout	Anger tidsgränsen för nätverk för att skicka telemetri till inmatningstjänsten på några sekunder. Standardvärdet är 10s.

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)

Kommentar

Autentiseringsfunktionen är tillgänglig från opencensus-ext-azure och med v1.1b0.

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

Kommentar

Microsoft Entra-autentisering är endast tillgängligt för Python v2.7, v3.6 och v3.7. Stöd för Microsoft Entra-ID i Application Insights OpenCensus Python SDK ingår från och med betaversionen opencensus-ext-azure 1.1b0.

Kommentar

OpenCensus Python SDK är inaktuellt, men Microsoft stöder det tills den upphör den 30 september 2024. Nu rekommenderar vi det OpenTelemetry-baserade Python-erbjudandet och ger migreringsvägledning.

Skapa lämpliga autentiseringsuppgifter och skicka dem till konstruktorn för Azure Monitor-exportören. Kontrollera att din niska veze 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.