Observerbarhet med .NET 10 och OpenTelemetry: Från Noll till Aspire-Ready

using System.Diagnostics;
using System.Diagnostics.Metrics;

namespace EnterpriseTelemetry.Diagnostics;

public static class ApplicationDiagnostics
{
    // Namnet på tjänsten som identifierar oss i dashboards
    public const string ServiceName = "EnterpriseOrderApi";
    public const string ServiceVersion = "1.0.0";

    // Vår centrala källa för spårning (Tracing)
    public static class Orders
    {
        public const string SourceName = "Enterprise.Orders.Core";
        public static readonly ActivitySource Source = new(SourceName, ServiceVersion);
    }

    // Vår centrala källa för prestandamätning (Metrics)
    public static class Metrics
    {
        public const string MeterName = "Enterprise.Orders.Metrics";
        public static readonly Meter OrderMeter = new(MeterName, ServiceVersion);

        // Exempel på en global räknare för skapade ordrar
        public static readonly Counter<long> OrdersCreatedCounter =
            OrderMeter.CreateCounter<long>("orders.created.count", description: "Totalt antal skapade ordrar");
    }
}

using System.Diagnostics;
using System.Security.Claims;
using Microsoft.AspNetCore.Http;
using OpenTelemetry;

namespace EnterpriseTelemetry.Middleware;

public class TelemetryEnrichmentMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext context)
    {
        // Hämta aktiviteten som ASP.NET Core redan har startat för detta HTTP-anrop
        Activity? currentActivity = Activity.Current;

        if (currentActivity is not null && context.User.Identity?.IsAuthenticated == true)
        {
            // Extrahera information från användarens Claims (t.ex. från en JWT-token)
            string? userId = context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            string? tenantId = context.User.FindFirst("tenant_id")?.Value;

            if (userId is not null)
            {
                // Sätt en lokal tagg (syns på denna specifika spårning)
                currentActivity.SetTag("app.user.id", userId);
                // Sätt Baggage (skickas vidare över nätverket till nästa mikrotjänst)
                Baggage.SetBaggage("user.id", userId);
            }

            if (tenantId is not null)
            {
                currentActivity.SetTag("app.tenant.id", tenantId);
                Baggage.SetBaggage("tenant.id", tenantId);
            }
        }

        // Fortsätt till nästa steg i applikationens pipeline
        await next(context);
    }
}

using System.Diagnostics;
using EnterpriseTelemetry.Diagnostics;
using EnterpriseTelemetry.Middleware;
using EnterpriseTelemetry.Services;
using OpenTelemetry.Logs;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);

// 1. Konfigurera gemensam resursinformation för all telemetri
var resourceBuilder = ResourceBuilder.CreateDefault()
    .AddService(ApplicationDiagnostics.ServiceName, serviceVersion: ApplicationDiagnostics.ServiceVersion)
    .AddEnvironmentVariableDetector();

// 2. Konfigurera OpenTelemetry (Traces & Metrics)
builder.Services.OpenTelemetry()
    .WithResources(res => res.AddResource(resourceBuilder.Build()))
    .WithTracing(tracing =>
    {
        tracing
            .AddSource(ApplicationDiagnostics.Orders.SourceName) // Lyssna på vår anpassade källa
            .AddAspNetCoreInstrumentation(options => options.RecordException = true)
            .AddHttpClientInstrumentation()
            .AddOtlpExporter(); // Skickar data via standard OTLP (t.ex. till Aspire Dashboard)
    })
    .WithMetrics(metrics =>
    {
        metrics
            .AddMeter(ApplicationDiagnostics.Metrics.MeterName) // Lyssna på vår mätarklass
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddRuntimeInstrumentation() // CPU, minne, trådar helt gratis
            .AddOtlpExporter();
    });

// 3. Konfigurera OpenTelemetry Logging
builder.Logging.ClearProviders(); // Rensa standardleverantörer om du vill styra helt själv
builder.Logging.AddOpenTelemetry(options =>
{
    options.SetResourceBuilder(resourceBuilder);
    options.IncludeFormattedMessage = true;
    options.IncludeScopes = true; // Mycket viktigt! Gör att LogScopes och Baggage följer med i loggen
    options.ParseStateValues = true;
    options.AddOtlpExporter();
});

// Registrera våra egna tjänster
builder.Services.AddScoped<OrderProcessingService>();

var app = builder.Build();

app.UseHttpsRedirection();

// Registrera vår middleware EFTER auth men FÖRE endpoints
app.UseAuthentication();
app.UseAuthorization();
app.UseMiddleware<TelemetryEnrichmentMiddleware>();

// Enkel endpoint för att testa flödet
app.MapPost("/api/orders", async (OrderProcessingService orderContext) =>
{
    var orderId = Guid.NewGuid();
    await orderContext.CreateOrderAsync(orderId);
    return Results.Accepted($"/api/orders/{orderId}", new { Id = orderId });
});

app.Run();

using System.Diagnostics;
using EnterpriseTelemetry.Diagnostics;

namespace EnterpriseTelemetry.Services;

// Snygg och ren klassdefinition tack vare Primary Constructor i modern C#
public class OrderProcessingService(ILogger<OrderProcessingService> logger)
{
    public async Task CreateOrderAsync(Guid orderId)
    {
        // Starta en aktivitet (Span) för den här operationen.
        // Om ingen dashboard lyssnar blir 'activity' null automatiskt vilket sparar CPU/Minne.
        using Activity? activity = ApplicationDiagnostics.Orders.Source.StartActivity("CreateOrder");

        // Sätt sökbara taggar för spårningen
        activity?.SetTag("order.id", orderId.ToString());

        // Skriv en strukturerad logg. TraceId injiceras magiskt i bakgrunden!
        logger.LogInformation("Initierar skapande av order {OrderId}.", orderId);

        try
        {
            // Simulera validering och databasarbete
            await Task.Delay(80);
            activity?.AddEvent(new ActivityEvent("OrderValidatedInDatabase")); // Tidsstämplat delsteg

            await Task.Delay(40);

            // Öka vår globala Metric-räknare
            ApplicationDiagnostics.Metrics.OrdersCreatedCounter.Add(1,
                new KeyValuePair<string, object?>("order.status", "Success"));

            logger.LogInformation("Order {OrderId} sparades framgångsrikt i systemet.", orderId);
        }
        catch (Exception ex)
        {
            // Om något kraschar flaggar vi spåret som korrupt och loggar detaljerna
            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
            activity?.RecordException(ex);

            logger.LogError(ex, "Ett allvarligt fel inträffade vid skapande av order {OrderId}.", orderId);
            throw;
        }
    }
}