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

Odkazy v tomto článku můžou otevírat obsah v nové dokumentaci Microsoft Foundry místo dokumentace Foundry (classic), 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í projektu.
Instrumentace sady OpenAI SDK
Zachytávání obsahu zprávy (volitelné)
Zobrazit časové osy a úseky trasování.
Propojte trasování s hodnoticími smyčkami

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

Požadavky

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

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

Povolení trasování v projektu

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

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

Přejděte na portál Foundry a přejděte do projektu.
Na bočním navigačním panelu vyberte Trasování.
Pokud prostředek Aplikace Azure 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í Aplikace Azure Insights, použijte rozevírací seznam Název prostředku Application Insights k nalezení prostředku a vyberte Připojit.
  
  Tip
  
  Pokud se chcete připojit k existujícímu Aplikace Azure Insights, potřebujete alespoň přístup přispěvatele k prostředku Foundry (nebo centru).
2. Pokud se chcete připojit k novému prostředku Aplikace Azure 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é.
    
    Tip
    
    Pokud chcete vytvořit nový prostředek Aplikace Azure Insights, potřebujete také roli přispěvatele do vybrané skupiny prostředků (nebo výchozího prostředku).
  3. Vyberte Vytvořit pro vytvoření prostředku a jeho připojení k prostředku Foundry.
3. Jakmile je připojení nakonfigurované, můžete použít trasování v jakémkoli projektu v rámci prostředku.
Tip

Ujistěte se, že máte v prostředku Application Insights přiřazenou roli čtenáře Log Analytics. Pokud jsou podkladové Log Analytics tabulky chráněné, přiřaďte také roli Privileged Monitoring Data Reader. Další informace o přiřazování rolí najdete v tématu Přiřazení rolí Azure pomocí portálu Azure. Pomocí skupin Microsoft Entra můžete snadněji spravovat přístup pro uživatele.
Přejděte na cílovou stránku 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é Entra ID, použijte Aplikace Azure Insights připojovací řetězec, jak je uvedeno v kroku 3 kurzu.

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 do projektu.
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:
- Trace ID: Jedinečný identifikátor transakce
- Č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 sledování
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ílaly 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 připojovací řetězec pro propojený prostředek služby Application Insights (Projekt > Trasování > Správa zdroje dat > Připojovací řetězec):

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

Konfigurujte Azure Monitor a instrumentujte 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)

Vraťte se do portálu na trasování, abyste zobrazili nové stopy.
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 spanů k zachycení úseků, které vás zajímají. Pokud chcete začít generovat vlastní rozsahy, získejte kopii aktuálního tracer objektu.
```
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, která iteruje assess_claims_with_context seznam deklarací identity a ověřuje, jestli je deklarace podporována kontextem pomocí 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ů . trace Objekt použijte pro přístup k nim 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é sledovat vaši aplikaci a odesílat záznamy do místní konzoly příkazového řádku. 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í záznamy 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)

Jako obvykle použijte OpenAI SDK.

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 Foundry Toolkit

Foundry 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 přístupu ke cloudu.

Sada nástrojů podporuje sadu OpenAI SDK a další architektury AI prostřednictvím OpenTelemetry. Stopy můžete okamžitě zobrazit ve svém 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ě Foundry Toolkit.

Sledujte agenty pomocí sady Microsoft Foundry SDK

Váš názor

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

Last updated on 2026-06-26