Bagikan melalui

Inspeksi data telemetri dengan Dasbor Aspire

Dasbor Aspire adalah bagian dari penawaran .NET Aspire . Dasbor memungkinkan pengembang untuk memantau dan memeriksa aplikasi terdistribusi mereka.

Dalam contoh ini, kita akan menggunakan mode mandiri dan mempelajari cara mengekspor data telemetri ke Dasbor Aspire, dan memeriksa data di sana.

Pengekspor

Eksportir bertanggung jawab untuk mengirim data telemetri ke tujuan. Baca selengkapnya tentang pengekspor di sini. Dalam contoh ini, kami menggunakan pengekspor OpenTelemetry Protocol (OTLP) untuk mengirim data telemetri ke Dasbor Aspire.

Prasyarat

  • Penyebaran penyelesaian obrolan Azure OpenAI.
  • Docker
  • .Net SDK terbaru untuk sistem operasi Anda.

Catatan

Pengamatan Kernel Semantik belum tersedia untuk Java.

Siapkan

Membuat aplikasi konsol baru

Di terminal, jalankan perintah berikut untuk membuat aplikasi konsol baru di C#:

dotnet new console -n TelemetryAspireDashboardQuickstart

Navigasikan ke direktori proyek yang baru dibuat setelah perintah selesai.

Memasang paket yang diperlukan

  • Kernel Semantik

    dotnet add package Microsoft.SemanticKernel

  • Pengekspor Konsol OpenTelemetry

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Membuat aplikasi sederhana dengan Semantic Kernel

Dari direktori proyek, buka Program.cs file dengan editor favorit Anda. Kita akan membuat aplikasi sederhana yang menggunakan Semantic Kernel untuk mengirim permintaan ke model penyelesaian obrolan. Ganti konten yang ada dengan kode berikut dan isi nilai yang diperlukan untuk deploymentName, endpoint, dan 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);
        }
    }
}

Menambahkan telemetri

Jika Anda menjalankan aplikasi konsol sekarang, Anda harus mengharapkan untuk melihat kalimat yang menjelaskan mengapa langit berwarna biru. Untuk mengamati kernel melalui telemetri, ganti // Telemetry setup code goes here komentar dengan kode berikut:

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

Akhirnya Batalkan komentar baris // builder.Services.AddSingleton(loggerFactory); untuk menambahkan pabrik pencatat ke penyusun.

Silakan lihat artikel ini untuk informasi selengkapnya tentang kode penyiapan telemetri. Satu-satunya perbedaan di sini adalah kita menggunakan AddOtlpExporter untuk mengekspor data telemetri ke Dasbor Aspire.

Membuat lingkungan virtual Python baru

python -m venv telemetry-aspire-dashboard-quickstart

Aktifkan lingkungan virtual.

telemetry-aspire-dashboard-quickstart\Scripts\activate

Memasang paket yang diperlukan

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

Membuat skrip Python sederhana dengan Semantic Kernel

Buat skrip Python baru dan buka dengan editor favorit Anda.

New-Item -Path telemetry_aspire_dashboard_quickstart.py -ItemType file

Kita akan membuat skrip Python sederhana yang menggunakan Semantic Kernel untuk mengirim permintaan ke model penyelesaian obrolan. Ganti konten yang ada dengan kode berikut dan isi nilai yang diperlukan untuk deployment_name, endpoint, dan 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())

Menambahkan telemetri

Variabel lingkungan

Silakan lihat artikel ini untuk informasi selengkapnya tentang menyiapkan variabel lingkungan yang diperlukan untuk memungkinkan kernel memancarkan rentang untuk konektor AI.

Kode

Jika Anda menjalankan skrip sekarang, Anda harus mengharapkan untuk melihat kalimat yang menjelaskan mengapa langit berwarna biru. Untuk mengamati kernel melalui telemetri, ganti # Telemetry setup code goes here komentar dengan kode berikut:

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

Silakan lihat artikel ini untuk informasi selengkapnya tentang kode penyiapan telemetri. Satu-satunya perbedaan di sini adalah kita menggunakan OTLP[Span|Metric|Log]Exporter untuk mengekspor data telemetri ke Dasbor Aspire.

Catatan

Pengamatan Kernel Semantik belum tersedia untuk Java.

Memulai Dasbor Aspire

Ikuti instruksi di sini untuk memulai dasbor. Setelah dasbor berjalan, buka browser dan navigasi ke http://localhost:18888 untuk mengakses dasbor.

jalankan

Jalankan aplikasi konsol dengan perintah berikut:

dotnet run

Jalankan skrip Python dengan perintah berikut:

python telemetry_aspire_dashboard_quickstart.py

Catatan

Pengamatan Kernel Semantik belum tersedia untuk Java.

Memeriksa data telemetri

Setelah menjalankan aplikasi, buka dasbor untuk memeriksa data telemetri.

Tip

Ikuti panduan ini untuk menjelajahi antarmuka Dasbor Aspire.

Jejak

Jika ini adalah pertama kalinya Anda menjalankan aplikasi setelah memulai dasbor, Anda akan melihat satu jejak adalah Traces tab . Klik jejak untuk melihat detail selengkapnya.

Gambaran Umum Pelacakan

Dalam detail pelacakan, Anda dapat melihat rentang yang mewakili fungsi prompt dan rentang yang mewakili model penyelesaian obrolan. Klik rentang penyelesaian obrolan untuk melihat detail tentang permintaan dan respons.

Tip

Anda dapat memfilter atribut rentang untuk menemukan atribut yang Anda minati.

TracesDetails

Log

Buka tab Structured untuk melihat log yang dipancarkan oleh aplikasi. Silakan lihat panduan ini tentang cara bekerja dengan log terstruktur di dasbor.

Langkah berikutnya

Sekarang setelah Anda berhasil menghasilkan data telemetri ke Dasbor Aspire, Anda dapat menjelajahi lebih banyak fitur Kernel Semantik yang dapat membantu Anda memantau dan mendiagnosis aplikasi Anda:

Telemetri tingkat lanjut dengan Kernel Semantik