OpenTelemetry

kubectl describe trainer fpommerening

{
  name: "Frank Pommerening",
  employer: {},
  skills: [
    "Senior-Softwareentwickler",
    "Consultant",
    "Trainer"
  ],
  communication:{
    email : "frank@pommerening-consulting.de",
    twitter: "@fpommerening"
  }
}

OpenTelemetry

Überblick

Überblick

• Ursprünglich aus OpenCensus und OpenTracing hervorgegangen
• Seit August 2021 - Ein Projekt der CNCF in der Inkubationsphase
• Verarbeitung von Telemetriedaten wie Logs, verteilte Traces und Metriken
• Verfolgt offene Standards und bietet eine lose Kopplung
• Herstellerunabhängig und interoperabel
• Werkzeuge, APIs und SDKs zur Erzeugung, Erfassung
  und Export von Telemetriedaten

Bestandteile

OpenTelemetry Protocol (OTLP)

• Mechanismen zum Kodierung, Transport und
  Übertragung von Telemetriedaten
• Gilt für Telemetriequellen, Zwischenknoten und Backends
• Verwendet HTTP oder gRPC mit dem gleichen Protobuf-Schema
• Bietet binäre oder JSON-Übertragung (Experimentell)
• Enthält Optionen zur Übertragungssteuerung, einschließlich Throttling

OpenTelemetry Collector

• Das zentrale Element von OpenTelemetry
• Sammlung, Verarbeitung und Weiterleitung von Telemetriedaten
• Verwendet eine Pipeline-Verarbeitung

APIs und SDKs

• Gemeinsame Schnittstellen, einschließlich Protobuf
• Bibliotheken zur Integration in eigene Anwendungen

Sprachunterstützung

OpenTelemetry

.NET

Übersicht

• Unterstützung für Full-Framework < 4.6.1 und .NET (Core)
• Bereitstellung als Nuget-Pakete

Exporter

Instrumentation

Integration

Dependency Injection

services.AddOpenTelemetry().ConfigureResource(rb => 
            rb.AddEnvironmentVariableDetector().AddService(ServiceName))
  .WithMetrics(metricsBuilder =>
  {
    metricsBuilder.AddAspNetCoreInstrumentation();
    metricsBuilder.AddHttpClientInstrumentation();
    metricsBuilder.AddOtlpExporter(otlpOptions =>{ otlpOptions.Endpoint = new Uri(...);}));
  })
  .WithTracing(WithTracing =>
  {
    traceBuilder.SetSampler(new AlwaysOnSampler());
    traceBuilder.AddAspNetCoreInstrumentation();
    traceBuilder.AddHttpClientInstrumentation();
    traceBuilder.AddOtlpExporter(otlpOptions =>{ otlpOptions.Endpoint = new Uri(...);}));
  });
  

Manuell

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .ConfigureResource(res => res.AddService(ServiceName))
    .AddAspNetCoreInstrumentation()
    .AddHttpClientInstrumentation()
    .AddOtlpExporter(otlpOptions =>{ otlpOptions.Endpoint = new Uri(...);
    .Build();

using var meterProvider = Sdk.CreateMeterProviderBuilder()
    .ConfigureResource(res => res.AddService(ServiceName))
    .AddAspNetCoreInstrumentation()
    .AddHttpClientInstrumentation()
    .AddOtlpExporter(otlpOptions =>{ otlpOptions.Endpoint = new Uri(...);
    .Build();

Eigene Instrumentation

Activity / ActivitySource

ActivitySource ActivitySource = new ActivitySource(ActivitySourceName, ...)

using var activity = ActivitySource.StartActivity(ActivityName);

Metriken

Meter Meter = new Meter(MeterName, ...)

var counter = Meter.CreateCounter<int>(CounterName, Unit, Description);
var gauge = Meter.CreateObservableGauge<int>(CounterName, ()=>GetValue(), Unit, Description);

Logging

OpenTelemetry

Collector

Überblick

• Der Collector ist das zentrale Element von OpenTelemetry.
• Er sammelt, verarbeitet und leitet Telemetriedaten in einer Pipeline weiter.
• Die Ein- und Ausgänge der Pipelines folgen etablierten Standards, darunter Prometheus, Jaeger und Fluent Bit.
• Die Umstellung der Systeme auf den Collector kann schrittweise erfolgen.
• Unterstützung verschiedener CPU Architekturen
  u.a. x86/x64, PPC und ARM7/ARM64.
• Für verschiedene Betriebssysteme
  wie Windows, MacOS und Linux verfügbar.
• Die Konfiguration erfolgt in YAML oder CRD für den Operator.

Bestandteile

Receiver

Exporter

Processor

Extensions

Service / Pipelines

Konfiguration

receivers:
  otlp:
    protocols:
      grpc:{}
      http:{}
exporters:
  jaeger:
    endpoint: jaeger.fqdn:14250
extensions:
  health_check: {}
processors:
  batch: {}
service:
  extensions:
  - health_check
  pipelines:
    traces:
      exporters:
      - jaeger
      processors:
      - batch
      receivers:
      - otlp

Struktur

Beispielanwendung

Konfiguration

receivers:
  otlp:
    protocols:
      grpc: {}
processors:
  resource:
    attributes:
    - action: insert
      key: loki.resource.labels
      value: service.name
exporters:
  otlp/jeager:
    endpoint: jaeger-collector.jaeger:4317
    tls:
      insecure: true
  prometheus:
    endpoint: "${MY_POD_IP}:9090"
    send_timestamps: true
    metric_expiration: 15m
    resource_to_telemetry_conversion:
      enabled: true
  loki:
    endpoint: http://loki-write.loki:3100/loki/api/v1/push
  otlp/aspecto:
    endpoint: otelcol.aspecto.io:4317
    headers:
      Authorization: not-my-key
service:
  pipelines:
    logs:
      receivers:
        - otlp
      processors:
        - resource
      exporters:
        - loki
    metrics:
      receivers:
        - otlp
      exporters:
        - prometheus
    traces:
      receivers:
        - otlp
      exporters:
        - otlp/jeager
        - otlp/aspecto

OpenTelemetry

Metriken mit .NET

Überblick

• Metriken sind quantitative Daten, die normalerweise aggregiert werden.
• Sie dienen der Messung und Überwachung der Leistung
  und des Verhaltens eines Systems.
• Arten von Metriken sind u.a. Zähler, Messwerte und Histogramme.
• Beispiele für Metriken sind Anfragen pro Sekunde und die CPU-Auslastung.
• Metriken sind nützlich, um Trends, Muster und Engpässe
  in einer Anwendung zu erkennen.
• Es gibt umfassende Instrumentierungen für die .NET-Runtime,
  ASP.NET, gRPC und andere Frameworks.
• Die Konfiguration erfolgt über die Klasse MeterProviderBuilder.

Exporter

OpenTelemetry Exporter

Services.AddOpenTelemetry()
  .WithMetrics(mb => mb.AddOtlpExporter(opt =>  opt.Endpoint = new Uri(...)));

Prometheus Exporter

ASP.NET

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().WithMetrics(mb => mb.AddPrometheusExporter());
var app = builder.Build();
app.UseOpenTelemetryPrometheusScrapingEndpoint();

HTTP Listener

var meterProvider = Sdk.CreateMeterProviderBuilder()
  .AddMeter(MyMeter.Name)
  .AddPrometheusHttpListener(options => options.UriPrefixes =
        new string[] { "http://localhost:9090/" })
  .Build();

Meter

public const string MeterName = "fp.monitoring.workshop.instrumentationlibrary";
using Meter meter = new Meter(MeterName);

Services.AddOpenTelemetry().WithMetrics(mb =>  mb.AddMeter(MeterName));

Counter

Counter<int> executionCounter = meter.CreateCounter<int>("executions");
executionCounter.Add(1);

ObservableCounter<int> executionCounter = 
        meter.CreateCounter<int>("executions", ()=> QueryExecutions());

UpDownCounter

UpDownCounter-Metriken sind mit den Counter-Metriken vergleich. Abweichend sind Inkrementierung und Dekrementierung vorgesehen.

Beispiel: Länge einer Warteschlange

UpDownCounter<int> queryItemCounter = meter.CreateUpDownCounter<int>("query.lenght");
  queryItemCounter.Add(5);
  queryItemCounter.Add(-1);

ObservableUpDownCounter<int> queryLength = 
        meter.CreateObservableUpDownCounter<int>("query.lenght", ()=> MyQuery.Lenght);

Gauge

Gauge-Metriken können beliebige Zahlenwerte annehmen. Die Ermittlung des aktuellen Wertes erfolgt bei der Veröffentlichung der Metriken.
Je nach Aufwand ist ein Cache zu empfehlen.

Beispiele: aktueller RAM-Verbrauch, Anzahl Objekte im Lager.

meter.CreateObservableGauge("my_sample_gauge", observeValue: () => ObserveMyValue());

Histogram

Histogram-Metriken stellen die Verteilung von Zahlenwerten in Buckets dar.

Beispiel: Verarbeitungszeit je Anfrage.

Histogram<double> mySampleHistogram = meter.CreateHistogram<double>("my_sample_histogram");
mySampleHistogram.Record(14.5d);
mySampleHistogram.Record(67.1d);

Bucket-Boundaries

OpenTelemetry liefert einen Default für die Bucketgrenzen der Histogramme. Eigene Werte können ggf. in diesen Grenzen unzureichend abgebildet werden. Die Konfiguration eines View definiert eigene Bucket-Boundaries.

Services.AddOpenTelemetry().WithMetrics(mb =>{ ...
    mb.AddView("my_sample_histogram", 
    new ExplicitBucketHistogramConfiguration
    {
        Boundaries = new double[] {1, 2, 5, 10, 50, 100}
    });
});

Einheiten / Beschreibungen

Einheiten (Units) und Beschreibung (Descriptions) sind optionale Metadaten. Diese werden bei der Erstellung der Metriken angegeben.

UpDownCounter<int> queryLength = 
        meter.CreateUpDownCounter<int>("query.lenght","wi", "count of unprocessed work items");
meter.CreateObservableGauge("system.ram.free", 
        ()=>> querySystemRam(), "MiB", "amount of free system memory"); 

Label

Labels sind optionale Metadaten, die den jeweiligen Metrik-Wert näher beschreiben. Die Angabe erfolgt als 1 .. n Key-Value-Pair.

MyIntSampleCounter.Add(2, KeyValuePair.Create<string, object>("label1", value));

MySampleHistogram.Record(14.5d, new TagList{{"label1", 42}});     

meter.CreateObservableGauge("my.sample.gauge",              
  observeValue: () => new Measurement<int>(42,
      KeyValuePair.Create<string, object>("label2", "value2")));

OpenTelemetry

Tracing mit .NET

Überblick

• Tracing beschäftigt sich mit der Überwachung und Verfolgung
  von Anfragen und Transaktionen in Anwendungen und Diensten.
• Ziel ist die Erfassung der zeitlichen Abläufe,
  um Leistungsprobleme zu identifizieren.
• Es ermöglicht die Verfolgung von Anfragen über verschiedene Dienste hinweg und unterstützt die Fehlerdiagnose in verteilten Systemen.
• Die Verknüpfung des Anfragekontexts dient dazu,
  die Anfragen zu korrelieren.
• Spezieller Code muss in Anwendungen eingebettet werden,
  um das Tracing durchzuführen.
• Tracing mit OpenTelemetry und C# nutzt bestehende Strukturen (ActivitySource / Activity).

Sampler

• Sampler können dazu beitragen, den Overhead
  durch das Tracing zu reduzieren.
• Die Ausführung erfolgt vor der Erstellung der Activity / des Spans.
• Sampler verfügen nur über wenige Kontextinformationen zur Ausführung.
• Standard-Sampler umfassen:
  • AlwaysOnSampler
  • AlwaysOffSampler
  • ParentBasedSampler
  • TraceIdRatioBasedSampler
• Erstellung / Verwendung eigener Sampler kann performancekritisch sein.

Registrierung

Services.AddOpenTelemetry()
  .WithTracing(tb => 
  {
    tb.SetSampler(SAMPLER);
    tb.AddOtlpExporter(opt =>  opt.Endpoint = new Uri(...));
  });

Services.AddOpenTelemetry()
        .WithTracing(tb => 
        {
            ...
            tb.AddAspNetCoreInstrumentation();
            tb.AddHttpClientInstrumentation();
            tb.AddGrpcClientInstrumentation();
            ...
        });

ActivitySource

public const string ActivitySourceName = "fp.monitoring.workshop.instrumentationlibrary";
using myActivitySource = new ActivitySource(ActivitySourceName);

Services.AddOpenTelemetry()
  .WithTracing(tb => 
    {  tb.AddSource(ActivitySourceName);  });

Activity / Span

using var activity = ActivitySource.StartActivity(ActivityName);

Tags

Activity.Current?.SetTag("myKey", myValue)
var value = Activity.Current?.GetTagItem("myKey");

Status

Activity.Current?.SetStatus(ActivityStatusCode.Ok);
var status = Activity.Current?.GetStatus()

Activity Events

var activityEvent = new ActivityEvent("Something is happen...");
Activity.Current?.AddEvent(activityEvent);

Activity.Current?.RecordException(EXCEPTION);

OpenTelemetry

Logging mit .NET

Überblick

• Logging beinhaltet das Aufzeichnen von Ereignissen, Nachrichten, Fehlern oder Statusinformationen aus Anwendungen und Systemen.
• Jeder Eintrag ist mit einem Zeitpunkt versehen.
• Die Korrelation mehrerer Einträge kann durch künstliche
  Schlüssel oder den Zeitpunkt erfolgen.
• Die Protokollierung erfolgt in strukturierter oder unstrukturierter Form.
• Logging hilft dabei, Sicherheitsverletzungen zu erkennen und
  erleichtert die Einhaltung von Vorschriften und Richtlinien.
• Die Unterstützung für Logging wurde als letzter Bestandteil von OpenTelemetry in C# eingeführt.

Registrierung

var builder = WebApplication.CreateBuilder(args);
builder.Logging.ClearProviders();        
builder.Logging.AddOpenTelemetry(options =>
  {
    options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(ServiceName));
    otlpOptions.Endpoint = new Uri(...);
  }

Erstellung

public class MyClass()
{
    private ILogger<MyClass> _logger;
    public MyClass(ILogger<MyClass> logger)
    {
        _logger = logger;
    }
    public void DoSomething()
    {
        _logger.LogInformation("INFO");
    }
}

Vielen Dank für die Aufmerksamkeit