Ispezione dei dati di telemetria con Application Insights

• Distribuzione del completamento della chat OpenAI di Azure.
• Istanza di Application Insights. Seguire le istruzioni riportate qui per creare una risorsa se non ne è disponibile una. Copiare il stringa di connessione per usarlo in un secondo momento.
• La versione più recente di .Net SDK per il sistema operativo.

• Distribuzione del completamento della chat OpenAI di Azure.
• Istanza di Application Insights. Seguire le istruzioni riportate qui per creare una risorsa se non ne è disponibile una. Copiare il stringa di connessione per usarlo in un secondo momento.
• Python 3.10, 3.11 o 3.12 installato nel computer.

Creare un nuovo progetto di applicazione console

In un terminale eseguire il comando seguente per creare una nuova applicazione console in C#:

dotnet new console -n TelemetryApplicationInsightsQuickstart

Passare alla directory del progetto appena creata al termine del comando.

Installare i pacchetti necessari

• Kernel semantico

  dotnet add package Microsoft.SemanticKernel
  

• Utilità di esportazione della console OpenTelemetry

  dotnet add package Azure.Monitor.OpenTelemetry.Exporter
  

Creare una semplice applicazione con il kernel semantico

Dalla directory del progetto aprire il file con l'editor Program.cs preferito. Verrà creata una semplice applicazione che usa il kernel semantico per inviare una richiesta a un modello di completamento della chat. Sostituire il contenuto esistente con il codice seguente e immettere i valori obbligatori per deploymentName, endpointe apiKey:

using Azure.Monitor.OpenTelemetry.Exporter;

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 TelemetryApplicationInsightsQuickstart
{
    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);
        }
    }
}

Aggiungere dati di telemetria

Se si esegue l'app console ora, è consigliabile vedere una frase che spiega perché il cielo è blu. Per osservare il kernel tramite telemetria, sostituire il // Telemetry setup code goes here commento con il codice seguente:

// Replace the connection string with your Application Insights connection string
var connectionString = "your-application-insights-connection-string";

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

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

using var traceProvider = Sdk.CreateTracerProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource("Microsoft.SemanticKernel*")
    .AddAzureMonitorTraceExporter(options => options.ConnectionString = connectionString)
    .Build();

using var meterProvider = Sdk.CreateMeterProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddMeter("Microsoft.SemanticKernel*")
    .AddAzureMonitorMetricExporter(options => options.ConnectionString = connectionString)
    .Build();

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

Rimuovere infine il commento dalla riga per aggiungere la factory // builder.Services.AddSingleton(loggerFactory); del logger al generatore.

Per altre informazioni sul codice di configurazione dei dati di telemetria, vedere questo articolo . L'unica differenza è che viene usato AddAzureMonitor[Trace|Metric|Log]Exporter per esportare i dati di telemetria in Application Insights.

Creare un nuovo ambiente virtuale Python

python -m venv telemetry-application-insights-quickstart

Attivare l'ambiente virtuale.

telemetry-application-insights-quickstart\Scripts\activate

Installare i pacchetti necessari

pip install semantic-kernel azure-monitor-opentelemetry-exporter

Creare uno script Python semplice con il kernel semantico

Creare un nuovo script Python e aprirlo con l'editor preferito.

New-Item -Path telemetry_application_insights_quickstart.py -ItemType file

touch telemetry_application_insights_quickstart.py

Verrà creato un semplice script Python che usa il kernel semantico per inviare una richiesta a un modello di completamento della chat. Sostituire il contenuto esistente con il codice seguente e immettere i valori obbligatori per deployment_name, endpointe api_key:

import asyncio
import logging

from azure.monitor.opentelemetry.exporter import (
    AzureMonitorLogExporter,
    AzureMonitorMetricExporter,
    AzureMonitorTraceExporter,
)

from opentelemetry._logs import set_logger_provider
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())

Aggiungere dati di telemetria

Variabili di ambiente

Per altre informazioni sulla configurazione delle variabili di ambiente necessarie per consentire al kernel di generare intervalli per i connettori di intelligenza artificiale, vedere questo articolo .

Codice

Se si esegue lo script ora, si dovrebbe aspettare di vedere una frase che spiega perché il cielo è blu. Per osservare il kernel tramite telemetria, sostituire il # Telemetry setup code goes here commento con il codice seguente:

# Replace the connection string with your Application Insights connection string
connection_string = "your-application-insights-connection-string"

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


def set_up_logging():
    exporter = AzureMonitorLogExporter(connection_string=connection_string)

    # 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 = AzureMonitorTraceExporter(connection_string=connection_string)

    # 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 = AzureMonitorMetricExporter(connection_string=connection_string)

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

Per altre informazioni sul codice di configurazione dei dati di telemetria, vedere questo articolo . L'unica differenza è che viene usato AzureMonitor[Trace|Metric|Log]Exporter per esportare i dati di telemetria in Application Insights.

Eseguire l'applicazione console con il comando seguente:

dotnet run

Eseguire lo script Python con il comando seguente:

python telemetry_application_insights_quickstart.py

Se l'opzione è impostata Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive su true, verranno visualizzate anche due tracce che contengono i dati sensibili della richiesta e il risultato di completamento.

Fare clic su di essi e verrà visualizzato il prompt e il risultato di completamento nella sezione proprietà personalizzate.

Se la variabile di ambiente è impostata SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE su true, verranno visualizzate anche due tracce che contengono i dati sensibili della richiesta e il risultato di completamento.

Fare clic su di essi e verrà visualizzato il prompt e il risultato di completamento nella sezione proprietà personalizzate.