OpenTelemetry mit Azure Monitor: Geschäftsmetriken und technische Signale verbinden

10 MinutenFlorian Bader
Wie OpenTelemetry Geschäftsmetriken, Logs und Traces einheitlich erfasst und welche Rollen Azure Monitor, Application Insights und Log Analytics übernehmen.

Ein Dienst kann erreichbar sein, während Bestellungen scheitern, Zahlungen abgelehnt werden oder eine neue Version den Ablauf verlangsamt. Ein grüner Health Check zeigt Verfügbarkeit, nicht ob Kundinnen und Kunden ihr Ziel erreichen.

Wenn deine Anwendung heute Daten mit dem Application Insights SDK sendet, kannst du Application Insights auch nach dem Wechsel zu OpenTelemetry weiter als Empfänger nutzen. Application Insights ist die anwendungsbezogene Diagnosefunktion innerhalb von Azure Monitor. OpenTelemetry standardisiert, wie Anwendungen Logs, Metriken und Traces erzeugen und exportieren.

Alternativ leitest du Telemetrie über das OpenTelemetry Protocol (OTLP) an die nativen Ingestion-Endpunkte von Azure Monitor. OTLP legt fest, wie Telemetriedaten zwischen Anwendung, Collector und empfangendem System übertragen werden. Für den Einstieg kannst du aber die Instrumentierung modernisieren, ohne gleichzeitig die Speicherung und Auswertung deiner Daten umzustellen.

Monitoring muss Geschäfts- und Technikfragen beantworten

Verfügbarkeit und CPU-Auslastung zeigen nicht, ob ein Geschäftsprozess funktioniert. Für einen Shop sind abgeschlossene Bestellungen und abgelehnte Zahlungen ebenso wichtig wie HTTP-Fehler, Laufzeit und Abhängigkeiten.

Ein Trace bildet den Weg eines Vorgangs durch die Anwendung und beteiligte Dienste ab. Er besteht aus Spans, die jeweils einen Arbeitsschritt mit Startzeit, Dauer und weiteren Angaben beschreiben. Ein SQL-Span erfasst beispielsweise eine Datenbankabfrage, ein Zahlungs-Span den Aufruf eines Zahlungsdienstes.

SignalBeispielFrage
Geschäftsmetrikorders.completed, order.processing.durationWerden Bestellungen abgeschlossen und wie lange dauert es?
Fachliches Ereignispayment.authorization.failed mit FehlerkategorieAn welcher Prozessstufe scheitern Vorgänge?
Requests und AbhängigkeitenEingehender HTTP-Request, SQL- oder Zahlungs-SpanWo wird ein Ablauf langsam oder fehlerhaft?
FehlerlogsStrukturierter Fehlercode, Exception und Trace-KontextWas ist bei diesem Vorgang passiert?
Technische MetrikRequest-Rate, Fehlerquote, p95-Latenz, Queue-TiefeIst die Störung breit oder auf einzelne Vorgänge begrenzt?

Ein fachliches Ereignis beschreibt, was bei einem einzelnen Vorgang passiert ist. Das Ereignis payment.authorization.failed kann etwa mit dem Grund issuer_declined festhalten, dass die kartenausgebende Bank eine Zahlung abgelehnt hat.

Metriken fassen dagegen viele Vorgänge zusammen. Ein Counter ist ein Zähler, den die Anwendung beispielsweise bei jeder abgeschlossenen Bestellung erhöht. Ein Histogramm erfasst Messwerte wie die Bearbeitungsdauer und zeigt ihre Verteilung, sodass langsame Vorgänge nicht in einem Durchschnitt verschwinden.

OpenTelemetry standardisiert Instrumentierung

OpenTelemetry definiert APIs, SDKs, semantische Konventionen und OTLP für Logs, Metriken und Traces. Es ist kein Speicher und kein Dashboard. Der praktische Gewinn liegt in der Entkopplung. Der Anwendungscode nutzt einen gemeinsamen Standard, während Exporter oder ein OpenTelemetry Collector den Datenweg zum Ziel übernehmen. Ein Collector kann Telemetrie zentral bündeln, anreichern, filtern oder an mehrere Ziele weiterleiten. Das hilft bei mehreren Sprachen, Plattformen oder Backends, bringt aber auch eine zusätzliche Komponente mit eigener Konfiguration und Betrieb.

Wenn du bereits Application Insights nutzt, musst du dessen Diagnoseansichten nicht sofort aufgeben. OpenTelemetry kann weiterhin in Application Insights exportieren. Der Wechsel standardisiert nur die Instrumentierung.

Automatische Instrumentierung erfasst typische Server-Requests und ausgehende Aufrufe, etwa über HttpClient oder SQL, sofern passende Instrumentierungen registriert sind. Eigene Spans machen zusätzlich fachliche Arbeitsschritte wie Bestellverarbeitung, Import oder Preisberechnung im Trace sichtbar. Mit dem W3C-Standard für Trace Context lässt sich ein Trace über Services verbinden, wenn der Kontext auch über asynchrone Nachrichten weitergegeben wird.

Setze für jeden Dienst konsistente Resource Attributes wie service.name, service.version und deployment.environment.name. Die OpenTelemetry Semantic Conventions helfen, Signale verschiedener Komponenten einheitlich zu benennen. So kannst du einen Fehler einer Version und Umgebung zuordnen und den Request bis zur betroffenen Abhängigkeit verfolgen.

Welche Rolle spielen Azure Monitor, Application Insights und Log Analytics?

Die Begriffe beschreiben verschiedene Ebenen. OpenTelemetry standardisiert die Instrumentierung, Azure Monitor ist die Monitoring-Plattform und Application Insights sowie Log Analytics bieten unterschiedliche Wege, Telemetrie auszuwerten.

BausteinAufgabe
Azure MonitorÜbergreifende Plattform für Metriken, Logs, Alerts und Dashboards
Log AnalyticsWorkspace und KQL-Abfragen für Logs und Traces
Application InsightsAnwendungsdiagnose mit Application Map, Fehlern, Performance, Transaction Search und Live Metrics
OpenTelemetryHerstellerneutraler Standard für Instrumentierung, Kontext und Telemetrie-Transport

Im workspace-basierten Modell ist Application Insights mit einem Log Analytics Workspace verknüpft. Viele Telemetrie-Tabellen lassen sich dort mit KQL abfragen. Application Insights ergänzt die Daten um anwendungsbezogene Ansichten und Diagnosefunktionen. Log Analytics instrumentiert die Anwendung nicht selbst. Es stellt Workspace und KQL-Abfragen bereit. Bei direkter OTLP-Ingestion liegen Logs und Traces im Log Analytics Workspace. Metriken liegen in einem Azure Monitor Workspace und lassen sich mit PromQL oder Grafana auswerten.

Für neue .NET-, Node.js- und Python-Anwendungen oder den ersten Schritt zu OpenTelemetry empfiehlt Microsoft die Microsoft OpenTelemetry Distro. Bei einer bestehenden .NET-Anwendung mit Application Insights SDK 2.x empfiehlt Microsoft ein Upgrade auf SDK 3.x, wenn du möglichst wenig neu instrumentieren willst. SDK 3.x behält viele TelemetryClient-APIs bei und gibt Telemetrie über OpenTelemetry aus. Alternativ kannst du mit der Distro neu starten. Initialisiere nicht beide Instrumentierungspfade für dieselben Signale.

Mit Azure Monitor als Exportziel und einer APPLICATIONINSIGHTS_CONNECTION_STRING sendet die Distro Daten an Application Insights. So kannst du OpenTelemetry einsetzen und weiterhin Application Map, Fehler- und Performance-Ansichten sowie Live Metrics nutzen.

Azure Monitor unterstützt außerdem native OTLP-Ingestion über einen OpenTelemetry Collector, den Azure Monitor Agent oder das AKS-Add-on. Bei manueller Konfiguration leiten Data Collection Rules und Data Collection Endpoints Logs und Traces in einen Log Analytics Workspace sowie Metriken in einen separaten Azure Monitor Workspace für Prometheus.

Auch Daten aus diesem Collector-Pfad kannst du mit Application Insights auswerten. Dafür muss eine Application-Insights-Ressource mit den OTLP-Ressourcen verknüpft sein; Daten im selben Log Analytics Workspace allein reichen dafür nicht aus. Microsoft empfiehlt die Einrichtung über Application Insights mit aktivierter OTLP-Unterstützung, weil sie die benötigten Ressourcen und Verknüpfungen automatisch anlegt. Für Application-Insights-Dashboards müssen OTLP-Metriken mit Delta Temporality und Exponential-Histogramm-Aggregation exportiert werden.

Ohne Application-Insights-Ressource kannst du Logs und Traces mit KQL sowie Metriken mit PromQL oder Grafana auswerten, verzichtest aber auf die Application-Insights-spezifischen Diagnoseansichten. Bei manueller Einrichtung verwaltest du Workspaces, Regeln, Endpoints und Identitäten selbst. Das gibt dir mehr Kontrolle, wenn du bestehende Ressourcen wiederverwenden oder eine mehrzielige Telemetrie-Pipeline betreiben willst.

Ein risikoarmer Einstieg ist ein einzelner Dienst. Behalte zunächst Application Insights als Ziel und vergleiche Geschäftsmetriken, Request-Fehler und Trace-Korrelation mit dem bisherigen Stand. Entscheide erst danach, ob direkte OTLP-Ingestion oder ein Collector zusätzliche Anforderungen erfüllt.

Prüfe den Datenpfad mit einem gezielt ausgelösten Erfolgs- und Fehlerfall. Beide sollten denselben Dienst, die Umgebung, die Version und einen korrelierten Trace zeigen. Der Fehlerfall sollte zusätzlich im passenden Geschäftssignal und strukturierten Log sichtbar sein. Application Insights bietet dafür Transaction Search; ohne diese Einbindung verwendest du für Logs und Traces Log Analytics und KQL. Tabellennamen und Spalten können sich je nach Ingestionspfad unterscheiden, also teste Abfragen gegen das tatsächlich verwendete Schema.

ASP.NET Core pragmatisch instrumentieren

Die Distro bringt gängige Instrumentierungen für Web-Requests, Abhängigkeiten, Logs und Laufzeitdaten mit. Eigene ActivitySource- und Meter-Namen meldest du zusätzlich an, damit fachliche Spans und Metriken exportiert werden. In einem neuen Projekt kann die Konfiguration beispielsweise so aussehen.

using System.Collections.Generic;
using Microsoft.OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);
var telemetry = builder.Services.AddOpenTelemetry();

telemetry.ConfigureResource(resource => resource
    .AddService(
        serviceName: "shop-api",
        serviceVersion: typeof(Program).Assembly.GetName().Version?.ToString() ?? "unknown")
    .AddAttributes(new Dictionary<string, object>
    {
        ["deployment.environment.name"] = builder.Environment.EnvironmentName
    }))
    .WithTracing(tracing => tracing.AddSource("Shop.Orders"))
    .WithMetrics(metrics => metrics.AddMeter("Shop.Orders"))
    .UseMicrosoftOpenTelemetry(options =>
    {
        options.Exporters = ExportTarget.AzureMonitor;
    });

AddSource und AddMeter müssen zu den Namen deiner ActivitySource und Meter passen. Im Handler startest du einen Span für die Bestellverarbeitung, zählst abgeschlossene Bestellungen und misst die Dauer mit einem Histogramm. Eine kleine Menge fester Werte wie channel=web oder channel=partner hilft bei der Auswertung. Eine einzelne orderId würde die Metrikkardinalität unnötig erhöhen.

Die Instrumente bleiben in einer gemeinsam genutzten Klasse registriert, statt bei jedem Request neu angelegt zu werden.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Metrics;

public static class OrderTelemetry
{
    public const string Name                                = "Shop.Orders";
    public static readonly ActivitySource Source            = new(Name);
    private static readonly Meter Meter                     = new(Name);

    public static readonly Counter<long> Completed           =
        Meter.CreateCounter<long>("orders.completed");
    public static readonly Counter<long> PaymentFailed       =
        Meter.CreateCounter<long>("orders.payment_failed");
    public static readonly Histogram<double> ProcessingTime =
        Meter.CreateHistogram<double>("order.processing.duration", unit: "ms");
}

Im Handler mit injiziertem Zahlungsdienst, Repository und ILogger verwendest du die Instrumente zum Beispiel so. Order.Channel ist hier ein Enum mit den begrenzten Werten Web und Partner.

public async Task ProcessOrderAsync(Order order, CancellationToken cancellationToken)
{
    var startedAt = Stopwatch.GetTimestamp();
    var channel = order.Channel.ToString().ToLowerInvariant();
    var outcome = "error";
    using var activity = OrderTelemetry.Source.StartActivity("order.process");

    activity?.SetTag("order.channel", channel);

    try
    {
        await payment.AuthorizeAsync(order, cancellationToken);
        await orders.SaveAsync(order, cancellationToken);
        outcome = "completed";

        OrderTelemetry.Completed.Add(
            1,
            new KeyValuePair<string, object?>("channel", channel),
            new KeyValuePair<string, object?>("outcome", outcome));
        activity?.SetStatus(ActivityStatusCode.Ok);
    }
    catch (PaymentAuthorizationException exception)
    {
        outcome = "payment_failed";
        OrderTelemetry.PaymentFailed.Add(
            1,
            new KeyValuePair<string, object?>("channel", channel),
            new KeyValuePair<string, object?>("reason", outcome));
        activity?.AddEvent(new ActivityEvent("payment.authorization.failed"));
        activity?.SetStatus(ActivityStatusCode.Error, outcome);
        logger.LogError(
            exception,
            "Payment authorization failed with category {FailureCategory}",
            outcome);
        throw;
    }
    finally
    {
        OrderTelemetry.ProcessingTime.Record(
            Stopwatch.GetElapsedTime(startedAt).TotalMilliseconds,
            new KeyValuePair<string, object?>("channel", channel),
            new KeyValuePair<string, object?>("outcome", outcome));
    }
}

Der Counter zählt abgeschlossene Bestellungen, das Histogramm erfasst die Dauer für erfolgreiche und fehlgeschlagene Vorgänge. channel, outcome und reason haben nur wenige mögliche Werte. Eine Bestellnummer gehört nicht in Metrikdimensionen. SetTag ergänzt Metadaten am Trace, das strukturierte Fehlerlog enthält dieselbe Fehlerkategorie und wird über den aktiven Trace korrelierbar. Protokolliere technische Ausnahmen ebenfalls strukturiert. Die Request-Instrumentierung liefert dazu HTTP-Status und Trace-Kontext. Erfasse keine vollständigen Request-Bodies, Tokens oder personenbezogenen Daten. Initialisiere nicht mehrere Distros oder Provider für dieselben Signale im selben Prozess.

Sonderfälle: Browser und lokale Entwicklung

Browser-Telemetrie

Für Browser-Anwendungen bleibt die Instrumentierung eine Ausnahme vom serverseitigen OpenTelemetry-Pfad. Microsoft empfiehlt für JavaScript im Browser das Application Insights JavaScript SDK. Laut Azure-Monitor-FAQ wird OpenTelemetry im Browser nicht empfohlen und von Azure nicht unterstützt. Das SDK nutzt selbst kein OpenTelemetry, erfasst aber Seitenaufrufe und Client-Fehler. Erweiterungen können weitere Interaktionen ergänzen.

Backend-Requests instrumentierst du weiterhin mit OpenTelemetry. Für die Korrelation von Browser und Server müssen Trace Context und CORS für die beteiligten Origins zusammenpassen. Das Browser-SDK sendet an eine Application-Insights-Ressource und kann daher auch dann als eigener Baustein bleiben, wenn dein Backend direkt per OTLP exportiert.

Die Grafik zeigt diese beiden Quellen und ihre Datenwege, keine zusätzlichen Anwendungsdienste. Der mittlere OpenTelemetry-Block steht für die Instrumentierung in deiner bestehenden Backend-Anwendung. Der Collector empfängt und verarbeitet deren Telemetrie; er ersetzt weder die Anwendung noch ihre Instrumentierung. Der obere Pfad zeigt die native OTLP-Ingestion, der untere den Export über die Distro sowie die separate Browser-Telemetrie.

Die bestehende Backend-Anwendung erzeugt Telemetrie mit OpenTelemetry und exportiert sie über die Distro oder einen Collector zu Azure Monitor. Der Browser sendet separat über das Application Insights JavaScript SDK.

Die getrennten Pfade bedeuten nicht, dass Collector-Daten von Application Insights ausgeschlossen sind. Auch der obere Pfad lässt sich wie oben beschrieben mit einer Application-Insights-Ressource verknüpfen.

Lokaler Blick mit dem Aspire Dashboard

Das standalone Aspire Dashboard zeigt lokale Logs, Metriken und Traces aus jeder Anwendung mit OTLP-Exporter. Du brauchst dafür keinen Aspire AppHost. So kannst du Instrumentierung prüfen, bevor Telemetrie Azure erreicht.

Starte das Dashboard zum Beispiel mit Docker.

docker run --rm -it -p 18888:18888 -p 4317:18889 -p 4318:18890 --name aspire-dashboard mcr.microsoft.com/aspire/dashboard:latest

Richte den OTLP/gRPC-Exporter lokal auf http://localhost:4317 aus und öffne das Dashboard unter http://localhost:18888. Das Dashboard gibt beim Start standardmäßig ein Login-Token aus. Es ist für Entwicklung und kurze Diagnosen gedacht, nicht als Produktionsspeicher.

Gute Telemetrie ist Voraussetzung für sinnvolle GenAI

Ein Alert wird hilfreicher, wenn er nicht nur CPU-Auslastung meldet, sondern eine steigende Bestellfehlerquote, eine langsame Payment-Abhängigkeit sowie betroffene Version und Umgebung benennt. Dann kann ein Agent Logs und Traces gezielt prüfen, statt aus einem einzelnen Alarmtext eine Ursache zu erraten.

Unser Beitrag Agentic Ops mit Grafana und GitHub zeigt, wie ein Grafana-Alert zu einem nachverfolgbaren GitHub-Issue für eine agentische Erstanalyse wird. Der Agent bekommt dafür begrenzte Abfragen und redigierten Kontext, keine unkontrollierten Rohdaten oder Produktionsrechte. OpenTelemetry löst nicht automatisch jeden Incident. Konsistente Geschäftsmetriken, Fehlerlogs und korrelierte Traces geben einer Analyse aber belastbare Anhaltspunkte, bevor ein Entwickler übernimmt.

Beobachte Geschäftserfolg und technischen Weg dorthin

OpenTelemetry standardisiert die Instrumentierung. Azure Monitor nimmt Telemetrie auf, Application Insights ergänzt sie um anwendungsbezogene Diagnose und Log Analytics ermöglicht KQL-Abfragen. Beginne mit einem wichtigen Geschäftsprozess und definiere sein Erfolgssignal. Verbinde es mit Requests, Abhängigkeiten, Fehlerlogs und Traces. Behalte beim Wechsel zunächst Application Insights als Ziel, prüfe die Korrelation und entscheide danach, ob direkte OTLP-Ingestion oder ein Collector zusätzlichen Nutzen bringt.

Wie erkennst du, dass ein Geschäftsprozess scheitert, bevor Nutzer oder Entwicklung es melden? Diskutiere mit uns auf LinkedIn.

Autoren