Visa spårningsresultat för AI-program med OpenAI SDK

2025-09-22

Lär dig hur du visar spårningsresultat som ger insyn i AI-programkörning. Använd spårningar för att diagnostisera felaktiga verktygsanrop, vilseledande uppmaningar, flaskhalsar för svarstid och utvärderingspoäng av låg kvalitet.

I den här artikeln lär du dig att:

Aktivera spårning för ett projekt.
Instrumentera OpenAI SDK.
Samla in meddelandeinnehåll (valfritt).
Visa tidslinjer och intervall för spårning.
Koppla spårning med utvärderingsloopar.

Den här artikeln beskriver hur du visar spårningsresultat för AI-program med OpenAI SDK med OpenTelemetry i Azure AI Foundry.

Prerequisites

Du behöver följande för att slutföra den här självstudien:

Ett Azure AI Foundry-projekt har skapats.
Ett AI-program som använder OpenAI SDK för att göra anrop till modeller som finns i Azure AI Foundry.

Aktivera spårning i projektet

Azure AI Foundry lagrar spårningar i Azure Application Insights med hjälp av OpenTelemetry. Nya resurser etablerar inte Application Insights automatiskt. Associera (eller skapa) en resurs en gång per Azure AI Foundry-resurs.

Följande steg visar hur du konfigurerar din resurs:

Gå till Azure AI Foundry-portalen och gå till projektet.
I sidonavigeringsfältet väljer du Spårning.
Om en Azure Application Insights-resurs inte är associerad med din Azure AI Foundry-resurs associerar du en. Om du redan har en Application Insights-resurs associerad visas inte aktiveringssidan nedan och du kan hoppa över det här steget.
1. Om du vill återanvända en befintlig Azure Application Insights använder du det nedrullningsbara Resursnamnet för Application Insights för att hitta resursen och väljer Anslut.
  
  Tip
  
  För att ansluta till en befintlig Azure Application Insights behöver du minst deltagaråtkomst till Azure AI Foundry-resursen (eller hubben).
2. Om du vill ansluta till en ny Azure Application Insights-resurs väljer du alternativet Skapa ny.
  1. Använd konfigurationsguiden för att konfigurera den nya resursens namn.
  2. Som standard skapas den nya resursen i samma resursgrupp där Azure AI Foundry-resursen skapades. Använd alternativet Avancerat inställningar för att konfigurera en annan resursgrupp eller prenumeration.
    
    Tip
    
    Om du vill skapa en ny Azure Application Insights-resurs behöver du också deltagarrollen till den resursgrupp som du har valt (eller standardresursen).
  3. Välj Skapa för att skapa resursen och ansluta den till Azure AI Foundry-resursen.
3. När anslutningen har konfigurerats är du redo att använda spårning i alla projekt i resursen.
Tip

Kontrollera att rollen Log Analytics-läsare har tilldelats i Application Insights-resursen. Mer information om hur du tilldelar roller finns i Tilldela Azure-roller med hjälp av Azure-portalen. Använd Microsoft Entra-grupper för att enklare hantera åtkomst för användare.
Gå till projektets landningssida och kopiera projektets slutpunkts-URI. Du behöver det senare.

Important

Om du använder ett projekts slutpunkt måste du konfigurera Microsoft Entra-ID i ditt program. Om du inte har konfigurerat Etttra-ID använder du Anslutningssträngen för Azure Application Insights enligt beskrivningen i steg 3 i självstudien.

Visa spårningsresultat i Azure AI Foundry-portalen

När du har konfigurerat spårningen och programmet har instrumenterats kan du visa spårningsresultat i Azure AI Foundry-portalen:

Gå till Azure AI Foundry-portalen och gå till projektet.
I sidonavigeringsfältet väljer du Spårning.
Du ser en lista över spårningsresultat från dina instrumenterade program. Varje spårning visar:
- Spårnings-ID: Unik identifierare för spårningen
- Starttid: När spårningen började
- Varaktighet: Hur lång tid åtgärden tog
- Status: Status för lyckad eller misslyckad
- Åtgärder: Antal intervall i spårningen
Välj valfri spårning för att visa detaljerade spårningsresultat, inklusive:
- Tidslinje för fullständig exekvering
- Indata och utdata för varje åtgärd
- Prestandamått och tidsinställning
- Felinformation om något har inträffat
- Anpassade attribut och metadata

Instrumentera OpenAI SDK

När du utvecklar med OpenAI SDK kan du instrumentera koden så att spårningar skickas till Azure AI Foundry. Följ dessa steg för att instrumentera koden:

Installera paket:

pip install azure-ai-projects azure-monitor-opentelemetry opentelemetry-instrumentation-openai-v2

(Valfritt) Samla in meddelandeinnehåll:
- PowerShell: setx OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT true
- Bash: export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true

Hämta anslutningssträngen för den länkade Application Insights-resursen (Projekt > Spårning > Hantera datakälla > Anslutningssträng):

from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

project_client = AIProjectClient(
     credential=DefaultAzureCredential(),
     endpoint="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>",
)
connection_string = project_client.telemetry.get_application_insights_connection_string()

Konfigurera Azure Monitor och instrumentera OpenAI SDK.

from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor

configure_azure_monitor(connection_string=connection_string)
OpenAIInstrumentor().instrument()

Skicka en begäran:

client = project_client.get_openai_client()
response = client.chat.completions.create(
     model="gpt-4o-mini", 
     messages=[{"role": "user", "content": "Write a short poem on open telemetry."}],
)
print(response.choices[0].message.content)

Gå tillbaka till Spårning i portalen för att visa nya spårningar.
Det kan vara användbart att samla in delar av koden som blandar affärslogik med modeller när du utvecklar komplexa program. OpenTelemetry använder begreppet spans för att samla in avsnitt som du är intresserad av. Om du vill börja generera dina egna intervall hämtar du en instans av det aktuella spårningsobjektet.
```
from opentelemetry import trace

tracer = trace.get_tracer(__name__)
```

Använd sedan dekoratörer i din metod för att samla in specifika scenarier i din kod som du är intresserad av. Dessa dekoratörer genererar intervall automatiskt. Följande kodexempel instrumenterar en metod som kallas assess_claims_with_context som itererar över en lista över anspråk och verifierar om anspråket stöds av kontexten med hjälp av en LLM. Alla anrop som görs i den här metoden samlas in inom samma intervall:

def build_prompt_with_context(claim: str, context: str) -> str:
    return [{'role': 'system', 'content': "I will ask you to assess whether a particular scientific claim, based on evidence provided. Output only the text 'True' if the claim is true, 'False' if the claim is false, or 'NEE' if there's not enough evidence."},
            {'role': 'user', 'content': f"""
                The evidence is the following: {context}

                Assess the following claim on the basis of the evidence. Output only the text 'True' if the claim is true, 'False' if the claim is false, or 'NEE' if there's not enough evidence. Do not output any other text.

                Claim:
                {claim}

                Assessment:
            """}]

@tracer.start_as_current_span("assess_claims_with_context")
def assess_claims_with_context(claims, contexts):
    responses = []
    for claim, context in zip(claims, contexts):
        response = client.chat.completions.create(
            model="gpt-4.1",
            messages=build_prompt_with_context(claim=claim, context=context),
        )
        responses.append(response.choices[0].message.content.strip('., '))

    return responses

Spårningsresultat ser ut så här:

Du kanske också vill lägga till extra information i det aktuella intervallet. OpenTelemetry använder begreppet attribut för detta. Använd objektet trace för att komma åt dem och inkludera extra information. Se hur assess_claims_with_context metoden har ändrats för att inkludera ett attribut:

@tracer.start_as_current_span("assess_claims_with_context")
def assess_claims_with_context(claims, contexts):
    responses = []
    current_span = trace.get_current_span()

    current_span.set_attribute("operation.claims_count", len(claims))

    for claim, context in zip(claims, contexts):
        response = client.chat.completions.create(
            model="gpt-4.1",
            messages=build_prompt_with_context(claim=claim, context=context),
        )
        responses.append(response.choices[0].message.content.strip('., '))

    return responses

Skriv ut till konsolen

Det kan vara användbart att även spåra ditt program och skicka spårningarna till den lokala körningskonsolen. Den här metoden kan vara fördelaktig när du kör enhetstester eller integreringstester i ditt program med hjälp av en automatiserad CI/CD-pipeline. Spårningar kan skickas till konsolen och samlas in av ditt CI/CD-verktyg för ytterligare analys.

Konfigurera spårning på följande sätt:

Instrumentera OpenAI SDK som vanligt:

from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor

OpenAIInstrumentor().instrument()

Konfigurera OpenTelemetry för att skicka spårningar till konsolen:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

span_exporter = ConsoleSpanExporter()
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
trace.set_tracer_provider(tracer_provider)

Använd OpenAI SDK som vanligt:

response = client.chat.completions.create(
    model="deepseek-v3-0324",
    messages=[
        {"role": "user", "content": "Write a short poem on open telemetry."},
    ],
)

{
    "name": "chat deepseek-v3-0324",
    "context": {
        "trace_id": "0xaaaa0a0abb1bcc2cdd3d",
        "span_id": "0xaaaa0a0abb1bcc2cdd3d",
        "trace_state": "[]"
    },
    "kind": "SpanKind.CLIENT",
    "parent_id": null,
    "start_time": "2025-06-13T00:02:04.271337Z",
    "end_time": "2025-06-13T00:02:06.537220Z",
    "status": {
        "status_code": "UNSET"
    },
    "attributes": {
        "gen_ai.operation.name": "chat",
        "gen_ai.system": "openai",
        "gen_ai.request.model": "deepseek-v3-0324",
        "server.address": "my-project.services.ai.azure.com",
        "gen_ai.response.model": "DeepSeek-V3-0324",
        "gen_ai.response.finish_reasons": [
            "stop"
        ],
        "gen_ai.response.id": "aaaa0a0abb1bcc2cdd3d",
        "gen_ai.usage.input_tokens": 14,
        "gen_ai.usage.output_tokens": 91
    },
    "events": [],
    "links": [],
    "resource": {
        "attributes": {
            "telemetry.sdk.language": "python",
            "telemetry.sdk.name": "opentelemetry",
            "telemetry.sdk.version": "1.31.1",
            "service.name": "unknown_service"
        },
        "schema_url": ""
    }
}

Spåra lokalt med AI Toolkit

AI Toolkit är ett enkelt sätt att spåra lokalt i VS Code. Den använder en lokal OTLP-kompatibel insamlare, vilket gör den perfekt för utveckling och felsökning utan att behöva molnåtkomst.

Verktygslådan stöder OpenAI SDK och andra AI-ramverk via OpenTelemetry. Du kan se spårningar direkt i utvecklingsmiljön.

Detaljerade installationsinstruktioner och SDK-specifika kodexempel finns i Spårning i AI Toolkit.

Spåra agenter med Azure AI Foundry SDK

Feedback

Var den här sidan till hjälp?