Delen via

Inspectie van telemetriegegevens met Aspire Dashboard

  • Artikel

Aspire Dashboard maakt deel uit van het .NET Aspire-aanbod . Met het dashboard kunnen ontwikkelaars hun gedistribueerde toepassingen bewaken en inspecteren.

In dit voorbeeld gebruiken we de zelfstandige modus en leren we hoe we telemetriegegevens naar Aspire Dashboard exporteren en de gegevens daar inspecteren.

Exportfunctie

Exporteurs zijn verantwoordelijk voor het verzenden van telemetriegegevens naar een bestemming. Lees hier meer over exporteurs. In dit voorbeeld gebruiken we de OTLP-exporteur (OpenTelemetry Protocol) om telemetriegegevens naar Aspire Dashboard te verzenden.

Vereisten

  • Een voltooiingsimplementatie van een Azure OpenAI-chat.
  • Docker
  • De nieuwste .Net SDK voor uw besturingssysteem.

Notitie

Waarneembaarheid van Semantische kernel is nog niet beschikbaar voor Java.

Instellingen

Een nieuwe consoletoepassing maken

Voer in een terminal de volgende opdracht uit om een nieuwe consoletoepassing te maken in C#:

dotnet new console -n TelemetryAspireDashboardQuickstart

Navigeer naar de zojuist gemaakte projectmap nadat de opdracht is voltooid.

De vereiste pakketten installeren

  • Semantic Kernel

    dotnet add package Microsoft.SemanticKernel

  • OpenTelemetry Console Exporter

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Een eenvoudige toepassing maken met Semantische kernel

Open het Program.cs bestand vanuit de projectmap met uw favoriete editor. We gaan een eenvoudige toepassing maken die gebruikmaakt van Semantische kernel om een prompt naar een voltooiingsmodel voor een chat te verzenden. Vervang de bestaande inhoud door de volgende code en vul de vereiste waarden voor deploymentName, endpointen 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 toevoegen

Als u de console-app nu uitvoert, ziet u een zin waarin wordt uitgelegd waarom de lucht blauw is. Vervang de // Telemetry setup code goes here opmerking door de volgende code om de kernel via telemetrie te observeren:

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

Verwijder ten slotte de opmerking bij de lijn // builder.Services.AddSingleton(loggerFactory); om de loggerfactory toe te voegen aan de opbouwfunctie.

Raadpleeg dit artikel voor meer informatie over de code voor het instellen van telemetriegegevens. Het enige verschil hier is dat we telemetriegegevens AddOtlpExporter exporteren naar Aspire Dashboard.

Een nieuwe virtuele Python-omgeving maken

python -m venv telemetry-aspire-dashboard-quickstart

Activeer de virtuele omgeving.

telemetry-aspire-dashboard-quickstart\Scripts\activate

De vereiste pakketten installeren

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

Een eenvoudig Python-script maken met Semantische kernel

Maak een nieuw Python-script en open het met uw favoriete editor.

New-Item -Path telemetry_aspire_dashboard_quickstart.py -ItemType file

We gaan een eenvoudig Python-script maken dat gebruikmaakt van Semantic Kernel om een prompt naar een voltooiingsmodel voor een chat te verzenden. Vervang de bestaande inhoud door de volgende code en vul de vereiste waarden voor deployment_name, endpointen 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 toevoegen

Omgevingsvariabelen

Raadpleeg dit artikel voor meer informatie over het instellen van de vereiste omgevingsvariabelen, zodat de kernel spans kan verzenden voor AI-connectors.

Code

Als u het script nu uitvoert, zou u een zin moeten zien waarin wordt uitgelegd waarom de hemel blauw is. Vervang de # Telemetry setup code goes here opmerking door de volgende code om de kernel via telemetrie te observeren:

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

Raadpleeg dit artikel voor meer informatie over de code voor het instellen van telemetriegegevens. Het enige verschil hier is dat we telemetriegegevens OTLP[Span|Metric|Log]Exporter exporteren naar Aspire Dashboard.

Notitie

Waarneembaarheid van Semantische kernel is nog niet beschikbaar voor Java.

Het Dashboard van Aspire starten

Volg de instructies hier om het dashboard te starten. Zodra het dashboard wordt uitgevoerd, opent u een browser en gaat u naar toegang tot http://localhost:18888 het dashboard.

Uitvoeren

Voer de consoletoepassing uit met de volgende opdracht:

dotnet run

Voer het Python-script uit met de volgende opdracht:

python telemetry_aspire_dashboard_quickstart.py

Notitie

Waarneembaarheid van Semantische kernel is nog niet beschikbaar voor Java.

Telemetriegegevens inspecteren

Nadat u de toepassing hebt uitgevoerd, gaat u naar het dashboard om de telemetriegegevens te controleren.

Tip

Volg deze handleiding om de Aspire Dashboard-interface te verkennen.

Traceringen

Als dit de eerste keer is dat u de toepassing uitvoert nadat u het dashboard hebt gestart, ziet u dat een tracering het Traces tabblad is. Klik op de tracering om meer details weer te geven.

TracesOverview

In de traceringsdetails ziet u het bereik dat de promptfunctie vertegenwoordigt en de periode die het voltooiingsmodel van de chat vertegenwoordigt. Klik op het voltooiingsbereik van de chat om details over de aanvraag en het antwoord te bekijken.

Tip

U kunt de kenmerken van de spans filteren om de kenmerken te vinden waarin u geïnteresseerd bent.

TracesDetails

Logboeken

Ga naar het Structured tabblad om de logboeken weer te geven die door de toepassing zijn verzonden. Raadpleeg deze handleiding voor het werken met gestructureerde logboeken in het dashboard.

Volgende stappen

Nu u telemetriegegevens naar Aspire Dashboard hebt uitgevoerd, kunt u meer functies van Semantische Kernel verkennen waarmee u uw toepassing kunt bewaken en diagnosticeren:

Geavanceerde telemetrie met Semantische kernel