Inspection des données de télémétrie avec Application Insights

• Déploiement d’une conversation Azure OpenAI terminée.
• Une instance Application Insights. Suivez les instructions ci-dessous pour créer une ressource si vous n’en avez pas. Copiez la chaîne de connexion pour une utilisation ultérieure.
• Dernier SDK .Net pour votre système d’exploitation.

• Déploiement d’une conversation Azure OpenAI terminée.
• Une instance Application Insights. Suivez les instructions ci-dessous pour créer une ressource si vous n’en avez pas. Copiez la chaîne de connexion pour une utilisation ultérieure.
• Python 3.10, 3.11 ou 3.12 installé sur votre ordinateur.

Créer une application console

Dans un terminal, exécutez la commande suivante pour créer une application console en C# :

dotnet new console -n TelemetryApplicationInsightsQuickstart

Accédez au répertoire du projet nouvellement créé une fois la commande terminée.

Installer les packages nécessaires

• Noyau sémantique

  dotnet add package Microsoft.SemanticKernel
  

• OpenTelemetry Console Exporter

  dotnet add package Azure.Monitor.OpenTelemetry.Exporter
  

Créer une application simple avec le noyau sémantique

Dans le répertoire du projet, ouvrez le Program.cs fichier avec votre éditeur favori. Nous allons créer une application simple qui utilise le noyau sémantique pour envoyer une invite à un modèle d’achèvement de conversation. Remplacez le contenu existant par le code suivant et renseignez les valeurs requises pour deploymentName, endpointet 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);
        }
    }
}

Ajouter des données de télémétrie

Si vous exécutez l’application console maintenant, vous devez vous attendre à voir une phrase expliquant pourquoi le ciel est bleu. Pour observer le noyau via la télémétrie, remplacez le // Telemetry setup code goes here commentaire par le code suivant :

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

Enfin, supprimez les marques de commentaire de la ligne // builder.Services.AddSingleton(loggerFactory); pour ajouter la fabrique d’enregistreurs d’événements au générateur.

Pour plus d’informations sur le code de configuration de la télémétrie, consultez cet article . La seule différence ici est que nous utilisons AddAzureMonitor[Trace|Metric|Log]Exporter pour exporter des données de télémétrie vers Application Insights.

Créer un environnement virtuel Python

python -m venv telemetry-application-insights-quickstart

Activez l’environnement virtuel.

telemetry-application-insights-quickstart\Scripts\activate

Installer les packages nécessaires

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

Créer un script Python simple avec le noyau sémantique

Créez un script Python et ouvrez-le avec votre éditeur favori.

New-Item -Path telemetry_application_insights_quickstart.py -ItemType file

touch telemetry_application_insights_quickstart.py

Nous allons créer un script Python simple qui utilise le noyau sémantique pour envoyer une invite à un modèle d’achèvement de conversation. Remplacez le contenu existant par le code suivant et renseignez les valeurs requises pour deployment_name, endpointet 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())

Ajouter des données de télémétrie

Variables d'environnement

Reportez-vous à cet article pour plus d’informations sur la configuration des variables d’environnement requises pour permettre au noyau d’émettre des étendues pour les connecteurs IA.

Code

Si vous exécutez le script maintenant, vous devez vous attendre à voir une phrase expliquant pourquoi le ciel est bleu. Pour observer le noyau via la télémétrie, remplacez le # Telemetry setup code goes here commentaire par le code suivant :

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

Pour plus d’informations sur le code de configuration de la télémétrie, consultez cet article . La seule différence ici est que nous utilisons AzureMonitor[Trace|Metric|Log]Exporter pour exporter des données de télémétrie vers Application Insights.

Exécutez l’application console avec la commande suivante :

dotnet run

Exécutez le script Python avec la commande suivante :

python telemetry_application_insights_quickstart.py

Si le commutateur Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive est défini truesur , vous verrez également deux traces qui contiennent les données sensibles de l’invite et le résultat de la saisie semi-automatique.

Cliquez dessus et vous verrez l’invite et le résultat de la saisie semi-automatique sous la section propriétés personnalisées.

Si la variable SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE d’environnement est définie truesur , vous verrez également deux traces qui contiennent les données sensibles de l’invite et le résultat de la saisie semi-automatique.

Cliquez dessus et vous verrez l’invite et le résultat de la saisie semi-automatique sous la section propriétés personnalisées.