Konfigurieren der Ablaufverfolgung für KI-Agent-Frameworks (Vorschau)

Wichtig

In diesem Artikel markierte Elemente (Vorschau) befinden sich derzeit in der öffentlichen Vorschau. Diese Vorschau wird ohne Vereinbarung auf Serviceebene bereitgestellt und wird für Produktionsworkloads nicht empfohlen. Bestimmte Features werden möglicherweise nicht unterstützt oder weisen eingeschränkte Funktionen auf. Weitere Informationen finden Sie unter Supplementale Nutzungsbedingungen für Microsoft Azure Previews.

Hinweis

Die Ablaufverfolgung ist in der Regel nur für Echtzeit-Agents verfügbar. Workflow, gehostete und benutzerdefinierte Agents befinden sich in der Vorschau.

Wenn sich KI-Agenten in der Produktion unerwartet verhalten, verschafft Ihnen die Ablaufverfolgung die nötige Einsicht, um die Ursache schnell zu identifizieren. Das Tracing erfasst detaillierte Telemetriedaten, einschließlich LLM-Aufrufe, Toolaufrufe und Agent-Entscheidungsflüsse, sodass Sie Probleme debuggen, Latenz überwachen und das Verhalten von Agenten bei verschiedenen Anforderungen nachvollziehen können.

Microsoft Foundry bietet Ablaufverfolgungsintegrationen für beliebte Agent-Frameworks, die minimale Codeänderungen erfordern. In diesem Artikel erfahren Sie, wie Sie:

  • Konfigurieren Sie die automatische Ablaufverfolgung für das Microsoft Agent Framework.
  • Einrichten des langchain-azure-ai Tracers für LangChain und LangGraph
  • Instrumentieren des OpenAI Agents SDK mit OpenTelemetry
  • Überprüfen, ob Spuren im Foundry-Portal angezeigt werden
  • Beheben häufig auftretende Ablaufverfolgungsprobleme

Voraussetzungen

  • Ein Foundry-Projekt mit Überwachung verbunden mit Azure Monitor Application Insights.
  • Mitwirkender oder höherer Rolle für die Application Insights-Ressource für die Erfassung der Ablaufverfolgung.
  • Zugriff auf die verbundene Application Insights-Ressource zum Anzeigen von Ablaufverfolgungen. Bei protokollbasierten Abfragen benötigen Sie möglicherweise auch Zugriff auf den zugeordneten Log Analytics Arbeitsbereich.
  • Python 3.10 oder höher (erforderlich für alle Codebeispiele in diesem Artikel).
  • Die langchain-azure-ai Paketversion 0.1.0 oder höher (erforderlich für LangChain- und LangGraph-Beispiele).
  • Wenn Sie LangChain oder LangGraph verwenden, benötigen Sie eine Python-Umgebung mit installiertem pip.

Bestätigen, dass Sie Telemetrie anzeigen können

Um Trace-Daten anzuzeigen, stellen Sie sicher, dass Ihr Konto Zugriff auf die verbundene Application Insights-Ressource hat.

  1. Öffnen Sie im Azure-Portal die Application Insights-Ressource, die mit Ihrem Foundry-Projekt verbunden ist.

  2. Wählen Sie access control (IAM) aus.

  3. Weisen Sie Ihrem Benutzer oder Ihrer Gruppe eine entsprechende Rolle zu.

    Wenn Sie protokollbasierte Abfragen verwenden, gewähren Sie zunächst die Rolle Log Analytics Reader.

Sicherheit und Datenschutz

Die Ablaufverfolgung kann vertrauliche Informationen erfassen (z. B. Benutzereingaben, Modellausgaben und Tool-Argumente und -Ergebnisse).

  • Aktivieren Sie die Inhaltsaufzeichnung während der Entwicklung und beim Debuggen, um vollständige Anforderungs- und Antwortdaten anzuzeigen. Deaktivieren Sie die Inhaltsaufzeichnung in Produktionsumgebungen, um vertrauliche Daten zu schützen. In den Beispielen in diesem Artikel wird die Inhaltsaufzeichnung durch Einstellungen wie enable_content_recording und OTEL_RECORD_CONTENT gesteuert.
  • Speichern Sie keine geheimen Schlüssel, Anmeldeinformationen oder Token in Eingabeaufforderungen oder Toolargumenten.

Weitere Anleitungen finden Sie unter "Sicherheit und Datenschutz".

Hinweis

Trace-Daten, die in Application Insights gespeichert sind, unterliegen den Datenaufbewahrungseinstellungen Ihres Arbeitsbereichs und den Preisen von Azure Monitor. Berücksichtigen Sie bei der Kostenverwaltung die Anpassung der Samplingraten oder Aufbewahrungszeiträume in der Produktion. Sehen Sie Azure Monitor pricing und Konfigurieren Sie Datenaufbewahrung und Archivierung.

Konfigurieren der Ablaufverfolgung für Microsoft Agent Framework

Microsoft Foundry hat native Integrationen mit beiden Microsoft-Agent-Frameworks. Agenten, die mit einem der beiden Frameworks erstellt wurden, geben automatisch Tracing-Informationen aus, wenn das Tracing für Ihr Foundry-Projekt aktiviert ist – es sind weder zusätzlicher Code noch zusätzliche Pakete erforderlich.

So überprüfen Sie, ob die Ablaufverfolgung funktioniert:

  1. Führen Sie Ihren Agenten mindestens einmal aus.
  2. Wechseln Sie im Gießereiportal zu Observability>Traces.
  3. Bestätigen Sie, dass eine neue Ablaufverfolgung mit Spannen für die Vorgänge Ihres Agenten angezeigt wird.

Traces werden in der Regel innerhalb von 2 bis 5 Minuten nach der Ausführung des Agents angezeigt. Weitere Informationen zur erweiterten Konfiguration finden Sie in der frameworkspezifischen Dokumentation:

Ablaufverfolgung für LangChain und LangGraph konfigurieren

Hinweis

Die Ablaufverfolgungsintegration für LangChain und LangGraph ist derzeit nur in Python verfügbar.

Verwenden Sie das langchain-azure-ai-Paket, um OpenTelemetry-kompatible Spannen für LangChain- und LangGraph-Vorgänge auszugeben. DieseAblaufverfolgungen werden in der Ansicht > Traces" im Foundry-Portal angezeigt.

Beispiel: LangChain v1-Agent mit Azure AI-Ablaufverfolgung

Verwenden Sie dieses End-to-End-Beispiel, um einen LangChain v1 -Agent (Vorschau) mithilfe des langchain-azure-ai Tracers zu instrumentieren. Dieser Tracer implementiert die neuesten semantischen Konventionen von OpenTelemetry (OTel), sodass Sie detaillierte Traces in der Foundry-Observability-Ansicht nachverfolgen können.

LangChain v1: Installieren von Paketen

pip install \
  langchain-azure-ai \
  langchain \
  langgraph \
  langchain-openai \
  azure-identity \
  python-dotenv \
  rich

LangChain v1: Konfigurieren der Umgebung

  • APPLICATION_INSIGHTS_CONNECTION_STRING: Azure Monitor Application Insights-Verbindungszeichenfolge für die Nachverfolgung.
  • AZURE_OPENAI_ENDPOINT: Ihre Azure OpenAI-Endpunkt-URL.
  • AZURE_OPENAI_CHAT_DEPLOYMENT: Der Bereitstellungsname des Chatmodells.
  • AZURE_OPENAI_VERSION: API-Version, z. B 2024-08-01-preview. .
  • Das SDK löst Azure Anmeldeinformationen mithilfe von DefaultAzureCredential auf, die Umgebungsvariablen, verwaltete Identität und VS Code-Anmeldung unterstützt.

Speichern Sie diese Werte in einer .env Datei für die lokale Entwicklung.

LangChain v1: Tracer-Setup

from dotenv import load_dotenv
import os
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Weather information agent",
    id="weather_info_agent_771929",
)

tracers = [azure_tracer]

LangChain v1: Modellsetup (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
)

LangChain v1: Definieren von Tools und Eingabeaufforderungen

from dataclasses import dataclass
from langchain_core.tools import tool

system_prompt = """You are an expert weather forecaster, who speaks in puns.

You have access to two tools:

- get_weather_for_location: use this to get the weather for a specific location
- get_user_location: use this to get the user's location

If a user asks you for the weather, make sure you know the location.
If you can tell from the question that they mean wherever they are,
use the get_user_location tool to find their location."""

# Mock user locations keyed by user id (string)
USER_LOCATION = {
    "1": "Florida",
    "2": "SF",
}

@dataclass
class UserContext:
    user_id: str

@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

LangChain v1: Verwenden des Laufzeitkontexts und Definieren eines Benutzerinformationstools

from langgraph.runtime import get_runtime
from langchain_core.runnables import RunnableConfig

@tool
def get_user_info(config: RunnableConfig) -> str:
    """Retrieve user information based on user ID."""
    runtime = get_runtime(UserContext)
    user_id = runtime.context.user_id
    return USER_LOCATION[user_id]

LangChain v1: Erstellen des Agents

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver
from dataclasses import dataclass

@dataclass
class WeatherResponse:
    conditions: str
    punny_response: str

checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    prompt=system_prompt,
    tools=[get_user_info, get_weather],
    response_format=WeatherResponse,
    checkpointer=checkpointer,
)

LangChain v1: Ausführen des Agents mit Ablaufverfolgung

from rich import print

def main():
    config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
    context = UserContext(user_id="1")

    r1 = agent.invoke(
        {"messages": [{"role": "user", "content": "what is the weather outside?"}]},
        config=config,
        context=context,
    )
    print(r1.get("structured_response"))

    r2 = agent.invoke(
        {"messages": [{"role": "user", "content": "Thanks"}]},
        config=config,
        context=context,
    )
    print(r2.get("structured_response"))

if __name__ == "__main__":
    main()

Bei aktivierter langchain-azure-ai erzeugen alle LangChain v1-Vorgänge (LLM-Aufrufe, Toolaufrufe, Agentschritte) OpenTelemetry-Spans mittels der neuesten semantischen Konventionen. Diese Traces werden in der Ansicht Observability>Traces im Foundry-Portal angezeigt und mit Ihrer Application Insights-Ressource verknüpft.

Tipp

Warten Sie nach dem Ausführen des Agents einige Minuten, bis Traces erscheinen. Wenn keine Ablaufverfolgungen angezeigt werden, vergewissern Sie sich, dass Ihre Application Insights-Verbindungszeichenfolge korrekt ist, und lesen Sie den Abschnitt Häufige Probleme beheben.

Überprüfen Sie Ihre LangChain v1-Nachverfolgungen

Nach dem Ausführen des Agents:

  1. Warten Sie 2 bis 5 Minuten, bis die Traces übertragen werden.
  2. Wechseln Sie im Gießereiportal zu Observability>Traces.
  3. Suchen Sie nach einem Trace mit dem von Ihnen angegebenen Namen (z. B. "Wetterinformationsagent").
  4. Erweitern Sie die Ablaufverfolgung, um die Spannweiten für LLM-Aufrufe, Toolaufrufe und Agentenschritte anzuzeigen.

Wenn keine Ablaufverfolgungen angezeigt werden, überprüfen Sie den Abschnitt "Häufig auftretende Probleme beheben ".

Beispiel: LangGraph-Agent mit Azure AI-Ablaufverfolgung

Dieses Beispiel zeigt einen einfachen LangGraph-Agenten, der mit langchain-azure-ai instrumentiert ist, um OpenTelemetry-kompatible Tracing für Diagrammschritte, Toolaufrufe und Modellaufrufe auszugeben.

LangGraph: Installieren von Paketen

pip install \
  langchain-azure-ai \
  langgraph>=1.0.0 \
  langchain>=1.0.0 \
  langchain-openai \
  azure-identity \
  python-dotenv

LangGraph: Konfigurieren der Umgebung

  • APPLICATION_INSIGHTS_CONNECTION_STRING: Azure Monitor Application Insights-Verbindungszeichenfolge für die Nachverfolgung.
  • AZURE_OPENAI_ENDPOINT: Ihre Azure OpenAI-Endpunkt-URL.
  • AZURE_OPENAI_CHAT_DEPLOYMENT: Der Bereitstellungsname des Chatmodells.
  • AZURE_OPENAI_VERSION: API-Version, z. B 2024-08-01-preview. .

Speichern Sie diese Werte in einer .env Datei für die lokale Entwicklung.

LangGraph-Tracer-Einrichtung

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=os.getenv("OTEL_RECORD_CONTENT", "true").lower() == "true",
    name="Music Player Agent",
)

LangGraph: Tools

from langchain_core.tools import tool

@tool
def play_song_on_spotify(song: str):
    """Play a song on Spotify"""
    # Integrate with Spotify API here.
    return f"Successfully played {song} on Spotify!"

@tool
def play_song_on_apple(song: str):
    """Play a song on Apple Music"""
    # Integrate with Apple Music API here.
    return f"Successfully played {song} on Apple Music!"

tools = [play_song_on_apple, play_song_on_spotify]

LangGraph: Modellsetup (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
).bind_tools(tools, parallel_tool_calls=False)

Erstellen des LangGraph-Workflows

from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver

tool_node = ToolNode(tools)

def should_continue(state: MessagesState):
    messages = state["messages"]
    last_message = messages[-1]
    return "continue" if getattr(last_message, "tool_calls", None) else "end"

def call_model(state: MessagesState):
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": [response]}

workflow = StateGraph(MessagesState)
workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END,
    },
)
workflow.add_edge("action", "agent")

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

LangGraph: Ausführen mit Ablaufverfolgung

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
input_message = HumanMessage(content="Can you play Taylor Swift's most popular song?")

for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()

Mit aktivierter langchain-azure-ai-Funktion erzeugt Ihre LangGraph-Ausführung OpenTelemetry-kompatible Spans für Modellaufrufe, Toolaufrufe und Graph-Übergänge. Diese Ablaufverfolgungen fließen zu Application Insights und werden in der Ansicht „Observability“>„Traces“ im Foundry-Portal angezeigt.

Tipp

Jeder Diagrammknoten und jeder Randübergang erstellt eine separate Spanne, wodurch der Entscheidungsfluss des Agents leicht zu visualisieren ist.

Überprüfen Sie Ihre LangGraph-Ablaufverfolgungen

Nach dem Ausführen des Agents:

  1. Warten Sie 2 bis 5 Minuten, bis die Traces übertragen werden.
  2. Wechseln Sie im Gießereiportal zu Observability>Traces.
  3. Suchen Sie nach einer Spur mit dem von Ihnen angegebenen Namen (z. B. "Music Player Agent").
  4. Erweitern Sie die Ablaufverfolgung, um Spannweiten für Diagrammknoten, Toolaufrufe und Modellaufrufe anzuzeigen.

Wenn keine Ablaufverfolgungen angezeigt werden, überprüfen Sie den Abschnitt "Häufig auftretende Probleme beheben ".

Beispiel: LangChain-Version 0.3-Setup mit Azure AI-Nachverfolgung

In diesem minimalen Setup zeigen wir, wie sie Azure AI-Ablaufverfolgung in einer LangChain 0.3-Anwendung mithilfe des langchain-azure-ai Tracers und AzureChatOpenAI aktivieren.

LangChain 0.3: Installieren von Paketen

pip install \
  "langchain>=0.3,<0.4" \
  langchain-openai \
  langchain-azure-ai \
  python-dotenv

LangChain 0.3: Konfigurieren der Umgebung

  • APPLICATION_INSIGHTS_CONNECTION_STRING: Application Insights-Verbindungszeichenfolge zur Ablaufverfolgung. Um diesen Wert zu finden, öffnen Sie Ihre Application Insights-Ressource im Azure-Portal, wählen Sie Overview aus, und kopieren Sie die Verbindenzeichenfolge.
  • AZURE_OPENAI_ENDPOINT: Azure OpenAI-Endpunkt-URL.
  • AZURE_OPENAI_CHAT_DEPLOYMENT: Bereitstellungsname des Chatmodells.
  • AZURE_OPENAI_VERSION: API-Version, z. B 2024-08-01-preview. .
  • AZURE_OPENAI_API_KEY: Azure OpenAI-API-Schlüssel.

Hinweis

In diesem Beispiel wird die API-Schlüsselauthentifizierung aus Gründen der Einfachheit verwendet. Verwenden Sie DefaultAzureCredential für Produktionsworkloads wie get_bearer_token_provider in den Beispielen LangChain v1 und LangGraph dargestellt.

LangChain 0.3: Tracer und Modellsetup

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer
from langchain_openai import AzureChatOpenAI

load_dotenv(override=True)

# Tracer: emits spans conforming to updated OTel spec
azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Trip Planner Orchestrator",
    id="trip_planner_orchestrator_v3",
)
tracers = [azure_tracer]

# Model: Azure OpenAI with callbacks for tracing
llm = AzureChatOpenAI(
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    temperature=0.2,
    callbacks=tracers,
)

Befestigen Sie callbacks=[azure_tracer] an Ihren Ketten, Tools oder Agents, um sicherzustellen, dass die Vorgänge in LangChain 0.3 nachverfolgt werden. Nachdem Sie Ihre Kette oder Ihren Agenten ausgeführt haben, werden Ablaufverfolgungen innerhalb von 2 bis 5 Minuten in der Ansicht > Traces im Foundry-Portal angezeigt.

Konfigurieren der Ablaufverfolgung für das SDK für OpenAI Agents

Das OpenAI Agents SDK unterstützt die OpenTelemetry-Instrumentierung. Verwenden Sie den folgenden Codeausschnitt, um Tracing und Exportspannen für Azure Monitor zu konfigurieren. Wenn APPLICATION_INSIGHTS_CONNECTION_STRING nicht gesetzt ist, greift der Exporter auf die Konsole für das lokale Debuggen zurück.

Installieren Sie vor dem Ausführen des Beispiels die erforderlichen Pakete:

pip install opentelemetry-sdk opentelemetry-instrumentation-openai-agents azure-monitor-opentelemetry-exporter

import os
from opentelemetry import trace
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

# Configure tracer provider + exporter
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "openai-agents-app"),
})
provider = TracerProvider(resource=resource)

conn = os.getenv("APPLICATION_INSIGHTS_CONNECTION_STRING")
if conn:
    from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
    provider.add_span_processor(
        BatchSpanProcessor(AzureMonitorTraceExporter.from_connection_string(conn))
    )
else:
    provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

trace.set_tracer_provider(provider)

# Instrument the OpenAI Agents SDK
OpenAIAgentsInstrumentor().instrument(tracer_provider=trace.get_tracer_provider())

# Example: create a session span around your agent run
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("agent_session[openai.agents]"):
    # ... run your agent here
    pass

Überprüfen Sie Ablaufverfolgungen im Foundry-Portal

  1. Melden Sie sich bei Microsoft Foundry an. Stellen Sie sicher, dass die Umschaltfläche "Neue Gießerei " aktiviert ist. Diese Schritte beziehen sich auf Foundry (neu).
  2. Bestätigen Sie, dass die Ablaufverfolgung für Ihr Projekt eingeschaltet ist. Wenn erforderlich, folgen Sie der Anleitung zur Einrichtung der Verfolgung in Microsoft Foundry.
  3. Führen Sie Ihren Agenten mindestens einmal aus.
  4. Wechseln Sie im Gießereiportal zu Observability>Traces.
  5. Bestätigen Sie, dass eine neue Ablaufverfolgung mit Spannen für die Vorgänge Ihres Agenten angezeigt wird.

Traces werden in der Regel innerhalb von 2 bis 5 Minuten nach der Ausführung des Agents angezeigt. Wenn Ablaufverfolgungen nach diesem Zeitpunkt immer noch nicht angezeigt werden, lesen Sie die Problembehandlung häufig auftretender Probleme.

Behandeln häufiger Probleme

Angelegenheit Ursache Auflösung
In Foundry werden keine Ablaufverfolgungen angezeigt. Die Ablaufverfolgung ist nicht verbunden, es gibt keinen aktuellen Datenverkehr und die Datenaufnahme wird verzögert. Bestätigen Sie die Application Insights-Verbindung, generieren Sie neuen Datenverkehr, und aktualisieren Sie nach 2 bis 5 Minuten.
Es werden keine LangChain- oder LangGraph-Spans angezeigt. Ablaufverfolgungsrückrufe sind nicht an die Ausführung angefügt. Vergewissern Sie sich, dass Sie den Tracer in callbacks übergeben (zum Beispiel config = {"callbacks": [azure_tracer]}), für den Lauf, den Sie nachverfolgen möchten.
LangChain-Abschnitte erscheinen, aber Werkzeugaufrufe fehlen. Werkzeuge sind entweder nicht an das Modell gebunden oder der Werkzeugknoten ist nicht konfiguriert. Stellen Sie sicher, dass Tools an das Modell übergeben bind_tools() werden und dass Toolknoten zu Ihrem Graph hinzugefügt werden.
Ablaufverfolgungen werden angezeigt, sind jedoch unvollständig oder es fehlen bestimmte Abschnitte. Die Inhaltsaufzeichnung ist deaktiviert, oder einige Vorgänge werden nicht instrumentiert. Aktivieren Sie enable_content_recording=True für vollständige Telemetrie. Fügen Sie für benutzerdefinierte Vorgänge manuelle Spans mithilfe des OpenTelemetry SDK hinzu.
Beim Abfragen der Telemetrie werden Autorisierungsfehler angezeigt. Fehlende RBAC-Berechtigungen für Application Insights oder Log Analytics Bestätigen Sie den Zugriff in access control (IAM) für die verbundenen Ressourcen. Weisen Sie für Protokollabfragen die Rolle Log Analytics Reader zu.
Vertrauliche Inhalte erscheinen in Spuren Die Inhaltsaufzeichnung ist aktiviert, und Eingabeaufforderungen, Toolargumente oder Ausgaben umfassen vertrauliche Daten. Deaktivieren Sie die Aufzeichnung von Inhalten in der Produktion und entfernen Sie vertrauliche Daten, bevor sie in die Telemetrie eingehen.

Nächste Schritte

  • Last updated on