Mi az elosztott nyomkövetés és a telemetriai korreláció?
Feljegyzés
Az alábbi dokumentáció az Alkalmazás Elemzések klasszikus API-ra támaszkodik. Az Alkalmazás Elemzések hosszú távú terve az Adatok gyűjtése Az OpenTelemetria használatával. További információ: Az Azure Monitor OpenTelemetria engedélyezése .NET-, Node.js-, Python- és Java-alkalmazásokhoz.
A modern felhő- és mikroszolgáltatás-architektúrák egyszerű, egymástól függetlenül üzembe helyezhető szolgáltatásokat tettek lehetővé, amelyek csökkentik a költségeket, miközben növelik a rendelkezésre állást és az átviteli sebességet. Ez azonban megnehezítette az általános rendszerek érvelését és hibakeresését. Az elosztott nyomkövetés egy olyan teljesítményprofilozóval oldja meg ezt a problémát, amely a felhő- és mikroszolgáltatás-architektúrák hívásveremeihez hasonlóan működik.
Az Azure Monitor két szolgáltatást biztosít az elosztott nyomkövetési adatok használatához: az egyetlen tranzakció/kérelem tranzakciódiagnosztikai nézetét és az alkalmazástérkép nézetet, amely a rendszerek interakcióit mutatja be.
Az alkalmazás Elemzések külön monitorozza az egyes összetevőket, és elosztott telemetriai korreláció használatával észleli, hogy melyik összetevő felelős a hibákért vagy a teljesítménycsökkenésért. Ez a cikk az alkalmazás Elemzések által használt különböző nyelveken és platformokon alkalmazott adatmodellt, környezetpropagálási technikákat, protokollokat és a korrelációs taktikák implementálását ismerteti.
Elosztott nyomkövetés engedélyezése
Az alkalmazások elosztott nyomkövetésének engedélyezéséhez adja hozzá a megfelelő ügynököt, SDK-t vagy tárat az egyes szolgáltatásokhoz a programozási nyelv alapján.
Engedélyezés alkalmazáson keresztül Elemzések automatikus beléptetéssel vagy SDK-kkal
Az alkalmazás Elemzések ügynökök és SDK-k a .NET, a .NET Core, a Java, a Node.js és a JavaScript esetében mind támogatják az elosztott nyomkövetést natív módon. Az egyes alkalmazások Elemzések SDK telepítésére és konfigurálására vonatkozó utasítások a következőkhöz érhetők el:
A megfelelő alkalmazás Elemzések SDK telepítésével és konfigurálásával a rendszer automatikusan gyűjti a nyomkövetési információkat a népszerű keretrendszerekhez, kódtárakhoz és technológiákhoz az SDK függőségi autoklektorai által. A támogatott technológiák teljes listája elérhető a Dependency autocollection dokumentációjában.
Bármely technológia manuálisan is nyomon követhető a TelemetryClient TrackDependencyhívásával.
Engedélyezés OpenTelemetry használatával
Az alkalmazás Elemzések mostantól támogatja az elosztott nyomkövetést az OpenTelemetria segítségével. Az OpenTelemetria szállítósemleges kialakítást biztosít a nyomkövetések, metrikák és naplók alkalmazás Elemzések való küldéséhez. Az OpenTelemetry-közösség kezdetben az elosztott nyomkövetést vette igénybe. A metrikák és a naplók még folyamatban vannak.
A teljes megfigyelhetőségi történet mindhárom pillért tartalmazza. Az Azure Monitor OpenTelemetry-alapú ajánlataink állapotának ellenőrzéséhez tekintse meg a legújabb állapotot a benne foglalt ajánlatokról, az általánosan elérhető ajánlatokról és a támogatási lehetőségekről.
Az alábbi oldalak nyelvi útmutatást nyújtanak a Microsoft OpenTelemetry-alapú ajánlatainak engedélyezéséhez és konfigurálásához. Fontos, hogy megosztjuk az egyes ajánlatok elérhető funkcióit és korlátait, hogy megállapíthassa, az OpenTelemetria megfelelő-e a projekthez.
Engedélyezés az OpenCensuson keresztül
Az Alkalmazás Elemzések SDK-k mellett az Alkalmazás Elemzések az OpenCensuson keresztüli elosztott nyomkövetést is támogatja. Az OpenCensus egy nyílt forráskódú, szállítói-agnosztikus kódtár-disztribúció, amely metrikák gyűjtését és elosztott nyomkövetést biztosít a szolgáltatások számára. Emellett lehetővé teszi a nyílt forráskódú közösség számára az elosztott nyomkövetést olyan népszerű technológiákkal, mint a Redis, a Memcached vagy a MongoDB. A Microsoft számos más monitorozási és felhőpartnerrel együttműködik az OpenCensuson.
A Pythonhoz készült OpenCensusról további információt az Azure Monitor beállítása a Python-alkalmazáshoz című témakörben talál.
Az OpenCensus webhelye api-referenciadokumentációt tart fenn a Pythonhoz, a Go-hoz és az OpenCensus használatához szükséges különböző útmutatókhoz.
Adatmodell telemetriai korrelációhoz
Az alkalmazás Elemzések definiál egy adatmodellt az elosztott telemetriai korrelációhoz. Ha a telemetriát logikai művelethez szeretné társítani, minden telemetriai elemhez tartozik egy környezetmező.operation_Id
Az elosztott nyomkövetés minden telemetriai eleme megosztja ezt az azonosítót. Így akkor is társíthat más összetevők által jelentett telemetriát, ha egyetlen rétegből veszíti el a telemetriát.
Az elosztott logikai műveletek általában kisebb műveletekből állnak, amelyeket az egyik összetevő feldolgoz. A kérelemtelemetria határozza meg ezeket a műveleteket. Minden kérelemtelemetriaelem saját id
, amely egyedileg és globálisan azonosítja azt. A kérelemhez társított összes telemetriai elemnek (például nyomkövetésnek és kivételnek) a kérelem id
értékére kell állítaniaoperation_parentId
.
A függőségi telemetria minden kimenő műveletet jelöl, például egy másik összetevőhöz irányuló HTTP-hívást. Azt is meghatározza, hogy a saját id
, amely globálisan egyedi. A függőségi hívás által kezdeményezett kérelemtelemetria ezt id
használja annak operation_parentId
.
Az elosztott logikai művelet nézetét a következővel operation_Id
hozhatja létre: . operation_parentId
request.id
dependency.id
Ezek a mezők a telemetriai hívások oksági sorrendjét is meghatározzák.
Mikroszolgáltatási környezetben az összetevőkből származó nyomkövetések különböző tárolóelemekre is áttérhetnek. Minden összetevőnek saját kapcsolati sztring lehet az Alkalmazás Elemzések. A logikai művelet telemetriájának lekéréséhez az alkalmazás Elemzések minden tárolóelemből lekérdezi az adatokat.
Ha a tárelemek száma nagy, tippet kell adnia arról, hogy hol keresse a következőt. Az alkalmazás Elemzések adatmodell két mezőt határoz meg a probléma megoldásához: request.source
ésdependency.target
. Az első mező azonosítja a függőségi kérelmet kezdeményező összetevőt. A második mező azonosítja, hogy melyik összetevő válaszolt a függőségi hívásra.
További információ a több különálló példányból a app
lekérdezési kifejezés használatával történő lekérdezésről: app() kifejezés az Azure Monitor-lekérdezésben.
Példa
Lássunk egy példát. A Stock Prices nevű alkalmazás egy részvény aktuális piaci árát jeleníti meg egy Stock nevű külső API használatával. A Tőzsdei árak alkalmazásnak van egy Stock lap nevű oldala, amelyet az ügyfél webböngészője a segítségével GET /Home/Stock
nyit meg. Az alkalmazás HTTP-hívással GET /api/stock/value
lekérdezi a Stock API-t.
Az eredményként kapott telemetriát egy lekérdezés futtatásával elemezheti:
(requests | union dependencies | union pageViews)
| where operation_Id == "STYz"
| project timestamp, itemType, name, id, operation_ParentId, operation_Id
Az eredményekben az összes telemetriaelem osztozik a gyökérben operation_Id
. Amikor Ajax-hívást kezdeményez a lapról, a rendszer egy új egyedi azonosítót (qJSXU
) rendel a függőségi telemetriahoz, és a pageView azonosítóját operation_ParentId
használja a rendszer. A kiszolgálókérés ezután az Ajax-azonosítót használja a következőként operation_ParentId
: .
Itemtype | név | ID (Azonosító) | operation_ParentId | operation_Id |
---|---|---|---|---|
pageView | Stock page | STYz |
STYz |
|
Függőség | GET /Home/Stock | qJSXU |
STYz |
STYz |
kérés | GET Home/Stock | KqKwlrSt9PA= |
qJSXU |
STYz |
Függőség | GET /api/stock/value | bBrf2L7mm2g= |
KqKwlrSt9PA= |
STYz |
Amikor a hívást GET /api/stock/value
egy külső szolgáltatáshoz intézik, ismernie kell a kiszolgáló identitását, hogy megfelelően be tudja állítani a dependency.target
mezőt. Ha a külső szolgáltatás nem támogatja a figyelést, target
a szolgáltatás állomásnevére van állítva. Például: stock-prices-api.com
. Ha azonban a szolgáltatás egy előre definiált HTTP-fejléc visszaadásával azonosítja magát, tartalmazza azt a szolgáltatásidentitást, target
amely lehetővé teszi, hogy az alkalmazás Elemzések elosztott nyomkövetést hozzon létre a szolgáltatásból származó telemetriai adatok lekérdezésével.
Korrelációs fejlécek a W3C TraceContext használatával
Az alkalmazás Elemzések a W3C Trace-Contextre vált, amely a következőket határozza meg:
traceparent
: A hívás globálisan egyedi műveleti azonosítóját és egyedi azonosítóját hordozza.tracestate
: Rendszerspecifikus nyomkövetési környezetet hordoz.
Az Alkalmazás Elemzések SDK legújabb verziója támogatja a Trace-Context protokollt, de előfordulhat, hogy be kell jelentkeznie. (Az alkalmazás Elemzések SDK által támogatott korábbi korrelációs protokolllal való visszamenőleges kompatibilitás megmarad.)
A korrelációs HTTP protokoll, más néven Request-Id elavult. Ez a protokoll két fejlécet határoz meg:
Request-Id
: A hívás globálisan egyedi azonosítóját hordozza.Correlation-Context
: Az elosztott nyomkövetési tulajdonságok név-érték párok gyűjteményét hordozza.
Az alkalmazás Elemzések a korrelációs HTTP protokoll bővítményét is meghatározza. Név-érték párok használatával Request-Context
propagálja az azonnali hívó vagy hívó által használt tulajdonságok gyűjteményét. Az Alkalmazás Elemzések SDK ezzel a fejléccel állítja be a mezőket és request.source
a dependency.target
mezőket.
A W3C Trace-Context és az Application Elemzések adatmodellek leképezése a következő módon:
Application Insights | W3C TraceContext |
---|---|
Id és Request Dependency |
parent-id |
Operation_Id |
nyomkövetési azonosító |
Operation_ParentId |
a span szülőazonosítója . Ennek a mezőnek üresnek kell lennie, ha gyökértartományról van szó. |
További információ: Application Elemzések telemetria adatmodell.
W3C elosztott nyomkövetés támogatásának engedélyezése .NET-alkalmazásokhoz
A W3C TraceContext-alapú elosztott nyomkövetés alapértelmezés szerint engedélyezve van az összes legutóbbi .NET-keretrendszer/.NET Core SDK-ban, valamint az örökölt Request-Id protokolllal való visszamenőleges kompatibilitással.
A W3C elosztott nyomkövetés támogatásának engedélyezése Java-alkalmazásokhoz
Java 3.0-ügynök
A Java 3.0-ügynök támogatja a W3C-t a dobozon kívül, és nincs szükség további konfigurációra.
Java SDK
Bejövő konfiguráció
Java-Enterprise kiadás-alkalmazások esetén adja hozzá a következő kódot az
<TelemetryModules>
alkalmazás címkéjére Elemzések.xml:<Add type="com.microsoft.applicationinsights.web.extensibility.modules.WebRequestTrackingTelemetryModule> <Param name = "W3CEnabled" value ="true"/> <Param name ="enableW3CBackCompat" value = "true" /> </Add>
Spring Boot-alkalmazások esetén adja hozzá az alábbi tulajdonságokat:
azure.application-insights.web.enable-W3C=true
azure.application-insights.web.enable-W3C-backcompat-mode=true
Kimenő konfiguráció
Adja hozzá a következő kódot a AI-Agent.xml:
<Instrumentation> <BuiltIn enabled="true"> <HTTP enabled="true" W3C="true" enableW3CBackCompat="true"/> </BuiltIn> </Instrumentation>
Feljegyzés
A visszamenőleges kompatibilitási mód alapértelmezés szerint engedélyezve van, és a
enableW3CBackCompat
paraméter nem kötelező. Csak akkor használja, ha ki szeretné kapcsolni a visszamenőleges kompatibilitást.Ideális esetben kikapcsolhatja ezt a módot, ha az összes szolgáltatás a W3C protokollt támogató SDK-k újabb verzióira frissül. Javasoljuk, hogy a lehető leghamarabb lépjen ezekre az újabb SDK-kra.
Fontos, hogy a bejövő és kimenő konfigurációk pontosan azonosak legyenek.
W3C elosztott nyomkövetés támogatásának engedélyezése webalkalmazásokhoz
Ez a funkció alapértelmezés szerint engedélyezve van a JavaScripthez, és a fejlécek automatikusan bekerülnek, ha az üzemeltetési lap tartománya megegyezik azzal a tartománnyal, amelybe a kéréseket küldi (például a tárhelyoldal és example.com
az Ajax-kérelmek küldése example.com
). Az elosztott nyomkövetési mód módosításához használja a distributedTracingMode
konfigurációs mezőt. AI_AND_W3C alapértelmezés szerint az Alkalmazás Elemzések által létrehozott örökölt szolgáltatásokkal való visszamenőleges kompatibilitás érdekében van megadva.
-
Adja hozzá a következő konfigurációt:
distributedTracingMode: DistributedTracingModes.W3C
JavaScript (web) SDK Loader Script-alapú beállítás
Adja hozzá a következő konfigurációt:
distributedTracingMode: 2 // DistributedTracingModes.W3C
Ha az XMLHttpRequest vagy a Fetch Ajax-kérelmeket egy másik tartománygazda továbbítja, beleértve az altartományokat is, a korrelációs fejlécek alapértelmezés szerint nem jelennek meg. A funkció engedélyezéséhez állítsa a konfigurációs mezőt a enableCorsCorrelation
következőretrue
: . Ha be true
van állítvaenableCorsCorrelation
, minden XMLHttpRequest és Fetch Ajax-kérés tartalmazza a korrelációs fejléceket. Ennek eredményeképpen, ha a meghívni kívánt kiszolgálón lévő alkalmazás nem támogatja a traceparent
fejlécet, a kérés sikertelen lehet attól függően, hogy a böngésző/ verzió érvényesítheti-e a kérést a kiszolgáló által elfogadott fejlécek alapján. A konfigurációs mező használatával correlationHeaderExcludedDomains
kizárhatja a kiszolgáló tartományát az összetevők közötti korrelációs fejlécinjektálásból. Például kizárhatja correlationHeaderExcludedDomains: ['*.auth0.com']
a korrelációs fejléceket az Auth0 identitásszolgáltatónak küldött kérelmekből.
Fontos
A korreláció engedélyezéséhez szükséges összes konfiguráció megtekintéséhez tekintse meg a JavaScript korrelációs dokumentációját.
Telemetriai korreláció az OpenCensus Pythonban
Az OpenCensus Python további konfiguráció nélkül támogatja a W3C Trace-Context-t .
Referenciaként az OpenCensus adatmodellt ezen a GitHub-oldalon találja.
Bejövő kérések korrelációja
Az OpenCensus Python korrelálja a W3C Trace-Context fejléceket a bejövő kérésekből a kérésekből létrehozott időtartamokra. Az OpenCensus automatikusan korrelál ezen népszerű webalkalmazás-keretrendszerek integrációjával: Flask, Django és Piramis. A W3C Trace-Context fejléceket csak a megfelelő formátumban kell feltöltenie, és a kéréssel együtt el kell küldenie őket.
Ismerje meg ezt a Flask-mintaalkalmazást. Telepítse a Flaskot, az OpenCensus-t és a Flask és az Azure bővítményeit.
pip install flask opencensus opencensus-ext-flask opencensus-ext-azure
Hozzá kell adnia az alkalmazás Elemzések kapcsolati sztring a környezeti változóhoz.
APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
Flask-mintaalkalmazás
from flask import Flask
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.ext.flask.flask_middleware import FlaskMiddleware
from opencensus.trace.samplers import ProbabilitySampler
app = Flask(__name__)
middleware = FlaskMiddleware(
app,
exporter=AzureExporter(
connection_string='<appinsights-connection-string>', # or set environment variable APPLICATION_INSIGHTS_CONNECTION_STRING
),
sampler=ProbabilitySampler(rate=1.0),
)
@app.route('/')
def hello():
return 'Hello World!'
if __name__ == '__main__':
app.run(host='localhost', port=8080, threaded=True)
Ez a kód egy Flask-mintaalkalmazást futtat a helyi gépen, és figyeli a portot 8080
. A nyomkövetési környezet korrelációjához küldjön egy kérést a végpontnak. Ebben a példában egy parancsot curl
használhat:
curl --header "traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01" localhost:8080
A Trace-Context fejlécformátumának megtekintésével a következő információk származtathatók:
version
: 00
trace-id
: 4bf92f3577b34da6a3ce929d0e0e4736
parent-id/span-id
: 00f067aa0ba902b7
trace-flags
: 01
Ha megtekinti az Azure Monitornak küldött kérelembejegyzést, láthatja a nyomkövetési fejléc adataival kitöltött mezőket. Az adatokat az Azure Monitor-alkalmazás Elemzések erőforrás Naplók (Elemzések) területén találja.
A id
mező formátuma <trace-id>.<span-id>
trace-id
a kérelemben átadott nyomkövetési fejlécből származik, és span-id
egy 8 bájtos generált tömb ehhez a tartományhoz.
A operation_ParentId
mező formátuma <trace-id>.<parent-id>
mindkettő, trace-id
és parent-id
a kérelemben átadott nyomkövetési fejlécből származik.
Napló-összefüggések
Az OpenCensus Python lehetővé teszi a naplók korrelációját egy nyomkövetési azonosító, egy span ID és egy mintavételezési jelző hozzáadásával a naplórekordokhoz. Ezeket az attribútumokat az OpenCensus naplózási integrációjának telepítésével veheti fel. A következő attribútumok lesznek hozzáadva a Python-objektumokhoz LogRecord
: traceId
, spanId
és traceSampled
(csak az integráció után létrehozott naplózókra vonatkozik).
Telepítse az OpenCensus naplózási integrációját:
python -m pip install opencensus-ext-logging
Mintaalkalmazás
import logging
from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer
config_integration.trace_integrations(['logging'])
logging.basicConfig(format='%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s')
tracer = Tracer(sampler=AlwaysOnSampler())
logger = logging.getLogger(__name__)
logger.warning('Before the span')
with tracer.span(name='hello'):
logger.warning('In the span')
logger.warning('After the span')
A kód futtatásakor a következő nyomatok jelennek meg a konzolon:
2019-10-17 11:25:59,382 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=0000000000000000 Before the span
2019-10-17 11:25:59,384 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=70da28f5a4831014 In the span
2019-10-17 11:25:59,385 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=0000000000000000 After the span
Figyelje meg, hogy a naplóüzenetnek van egy spanId
ajándéka, amely a megadott tartományon belül van. Ez spanId
ugyanaz, mint ami a nevesített hello
tartományhoz tartozik.
A naplóadatokat a következővel AzureLogHandler
exportálhatja: . További információ: Az Azure Monitor beállítása a Python-alkalmazáshoz.
A megfelelő korreláció érdekében nyomkövetési információkat is továbbíthatunk az egyik összetevőről a másikra. Vegyük például azt a forgatókönyvet, amelyben két összetevő van, module1
és module2
. Az 1. modul függvényeket hív meg a 2. modulban. Ha mind a kettőből, mind module1
module2
egyetlen nyomkövetésből szeretne naplókat lekérni, a következő megközelítést használhatjuk:
# module1.py
import logging
from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer
from module_2 import function_1
config_integration.trace_integrations(["logging"])
logging.basicConfig(
format="%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s"
)
tracer = Tracer(sampler=AlwaysOnSampler())
logger = logging.getLogger(__name__)
logger.warning("Before the span")
with tracer.span(name="hello"):
logger.warning("In the span")
function_1(logger, tracer)
logger.warning("After the span")
# module_2.py
import logging
from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer
config_integration.trace_integrations(["logging"])
logging.basicConfig(
format="%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s"
)
logger = logging.getLogger(__name__)
tracer = Tracer(sampler=AlwaysOnSampler())
def function_1(logger=logger, parent_tracer=None):
if parent_tracer is not None:
tracer = Tracer(
span_context=parent_tracer.span_context,
sampler=AlwaysOnSampler(),
)
else:
tracer = Tracer(sampler=AlwaysOnSampler())
with tracer.span("function_1"):
logger.info("In function_1")
Telemetriai korreláció a .NET-ben
Az alkalmazás előkészítésekor a korreláció alapértelmezés szerint kezelhető. Nincs szükség speciális műveletekre.
- Alkalmazás Elemzések ASP.NET Core-alkalmazásokhoz
- Alkalmazás Elemzések konfigurálása a ASP.NET webhelyhez
- Alkalmazás Elemzések feldolgozószolgáltatás-alkalmazásokhoz (nem HTTP-alkalmazásokhoz)
A .NET-futtatókörnyezet az Activity és a DiagnosticSource segítségével támogatja az elosztott terjesztést
Az alkalmazás Elemzések .NET SDK a telemetriát gyűjti DiagnosticSource
és Activity
korrelálja.
Telemetriai korreláció Java nyelven
A Java-ügynök támogatja a telemetriai adatok automatikus korrelációját. Automatikusan kitölti operation_id
a kérés hatókörében kibocsátott összes telemetriát (például nyomkövetéseket, kivételeket és egyéni eseményeket). A HTTP-en keresztüli szolgáltatásközi hívásokhoz korábban ismertetett korrelációs fejléceket is propagálja, ha a Java SDK-ügynök konfigurálva van.
Feljegyzés
Az alkalmazás Elemzések Java-ügynök automatikusan észleli a JMS, a Kafka, a Netty/Webflux stb. kérelmeket és függőségeket. Java SDK esetén a korrelációs funkció csak az Apache HttpClienten keresztül indított hívásokat támogatja. Az SDK nem támogatja az olyan üzenetkezelési technológiák közötti automatikus környezetterjesztést, mint a Kafka, a RabbitMQ és az Azure Service Bus.
Az egyéni telemetriai adatok gyűjtéséhez az alkalmazást Java 2.6 SDK-val kell rendszereznünk.
Szerepkörnevek
Előfordulhat, hogy testre szeretné szabni, hogy az összetevőnevek hogyan jelenjenek meg az Alkalmazástérképen. Ehhez manuálisan is beállíthatja cloud_RoleName
az alábbi műveletek egyikét:
Az Alkalmazás Elemzések Java esetében állítsa be a felhőbeli szerepkör nevét az alábbiak szerint:
{ "role": { "name": "my cloud role name" } }
A felhőbeli szerepkör nevét a környezeti változóval
APPLICATIONINSIGHTS_ROLE_NAME
is beállíthatja.Az Application Elemzések Java SDK 2.5.0-s és újabb verzióival az alkalmazáshoz való hozzáadással
<RoleName>
adhatja megcloud_RoleName
Elemzések.xml fájlját:<?xml version="1.0" encoding="utf-8"?> <ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings" schemaVersion="2014-05-30"> <ConnectionString>InstrumentationKey=00000000-0000-0000-0000-000000000000</ConnectionString> <RoleName>** Your role name **</RoleName> ... </ApplicationInsights>
Ha a Spring Bootot az Application Elemzések Spring Boot Starter alkalmazással használja, állítsa be az alkalmazás egyéni nevét az application.properties fájlban:
spring.application.name=<name-of-app>
A felhőbeli szerepkör nevét környezeti változó vagy rendszertulajdonság használatával is beállíthatja. Részletekért tekintse meg a felhőbeli szerepkör nevének konfigurálását ismertető cikket.
Következő lépések
- Alkalmazástérkép
- Egyéni telemetriai adatok írása.
- Az ASP.NET Core és ASP.NET speciális korrelációs forgatókönyveit az egyéni műveletek nyomon követése című témakörben talál.
- További információ a cloud_RoleName más SDK-khoz való beállításáról.
- A mikroszolgáltatás összes összetevőjének előkészítése az Alkalmazás Elemzések. Tekintse meg a támogatott platformokat.
- Az alkalmazás Elemzések típusainak adatmodellje.
- Ismerje meg, hogyan terjesztheti ki és szűrheti a telemetriát.
- Tekintse át az alkalmazás Elemzések konfigurációs referenciát.