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
, metrics
och 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
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()
En loggpost genereras för varje tal i intervallet.
Log Entry - 0 Log Entry - 1 Log Entry - 2 Log Entry - 3 Log Entry - 4
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 tillAzureLogHandler
, 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}")
Exportören skickar loggdata till Azure Monitor. Du hittar data under
traces
.I det här sammanhanget
traces
är inte samma somtracing
.traces
Här refererar till den typ av telemetri som du ser i Azure Monitor när du använderAzureLogHandler
. Mentracing
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.Du kan också lägga till anpassade egenskaper i dina loggmeddelanden i nyckelordsargumentet
extra
med hjälp av fältetcustom_dimensions
. De här egenskaperna visas som nyckel/värde-par icustomDimensions
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
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()
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)
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()
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
, mencustomMetrics
egenskapernavalueCount
,valueSum
,valueMin
,valueMax
ochvalueStdDev
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 tags
av , som är som en ordlista med nyckel/värde-par.
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") ...
För en specifik
View
anger 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()) ...
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 ...
Under tabellen
customMetrics
har alla måttposter som genereras med hjälpprompt_view
av anpassade dimensioner{"url":"http://example.com"}
.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.
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()
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)]
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()
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 underdependencies
.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-python your-ikey . Före v1.0.3 är $USER .azure python-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 underdependencies
. - 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 underexceptions
.
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.