Inspektion av telemetridata med Application Insights
Application Insights är en del av Azure Monitor, som är en omfattande lösning för att samla in, analysera och agera på telemetridata från molnet och lokala miljöer. Med Application Insights kan du övervaka programmets prestanda, identifiera problem och diagnostisera problem.
I det här exemplet får vi lära oss hur du exporterar telemetridata till Application Insights och inspekterar data i Application Insights-portalen.
Varning
Semantisk kernel använder en .NET 8-funktion som kallas nyckeltjänster. Application Insights har problem med tjänstregistrering, vilket gör det inkompatibelt med nyckelade tjänster. Om du använder Semantic Kernel med tjänster med nycklar och stöter på oväntade fel som rör Application Insights-beroendeinjektion bör du registrera Application Insights före några tjänster med nycklar för att lösa problemet. Mer information finns i microsoft/ApplicationInsights-dotnet#2879
Exportör
Exportörer ansvarar för att skicka telemetridata till ett mål. Läs mer om exportörer här. I det här exemplet använder vi Azure Monitor-exportören för att mata ut telemetridata till en Application Insights-instans.
Förutsättningar
- En distribution av Azure OpenAI-chatten.
- En Application Insights-instans. Följ anvisningarna här för att skapa en resurs om du inte har någon. Kopiera anslutningssträng för senare användning.
- Den senaste .Net SDK för operativsystemet.
- En distribution av Azure OpenAI-chatten.
- En Application Insights-instans. Följ anvisningarna här för att skapa en resurs om du inte har någon. Kopiera anslutningssträng för senare användning.
- Python 3.10, 3.11 eller 3.12 installerat på datorn.
Kommentar
Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.
Ställ in
Skapa ett nytt konsolprogram
I en terminal kör du följande kommando för att skapa ett nytt konsolprogram i C#:
dotnet new console -n TelemetryApplicationInsightsQuickstart
Navigera till den nyligen skapade projektkatalogen när kommandot har slutförts.
Installera de paket som krävs
Semantic Kernel
dotnet add package Microsoft.SemanticKernelOpenTelemetry Console Exporter
dotnet add package Azure.Monitor.OpenTelemetry.Exporter
Skapa ett enkelt program med semantisk kernel
Öppna filen med din favoritredigerare från projektkatalogen Program.cs . Vi ska skapa ett enkelt program som använder semantisk kernel för att skicka en uppmaning till en modell för chattens slutförande. Ersätt det befintliga innehållet med följande kod och fyll i de nödvändiga värdena för deploymentName, endpointoch 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);
}
}
}
Lägg till telemetri
Om du kör konsolappen nu bör du förvänta dig att se en mening som förklarar varför himlen är blå. Om du vill observera kerneln via telemetri ersätter du kommentaren // Telemetry setup code goes here med följande kod:
// 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);
});
Ta slutligen bort kommentaren till raden // builder.Services.AddSingleton(loggerFactory); för att lägga till loggerfabriken i byggverktyget.
Mer information om konfigurationskoden för telemetri finns i den här artikeln . Den enda skillnaden här är att vi använder AddAzureMonitor[Trace|Metric|Log]Exporter för att exportera telemetridata till Application Insights.
Skapa en ny virtuell Python-miljö
python -m venv telemetry-application-insights-quickstart
Aktivera den virtuella miljön.
telemetry-application-insights-quickstart\Scripts\activate
Installera de paket som krävs
pip install semantic-kernel azure-monitor-opentelemetry-exporter
Skapa ett enkelt Python-skript med semantisk kernel
Skapa ett nytt Python-skript och öppna det med din favoritredigerare.
New-Item -Path telemetry_application_insights_quickstart.py -ItemType file
Vi ska skapa ett enkelt Python-skript som använder semantisk kernel för att skicka en uppmaning till en modell för chattens slutförande. Ersätt det befintliga innehållet med följande kod och fyll i de nödvändiga värdena för deployment_name, endpointoch 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())
Lägg till telemetri
Miljövariabler
Mer information om hur du konfigurerar nödvändiga miljövariabler finns i den här artikeln så att kerneln kan generera intervall för AI-anslutningsappar.
Kod
Om du kör skriptet nu bör du förvänta dig att se en mening som förklarar varför himlen är blå. Om du vill observera kerneln via telemetri ersätter du kommentaren # Telemetry setup code goes here med följande kod:
# 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()
Mer information om konfigurationskoden för telemetri finns i den här artikeln . Den enda skillnaden här är att vi använder AzureMonitor[Trace|Metric|Log]Exporter för att exportera telemetridata till Application Insights.
Kommentar
Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.
Kör
Kör konsolprogrammet med följande kommando:
dotnet run
Kör Python-skriptet med följande kommando:
python telemetry_application_insights_quickstart.py
Kommentar
Semantisk kernelobservabilitet är ännu inte tillgängligt för Java.
Granska telemetridata
När du har kört programmet går du till Application Insights-portalen för att inspektera telemetridata. Det kan ta några minuter innan data visas i portalen.
Transaktionssökning
Gå till fliken Transaktionssökning för att visa de transaktioner som har registrerats.
Tryck på uppdatera för att se de senaste transaktionerna. När resultatet visas klickar du på en av dem för att se mer information.
Växla mellan knappen Visa alla och Visa tidslinje för att se alla spårningar och beroenden för transaktionen i olika vyer.
Viktigt!
Spårningar representerar traditionella loggposter och OpenTelemetry-spanhändelser. De är inte samma som distribuerade spårningar. Beroenden representerar anropen till (interna och externa) komponenter. Mer information om datamodellen i Application Insights finns i den här artikeln .
I det här exemplet bör du se två beroenden och flera spårningar. Det första beroendet representerar en kernelfunktion som skapas från prompten. Det andra beroendet representerar anropet till azure OpenAI-chattens slutförandemodell. När du expanderar chat.completion {your-deployment-name} beroendet bör du se information om anropet. En uppsättning gen_ai attribut är kopplade till beroendet, vilket ger ytterligare kontext om anropet.
Om växeln Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive är inställd truepå visas även två spårningar som innehåller känsliga data i prompten och slutföranderesultatet.
Klicka på dem så visas prompten och slutföranderesultatet under avsnittet anpassade egenskaper.
Om du har miljövariabeln SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE inställd på truevisas även två spårningar som innehåller känsliga data i prompten och slutföranderesultatet.
Klicka på dem så visas prompten och slutföranderesultatet under avsnittet anpassade egenskaper.
Log Analytics
Transaktionssökning är inte det enda sättet att inspektera telemetridata. Du kan också använda Log Analytics för att fråga efter och analysera data. Gå till loggarna under Övervakning för att starta.
Följ det här dokumentet för att börja utforska log analytics-gränssnittet.
Nedan visas några exempelfrågor som du kan använda för det här exemplet:
// 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)
Nästa steg
Nu när du har matat ut telemetridata till Application Insights kan du utforska fler funktioner i semantisk kernel som kan hjälpa dig att övervaka och diagnostisera ditt program: