Freigeben über

Inspektion von Telemetriedaten mit Dem Aspire Dashboard

  • Artikel

Aspire Dashboard ist Teil des .NET Aspire-Angebots . Mit dem Dashboard können Entwickler ihre verteilten Anwendungen überwachen und prüfen.

In diesem Beispiel verwenden wir den eigenständigen Modus und erfahren, wie Telemetriedaten nach Aspire Dashboard exportiert und die Daten dort untersucht werden.

Exporteur

Exporteure sind für das Senden von Telemetriedaten an ein Ziel verantwortlich. Weitere Informationen zu Exporteuren finden Sie hier. In diesem Beispiel verwenden wir den OpenTelemetry Protocol (OTLP) -Exporter, um Telemetriedaten an das Aspire Dashboard zu senden.

Voraussetzungen

  • Bereitstellung eines Azure OpenAI-Chats.
  • Docker
  • Das neueste .Net SDK für Ihr Betriebssystem.

Hinweis

Die semantische Kernel-Observability ist für Java noch nicht verfügbar.

Setup

Erstellen einer neuen Konsolenanwendung

Führen Sie in einem Terminal den folgenden Befehl aus, um eine neue Konsolenanwendung in C# zu erstellen:

dotnet new console -n TelemetryAspireDashboardQuickstart

Navigieren Sie nach Abschluss des Befehls zum neu erstellten Projektverzeichnis.

Installieren erforderlicher Pakete

  • Semantischer Kernel

    dotnet add package Microsoft.SemanticKernel

  • OpenTelemetry Console Exporter

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Erstellen einer einfachen Anwendung mit semantischem Kernel

Öffnen Sie die Program.cs Datei im Projektverzeichnis mit Ihrem bevorzugten Editor. Wir werden eine einfache Anwendung erstellen, die semantischen Kernel verwendet, um eine Eingabeaufforderung an ein Chatabschlussmodell zu senden. Ersetzen Sie den vorhandenen Inhalt durch den folgenden Code, und füllen Sie die erforderlichen Werte für deploymentName, endpointund apiKey:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using OpenTelemetry;
using OpenTelemetry.Logs;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

namespace TelemetryAspireDashboardQuickstart
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Telemetry setup code goes here

            IKernelBuilder builder = Kernel.CreateBuilder();
            // builder.Services.AddSingleton(loggerFactory);
            builder.AddAzureOpenAIChatCompletion(
                deploymentName: "your-deployment-name",
                endpoint: "your-azure-openai-endpoint",
                apiKey: "your-azure-openai-api-key"
            );

            Kernel kernel = builder.Build();

            var answer = await kernel.InvokePromptAsync(
                "Why is the sky blue in one sentence?"
            );

            Console.WriteLine(answer);
        }
    }
}

Telemetrie hinzufügen

Wenn Sie die Konsolen-App jetzt ausführen, sollten Sie einen Satz sehen, der erklärt, warum der Himmel blau ist. Um den Kernel über Telemetrie zu beobachten, ersetzen Sie den // Telemetry setup code goes here Kommentar durch den folgenden Code:

// Endpoint to the Aspire Dashboard
var endpoint = "http://localhost:4317";

var resourceBuilder = ResourceBuilder
    .CreateDefault()
    .AddService("TelemetryAspireDashboardQuickstart");

// Enable model diagnostics with sensitive data.
AppContext.SetSwitch("Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive", true);

using var traceProvider = Sdk.CreateTracerProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource("Microsoft.SemanticKernel*")
    .AddOtlpExporter(options => options.Endpoint = new Uri(endpoint))
    .Build();

using var meterProvider = Sdk.CreateMeterProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddMeter("Microsoft.SemanticKernel*")
    .AddOtlpExporter(options => options.Endpoint = new Uri(endpoint))
    .Build();

using var loggerFactory = LoggerFactory.Create(builder =>
{
    // Add OpenTelemetry as a logging provider
    builder.AddOpenTelemetry(options =>
    {
        options.SetResourceBuilder(resourceBuilder);
        options.AddOtlpExporter(options => options.Endpoint = new Uri(endpoint));
        // Format log messages. This is default to false.
        options.IncludeFormattedMessage = true;
        options.IncludeScopes = true;
    });
    builder.SetMinimumLevel(LogLevel.Information);
});

Entfernen Sie abschließend die Auskommentierung der Zeile // builder.Services.AddSingleton(loggerFactory); , um dem Generator die Loggerfabrik hinzuzufügen.

Weitere Informationen zum Telemetrieeinrichtungscode finden Sie in diesem Artikel . Der einzige Unterschied besteht darin, dass wir AddOtlpExporter Telemetriedaten nach Aspire Dashboard exportieren.

Erstellen einer neuen virtuellen Python-Umgebung

python -m venv telemetry-aspire-dashboard-quickstart

Aktivieren Sie die virtuelle Umgebung.

telemetry-aspire-dashboard-quickstart\Scripts\activate

Installieren erforderlicher Pakete

pip install semantic-kernel opentelemetry-exporter-otlp-proto-grpc

Erstellen eines einfachen Python-Skripts mit semantischem Kernel

Erstellen Sie ein neues Python-Skript, und öffnen Sie es mit Ihrem bevorzugten Editor.

New-Item -Path telemetry_aspire_dashboard_quickstart.py -ItemType file

Wir werden ein einfaches Python-Skript erstellen, das semantic Kernel verwendet, um eine Eingabeaufforderung an ein Chatabschlussmodell zu senden. Ersetzen Sie den vorhandenen Inhalt durch den folgenden Code, und füllen Sie die erforderlichen Werte für deployment_name, endpointund api_key:

import asyncio
import logging

from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.metrics import set_meter_provider
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import DropAggregation, View
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.semconv.resource import ResourceAttributes
from opentelemetry.trace import set_tracer_provider

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion


# Telemetry setup code goes here

async def main():
    # Create a kernel and add a service
    kernel = Kernel()
    kernel.add_service(AzureChatCompletion(
        api_key="your-azure-openai-api-key",
        endpoint="your-azure-openai-endpoint",
        deployment_name="your-deployment-name"
    ))

    answer = await kernel.invoke_prompt("Why is the sky blue in one sentence?")
    print(answer)


if __name__ == "__main__":
    asyncio.run(main())

Telemetrie hinzufügen

Umgebungsvariablen

Weitere Informationen zum Einrichten der erforderlichen Umgebungsvariablen zur Aktivierung des Kernels für KI-Connectors finden Sie in diesem Artikel .

Code

Wenn Sie das Skript jetzt ausführen, sollten Sie erwarten, dass sie einen Satz sehen, der erklärt, warum der Himmel blau ist. Um den Kernel über Telemetrie zu beobachten, ersetzen Sie den # Telemetry setup code goes here Kommentar durch den folgenden Code:

# Endpoint to the Aspire Dashboard
endpoint = "http://localhost:4317"

# Create a resource to represent the service/sample
resource = Resource.create({ResourceAttributes.SERVICE_NAME: "telemetry-aspire-dashboard-quickstart"})


def set_up_logging():
    exporter = OTLPLogExporter(endpoint=endpoint)

    # Create and set a global logger provider for the application.
    logger_provider = LoggerProvider(resource=resource)
    # Log processors are initialized with an exporter which is responsible
    # for sending the telemetry data to a particular backend.
    logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
    # Sets the global default logger provider
    set_logger_provider(logger_provider)

    # Create a logging handler to write logging records, in OTLP format, to the exporter.
    handler = LoggingHandler()
    # Add filters to the handler to only process records from semantic_kernel.
    handler.addFilter(logging.Filter("semantic_kernel"))
    # Attach the handler to the root logger. `getLogger()` with no arguments returns the root logger.
    # Events from all child loggers will be processed by this handler.
    logger = logging.getLogger()
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)


def set_up_tracing():
    exporter = OTLPSpanExporter(endpoint=endpoint)

    # Initialize a trace provider for the application. This is a factory for creating tracers.
    tracer_provider = TracerProvider(resource=resource)
    # Span processors are initialized with an exporter which is responsible
    # for sending the telemetry data to a particular backend.
    tracer_provider.add_span_processor(BatchSpanProcessor(exporter))
    # Sets the global default tracer provider
    set_tracer_provider(tracer_provider)


def set_up_metrics():
    exporter = OTLPMetricExporter(endpoint=endpoint)

    # Initialize a metric provider for the application. This is a factory for creating meters.
    meter_provider = MeterProvider(
        metric_readers=[PeriodicExportingMetricReader(exporter, export_interval_millis=5000)],
        resource=resource,
        views=[
            # Dropping all instrument names except for those starting with "semantic_kernel"
            View(instrument_name="*", aggregation=DropAggregation()),
            View(instrument_name="semantic_kernel*"),
        ],
    )
    # Sets the global default meter provider
    set_meter_provider(meter_provider)


# This must be done before any other telemetry calls
set_up_logging()
set_up_tracing()
set_up_metrics()

Weitere Informationen zum Telemetrieeinrichtungscode finden Sie in diesem Artikel . Der einzige Unterschied besteht darin, dass wir OTLP[Span|Metric|Log]Exporter Telemetriedaten nach Aspire Dashboard exportieren.

Hinweis

Die semantische Kernel-Observability ist für Java noch nicht verfügbar.

Start the Aspire Dashboard

Folgen Sie den Anweisungen hier , um das Dashboard zu starten. Sobald das Dashboard ausgeführt wird, öffnen Sie einen Browser, und navigieren Sie zu http://localhost:18888 dem Dashboard.

Ausführung

Führen Sie die Konsolenanwendung mit dem folgenden Befehl aus:

dotnet run

Führen Sie das Python-Skript mit dem folgenden Befehl aus:

python telemetry_aspire_dashboard_quickstart.py

Hinweis

Die semantische Kernel-Observability ist für Java noch nicht verfügbar.

Überprüfen von Telemetriedaten

Wechseln Sie nach dem Ausführen der Anwendung zum Dashboard, um die Telemetriedaten zu überprüfen.

Tipp

Folgen Sie diesem Leitfaden , um die Aspire Dashboard-Schnittstelle zu erkunden.

Traces

Wenn Sie die Anwendung zum ersten Mal nach dem Starten des Dashboards ausführen, sollte eine Ablaufverfolgung die Traces Registerkarte sein. Klicken Sie auf die Ablaufverfolgung, um weitere Details anzuzeigen.

TracesOverview

In den Ablaufverfolgungsdetails können Sie die Spanne sehen, die die Eingabeaufforderungsfunktion und die Spanne darstellt, die das Chatabschlussmodell darstellt. Klicken Sie auf die Chatabschlussspanne, um Details zur Anforderung und Antwort anzuzeigen.

Tipp

Sie können die Attribute der Spannen filtern, um den Gewünschten zu finden.

TracesDetails

Protokolle

Wechseln Sie zur Structured Registerkarte, um die von der Anwendung ausgegebenen Protokolle anzuzeigen. In diesem Leitfaden erfahren Sie, wie Sie mit strukturierten Protokollen im Dashboard arbeiten.

Nächste Schritte

Nachdem Sie nun telemetriedaten erfolgreich an das Aspire Dashboard ausgegeben haben, können Sie weitere Features des semantischen Kernels erkunden, die Ihnen helfen können, Ihre Anwendung zu überwachen und zu diagnostizieren:

Erweiterte Telemetrie mit semantischem Kernel