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

Cikk
08/11/2023

Megjegyzés

Az OpenCensus Python SDK elavult, de a Microsoft a 2024. szeptember 30-i kivezetésig támogatja. Most az OpenTelemetry-alapú Python-ajánlatot ajánljuk, és útmutatást nyújtunk a migrálá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 Microsoft nem javasolja más telemetriai SDK-k használatát a Pythonhoz telemetriai megoldásként, mert nem támogatottak.

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

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és, 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üldhesse 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

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

A rendszer naplóbejegyzést ad ki a tartomány minden egyes számához.
```
Log Entry - 0
Log Entry - 1
Log Entry - 2
Log Entry - 3
Log Entry - 4
```
Ezeket a naplóadatokat az Azure Monitorban szeretnénk megtekinteni. Ezt egy környezeti változóban () adhatja meg. APPLICATIONINSIGHTS_CONNECTION_STRING A connection_string közvetlenül is átadhatja a AzureLogHandlerfájlnak, de a kapcsolati sztringeket nem szabad hozzáadni a verziókövetéshez.
```
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 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__)
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}")
```
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 lát 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ó.

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

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 webhely beállításainak konfigurálásához használt fájlba kerül, általában settings.py.

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",
            "connection_string": "<appinsights-connection-string>",
        },
        "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.

# 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 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__)
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á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())
# 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

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: Az Azure-exportőr nem támogatja a mérési pontok hisztogrameloszlását.

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

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

A metrikák számos alkalommal nyomon követhetők. 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.
```
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)
```

Az értékek megadása bemutató célokra hasznos, de a metrikaadatokat az Azure Monitornak szeretnénk kibocsátani. Adja át a kapcsolati sztring közvetlenül az exportőrnek. Vagy megadható egy környezeti változóban, APPLICATIONINSIGHTS_CONNECTION_STRINGa következőben: . 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 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()

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

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 állítania, mivel az Application Insights háttérrendszere 60 másodperces időintervallumban feltételezi a metrikapontok ö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-ra állíthatók 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.

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

Adott Viewesetben adja meg azokat a címkéket, amelyeket akkor szeretne használni, ha 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())
...

Ü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
...
```
A tábla alatt a customMetrics használatával prompt_view kibocsátott összes metrikarekord egyéni dimenziókkal rendelkezik {"url":"http://example.com"}.

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

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

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.

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 main():
    with tracer.span(name="test") as span:
        for value in range(5):
            print(value)


if __name__ == "__main__":
    main()

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.

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

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, APPLICATIONINSIGHTS_CONNECTION_STRINGa következőben: . 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 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

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

Most, amikor futtatja a Python-szkriptet, csak az érték lesz kinyomtatva 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

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 `AzureMetricsExporter`haszná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`. Metrikák esetén 60 másodpercre kell állítania, különben a metrikaösszesítéseknek nincs értelme a metrikaböngészőben.
`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 `AzureLogHandlerAzureEventHandler`haszná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 a telemetriát másodpercek alatt elküldi a betöltési szolgáltatásnak. Az alapértelmezett érték: `10s`.

Integrálás Azure Functions

Ha egyéni telemetriát szeretne rögzíteni Azure Functions környezetekben, használja az OpenCensus Python Azure Functions bővítményt. További információ: Azure Functions Python fejlesztői útmutató.

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

Megjegyzés

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

Az Azure Monitor-exportőrök mindegyike támogatja a telemetria hasznos adatainak biztonságos küldésé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.

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

Az Aktív területen 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 jelennek meg: requests. A kimenő vagy folyamatban lévő kérések a alatt 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 következő területen tracesjelennek meg: . A kivételek a alatt exceptionsjelennek meg.

További információ a lekérdezések és naplók használatáról: Naplók az Azure Monitorban.

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

Hibaelhárítás

Az alkalmazás gazdagépe é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 töltsenek be a betöltési végpontokra. 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 származó nyers REST-ügyfelek vagy curl-parancsok használatával tesztelheti. Lásd: Hiányzó alkalmazástelemetria hibaelhárítása az Azure Monitor Application Insightsban.

Kibocsátási megjegyzések

A legújabb kibocsátási megjegyzésekért lásd: Python Azure Monitor-exportőr

Szolgáltatásunk Frissítések az Application Insights főbb fejlesztéseit is összegzi.

Következő lépések

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

Riasztások

Rendelkezésre állás áttekintése: Teszteket hozhat létre, 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ásokat állíthat be, hogy figyelmeztesse, 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.

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

Előfeltételek

Az OpenCensus Python SDK bemutatása

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

Telemetriai típusleképezések

Naplók

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

Kivételek küldése

Események küldése

Mintavételezés

Napló-összefüggések

Telemetria módosítása

Mérőszámok

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

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

Teljesítményszámlálók

Telemetria módosítása

Nyomkövetés

Mintavételezés

Nyomkövetési korreláció

Telemetria módosítása

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

Integrálás Azure Functions

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

Adatok megtekintése lekérdezésekkel

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

Hibaelhárítás

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

Kibocsátási megjegyzések

Következő lépések

Riasztások

További források