Udostępnij za pośrednictwem

Inspekcja danych telemetrycznych za pomocą pulpitu nawigacyjnego Aspirującego

  • Artykuł

Aspire Dashboard jest częścią oferty .NET Aspire . Pulpit nawigacyjny umożliwia deweloperom monitorowanie i sprawdzanie ich aplikacji rozproszonych.

W tym przykładzie użyjemy trybu autonomicznego i dowiesz się, jak wyeksportować dane telemetryczne do pulpitu nawigacyjnego Aspirującego i sprawdzić tam dane.

Eksporter

Eksporterzy są odpowiedzialni za wysyłanie danych telemetrycznych do miejsca docelowego. Przeczytaj więcej na temat eksporterów tutaj. W tym przykładzie używamy eksportera OpenTelemetry Protocol (OTLP) do wysyłania danych telemetrycznych do pulpitu nawigacyjnego Aspirującego.

Wymagania wstępne

  • Wdrożenie uzupełniania czatu usługi Azure OpenAI.
  • Docker
  • Najnowszy zestaw .Net SDK dla systemu operacyjnego.

Uwaga

Możliwość obserwowania jądra semantycznego nie jest jeszcze dostępna dla języka Java.

Ustawienia

Tworzenie nowej aplikacji konsolowej

W terminalu uruchom następujące polecenie, aby utworzyć nową aplikację konsolową w języku C#:

dotnet new console -n TelemetryAspireDashboardQuickstart

Przejdź do nowo utworzonego katalogu projektu po zakończeniu wykonywania polecenia.

Instalowanie wymaganych pakietów

  • Jądro semantyczne

    dotnet add package Microsoft.SemanticKernel

  • Eksporter konsoli OpenTelemetry

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Tworzenie prostej aplikacji za pomocą jądra semantycznego

W katalogu projektu otwórz plik za pomocą ulubionego Program.cs edytora. Utworzymy prostą aplikację, która używa jądra semantycznego do wysyłania monitu do modelu uzupełniania czatu. Zastąp istniejącą zawartość następującym kodem i wypełnij wymagane wartości dla deploymentName, endpointi 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);
        }
    }
}

Dodawanie telemetrii

Jeśli teraz uruchomisz aplikację konsolową, należy oczekiwać zdania wyjaśniającego, dlaczego niebo jest niebieskie. Aby obserwować jądro za pośrednictwem telemetrii, zastąp // Telemetry setup code goes here komentarz następującym kodem:

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

Na koniec usuń komentarz z wiersza // builder.Services.AddSingleton(loggerFactory); , aby dodać fabrykę rejestratora do konstruktora.

Aby uzyskać więcej informacji na temat kodu konfiguracji telemetrii, zapoznaj się z tym artykułem . Jedyną różnicą jest to, że używamy AddOtlpExporter do eksportowania danych telemetrycznych do pulpitu nawigacyjnego Aspire.

Tworzenie nowego środowiska wirtualnego języka Python

python -m venv telemetry-aspire-dashboard-quickstart

Aktywuj środowisko wirtualne.

telemetry-aspire-dashboard-quickstart\Scripts\activate

Instalowanie wymaganych pakietów

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

Tworzenie prostego skryptu języka Python za pomocą jądra semantycznego

Utwórz nowy skrypt języka Python i otwórz go za pomocą ulubionego edytora.

New-Item -Path telemetry_aspire_dashboard_quickstart.py -ItemType file

Utworzymy prosty skrypt języka Python, który używa jądra semantycznego do wysyłania monitu do modelu uzupełniania czatu. Zastąp istniejącą zawartość następującym kodem i wypełnij wymagane wartości dla deployment_name, endpointi 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())

Dodawanie telemetrii

Zmienne środowiskowe

Zapoznaj się z tym artykułem , aby uzyskać więcej informacji na temat konfigurowania wymaganych zmiennych środowiskowych, aby umożliwić jądro emitowania zakresów dla łączników sztucznej inteligencji.

Kod

Jeśli teraz uruchomisz skrypt, należy oczekiwać zdania wyjaśniającego, dlaczego niebo jest niebieskie. Aby obserwować jądro za pośrednictwem telemetrii, zastąp # Telemetry setup code goes here komentarz następującym kodem:

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

Aby uzyskać więcej informacji na temat kodu konfiguracji telemetrii, zapoznaj się z tym artykułem . Jedyną różnicą jest to, że używamy OTLP[Span|Metric|Log]Exporter do eksportowania danych telemetrycznych do pulpitu nawigacyjnego Aspire.

Uwaga

Możliwość obserwowania jądra semantycznego nie jest jeszcze dostępna dla języka Java.

Uruchamianie pulpitu nawigacyjnego Aspirującego

Postępuj zgodnie z instrukcjami podanymi tutaj , aby uruchomić pulpit nawigacyjny. Po uruchomieniu pulpitu nawigacyjnego otwórz przeglądarkę i przejdź do strony , aby http://localhost:18888 uzyskać dostęp do pulpitu nawigacyjnego.

Uruchom

Uruchom aplikację konsolową za pomocą następującego polecenia:

dotnet run

Uruchom skrypt języka Python za pomocą następującego polecenia:

python telemetry_aspire_dashboard_quickstart.py

Uwaga

Możliwość obserwowania jądra semantycznego nie jest jeszcze dostępna dla języka Java.

Inspekcja danych telemetrycznych

Po uruchomieniu aplikacji przejdź do pulpitu nawigacyjnego, aby sprawdzić dane telemetryczne.

Napiwek

Postępuj zgodnie z tym przewodnikiem , aby zapoznać się z interfejsem Pulpit nawigacyjny Aspiruj.

Ślady

Jeśli po raz pierwszy uruchamiasz aplikację po uruchomieniu pulpitu nawigacyjnego, powinna zostać wyświetlona jedna karta śledzenia Traces . Kliknij ślad, aby wyświetlić więcej szczegółów.

TracesOverview

W szczegółach śledzenia można zobaczyć zakres reprezentujący funkcję monitu i zakres reprezentujący model uzupełniania czatu. Kliknij zakres ukończenia czatu, aby wyświetlić szczegółowe informacje o żądaniu i odpowiedzi.

Napiwek

Możesz filtrować atrybuty zakresów, aby znaleźć ten, który cię interesuje.

TracesDetails

Dzienniki

Przejdź do karty, Structured aby wyświetlić dzienniki emitowane przez aplikację. Zapoznaj się z tym przewodnikiem dotyczącym pracy z dziennikami ustrukturyzowanymi na pulpicie nawigacyjnym.

Następne kroki

Po pomyślnym wyprowadzeniu danych telemetrycznych do pulpitu nawigacyjnego Aspirującego pulpitu nawigacyjnego możesz zapoznać się z bardziej funkcjami jądra semantycznego, które mogą ułatwić monitorowanie i diagnozowanie aplikacji:

Zaawansowane dane telemetryczne za pomocą jądra semantycznego