Zobrazení výsledků trasování pro aplikace AI pomocí sady OpenAI SDK (classic)

Platí jenom pro:Portál Foundry (Classic). Tento článek není k dispozici pro nový portál Foundry. Přečtěte si další informace o novém portálu.

Poznámka:

Některé odkazy v tomto článku můžou otevřít obsah v nové dokumentaci Microsoft Foundry místo dokumentace Foundry (klasické), kterou si právě prohlížíte.

Zjistěte, jak zobrazit výsledky trasování, které poskytují přehled o spuštění aplikace AI. Pomocí trasování můžete diagnostikovat nepřesná volání nástrojů, zavádějící výzvy, kritické body latence a skóre hodnocení nízké kvality.

V tomto článku se naučíte:

Povolte trasování pro projekt.
Instrumentace sady OpenAI SDK
Zachytávání obsahu zprávy (volitelné)
Zobrazte časové osy trasování a úseky.
Propojení trasování pomocí zkušebních smyček

Tento článek vysvětluje, jak zobrazit výsledky trasování pro AI aplikace pomocí OpenAI SDK s OpenTelemetry v Microsoft Foundry.

Předpoklady

K dokončení tohoto kurzu potřebujete následující:

Vytvořili jsme project Foundry.
Aplikace AI, která používá sadu OpenAI SDK k volání modelů hostovaných v Foundry.

Povolte trasování ve vašem projektu

Foundry ukládá trasování v Azure Application Insights pomocí OpenTelemetry. Nové prostředky nezřizují Application Insights automaticky. Přidružte (nebo vytvořte) prostředek jednou pro prostředek Foundry.

Následující kroky ukazují, jak nakonfigurovat prostředek:

Přejděte na portál Foundry a přejděte na svůj project.
Na bočním navigačním panelu vyberte Trasování.
Pokud prostředek Azure Application Insights není přidružený k vašemu prostředku Foundry, přidružte ho. Pokud už máte přidružený prostředek Application Insights, následující stránka povolení se nezobrazí a tento krok můžete přeskočit.
1. Pokud chcete znovu použít existující Azure Application Insights, pomocí rozevíracího seznamu Název prostředku Application Insights vyhledejte prostředek a vyberte Připojit.
  
  Návod
  
  Pokud se chcete připojit k existujícímu Azure Application Insights, potřebujete alespoň přístup přispěvatele k prostředku Foundry (nebo koncentrátoru).
2. Pokud se chcete připojit k novému prostředku Azure Application Insights, vyberte možnost Vytvořit nový.
  1. Pomocí průvodce konfigurací nakonfigurujte název nového prostředku.
  2. Ve výchozím nastavení se nový prostředek vytvoří ve stejné skupině prostředků, ve které byl vytvořen prostředek Foundry. Pomocí možnosti Upřesnit nastavení nakonfigurujte jinou skupinu prostředků nebo předplatné.
    
    Návod
    
    Pokud chcete vytvořit nový prostředek Azure Application Insights, potřebujete také roli přispěvatele do vybrané skupiny prostředků (nebo výchozího prostředku).
  3. Vyberte Vytvořit a tím vytvořte prostředek a připojte ho k prostředku Foundry.
3. Jakmile je připojení nakonfigurované, můžete použít trasování v libovolném projektu v rámci prostředku.
Návod

Ujistěte se, že máte v prostředku Application Insights přiřazenou roli čtenáře Log Analytics. Další informace o přiřazování rolí najdete v tématu Přiřaďte role Azure pomocí Azure portal. Pomocí Microsoft Entra skupin spravujte přístup pro uživatele snadněji.
Přejděte na domovskou stránku vašeho projektu a zkopírujte identifikátor URI koncového bodu projektu. Budete ho potřebovat později.

Důležité

Použití koncového bodu projektu vyžaduje konfiguraci Microsoft Entra ID ve vaší aplikaci. Pokud nemáte nakonfigurované ID Entra, použijte připojovací řetězec Azure Application Insights, jak je uvedeno ve kroku 3 tutoriálu.

Zobrazení výsledků trasování na portálu Foundry

Po nakonfigurování trasování a instrumentaci aplikace můžete zobrazit výsledky trasování na portálu Foundry:

Přejděte na portál Foundry a přejděte na svůj project.
Na bočním navigačním panelu vyberte Trasování.
Zobrazí se seznam výsledků trasování z instrumentovaných aplikací. Každá stopa ukazuje:
- Sledovací ID: Jedinečný identifikátor sledování
- Čas zahájení: Kdy bylo trasování zahájeno
- Doba trvání: Jak dlouho operace trvala
- Stav: Úspěch nebo selhání
- Operace: Počet úseků ve stopě
Výběrem libovolného trasování zobrazíte podrobné výsledky trasování, včetně:
- Kompletní časová osa provádění
- Vstupní a výstupní data pro každou operaci
- Metriky výkonu a časování
- Podrobnosti o chybě, pokud došlo k nějaké chybě
- Vlastní atributy a metadata

Instrumentace sady OpenAI SDK

Při vývoji pomocí sady OpenAI SDK můžete instrumentovat kód, aby se trasování odesílalo do Foundry. K instrumentaci kódu použijte tento postup:

Instalační balíčky:

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

(Volitelné) Zachytávání obsahu zprávy:
- Powershell: setx OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT true
- Bash: export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true

Získejte connection string pro propojený prostředek Application Insights (Projekt > Trasování > Správa zdroje dat > connection string):

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

Konfigurace Azure Monitoru a instrumentace sady 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()

Odeslání požadavku:

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)

Pokud chcete zobrazit nové trasování, vraťte se na portálu do trasování .
Při vývoji složitých aplikací může být užitečné zachytit části kódu, které kombinují obchodní logiku s modely. OpenTelemetry používá koncept "spans" k zachycení úseků, které vás zajímají. Pokud chcete začít generovat vlastní rozsahy, získejte instanci aktuálního objektu traceru .
```
from opentelemetry import trace

tracer = trace.get_tracer(__name__)
```

Pak pomocí dekorátorů v metodě zachyťte konkrétní scénáře v kódu, které vás zajímají. Tyto dekorátory generují rozsahy automaticky. Následující příklad kódu instrumentuje metodu assess_claims_with_context, která iteruje seznam nároků a ověřuje, zda je nárok podporován kontextem s využitím LLM. Všechna volání provedená v této metodě jsou zaznamenána ve stejném rozsahu:

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

Výsledky trasování vypadají takto:

Do aktuálního rozsahu můžete také přidat další informace. OpenTelemetry používá pro to koncept atributů . Pomocí objektu trace k nim přistupujte a uveďte další informace. Podívejte se, assess_claims_with_context jak byla metoda upravena tak, aby zahrnovala atribut:

@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

Trasování do konzoly

Může být užitečné také trasovat aplikaci a odesílat trasování do místní konzoly pro spuštění. Tento přístup může být užitečný při spouštění testů jednotek nebo integračních testů ve vaší aplikaci pomocí automatizovaného kanálu CI/CD. Trasovací soubory lze odeslat do konzoly a zachytit pomocí nástroje CI/CD pro další analýzu.

Trasování nakonfigurujte následujícím způsobem:

Instrumentace sady OpenAI SDK jako obvykle:

from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor

OpenAIInstrumentor().instrument()

Nakonfigurujte OpenTelemetry tak, aby odesílala trasování do konzoly:

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)

Použijte SDK OpenAI obvyklým způsobem:

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": ""
    }
}

Místní trasování s využitím sady AI Toolkit

Sada AI Toolkit nabízí jednoduchý způsob, jak trasovat místně ve VS Code. Používá místní kolektor kompatibilní s OTLP, díky čemuž je ideální pro vývoj a ladění bez nutnosti cloudového přístupu.

Sada nástrojů podporuje sadu OpenAI SDK a další architektury AI prostřednictvím OpenTelemetry. Trasování můžete okamžitě zobrazit ve vašem vývojovém prostředí.

Podrobné pokyny k nastavení a příklady kódu specifické pro sadu SDK najdete v tématu Trasování v sadě nástrojů AI.

Trasování agentů pomocí sady Microsoft Foundry SDK

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-26