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

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 Pythonhoz készült egyéb telemetriai SDK-k nem támogatottak, és a Microsoft nem ajánlott telemetriai megoldásként használni.

Az OpenCensus az OpenTelemetry-hez kapcsolódik. Továbbra is az OpenCensus használatát javasoljuk, míg az OpenTelemetry fokozatosan kiforrott.

Megjegyzés

Elérhető egy előzetes verziójú OpenTelemetry-alapú Python-ajánlat . További információért tekintse meg az OpenTelemetry áttekintését.

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.

Megjegyzés

2025. március 31-én megszűnik az eszközkulcsalapú betöltés támogatása. A rendszerállapotkulcs-betöltés 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áltsa át a kapcsolati sztringeket 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ési, metrikák és naplózási telemetria gyűjtését. Az Azure Monitor-exportőrök használatával elküldheti ezt az összegyűjtött telemetriát 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. Ezek a trace, metricsés logs. Ezekről a telemetriatípusokról további információt az Adatplatform áttekintése című témakörben talál. Az alábbi utasításokat követve küldje el ezeket a telemetriai típusokat a három exportőren keresztül.

Telemetriai típusleképezések

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

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 Kérelmek függőségei 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 valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  2. A kód folyamatosan kéri egy érték megadását. A rendszer minden megadott értékhez naplóbejegyzést ad ki.

    Enter a value: 24
    24
    Enter a value: 55
    55
    Enter a value: 123
    123
    Enter a value: 90
    90
    
  3. Az értékek megadása bemutató célokra hasznos, de a naplóadatokat az Azure Monitornak szeretnénk kibocsátani. Adja át a kapcsolati sztringet közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban, APPLICATIONINSIGHTS_CONNECTION_STRINGa következőben: . Javasoljuk, hogy a kapcsolati sztringgel példányosíthassa azokat az exportőröket, amelyek telemetriát küldenek az Application Insightsnak. Módosítsa az előző lépés kódját a következő kódminta alapján:

    import logging
    from opencensus.ext.azure.log_exporter import AzureLogHandler
    
    logger = logging.getLogger(__name__)
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    logger.addHandler(AzureLogHandler(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    )
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # logger.addHandler(AzureLogHandler())
    
    def valuePrompt():
        line = input("Enter a value: ")
        logger.warning(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  4. Az exportőr naplóadatokat küld az Azure Monitornak. Az adatokat a következő területen tracestalálja: .

    Ebben az összefüggésben nem ugyanaz, traces mint tracinga . Itt arra a telemetriai típusra hivatkozik, traces amelyet az Azure Monitorban fog látni a használata AzureLogHandlersorán. De tracing az OpenCensus egyik koncepcióját jelenti, és az elosztott nyomkövetésre vonatkozik.

    Megjegyzés

    A gyökérnaplózó a szinttel warningvan konfigurálva. Ez azt jelenti, hogy a rendszer figyelmen kívül hagyja a kisebb súlyosságú naplókat, és nem küldi el őket 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árokként jelennek meg az Azure Monitorban customDimensions .

    Megjegyzé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__)
    # TODO: replace the all-zero GUID with your instrumentation key.
    logger.addHandler(AzureLogHandler(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    )
    
    properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}
    
    # Use properties in logging statements
    logger.warning('action', extra=properties)
    

Megjegyzé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ő fontosságú adatgyűjtést. További információ: Statsbeat az Application Insightsban.

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ő verziójához hasonlóan, vagy megadhatja azt a Django naplózási konfigurációjában. Ez a kód a Django beállításainak konfigurálásához használt fájlba kerül. A Django beállításainak 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ával kapcsolatos további információkért lásd: Django-naplózás.

LOGGING = {
    "handlers": {
        "azure": {
            "level": "DEBUG",
        "class": "opencensus.ext.azure.log_exporter.AzureLogHandler",
            "instrumentation_key": "<your-ikey-here>",
         },
        "console": {
            "level": "DEBUG",
            "class": "logging.StreamHandler",
            "stream": sys.stdout,
         },
      },
    "loggers": {
        "logger_name": {"handlers": ["azure", "console"]},
    },
}

Győződjön meg arról, hogy a naplózót ugyanazzal a névvel használja, mint amelyet a konfigurációban megadott.

import logging

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 küldi el 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__)
# TODO: replace the all-zero GUID with your instrumentation key.
logger.addHandler(AzureLogHandler(
    connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
)

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ást, de explicit módon naplóznia kell a kivételtelemetriaadatokat.

Események küldése

A telemetriai adatokat pontosan ugyanúgy küldheti customEvent el, mint a telemetriát, kivéve, ha trace a telemetria helyett használja AzureEventHandler .

import logging

from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler(connection_string='InstrumentationKey=<your-instrumentation_key-here>'))
logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Mintavételezés

További információ az OpenCensus-mintavételezésről: Mintavételezés az OpenCensusban.

Napló-összefüggések

A naplók nyomkövetési környezeti adatokkal való bővítéséről az OpenCensus Python-naplók integrációja című témakörben olvashat bővebben.

Telemetria módosítása

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

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 összegző, csak növekedhet, és újraindítás esetén 0-ra állítható vissza.
  • Összeg: A mérési pontok összegzése. Az érték összegző, csak növekedhet, és újraindítás esetén 0-ra állítható vissza.
  • LastValue: Megtartja az utolsó rögzített értéket, és minden mást elvet.
  • Eloszlás: A mérési pontok hisztogrameloszlása. Ezt a módszert az Azure-exportőr nem támogatja.

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

  1. Először hozzunk létre néhány helyi metrikaadatot. 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 prompt():
        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])
    
    def main():
        while True:
            prompt()
    
    if __name__ == "__main__":
        main()
    
  2. A kód ismételt futtatása arra kéri, hogy válassza az Enter lehetőséget. A rendszer létrehoz egy metrikát, amely nyomon követi, hogy hányszor van kiválasztva az Enter . Minden bejegyzésnél a rendszer növeli az értéket, és a metrikaadatok megjelennek a konzolon. Az információk közé tartozik az aktuális érték és a metrika frissítésének aktuális időbélyege.

    Press enter.
    Point(value=ValueLong(5), timestamp=2019-10-09 20:58:04.930426)
    Press enter.
    Point(value=ValueLong(6), timestamp=2019-10-09 20:58:06.570167)
    Press enter.
    Point(value=ValueLong(7), timestamp=2019-10-09 20:58:07.138614)
    
  3. Az értékek megadása bemutató célokra hasznos, de a metrikaadatokat az Azure Monitornak szeretnénk kibocsátani. Adja át a kapcsolati sztringet közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban, APPLICATIONINSIGHTS_CONNECTION_STRINGa következőben: . Javasoljuk, hogy a kapcsolati sztringgel példányosíthassa azokat az exportőröket, amelyek telemetriát küldenek az Application Insightsnak. Módosítsa az előző lépés kódját 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()
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    exporter = metrics_exporter.new_metrics_exporter(
        connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000')
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # exporter = metrics_exporter.new_metrics_exporter()
    
    view_manager.register_exporter(exporter)
    
    def prompt():
        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])
    
    def main():
        while True:
            prompt()
    
    if __name__ == "__main__":
        main()
    
  4. Az exportőr rögzített időközönként metrikaadatokat küld az Azure Monitornak. Az alapértelmezett érték 15 másodpercenként. Az exportálási időköz módosításához adja meg export_interval paraméterként másodpercben a értéket a következőnek new_metrics_exporter(): . 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 érték összegző, csak növekedhet, és újraindítás esetén 0-ra állítható vissza.

    Az adatokat a alatt customMetricstalálja, de a customMetrics , valueSum, valueMin, valueMaxés valueStdDev tulajdonságokat valueCountnem használjá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 a használatával tags, amelyek a kulcs-érték párok szótárához hasonlóak.

  1. Szúrja be a használni kívánt címkéket a címketérképre. 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 az adott 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 fájlban View megadott címkekulcsokat a 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 a customMetrics használatával prompt_view kibocsátott összes metrikarekord egyéni dimenziókkal {"url":"http://example.com"}fog rendelkezni.

  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 metrikaexportáló teljesítményszámlálókat küld az Azure Monitornak. Ezt a képességet letilthatja, ha a enable_standard_metrics jelölőt False a metrikaexportáló konstruktorában értékre állítja.

...
exporter = metrics_exporter.new_metrics_exporter(
  enable_standard_metrics=False,
  connection_string='InstrumentationKey=<your-instrumentation-key-here>')
...

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érelmek száma (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 a következő helyen láthatja: performanceCounters. További információ: Teljesítményszámlálók.

Telemetria módosítása

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

Nyomkövetés

Megjegyzés

Az OpenCensus tracing esetében 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 helyileg. 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 valuePrompt():
        with tracer.span(name="test") as span:
            line = input("Enter a value: ")
            print(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  2. A kód ismételt futtatása arra kéri, hogy adjon meg egy értéket. Minden bejegyzésnél a rendszer kinyomtatja az értéket a rendszerhéjba. Az OpenCensus Python-modul létrehozza a megfelelő részét.SpanData Az OpenCensus projekt a nyomkövetést spanok fájaként definiálja.

    Enter a value: 4
    4
    [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)]
    Enter a value: 25
    25
    [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)]
    Enter a value: 100
    100
    [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. Az értékek megadása bemutató célokra hasznos, de az Azure Monitornak szeretnénk kibocsátani SpanData . Adja át a kapcsolati sztringet közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban, APPLICATIONINSIGHTS_CONNECTION_STRINGa következőben: . Javasoljuk, hogy a kapcsolati sztringgel példányosíthassa azokat az exportőröket, amelyek telemetriát küldenek az Application Insightsnak. Módosítsa az előző lépés kódját 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
    
    # TODO: replace the all-zero GUID with your instrumentation key.
    tracer = Tracer(
        exporter=AzureExporter(
            connection_string='InstrumentationKey=00000000-0000-0000-0000-000000000000'),
        sampler=ProbabilitySampler(1.0),
    )
    # You can also instantiate the exporter directly if you have the environment variable
    # `APPLICATIONINSIGHTS_CONNECTION_STRING` configured
    # exporter = AzureExporter()
    
    def valuePrompt():
        with tracer.span(name="test") as span:
            line = input("Enter a value: ")
            print(line)
    
    def main():
        while True:
            valuePrompt()
    
    if __name__ == "__main__":
        main()
    
  4. Most, amikor futtatja a Python-szkriptet, a rendszer továbbra is kéri az értékek megadását, de csak az értéket nyomtatja ki a rendszerhéjban. A rendszer elküldi a létrehozott elemet SpanData az Azure Monitornak. A kibocsátott span-adatokat a következő területen dependenciestalálja: .

    További információ a kimenő kérelmekről: OpenCensus Python-függőségek. További információ a bejövő kérelmekről: OpenCensus Python-kérelmek.

Mintavételezés

További információ az OpenCensus-mintavételezésről: Mintavételezés az OpenCensusban.

Nyomkövetési korreláció

A nyomkövetési adatok telemetriai korrelációjára vonatkozó további információkért lásd: OpenCensus Python-telemetria-korreláció.

Telemetria módosítása

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

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. Az egyes exportőrök által küldött telemetriai adatok típusainak megtekintéséhez tekintse meg az alábbi táblázatot.

Minden exportőr ugyanazokat az argumentumokat fogadja el a konfiguráláshoz, amelyek a konstruktorokon keresztül adhatók át. Az egyes adatokról itt talál információt:

Exportőr telemetriai adatai Description
connection_string Az Azure Monitor-erőforráshoz való csatlakozáshoz használt kapcsolati sztring. Elsőbbséget élvez a(z) felett instrumentation_key.
credential Az Azure Active Directory-hitelesítés által használt hitelesítőadat-osztály. Tekintse meg 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ó-metrikákat az Azure Monitornak. Az alapértelmezett érték: True.
export_interval A gyakoriság megadására szolgál az exportálás másodpercében. Az alapértelmezett érték: 15s.
grace_period Az exportőrök leállításának időtúllépését határozza meg másodpercben. Az alapértelmezett érték: 5s.
instrumentation_key Az Azure Monitor-erőforráshoz való csatlakozáshoz használt rendszerállapotkulcs.
logging_sampling_rate A és a esetében AzureLogHandlerAzureEventHandlerhasználatos. Mintavételezési sebességet [0,1.0] biztosít a naplók/események exportálásához. Az 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 a következő$USER.azurepython-file-name + .opencensus + + : .
timeout Megadja azt a hálózati időtúllépést, amely másodpercek alatt elküldi a telemetriát a betöltési szolgáltatásnak. Az 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ó: Az Azure Functions Python fejlesztői útmutatója.

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

Megjegyzés

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

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

Adatok megtekintése lekérdezésekkel

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

Képernyőkép az Áttekintés panelről, amelyen a Naplók (Elemzések) lap van kiválasztva.

Az Aktív csoportban található 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 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 alatt customMetricsjelennek meg.
  • Az Azure Monitor-naplók exportőrével küldött telemetriai adatok esetében a naplók a alatt tracesjelennek meg. A kivételek a alatt exceptionsjelennek meg.

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

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

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ásokké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 PowerShell nyers REST-ügyfélprogramjaival vagy curl-parancsokkal tesztelheti. Lásd: Hiányzó alkalmazástelemetria hibaelhárítása az Azure Monitor Application Insightsban.

Következő lépések

Riasztások

  • Rendelkezésre állási tesztek: Hozzon létre teszteket, hogy megbizonyosodjon róla, oldala látható 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.