Überprüfung von Telemetriedaten mit Application Insights
Application Insights ist Teil von Azure Monitor, einer umfassenden Lösung zum Sammeln, Analysieren und Handeln von Telemetriedaten aus Ihrer Cloud und lokalen Umgebungen. Mit Application Insights können Sie die Leistung Ihrer Anwendung überwachen, Probleme erkennen und Probleme diagnostizieren.
In diesem Beispiel erfahren Wir, wie Telemetriedaten in Application Insights exportiert und die Daten im Application Insights-Portal überprüft werden.
Exporteur
Exporteure sind für das Senden von Telemetriedaten an ein Ziel verantwortlich. Weitere Informationen zu Exporteuren finden Sie hier. In diesem Beispiel verwenden wir den Azure Monitor-Exporter, um Telemetriedaten in eine Application Insights-Instanz auszugeben.
Voraussetzungen
- Bereitstellung eines Azure OpenAI-Chats.
- Eine Application Insights-Instanz. Befolgen Sie die hier aufgeführten Anweisungen , um eine Ressource zu erstellen, wenn Sie keine ressource haben. Kopieren Sie die Verbindungszeichenfolge zur späteren Verwendung.
- Das neueste .Net SDK für Ihr Betriebssystem.
- Bereitstellung eines Azure OpenAI-Chats.
- Eine Application Insights-Instanz. Befolgen Sie die hier aufgeführten Anweisungen , um eine Ressource zu erstellen, wenn Sie keine ressource haben. Kopieren Sie die Verbindungszeichenfolge zur späteren Verwendung.
- Python 3.10, 3.11 oder 3.12 auf Ihrem Computer installiert.
Hinweis
Die semantische Kernel-Observability ist für Java noch nicht verfügbar.
Setup
Erstellen einer neuen Konsolenanwendung
Führen Sie in einem Terminal den folgenden Befehl aus, um eine neue Konsolenanwendung in C# zu erstellen:
dotnet new console -n TelemetryApplicationInsightsQuickstart
Navigieren Sie nach Abschluss des Befehls zum neu erstellten Projektverzeichnis.
Installieren erforderlicher Pakete
Semantischer Kernel
dotnet add package Microsoft.SemanticKernelOpenTelemetry Console Exporter
dotnet add package Azure.Monitor.OpenTelemetry.Exporter
Erstellen einer einfachen Anwendung mit semantischem Kernel
Öffnen Sie die Program.cs Datei im Projektverzeichnis mit Ihrem bevorzugten Editor. Wir werden eine einfache Anwendung erstellen, die semantischen Kernel verwendet, um eine Eingabeaufforderung an ein Chatabschlussmodell zu senden. Ersetzen Sie den vorhandenen Inhalt durch den folgenden Code, und füllen Sie die erforderlichen Werte für deploymentName, endpointund 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);
}
}
}
Telemetrie hinzufügen
Wenn Sie die Konsolen-App jetzt ausführen, sollten Sie einen Satz sehen, der erklärt, warum der Himmel blau ist. Um den Kernel über Telemetrie zu beobachten, ersetzen Sie den // Telemetry setup code goes here Kommentar durch den folgenden Code:
// 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);
});
Entfernen Sie abschließend die Auskommentierung der Zeile // builder.Services.AddSingleton(loggerFactory); , um dem Generator die Loggerfabrik hinzuzufügen.
Weitere Informationen zum Telemetrieeinrichtungscode finden Sie in diesem Artikel . Der einzige Unterschied besteht darin, dass wir AddAzureMonitor[Trace|Metric|Log]Exporter Telemetriedaten in Application Insights exportieren.
Erstellen einer neuen virtuellen Python-Umgebung
python -m venv telemetry-application-insights-quickstart
Aktivieren Sie die virtuelle Umgebung.
telemetry-application-insights-quickstart\Scripts\activate
Installieren erforderlicher Pakete
pip install semantic-kernel azure-monitor-opentelemetry-exporter
Erstellen eines einfachen Python-Skripts mit semantischem Kernel
Erstellen Sie ein neues Python-Skript, und öffnen Sie es mit Ihrem bevorzugten Editor.
New-Item -Path telemetry_application_insights_quickstart.py -ItemType file
Wir werden ein einfaches Python-Skript erstellen, das semantic Kernel verwendet, um eine Eingabeaufforderung an ein Chatabschlussmodell zu senden. Ersetzen Sie den vorhandenen Inhalt durch den folgenden Code, und füllen Sie die erforderlichen Werte für deployment_name, endpointund 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())
Telemetrie hinzufügen
Umgebungsvariablen
Weitere Informationen zum Einrichten der erforderlichen Umgebungsvariablen zur Aktivierung des Kernels für KI-Connectors finden Sie in diesem Artikel .
Code
Wenn Sie das Skript jetzt ausführen, sollten Sie erwarten, dass sie einen Satz sehen, der erklärt, warum der Himmel blau ist. Um den Kernel über Telemetrie zu beobachten, ersetzen Sie den # Telemetry setup code goes here Kommentar durch den folgenden Code:
# 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()
Weitere Informationen zum Telemetrieeinrichtungscode finden Sie in diesem Artikel . Der einzige Unterschied besteht darin, dass wir AzureMonitor[Trace|Metric|Log]Exporter Telemetriedaten in Application Insights exportieren.
Hinweis
Die semantische Kernel-Observability ist für Java noch nicht verfügbar.
Ausführung
Führen Sie die Konsolenanwendung mit dem folgenden Befehl aus:
dotnet run
Führen Sie das Python-Skript mit dem folgenden Befehl aus:
python telemetry_application_insights_quickstart.py
Hinweis
Die semantische Kernel-Observability ist für Java noch nicht verfügbar.
Überprüfen von Telemetriedaten
Nachdem Sie die Anwendung ausgeführt haben, wechseln Sie zum Application Insights-Portal, um die Telemetriedaten zu überprüfen. Es kann einige Minuten dauern, bis die Daten im Portal angezeigt werden.
Transaktionssuche
Navigieren Sie zur Registerkarte " Transaktionssuche ", um die transaktionen anzuzeigen, die aufgezeichnet wurden.
Drücken Sie die Aktualisierung, um die neuesten Transaktionen anzuzeigen. Wenn Ergebnisse angezeigt werden, klicken Sie auf eine davon, um weitere Details anzuzeigen.
Umschalten zwischen der Schaltfläche "Alle anzeigen" und "Zeitachse anzeigen", um alle Ablaufverfolgungen und Abhängigkeiten der Transaktion in verschiedenen Ansichten anzuzeigen.
Wichtig
Ablaufverfolgungen stellen herkömmliche Protokolleinträge und OpenTelemetry-Span-Ereignisse dar. Sie sind nicht identisch mit verteilten Ablaufverfolgungen. Abhängigkeiten stellen die Aufrufe von (internen und externen) Komponenten dar. Weitere Informationen zum Datenmodell in Application Insights finden Sie in diesem Artikel .
In diesem beispiel sollten zwei Abhängigkeiten und mehrere Ablaufverfolgungen angezeigt werden. Die erste Abhängigkeit stellt eine Kernelfunktion dar, die aus der Eingabeaufforderung erstellt wird. Die zweite Abhängigkeit stellt den Aufruf des Azure OpenAI-Chatabschlussmodells dar. Wenn Sie die chat.completion {your-deployment-name} Abhängigkeit erweitern, sollten die Details des Anrufs angezeigt werden. Eine Gruppe von gen_ai Attributen wird an die Abhängigkeit angefügt, die zusätzlichen Kontext zu dem Aufruf bereitstellt.
Wenn sie auf "Switch Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive " festgelegt truesind, werden auch zwei Ablaufverfolgungen angezeigt, die die vertraulichen Daten der Eingabeaufforderung und das Abschlussergebnis enthalten.
Klicken Sie darauf, und sie werden die Eingabeaufforderung und das Abschlussergebnis unter dem Abschnitt "Benutzerdefinierte Eigenschaften" angezeigt.
Wenn die Umgebungsvariable SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE auf true festgelegt ist, werden auch zwei Ablaufverfolgungen angezeigt, die die vertraulichen Daten der Eingabeaufforderung und das Abschlussergebnis enthalten.
Klicken Sie darauf, und sie werden die Eingabeaufforderung und das Abschlussergebnis unter dem Abschnitt "Benutzerdefinierte Eigenschaften" angezeigt.
Log Analytics
Die Transaktionssuche ist nicht die einzige Möglichkeit, Telemetriedaten zu prüfen. Sie können auch Log Analytics verwenden, um die Daten abzufragen und zu analysieren. Navigieren Sie zu den Protokollen unter "Überwachung ", um zu starten.
Folgen Sie diesem Dokument , um mit der Erkundung der Protokollanalyseschnittstelle zu beginnen.
Nachfolgend finden Sie einige Beispielabfragen, die Sie für dieses Beispiel verwenden können:
// 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ächste Schritte
Nachdem Sie nun Telemetriedaten erfolgreich an Application Insights ausgegeben haben, können Sie weitere Features des semantischen Kernels erkunden, die Ihnen helfen können, Ihre Anwendung zu überwachen und zu diagnostizieren: