Dela via

Inspektion av telemetridata med Aspire-instrumentpanelen

  • Artikel

Aspire Dashboard är en del av .NET Aspire-erbjudandet . På instrumentpanelen kan utvecklare övervaka och inspektera sina distribuerade program.

I det här exemplet använder vi det fristående läget och lär oss hur du exporterar telemetridata till Aspire Dashboard och inspekterar data där.

Exportör

Exportörer ansvarar för att skicka telemetridata till ett mål. Läs mer om exportörer här. I det här exemplet använder vi exportören OpenTelemetry Protocol (OTLP) för att skicka telemetridata till Aspire Dashboard.

Förutsättningar

  • En distribution av Azure OpenAI-chatten.
  • Docker
  • Den senaste .Net SDK för operativsystemet.

Kommentar

Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.

Ställ in

Skapa ett nytt konsolprogram

I en terminal kör du följande kommando för att skapa ett nytt konsolprogram i C#:

dotnet new console -n TelemetryAspireDashboardQuickstart

Navigera till den nyligen skapade projektkatalogen när kommandot har slutförts.

Installera de paket som krävs

  • Semantic Kernel

    dotnet add package Microsoft.SemanticKernel

  • OpenTelemetry Console Exporter

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Skapa ett enkelt program med semantisk kernel

Öppna filen med din favoritredigerare från projektkatalogen Program.cs . Vi ska skapa ett enkelt program som använder semantisk kernel för att skicka en uppmaning till en modell för chattens slutförande. Ersätt det befintliga innehållet med följande kod och fyll i de nödvändiga värdena för deploymentName, endpointoch 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);
        }
    }
}

Lägg till telemetri

Om du kör konsolappen nu bör du förvänta dig att se en mening som förklarar varför himlen är blå. Om du vill observera kerneln via telemetri ersätter du kommentaren // Telemetry setup code goes here med följande kod:

// 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);
});

Ta slutligen bort kommentaren till raden // builder.Services.AddSingleton(loggerFactory); för att lägga till loggerfabriken i byggverktyget.

Mer information om konfigurationskoden för telemetri finns i den här artikeln . Den enda skillnaden här är att vi använder AddOtlpExporter för att exportera telemetridata till Aspire Dashboard.

Skapa en ny virtuell Python-miljö

python -m venv telemetry-aspire-dashboard-quickstart

Aktivera den virtuella miljön.

telemetry-aspire-dashboard-quickstart\Scripts\activate

Installera de paket som krävs

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

Skapa ett enkelt Python-skript med semantisk kernel

Skapa ett nytt Python-skript och öppna det med din favoritredigerare.

New-Item -Path telemetry_aspire_dashboard_quickstart.py -ItemType file

Vi ska skapa ett enkelt Python-skript som använder semantisk kernel för att skicka en uppmaning till en modell för chattens slutförande. Ersätt det befintliga innehållet med följande kod och fyll i de nödvändiga värdena för deployment_name, endpointoch 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())

Lägg till telemetri

Miljövariabler

Mer information om hur du konfigurerar nödvändiga miljövariabler finns i den här artikeln så att kerneln kan generera intervall för AI-anslutningsappar.

Kod

Om du kör skriptet nu bör du förvänta dig att se en mening som förklarar varför himlen är blå. Om du vill observera kerneln via telemetri ersätter du kommentaren # Telemetry setup code goes here med följande kod:

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

Mer information om konfigurationskoden för telemetri finns i den här artikeln . Den enda skillnaden här är att vi använder OTLP[Span|Metric|Log]Exporter för att exportera telemetridata till Aspire Dashboard.

Kommentar

Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.

Starta Aspire-instrumentpanelen

Följ anvisningarna här för att starta instrumentpanelen. När instrumentpanelen har körts öppnar du en webbläsare och går till http://localhost:18888 för att komma åt instrumentpanelen.

Kör

Kör konsolprogrammet med följande kommando:

dotnet run

Kör Python-skriptet med följande kommando:

python telemetry_aspire_dashboard_quickstart.py

Kommentar

Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.

Granska telemetridata

När du har kört programmet går du över till instrumentpanelen för att inspektera telemetridata.

Dricks

Följ den här guiden om du vill utforska aspire-instrumentpanelens gränssnitt.

Spårningar

Om det här är första gången du kör programmet när du har startat instrumentpanelen bör du se att en enda spårning är Traces fliken. Klicka på spårningen om du vill visa mer information.

TracesOverview

I spårningsinformationen kan du se det intervall som representerar promptfunktionen och det intervall som representerar modellen för chattens slutförande. Klicka på chattens slutförandeintervall för att se information om begäran och svaret.

Dricks

Du kan filtrera attributen för spann för att hitta den du är intresserad av.

TracesDetails

Loggar

Gå till fliken Structured för att visa loggarna som genereras av programmet. Se den här guiden om hur du arbetar med strukturerade loggar på instrumentpanelen.

Nästa steg

Nu när du har matat ut telemetridata till Aspire-instrumentpanelen kan du utforska fler funktioner i semantisk kernel som kan hjälpa dig att övervaka och diagnostisera ditt program:

Avancerad telemetri med semantisk kernel