Kontrola telemetrických dat pomocí Application Insights

Application Insights je součástí služby Azure Monitor, což je komplexní řešení pro shromažďování, analýzu a zpracování telemetrických dat z vašich cloudových a místních prostředí. Pomocí Application Insights můžete monitorovat výkon vaší aplikace, zjišťovat problémy a diagnostikovat problémy.

V tomto příkladu se dozvíte, jak exportovat telemetrická data do Application Insights a zkontrolovat data na portálu Application Insights.

Varování

Sémantické jádro využívá funkci .NET 8, která se nazývá klíčové služby. Application Insights má problém s registrací služby, takže není kompatibilní se službami s klíči. Pokud používáte Semantic Kernel se službami s klíči a dochází k neočekávaným chybám souvisejícím s injektáží závislostí Application Insights, měli byste zaregistrovat Application Insights před jakýmkoli použitím služeb s klíči, abyste tento problém vyřešili. Další informace najdete v tématu microsoft/ApplicationInsights-dotnet#2879

Vývozce

Exportéři zodpovídají za odesílání telemetrických dat do cíle. Přečtěte si další informace o vývozcích zde. V tomto příkladu použijeme exportér Azure Monitoru k výstupu telemetrických dat do instance Application Insights.

Požadavky

• Nasazení dokončení chatu Azure OpenAI
• Instance Application Insights. Pokud ho nemáte, postupujte podle zde uvedených pokynů a vytvořte prostředek. Zkopírujte připojovací řetězec pro pozdější použití.
• Nejnovější sada .NET SDK pro váš operační systém.

• Nasazení dokončení chatu Azure OpenAI
• Instance Application Insights. Pokud ho nemáte, postupujte podle zde uvedených pokynů a vytvořte prostředek. Zkopírujte připojovací řetězec pro pozdější použití.
• Na počítači je nainstalovaný Python 3.10, 3.11 nebo 3.12 .

Poznámka:

Sémantická pozorovatelnost jádra zatím není pro Javu k dispozici.

Nastavení

Vytvoření nové konzolové aplikace

Spuštěním následujícího příkazu v terminálu vytvořte novou konzolovou aplikaci v jazyce C#:

dotnet new console -n TelemetryApplicationInsightsQuickstart

Po dokončení příkazu přejděte do nově vytvořeného adresáře projektu.

Instalace požadovaných balíčků

• Sémantické jádro

  dotnet add package Microsoft.SemanticKernel
  

• Exportér konzoly OpenTelemetry

  dotnet add package Azure.Monitor.OpenTelemetry.Exporter
  

Vytvoření jednoduché aplikace pomocí sémantického jádra

V adresáři projektu otevřete Program.cs soubor v oblíbeném editoru. Vytvoříme jednoduchou aplikaci, která používá sémantické jádro k odeslání výzvy do modelu dokončování chatu. Nahraďte stávající obsah následujícím kódem a vyplňte požadované hodnoty pro deploymentName, endpointa 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);
        }
    }
}

Přidání telemetrie

Pokud teď spustíte konzolovou aplikaci, měli byste očekávat větu s vysvětlením, proč je obloha modrá. Pokud chcete sledovat jádro prostřednictvím telemetrie, nahraďte // Telemetry setup code goes here komentář následujícím kódem:

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

Nakonec odkomentujte řádek // builder.Services.AddSingleton(loggerFactory); pro přidání objektu pro protokolování do tvůrce.

Další informace o kódu nastavení telemetrie najdete v tomto článku . Jediným rozdílem je, že k exportu telemetrických dat do Application Insights používáme AddAzureMonitor[Trace|Metric|Log]Exporter .

Vytvoření nového virtuálního prostředí Pythonu

python -m venv telemetry-application-insights-quickstart

Aktivujte virtuální prostředí.

telemetry-application-insights-quickstart\Scripts\activate

Instalace požadovaných balíčků

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

Vytvoření jednoduchého skriptu Pythonu s sémantickým jádrem

Vytvořte nový skript Pythonu a otevřete ho v oblíbeném editoru.

Powershell

New-Item -Path telemetry_application_insights_quickstart.py -ItemType file

Udeřit

touch telemetry_application_insights_quickstart.py

Vytvoříme jednoduchý skript Pythonu, který používá sémantické jádro k odeslání výzvy do modelu dokončování chatu. Nahraďte stávající obsah následujícím kódem a vyplňte požadované hodnoty pro deployment_name, endpointa 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())

Přidání telemetrie

Proměnné prostředí

Další informace o nastavení požadovaných proměnných prostředí pro povolení generování rozsahů pro konektory AI najdete v tomto článku .

Kód

Pokud skript spustíte teď, měli byste očekávat, že uvidíte větu s vysvětlením, proč je obloha modrá. Pokud chcete sledovat jádro prostřednictvím telemetrie, nahraďte # Telemetry setup code goes here komentář následujícím kódem:

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

Další informace o kódu nastavení telemetrie najdete v tomto článku . Jediným rozdílem je, že k exportu telemetrických dat do Application Insights používáme AzureMonitor[Trace|Metric|Log]Exporter .

Poznámka:

Sémantická pozorovatelnost jádra zatím není pro Javu k dispozici.

Spustit

Spusťte konzolovou aplikaci pomocí následujícího příkazu:

dotnet run

Spusťte skript Pythonu pomocí následujícího příkazu:

python telemetry_application_insights_quickstart.py

Poznámka:

Sémantická pozorovatelnost jádra zatím není pro Javu k dispozici.

Kontrola telemetrických dat

Po spuštění aplikace přejděte na portál Application Insights a prohlédněte si telemetrická data. Zobrazení dat na portálu může trvat několik minut.

Vyhledávání transakcí

Přejděte na kartu Vyhledávání transakcí a zobrazte transakce, které byly zaznamenány.

Pokud chcete zobrazit nejnovější transakce, stiskněte aktualizaci. Když se zobrazí výsledky, kliknutím na některý z nich zobrazíte další podrobnosti.

Přepněte mezi tlačítkem Zobrazit vše a Zobrazit časovou osu , abyste viděli všechna trasování a závislosti transakce v různých zobrazeních.

Důležité

Trasování představují tradiční položky protokolu a události rozsahu OpenTelemetry. Nejsou stejné jako distribuované trasování. Závislosti představují volání (interních a externích) komponent. Další informace o datovém modelu v Application Insights najdete v tomto článku .

V tomto konkrétním příkladu byste měli vidět dvě závislosti a více trasování. První závislost představuje funkci jádra, která se vytvoří z výzvy. Druhá závislost představuje volání modelu dokončení chatu Azure OpenAI. Když závislost rozbalíte chat.completion {your-deployment-name} , měli byste vidět podrobnosti volání. Sada gen_ai atributů je připojena k závislosti, která poskytuje další kontext volání.

Pokud máte přepínač Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive nastavený na true, zobrazí se také dvě trasování, která obsahují citlivá data výzvy a výsledek dokončení.

Klikněte na ně a zobrazí se výzva a výsledek dokončení v části vlastní vlastnosti.

Pokud máte proměnnou SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE prostředí nastavenou na true, zobrazí se také dvě trasování, která obsahují citlivá data výzvy a výsledek dokončení.

Klikněte na ně a zobrazí se výzva a výsledek dokončení v části vlastní vlastnosti.

Log Analytics

Vyhledávání transakcí není jediným způsobem, jak kontrolovat telemetrická data. Log Analytics můžete také použít k dotazování a analýze dat. Přejděte do protokolů v části Monitorování , abyste mohli začít.

Postupujte podle tohoto dokumentu a začněte zkoumat rozhraní Log Analytics.

Níže najdete několik ukázkových dotazů, které můžete použít v tomto příkladu:

// Retrieves the total number of completion and prompt tokens used for the model if you run the application multiple times.
dependencies
| where name startswith "chat"
| project model = customDimensions["gen_ai.request.model"], completion_token = toint(customDimensions["gen_ai.response.completion_tokens"]), prompt_token = toint(customDimensions["gen_ai.response.prompt_tokens"])
| where model == "gpt-4o"
| project completion_token, prompt_token
| summarize total_completion_tokens = sum(completion_token), total_prompt_tokens = sum(prompt_token)

// Retrieves all the prompts and completions and their corresponding token usage.
dependencies
| where name startswith "chat"
| project timestamp, operation_Id, name, completion_token = customDimensions["gen_ai.response.completion_tokens"], prompt_token = customDimensions["gen_ai.response.prompt_tokens"]
| join traces on operation_Id
| where message startswith "gen_ai"
|project timestamp, messages = customDimensions, token=iff(customDimensions contains "gen_ai.prompt", prompt_token, completion_token)

Další kroky

Teď, když úspěšně vypíšete telemetrická data do Application Insights, můžete prozkoumat další funkce sémantického jádra, které vám pomůžou monitorovat a diagnostikovat aplikaci:

Pokročilá telemetrie s sémantickým jádrem