Nyomkövetések gyűjtése és vizsgálata az Microsoft Foundry Toolkitben

A Microsoft Foundry Toolkit for Visual Studio Code segítségével gyűjtsön helyi nyomkövetéseket, vagy tekintse meg az Microsoft Foundryben üzembe helyezett ügynökök telemetriáját. A nyomkövetés egy kéréshez rögzített műveleteket csoportosít. Minden művelet egy időtartam, amely időzítéssel, állapottal és az instrumentáció által megadott attribútumokkal vagy eseményekkel rendelkezik.

Ez a cikk először a helyi adatgyűjtést, majd a telepített ügynökök felhőbeli nyomkövetését ismerteti. Válassza ki a vizsgálatnak megfelelő adatforrást:

Approach	Használja a következőhöz:	Adatok és felelősségek
Ügynökellenőrző	Küldjön egy helyi kérést, vizsgálja meg az élő választ és az eszköz eseményeit, vagy szüneteltesse a kódot egy törésponton.	A kiszolgáló protokolleseményeket és fejlesztési diagnosztikát biztosít. Ehhez a megközelítéshez nincs szükség az OTLP-gyűjtőre, és nem kell Cloud Trace-előzményeket létrehozni.
Helyi nyomkövetés	Hasonlítsa össze a rögzített modell-, eszköz- és ügynökspánokat a fejlesztés során.	Az alkalmazás telemetriát exportál az Eszközkészlet helyi gyűjtőjébe. Konfigurálhatja az instrumentációt, és kezelheti a tárolt helyi adatokat.
Hostolt ügynök nyomon követése	Vizsgálja meg a Foundryben üzembe helyezett ügynök által kezelt kérelmeket.	A nyomkövetések a projekt csatlakoztatott Application Insights-erőforrásában találhatók. A hozzáférésre, a megőrzésre és a díjakra az Azure-erőforrás konfigurációja vonatkozik.

Egy hosztolt ügynök futtatja az egyéni kódot a Foundry Agent Service-ben. A Foundry kezeli az üzemeltetést, de továbbra is Ön felelős a kódért és a függőségekért. A nyomkövetés nem helyettesíti az ügynökök létrehozását és üzembe helyezését.

Prerequisites

Visual Studio Code a jelenlegi nyilvános Foundry Toolkit bővítménnyel. Lásd: Install Foundry Toolkit.
Egy helyileg futtatható alkalmazás, amelynek modell- és eszközkapcsolatai konfigurálva vannak.
Az első példa egy Python Microsoft Agent Framework-alkalmazás és annak kiválasztott Python-környezete. Más SDK-k esetén használja a Python vagy a JavaScript és TypeScript telepítést.
Felhőbeli nyomkövetéshez egy üzembe helyezett ügynök és a Foundry-projektjéhez kapcsolódó Application Insights-erőforrás, vagy az ehhez való csatlakoztatási vagy létrehozási engedély.
Felhőbeli lekérdezések esetén a csatlakoztatott Application Insights-erőforráson a Log Analytics Reader szerepkör szükséges. Védett táblák esetén is rendelje hozzá a Privileged Monitoring Data Reader szerepkört. Tekintse meg az Foundry nyomkövetési előfeltételeit.

A helyi adatgyűjtés nem igényel Application Insights- vagy felhőalapú telemetriai engedélyeket. A modellhívások és az eszközök futtatása továbbra is használhatnak távoli szolgáltatásokat, és díjakat vonhatnak maguk után.

Helyi nyomok gyűjtése

A helyi gyűjtő telemetriát fogad az OpenTelemetry Protocol (OTLP) protokollon keresztül. Nem végzi el automatikusan az alkalmazás instrumentálását. A keretrendszernek vagy az instrumentációs könyvtárnak spanokat kell létrehoznia, és exportálnia kell őket a gyűjtőbe.

SDK és nyelvi beállítások

A beépített kialakítású SDK-knak továbbra is exportőrre van szükségük. Más SDK-k külön instrumentációs csomagot használnak.

SDK vagy keretrendszer	Python	JavaScript és TypeScript (Node.js)
Microsoft Ügynök-keretrendszer	Beépített OpenTelemetry-rendszerállapot.	Nincs dedikált eszközkészlet-beállítási útmutató.
Azure AI Inference SDK (előzetes verzió)	Azure SDK instrumentáló.	Azure SDK instrumentálás.
Foundry Projects SDK	Ügyféloldali eszköz (előzetes verzió).	Instrumentálja az alapul szolgáló OpenAI- vagy Azure SDK-klienst.
Foundry classic Agents SDK	Azure SDK instrumentáló.	Nincs külön útmutató a Toolkit beállításához.
Anthropic	OpenLLMetry instrumentor.	Traceloop instrumentáció.
Google GenAI (Gemini)	Google GenAI OpenTelemetry instrumentor.	Nincs dedikált eszközkészlet-beállítási útmutató.
LangChain	OpenLLMetry instrumentor.	Traceloop instrumentáció.
OpenAI SDK, beleértve az Azure OpenAI-ügyfeleket	OpenLLMetry instrumentor.	Traceloop-instrumentáció.
OpenAI Agents SDK	OpenLLMetry nyomkövetési processzor.	Nincs dedikált eszközkészlet-beállítási útmutató.

A „Nincs dedikált Toolkit beállítási útmutatója” azt jelenti, hogy ehhez a nyelvhez nincs SDK-specifikus beállítási útvonal, nem pedig azt, hogy a gyűjtő elutasítja a telemetriát. A gyűjtő elfogadja az OTLP-adatokat. Az instrumentáló eszköz határozza meg, hogy mely műveletek és üzenetadatok kerülnek rögzítésre.

Ezek a példák kiválasztott instrumentációs beállításokat használnak, nem pedig a kompatibilis kódtárak teljes listáját. Az OpenLLMetry és a Traceloop instrumentáció nem Microsoft könyvtárak.

Az instrumentáció beállítása

Használja ezt az eljárást egy meglévő Python Agent Framework-alkalmazáshoz. Az útmutatóhoz tartsa az ügynököt és a kollektort ugyanabban a helyi környezetben.

Válassza az Foundry Toolkit lehetőséget a tevékenységsávon, majd a Fejlesztői eszközök>Monitor>Nyomkövetés.
Az alkalmazás futtatása előtt válassza a Gyűjtő indítása lehetőséget.
Az alkalmazás Python környezetében telepítse a gRPC-exportőrt, ha még nincs deklarálva a függőségekben:
```
python -m pip install opentelemetry-exporter-otlp-proto-grpc
```
Hivatkozás: OpenTelemetry Python OTLP-exportőrök.
Az ügynök létrehozása vagy futtatása előtt egyszer konfigurálja az OpenTelemetryt az alkalmazás indításakor:
```
import os

os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:4317"
os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = "grpc"

from agent_framework.observability import configure_otel_providers

configure_otel_providers(enable_sensitive_data=False)
```
Referencia: Az Ügynök-keretrendszer megfigyelhetősége.

Ha az alkalmazás vagy a tárhelytár már konfigurálja az OpenTelemetry-szolgáltatókat, konfigurálja a meglévő exportőreit ahelyett, hogy újabb szolgáltatói beállításokat ad hozzá. A jelspecifikus OTEL_EXPORTER_OTLP_*_ENDPOINT változók felülbírálhatják az alapvégpontot. Ellenőrizze, hogy van-e olyan nyomkövetési, napló- vagy metrikabeállítás, amely máshová mutat.
Futtassa az alkalmazást a szokásos belépési pontján keresztül, és küldjön egy kérést, amely teszteli az ügynököt. Fejezze be a kérést, és adjon időt az exportőrnek a telemetriai adatok küldésére a folyamat leállítása előtt.
A Nyomkövetés területen válassza a Frissítés lehetőséget, majd válassza ki az új nyomkövetést a kiterjedés vizsgálatához.

Az Agent Framework instrumentálja a támogatott modellügyfeleket, az ügynököket és a munkafolyamat-műveleteket. Más keretrendszerek instrumentációs könyvtárat igényelhetnek. Az OTLP-kompatibilitás lehetővé teszi, hogy a gyűjtő adatokat fogadjon, míg a kibocsátott attribútumok és a generatív AI szemantikai konvenciók határozzák meg, hogy mit jelenít meg a megjelenítő.

Egy másik SDK-hoz vagy nyelvhez használja az alábbi beállítást az Agent Framework konfigurációja helyett. Először indítsa el a gyűjtőt, konfigurálja a rendszerezést az ügyfelek létrehozása előtt, majd futtassa az alkalmazást, és frissítse a nyomkövetési listát.

Gyűjtővégpontok

Egyezzen az exportőri protokoll és a gyűjtő végpontja között. Az eszközkészlet az alábbi alapértelmezett értékekkel a localhoston figyel:

Exportőr	Endpoint
OTLP gRPC	`http://localhost:4317`
OTLP HTTP nyomkövetési exportőr	`http://localhost:4318/v1/traces`
OTLP HTTP-naplóexportáló	`http://localhost:4318/v1/logs`

Egyes HTTP-exportőrök maguk is elfogadják http://localhost:4318 és hozzáfűzik a jelútvonalat. Az útvonal kétszeri hozzáfűzése helyett kövesse az exportőr konfigurációját. Egyes instrumentációs könyvtárak naplórekordként küldik el az üzenettartalmakat, így előfordulhat, hogy a spanok önálló exportálása nem biztosít bemeneti és kimeneti részleteket.

Ezek a portok nem kapcsolódnak sem az ügynök HTTP-kiszolgálójához, sem a hibakereső portokhoz. Tárolóban vagy távoli fejlesztési környezetben localhost erre a környezetre hivatkozik. Hozza létre a megfelelő kapcsolatot a gyűjtőhöz ahelyett, hogy azt feltételezze, hogy az az asztali gépre vonatkozik.

Python SDK beállítása

Az alábbi példák abból indulnak ki, hogy az alkalmazás már rendelkezik a modell SDK-jával, hitelesítő adataival és modellkonfigurációjával. Telepítse az SDK megosztott függőségeit és további csomagját az alábbi táblázat alapján:

python -m pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http

Hivatkozás: OpenTelemetry Python SDK, OTLP-exportálók.

Ezt a megosztott beállítást az alkalmazás indításakor egyszer adja hozzá, majd az instrumentálást a táblázat egyik sorából. Ne kombinálja azt egy másik kódtár szolgáltatóbeállításával.

import os

os.environ["TRACELOOP_TRACE_CONTENT"] = "false"
os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "false"
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "false"

from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
    OTLPSpanExporter,
)

provider = TracerProvider(
    resource=Resource.create({"service.name": "my-agent"})
)
provider.add_span_processor(BatchSpanProcessor(
    OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")
))
trace.set_tracer_provider(provider)

Hivatkozás: TracerProvider és span processzorok, OTLPSpanExporter.

Telepítse a csomagot a kiválasztott sorban a(z) python -m pip install <package> használatával. Az OpenAI, Anthropic, LangChain és különálló OpenAI-ügynökök példái nem Microsoft OpenLLMetry-instrumentálást használnak. Az SDK-verziók és a modell API-k eltérő részleteket eredményezhetnek.

SDK	További csomag	Instrumentáció a megosztott beállítás után
OpenAI, beleértve Azure OpenAI-ügyfeleket	`opentelemetry-instrumentation-openai`	`from opentelemetry.instrumentation.openai import OpenAIInstrumentor` `OpenAIInstrumentor().instrument()`
Anthropic	`opentelemetry-instrumentation-anthropic`	`from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor` `AnthropicInstrumentor().instrument()`
LangChain	`opentelemetry-instrumentation-langchain`	`from opentelemetry.instrumentation.langchain import LangchainInstrumentor` `LangchainInstrumentor().instrument()`
Google GenAI	`opentelemetry-instrumentation-google-genai`	`os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "NO_CONTENT"` `from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor` `GoogleGenAiSdkInstrumentor().instrument()`
Foundry Projects ügyféloldali nyomkövetés (előzetes verzió)	`azure-core-tracing-opentelemetry`, mellett `azure-ai-projects`	`os.environ["AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING"] = "true"` `from azure.ai.projects.telemetry import AIProjectInstrumentor` `AIProjectInstrumentor().instrument(enable_content_recording=False)`
Foundry Classic Agents SDK	`azure-core-tracing-opentelemetry`, mellette `azure-ai-agents`	`os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"` `from azure.ai.agents.telemetry import AIAgentsInstrumentor` `AIAgentsInstrumentor().instrument()`
Azure AI Inference SDK (előzetes verzió)	`azure-core-tracing-opentelemetry`, mellette `azure-ai-inference`	`os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"` `from azure.ai.inference.tracing import AIInferenceInstrumentor` `AIInferenceInstrumentor().instrument()`

Az Foundry-projektek esetében kövesse az ügyféloldali nyomkövetési útmutatót, és hozza létre az OpenAI-ügyfelet az instrumentálás után. Ez az útmutató eltér a klasszikus Agents SDK-tól. Ne instrumentálja ugyanazokat az OpenAI-hívásokat mind a AIProjectInstrumentor, mind egy külön OpenAI-instrumentorral.

OpenAI Agents SDK esetén telepítse opentelemetry-instrumentation-openai-agents és adja hozzá ezt a kódot a közös beállítás után:

from agents import set_trace_processors
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor

set_trace_processors([])
OpenAIAgentsInstrumentor().instrument()

Hivatkozás: OpenAI-ügynökök instrumentálása, OpenAI-ügynökök nyomkövetése.

Ez a példa lecseréli a meglévő nyomkövetési processzorokat az OpenTelemetry-processzor hozzáadása előtt. A csere nélkül az SDK a nyomkövetéseket is exportálhatja az alapértelmezett backendbe. Ha meglévő feldolgozókra van szüksége, a módosítás előtt tekintse át a nyomkövetési célhelyeket. Hagyja engedélyezve az SDK-nyomkövetést, hogy az OpenTelemetry-processzor eseményeket fogadjon.

Miután egy rövid élettartamú alkalmazás befejezte a kéréseit, a kilépés előtt hívja meg a provider.force_flush() függvényt a pufferelt spanek elküldéséhez. Ha segítségre van szüksége ezeknek a kódrészleteknek az adaptálásához, használja az Eszközkészlet nyomkövetési kód gen eszközét.

Üzenetnapló-rekordok exportálása

Egyes instrumentorok az attribútumok helyett az üzenet tartalmát OpenTelemetry-naplórekordokként bocsátják ki. Ha úgy dönt, hogy ezt a tartalmat egy ellenőrzött fejlesztési tesztben rögzíti, adja hozzá ezt a beállítást az előző Python trace provider mellé:

from opentelemetry import _logs
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

logger_provider = LoggerProvider(resource=provider.resource)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(
    OTLPLogExporter(endpoint="http://localhost:4318/v1/logs")
))
_logs.set_logger_provider(logger_provider)

Referencia: OpenTelemetry Python naplózási SDK, OTLPLogExporter.

Hívás logger_provider.force_flush() rövid élettartamú alkalmazásból való kilépés előtt. A naplóexportáló önmagában nem kapcsolja be a tartalomrögzítést. Kövesse a készülék tartalombeállításait és az adatkezelési útmutatót.

JavaScript és TypeScript SDK beállítása

Node.js alkalmazások esetében ossza meg egy nyomkövetési szolgáltatót, és regisztrálja az SDK rendszerállapotát. Ez a példa a CommonJS-t és az OpenTelemetria JavaScript 2.x szolgáltató konfigurációját használja. A CommonJS-be lefordított TypeScript-alkalmazások ugyanazt az inicializálási sorrendet használhatják.

Az alkalmazásnak már rendelkeznie kell a modell SDK-jával, hitelesítő adataival és modellkonfigurációjával. Telepítse a megosztott függőségeket és az OpenAI instrumentort:

npm install @opentelemetry/api @opentelemetry/sdk-trace-node \
  @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/instrumentation @traceloop/instrumentation-openai

Referencia: OpenTelemetry JavaScript-exportőrök, OpenAI-rendszerállapot.

Hozza létre tracing.cjs:

const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const {
  OTLPTraceExporter
} = require('@opentelemetry/exporter-trace-otlp-proto');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { OpenAIInstrumentation } = require('@traceloop/instrumentation-openai');

const provider = new NodeTracerProvider({
  spanProcessors: [
    new BatchSpanProcessor(new OTLPTraceExporter({
      url: 'http://localhost:4318/v1/traces'
    }))
  ]
});
provider.register();

registerInstrumentations({
  instrumentations: [new OpenAIInstrumentation({ traceContent: false })]
});

module.exports = provider;

Referencia: NodeTracerProvider, OpenAI-instrumentáció.

Töltse be ezt a fájlt a modell SDK importálása vagy require-olása előtt. Például futtassa a(z) node --require ./tracing.cjs app.cjs parancsot egy CommonJS-alkalmazáshoz. Egy másik SDK esetében cserélje le az OpenAI-csomagot, az importálást és a regisztrációs bejegyzést a megfelelő sorral:

SDK	Instrumentációs csomag	Importálás és regisztráció
OpenAI, beleértve az Azure OpenAI-ügyfeleket	`@traceloop/instrumentation-openai`	`const { OpenAIInstrumentation } = require('@traceloop/instrumentation-openai');` `new OpenAIInstrumentation({ traceContent: false })`
Anthropic	`@traceloop/instrumentation-anthropic`	`const { AnthropicInstrumentation } = require('@traceloop/instrumentation-anthropic');` `new AnthropicInstrumentation({ traceContent: false })`
LangChain	`@traceloop/instrumentation-langchain`	`const { LangChainInstrumentation } = require('@traceloop/instrumentation-langchain');` `new LangChainInstrumentation({ traceContent: false })`
Azure SDK műveletek, beleértve az Azure AI Inference-t	`@azure/opentelemetry-instrumentation-azure-sdk`	`const { createAzureSdkInstrumentation } = require('@azure/opentelemetry-instrumentation-azure-sdk');` `createAzureSdkInstrumentation()`

A Traceloop-csomagok nem a Microsoft instrumentációs csomagjai. Egy Foundry Projects-alkalmazás esetében lássa el monitorozással a modellkérelmet küldő klienst. Az Azure SDK instrumentációja nem helyettesíti az OpenAI-instrumentációt az OpenAI-ügyfélen keresztül indított hívások esetében.

Natív ECMAScript-modulok esetén kövesse az OpenTelemetry ESM-beállítását. Az instrumentálás betöltése a cél SDK után egyes hívásokat instrumentálatlanul hagyhat. Leállításkor a pufferelt spanok exportálásához várjon a(z) provider.shutdown() elemre, miután a kérések befejeződtek.

Important

Ezek a példák kikapcsolják az üzenet-tartalom rögzítését a felsorolt GenAI-instrumentálókhoz. Ez nem általános kitakarási garancia. Az adatok megosztása előtt tekintse át a többi exportőrt, az SDK-naplózást, a span attribútumokat és az egyéni instrumentálást. A támogatott csomagokat és API-kat a hivatkozott instrumentor dokumentációjában találja.

Helyi nyomok vizsgálata és kezelése

A spanfa segítségével kövesse a kérést az ügynök-orchesztrációtól a modell- és eszközműveletekig.

Jelöljön ki egy lassú vagy sikertelen span-t.
Ellenőrizze annak időtartamát és állapotát.
Nyissa meg a Bemenet + kimenet lehetőséget a rögzített üzenetekhez, ha a rendszer biztosítja őket, vagy a Metaadatok lehetőséget a span attribútumaihoz.

A példák kikapcsolva tartják az érzékeny tartalmak rögzítését. Az üzenetek nélküli időzítési adatok lehetnek a várt eredmény.

Egy ellenőrzött Agent Framework-fejlesztési teszthez állítsa be a meglévő konfigurációban a(z) enable_sensitive_data=True értéket a támogatott prompt-, válasz- és eszköztartalom rögzítéséhez. A teszt befejezésekor állítsa vissza erre: False. A többi instrumentáló saját tartalombeállításokkal rendelkezik.

Caution

A tartalomrögzítés személyes adatokat, titkokat, a segédeszközök argumentumait és eredményeket rögzíthet. Használjon nem bizalmas tesztadatokat, és minimalizálja vagy szerkessze ki a tartalmat, mielőtt a telemetriába kerül. Ne kapcsolja be az éles környezeti tartalom rögzítését kizárólag üres bemeneti és kimeneti nézet kitöltéséhez.

Az összegyűjtött nyomkövetési adatok egy traces.db nevű helyi SQLite-adatbázisban maradnak meg, a saját mappájában található .aitk könyvtár tracing alkönyvtárában. A megjelenítő bezárása nem törli őket.

A helyi gyűjtemény leállításához válassza a Collector leállítása lehetőséget. Az ügynök és a modellhívásai továbbra is futnak. A helyi rekordok eltávolításához jelölje ki a nyomkövetéseket a listában, és válassza a Delete parancsot.

A helyi tároló elkülönül az Application Insightstól. A helyi nyomok törlése nem távolítja el a felhő-telemetriát, és az Inspectorban lévő beszélgetés törlése egyik tárolót sem törli.

A hostolt ügynök nyomkövetéseinek megtekintése

Az üzembe helyezés után a helyi folyamat helyett használjon felhőbeli nyomkövetéseket a Foundryben futó ügynök vizsgálatához. Az eszközkészlet lekérdezi a projekt csatlakoztatott Application Insights-erőforrását. Nem tölti fel a helyi nyomkövetési adatbázist.

A kezdés előtt ellenőrizze a felhő előfeltételeit . Az ügynökhöz való hozzáférés önmagában nem ad engedélyt a telemetriai lekérdezésre.

Az Application Insights csatlakoztatása és egy kérés vizsgálata

Az ügynök Nyomok lapján csatlakoztathatja az Application Insightst, és megkereshet egy üzembe helyezett ügynöktől származó kérelmet.

A Foundry Toolkit oldalsávjában nyissa meg a Saját erőforrások>Ügynökök. Válassza a Hosted Agent lapot, majd válassza ki az ügynök nevét.
Válassza a Nyomvonalak lehetőséget. Ha a projekt nem rendelkezik csatlakoztatott erőforrással, válassza az App Insights engedélyezése lehetőséget.
Az App Insights beállításai között válasszon ki egy meglévő Application Insights-erőforrásnevet. Másik lehetőségként hozzon létre egy erőforrást, és töltse ki a szükséges erőforrás- és munkaterületmezőket. Válassza a Küldés lehetőséget , és várja meg a megerősítést.

Ez a projekt megosztott Application Insights-kapcsolatát módosítja, nem pedig a helyi munkaterület-beállítást. Az erőforrás-létrehozás és a telemetriagyűjtés Azure díjakat vonhat maga után. A küldés előtt ellenőrizze a tervezett projektet és erőforrást.
Térjen vissza a Playground, és küldjön egy tesztkérelmet az üzembe helyezett ügynöknek.
Engedélyezze a betöltési időt, majd nyissa meg újra a Tracest . A kérés megkereséséhez használja az időtartományt, Keresés beszélgetésazonosító alapján, állapot vagy időtartam szűrőket.
Jelöljön ki egy nyomkövetést, majd egy spant a metaadatok és az input + kimenet áttekintéséhez, ha a tartalom elérhető.

A beszélgetéshez társított műveletek vizsgálatához válassza ki a beszélgetés azonosítóját a nyomkövetési listában. A beszélgetési nézet egy műveletfát és metaadatokat jelenít meg.

Az Application Insights csatlakoztatása lehetővé teszi az Foundry kiszolgálóoldali nyomkövetését. A modellhívások, az eszközhívások és az egyéni kód láthatósága a hostoló könyvtártól és a keretrendszer instrumentációjától is függ. Lásd: Nyomkövetés beállítása a Foundryban a szolgáltatásoldali adatgyűjtéshez és a további kliensoldali instrumentáláshoz.

Az eszközkészlet nyomkövetési részletes lekérdezése jelenleg az elmúlt hét napot fedi le. Ez egy lekérdezési ablak, nem adatmegőrzési beállítás. Régebbi adatok esetén használja az Foundry portált vagy a Azure Monitor, a csatlakoztatott munkaterület megőrzési konfigurációjának függvényében.

Adatok, hozzáférés, megőrzés és költség

A tartalomrögzítés engedélyezése vagy egy felhőerőforrás csatlakoztatása előtt döntse el, hogy hova kerüljön a telemetria. Ugyanez a kérés létrehozhat helyi spaneket, felhőbeli telemetriát, valamint a modell- vagy eszközszolgáltatóknak küldött adatokat.

Adatforrás	Responsibilities
Helyi nyomok	A helyi adatbázishoz és a másolt adatokhoz való hozzáférés védelme. A gyűjtő leállítása nem állítja le az alkalmazásban konfigurált többi exportőrt.
Felhőbeli nyomok	Az Application Insights és Log Analytics szabályozhatja a hozzáférési, adatmegőrzési és telemetriai díjakat. Az eszközkészletszűrők nem módosítják ezeket a házirendeket.
Modell- és eszközhívások	A helyi gyűjtés nem akadályozza meg, hogy a kérések elhagyják a számítógépet. Tekintse át minden csatlakoztatott szolgáltatás adatkezelését, beleértve a nem Microsoft eszközöket is.

Az Foundry nyomkövetési útmutatóját a biztonság, az adatvédelem, az adatmegőrzés és a költségek érdekében használhatja. Az éles identitás, a hálózatelkülönítés és a kapcsolódó rendszerekhez való hozzáférés érdekében kövesse az üzemeltetett ügynök biztonsági és adatkezelési irányelveit. Ne kezelje a helyi hitelesítő adatokat az üzembe helyezett ügynök jogosultságaiként.

Troubleshooting

Issue	Mit kell ellenőrizni?
Nyomkövetés nem érhető el az oldalsávban.	Győződjön meg arról, hogy az aktuális bővítmény telepítve van, és engedélyezve van abban a környezetben, amelyben futtatja. A helyi nyomkövetéshez be kell tölteni a natív SQLite-összetevőt.
A gyűjtő nem indul el.	Ellenőrizze, hogy van-e a 4317-es vagy 4318-as portot használó másik folyamat, és tekintse át az Eszközkészlet kimenetét. Kerülje az egymással konfliktusban lévő gyűjtőket ugyanazokon a portokon.
A helyi kérelem sikeres, de nem jelenik meg nyom.	Győződjön meg arról, hogy az instrumentáció a kérés előtt lefut, a kollektor fut, és az exporter a megfelelő protokollt és végpontot használja. Ellenőrizze a végpontok felülbírálásait, az exportőr hibáit és a pufferelt telemetriát, majd válassza a Frissítés lehetőséget.
A spanek üzenetek nélkül láthatók.	Ellenőrizze a tartalomrögzítési beállításokat és a támogatott attribútumokat. Egyes könyvtárakhoz naplóexportőrre is szükség van. A hiányzó tartalom nem feltétlenül jelenti azt, hogy az adatgyűjtés meghiúsult.
A felhőbeli nyomok üresek.	Ellenőrizze a projektet és az Application Insights-kapcsolatot, hozzon létre új forgalmat, bővítse ki az időtartományt, és számoljon az adatbetöltési késéssel.
A felhőbeli lekérdezések engedélyezési hibával hiúsulnak meg.	Ellenőrizze az Application Insightshoz és a Log Analyticshez való olvasási hozzáférést, beleértve a védett táblákat is, a szolgáltatás előfeltételei használatával.
Egy régebbi nyomkövetési napló nem tartalmaz részleteket a Toolkitban.	A részletes lekérdezés hét napot fed le. Kérdezze le a régebbi megőrzött rekordokat a Foundryban vagy az Azure Monitorban.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Utolsó frissítés időpontja: 2026-10-08