Az Azure Monitor beállítása Python-alkalmazáshoz

Feljegyzés

Az OpenCensus Python SDK elavult, de a Microsoft 2024. szeptember 30-i nyugdíjba vonulásáig támogatja. Most az OpenTelemetry-alapú Python-ajánlatot javasoljuk, és migrálási útmutatást nyújtunk.

Az Azure Monitor támogatja a Python-alkalmazások elosztott nyomkövetését, metrikagyűjtését és naplózását.

A Microsoft által támogatott megoldás a Python-alkalmazások adatainak nyomon követésére és exportálására az OpenCensus Python SDK-on keresztül történik az Azure Monitor-exportőrökön keresztül.

A Microsoft nem javasolja más telemetriai SDK-k használatát a Pythonhoz telemetriai megoldásként, mert nem támogatottak.

Az OpenCensus az OpenTelemetria felé konvergál. Továbbra is az OpenCensus használatát javasoljuk, amíg az OpenTelemetria fokozatosan kiforr.

Előfeltételek

Azure-előfizetésre van szüksége. Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot.

Feljegyzés

2025. március 31-én megszűnik az eszközkulcsalapú betöltés támogatása. A rendszerállapot-kulcsok betöltése továbbra is működni fog, de a továbbiakban nem biztosítunk frissítéseket vagy támogatást a funkcióhoz. Váltás kapcsolati sztring az új képességek kihasználásához.

Az OpenCensus Python SDK bemutatása

Az OpenCensus nyílt forráskódú kódtárak készlete, amelyek lehetővé teszik az elosztott nyomkövetés, a metrikák és a naplózási telemetria gyűjtését. Az Azure Monitor-exportőrökkel ezt az összegyűjtött telemetriát elküldheti az Application Insightsnak. Ez a cikk végigvezeti az OpenCensus és az Azure Monitor-exportőrök Pythonhoz való beállításának folyamatán, hogy a monitorozási adatokat elküldje az Azure Monitornak.

Eszköz az OpenCensus Python SDK-val az Azure Monitor-exportőrökkel

Telepítse az OpenCensus Azure Monitor-exportőröket:

python -m pip install opencensus-ext-azure

Az SDK három Azure Monitor-exportőr használatával küld különböző típusú telemetriai adatokat az Azure Monitornak. Ők trace, metricsés logs. Ezekről a telemetriatípusokról további információt az Adatplatform áttekintésében talál. Ezeket a telemetriai típusokat a következő utasítások segítségével küldheti el a három exportőrnek.

Telemetriai típusleképezések

Az OpenCensus a következő exportőröket képezi le az Azure Monitorban látható telemetriai típusokhoz.

A megfigyelhetőség pillére	Telemetriai típus az Azure Monitorban	Magyarázat
Naplók	Nyomkövetések, kivételek, customEvents	Naplótelemetria, kivételtelemetria, eseménytelemetria
Mérőszámok	customMetrics, performanceCounters	Egyéni metrikák teljesítményszámlálói
Nyomkövetés	Függőségek kérése	Bejövő kérések, kimenő kérések

Naplók

1. Először hozzunk létre néhány helyi naplóadatot.

   
   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. A rendszer naplóbejegyzést ad ki a tartomány minden számához.

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

3. Ezeket a naplóadatokat az Azure Monitorban szeretnénk megtekinteni. Megadhatja egy környezeti változóban. APPLICATIONINSIGHTS_CONNECTION_STRING A connection_string közvetlenül a verziókövetésbe AzureLogHandleris átadhatja, de kapcsolati sztring nem szabad hozzáadni.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Javasoljuk, hogy a kapcsolati sztring használatával példányosíthassa azokat az exportőröket, amelyek telemetriai adatokat küldenek az Application Insightsnak. Módosítsa a kódot az előző lépésben a következő kódminta alapján:

   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. Az exportőr naplóadatokat küld az Azure Monitornak. Az adatok a következő alatt tracestalálhatók: .

   Ebben a kontextusban nem ugyanaz, traces mint tracinga . Itt arra a telemetriára hivatkozik, traces amelyet az Azure Monitor használ.AzureLogHandler Az OpenCensusban azonban tracing egy fogalomra hivatkozik, és az elosztott nyomkövetésre vonatkozik.

   Feljegyzés

   A gyökérnaplózó a következő szinttel warningvan konfigurálva: . Ez azt jelenti, hogy a kisebb súlyosságú naplókat figyelmen kívül hagyja a rendszer, és nem küldi el az Azure Monitornak. További információ: Naplózási dokumentáció.

5. A kulcsszóargumentumban extra egyéni tulajdonságokat is hozzáadhat a naplóüzenetekhez a custom_dimensions mező használatával. Ezek a tulajdonságok kulcs-érték párként jelennek meg az Azure Monitorban customDimensions .

   Feljegyzés

   Ahhoz, hogy ez a funkció működjön, át kell adnia egy szótárt a custom_dimensions mezőnek. Ha bármilyen más típusú argumentumot ad át, a naplózó figyelmen kívül hagyja őket.

   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)
   

Feljegyzés

Az Application Insights rendszerállapotának részeként diagnosztikai adatokat gyűjtünk és küldünk a Microsoftnak. Ezek az adatok segítenek az Application Insights futtatásában és fejlesztésében. Lehetősége van letiltani a nem alapvető adatgyűjtést. További információ: Statsbeat in Application Insights.

Naplózás konfigurálása Django-alkalmazásokhoz

A naplózást explicit módon konfigurálhatja az alkalmazás kódjában, a Django-alkalmazások előzőéhez hasonlóan, vagy megadhatja a Django naplózási konfigurációjában. Ez a kód a Django webhely beállításainak konfigurációjához használt fájlba is bekerülhet, általában settings.py.

A Django-beállítások konfigurálásáról további információt a Django beállításai című témakörben talál. A naplózás konfigurálásáról további információt a Django naplózásában talál.

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

Ügyeljen arra, hogy a naplózó neve megegyezik a konfigurációban megadott névvel.

# views.py

import logging
from django.shortcuts import request

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

Kivételek küldése

Az OpenCensus Python nem követi nyomon és küldi exception el automatikusan a telemetriát. A rendszer kivételekkel továbbítja AzureLogHandler a Python naplózási kódtárán keresztül. A normál naplózáshoz hasonlóan egyéni tulajdonságokat is hozzáadhat.

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)

Mivel a kivételeket explicit módon kell naplóznia, önnek kell naplóznia a nem kezelt kivételeket. Az OpenCensus nem korlátozza a naplózás módját, de explicit módon naplóznia kell a kivétel telemetriáját.

Események küldése

A telemetriai adatokat pontosan ugyanúgy küldheti customEvent el, mint a telemetriát, kivéve ahelyett, hogy trace ezt használjuk AzureEventHandler .

import logging
from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler())
# Alternatively manually pass in the connection_string
# logger.addHandler(AzureEventHandler(connection_string=<appinsights-connection-string>))

logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Mintavételezés

Az OpenCensus mintavételezéséről további információt az OpenCensus mintavételezésében talál.

Napló-összefüggések

A naplók nyomkövetési környezeti adatokkal való gazdagításáról további információt az OpenCensus Python-naplók integrációja című témakörben talál.

Telemetria módosítása

A nyomon követett telemetriai adatokNak az Azure Monitorba való elküldése előtt történő módosításáról az OpenCensus Python telemetriai processzorok című témakörben olvashat bővebben.

Mérőszámok

Az OpenCensus.stats négy összesítési módszert támogat, de részleges támogatást nyújt az Azure Monitorhoz:

• Darabszám: A mérési pontok száma. Az érték kumulatív, csak növekedhet, és újraindítás esetén 0 értékre állítható vissza.
• Összeg: A mérési pontok összegzése. Az érték kumulatív, csak növekedhet, és újraindítás esetén 0 értékre állítható vissza.
• LastValue: Megtartja az utolsó rögzített értéket, és minden mást elvet.
• Eloszlás: Az Azure-exportőr nem támogatja a mérési pontok hisztogram-eloszlását.

Példa a Count aggregation (Összesítések száma) példára

1. Először hozzunk létre néhány helyi metrikaadatokat. Létrehozunk egy metrikát, amely nyomon követi, hogy a felhasználó hányszor választja ki az Enter billentyűt.

   
   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. A metrikák sokszor nyomon követhetők. Minden bejegyzésnél az érték növekszik, és a metrikaadatok megjelennek a konzolon. Az információk tartalmazzák az aktuális értéket és az aktuális időbélyeget a metrikák frissítésekor.

   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. Az értékek megadása bemutató célokra hasznos, de a metrikaadatokat ki szeretnénk küldeni az Azure Monitornak. Adja át a kapcsolati sztring közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban is. APPLICATIONINSIGHTS_CONNECTION_STRING Javasoljuk, hogy a kapcsolati sztring használatával példányosíthassa azokat az exportőröket, amelyek telemetriai adatokat küldenek az Application Insightsnak. Módosítsa a kódot az előző lépésben a következő kódminta alapján:

   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. Az exportőr rögzített időközönként metrikaadatokat küld az Azure Monitornak. Ezt az értéket 60 másodpercre kell beállítania, mivel az Application Insights háttérrendszere 60 másodperces időközönként feltételezi a metrikák pontjainak összesítését. Egyetlen metrikát követünk nyomon, így a rendszer minden intervallumban elküldi ezeket a metrikaadatokat, bármilyen értéket és időbélyeget is tartalmaz. Az adatok kumulatívak, csak növekedhetnek, és újraindítás esetén 0 értékre állíthatók vissza.

   Az adatok customMetricsa alatt találhatók, de a customMetrics tulajdonságok valueCount, valueSum, valueMin, valueMaxés valueStdDev nem használhatók hatékonyan.

Egyéni dimenziók beállítása metrikákban

Az OpenCensus Python SDK lehetővé teszi egyéni dimenziók hozzáadását a metrikák telemetriai adataihoz tagsa kulcs-érték párok szótárához hasonlóan.

1. Szúrja be a használni kívánt címkéket a címketérképbe. A címketérkép egyfajta "készletként" működik az összes használható címke közül.

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

2. Adott Viewesetben adja meg azokat a címkéket, amelyeket akkor szeretne használni, amikor metrikákat rögzít ezzel a nézettel a címkekulcson keresztül.

   ...
   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. Ügyeljen arra, hogy a címketérképet használja a mérési térképen való rögzítéskor. A megadott címkekulcsokat a View rögzítéshez használt címketérképen kell megtalálni.

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

4. A tábla alatt az customMetrics összes, egyéni dimenzióval prompt_view kibocsátott metrikarekord rendelkezik egyéni dimenziókkal {"url":"http://example.com"}.

5. Ha különböző értékeket tartalmazó címkéket szeretne létrehozni ugyanazokkal a kulcsokkal, hozzon létre új címkeleképeztetéseket.

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

Teljesítményszámlálók

Alapértelmezés szerint a metrikák exportőre teljesítményszámlálókat küld az Azure Monitornak. Ezt a képességet letilthatja úgy, hogy False a enable_standard_metrics jelölőt a metrikák exportőrének konstruktorában állítja be.

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

A rendszer jelenleg a következő teljesítményszámlálókat küldi el:

• Rendelkezésre álló memória (bájt)
• Processzorhasználati idő (százalék)
• Bejövő kérések sebessége (másodpercenként)
• Bejövő kérelmek átlagos végrehajtási ideje (ezredmásodperc)
• Processzorhasználat feldolgozása (százalék)
• Privát bájtok (bájtok) feldolgozása

Ezeket a metrikákat látnia kell a következőben performanceCounters: . További információ: Teljesítményszámlálók.

Telemetria módosítása

A nyomon követett telemetriai adatokNak az Azure Monitorba való elküldése előtt történő módosításáról az OpenCensus Python telemetriai processzorok című témakörben olvashat bővebben.

Nyomkövetés

Feljegyzés

Az OpenCensusban tracing az elosztott nyomkövetésre utal. A AzureExporter paraméter elküldi és dependency telemetriát küld requests az Azure Monitornak.

1. Először hozzunk létre néhány nyomkövetési adatot helyben. A Python IDLE-ben vagy a választott szerkesztőben adja meg a következő kódot:

   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. Minden bejegyzésnél az érték a rendszerhéjra lesz nyomtatva. Az OpenCensus Python-modul létrehoz egy megfelelő elemet.SpanData Az OpenCensus projekt a nyomkövetést a spanok fájaként definiálja.

   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. A kimenet megtekintése bemutató célokra hasznos, de az Azure Monitornak szeretnénk kibocsátani SpanData . Adja át a kapcsolati sztring közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban is. APPLICATIONINSIGHTS_CONNECTION_STRING Javasoljuk, hogy a kapcsolati sztring használatával példányosíthassa azokat az exportőröket, amelyek telemetriai adatokat küldenek az Application Insightsnak. Módosítsa a kódot az előző lépésben a következő kódminta alapján:

   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. Most, amikor futtatja a Python-szkriptet, csak az érték lesz kinyomtatva a rendszerhéjban. A rendszer elküldi a létrehozott SpanData elemet az Azure Monitornak. A kibocsátott span adatok a következő alatt dependenciestalálhatók: .

   A kimenő kérelmekről további információt az OpenCensus Python-függőségek című témakörben talál. A bejövő kérelmekről további információt az OpenCensus Python-kérelmekben talál.

Mintavételezés

Az OpenCensus mintavételezéséről további információt az OpenCensus mintavételezésében talál.

Nyomkövetési korreláció

A nyomkövetési adatok telemetriai korrelációját az OpenCensus Python telemetriai korrelációjában talál.

Telemetria módosítása

A nyomon követett telemetria Azure Monitorba való elküldése előtt történő módosításáról további információt az OpenCensus Python telemetriai processzorok című témakörben talál.

Azure Monitor-exportőrök konfigurálása

Mint látható, három különböző Azure Monitor-exportőr támogatja az OpenCensus-t. Mindegyik különböző típusú telemetriát küld az Azure Monitornak. Ha meg szeretné tudni, hogy az egyes exportőrök milyen típusú telemetriát küldenek, tekintse meg az alábbi táblázatot.

Minden exportőr ugyanazokat az argumentumokat fogadja el a konstruktorok által átadott konfigurációhoz. Az egyes adatokról itt olvashat:

Exportőr telemetriai adatai	Leírás
connection_string	Az Azure Monitor-erőforráshoz való csatlakozáshoz használt kapcsolati sztring. Elsőbbséget instrumentation_keyélvez.
credential	Az Azure Active Directory-hitelesítés által használt hitelesítő osztály. Lásd az alábbi "Hitelesítés" szakaszt.
enable_standard_metrics	A következőhöz AzureMetricsExporterhasználatos: . Jelzi az exportőrnek, hogy automatikusan küldjön teljesítményszámláló mérőszámokat az Azure Monitornak. Alapértelmezett érték: True.
export_interval	A gyakoriság megadására szolgál az exportálás másodpercében. Alapértelmezett érték: 15s. Metrikák esetén 60 másodpercre kell állítania, különben a metrika-összesítéseknek nincs értelme a metrikák kezelőjében.
grace_period	Az exportőrök másodpercek alatt történő leállítására vonatkozó időtúllépés meghatározására szolgál. Alapértelmezett érték: 5s.
instrumentation_key	Az Azure Monitor-erőforráshoz való csatlakozáshoz használt rendszerállapot-kulcs.
logging_sampling_rate	AzureLogHandler Használt és AzureEventHandler. Mintavételezési gyakoriságot [0,1.0] biztosít a naplók/események exportálásához. Alapértelmezett érték: 1.0.
max_batch_size	Megadja az egyszerre exportált telemetriai adatok maximális méretét.
proxies	Az adatok Azure Monitorba való küldéséhez használandó proxyk sorozatát adja meg. További információ: proxyk.
storage_path	A helyi tárolómappa helyének elérési útja (nem küldött telemetriai adatok). Az opencensus-ext-azure 1.0.3-as verziótól az alapértelmezett elérési út az operációs rendszer temp könyvtára + + opencensus-pythonyour-ikey . Az 1.0.3-s verzió előtt az alapértelmezett elérési út az $USERpython-file-name + + .opencensus + .azure.
timeout	Megadja azt a hálózati időtúllépést, amely a telemetriát másodpercek alatt elküldi a betöltési szolgáltatásnak. Alapértelmezett érték: 10s.

Integrálás az Azure Functions szolgáltatással

Az egyéni telemetriai adatok Azure Functions-környezetekben való rögzítéséhez használja az OpenCensus Python Azure Functions-bővítményt. További információkért tekintse meg az Azure Functions Python fejlesztői útmutatóját.

Hitelesítés (előzetes verzió)

Feljegyzés

A hitelesítési funkció az 1.1b0-s verziótól opencensus-ext-azure érhető el.

Az Azure Monitor-exportőrök mindegyike támogatja a telemetriai hasznos adatok biztonságos küldésének konfigurációját OAuth-hitelesítéssel az Azure Active Directoryval. További információkért tekintse meg a hitelesítési dokumentációt.

Adatok megtekintése lekérdezésekkel

Az alkalmazásból küldött telemetriai adatokat a Naplók (Elemzések) lapon tekintheti meg.

Az Aktív listában:

• Az Azure Monitor nyomkövetési exportőrével küldött telemetriai adatok esetében a bejövő kérések a következő területen requestsjelennek meg: . A kimenő vagy folyamatban lévő kérések a következő területen dependenciesjelennek meg: .
• Az Azure Monitor-metrikák exportőrével küldött telemetriai adatok esetében az elküldött metrikák a következő területen customMetricsjelennek meg: .
• Az Azure Monitor-naplók exportőrével küldött telemetriai adatok esetében a naplók a következő alatt tracesjelennek meg: . A kivételek az alatt exceptionsjelennek meg.

A lekérdezések és naplók használatáról további információt az Azure Monitor naplói című témakörben talál.

A Microsoft Entra ID-alapú hitelesítés konfigurálása és engedélyezése

Feljegyzés

A Microsoft Entra-hitelesítés csak a Python 2.7-s, 3.6-os és 3.7-s verzióhoz érhető el. A Microsoft Entra ID támogatása az Application Insights OpenCensus Python SDK-ban az opencensus-ext-azure 1.1b0 bétaverzióval kezdődik.

Feljegyzés

Az OpenCensus Python SDK elavult, de a Microsoft 2024. szeptember 30-i nyugdíjba vonulásáig támogatja. Most az OpenTelemetry-alapú Python-ajánlatot javasoljuk, és migrálási útmutatást nyújtunk.

Hozza létre a megfelelő hitelesítő adatokat , és adja át őket az Azure Monitor-exportőr konstruktorának. Győződjön meg arról, hogy a kapcsolati sztring be van állítva az erőforrás rendszerállapot-kulcsával és betöltési végpontjával.

Az OpenCensus Azure Monitor-exportőrök támogatják ezeket a hitelesítési típusokat. Azt javasoljuk, hogy felügyelt identitásokat használjunk éles környezetekben.

Rendszer által hozzárendelt felügyelt identitás

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

Felhasználó által hozzárendelt felügyelt identitás

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

További információ a Pythonhoz készült OpenCensusról

• OpenCensus Python a GitHubon
• Testreszabás
• Azure Monitor-exportőrök a GitHubon
• OpenCensus-integrációk
• Azure Monitor-mintaalkalmazások

Hibaelhárítás

Az alkalmazásgazda és a betöltési szolgáltatás közötti kapcsolat tesztelése

Az Application Insights SDK-k és -ügynökök telemetriát küldenek, hogy REST-hívásként betöltse a betöltési végpontokat. A webkiszolgálóról vagy az alkalmazásgazdagépről a betöltési szolgáltatás végpontjaihoz való kapcsolódást a PowerShellből vagy curl parancsokból származó nyers REST-ügyfelek használatával tesztelheti. Tekintse meg a hiányzó alkalmazástelemetria hibaelhárítását az Azure Monitor Application Insightsban.

Release Notes (Kibocsátási megjegyzések)

A legújabb kibocsátási megjegyzésekért lásd : Python Azure Monitor Exporter

Szolgáltatásfrissítéseink az Application Insights főbb fejlesztéseit is összefoglalják.

Következő lépések

• A használati élmény engedélyezéséhez engedélyezze a web- vagy böngészőfelhasználói monitorozást
• Bejövő kérések nyomon követése.
• Kimenő kérések nyomon követése.
• Tekintse meg az alkalmazástérképet.
• Megtudhatja, hogyan hajthatja végre a végpontok közötti teljesítményfigyelést.

Riasztások

• Rendelkezésre állás áttekintése: Tesztek létrehozása annak érdekében, hogy a webhely látható legyen a weben.
• Intelligens diagnosztika: Ezek a tesztek automatikusan futnak, a beállításukhoz semmit sem kell tennie. Értesítést kap, ha az alkalmazásában szokatlanul magas a meghiúsult kérelmek száma.
• Metrikariasztások: Riasztások beállítása arra az esetre, ha egy metrika átlép egy küszöbértéket. Az alkalmazás kódjába beépített egyedi metrikákhoz is állíthat be riasztásokat.