# Core Serilog + ASP.NET Core integration
dotnet add package Serilog.AspNetCore

# Read logger config from appsettings.json
dotnet add package Serilog.Settings.Configuration

# Sinks
dotnet add package Serilog.Sinks.Console
dotnet add package Serilog.Sinks.Seq
dotnet add package Serilog.Sinks.File

# Common enrichers
dotnet add package Serilog.Enrichers.Environment
dotnet add package Serilog.Enrichers.Process
dotnet add package Serilog.Enrichers.Thread

using Serilog;

// Bootstrap logger — used during startup, before the host is built.
// Catches any failure in Startup itself.
Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateBootstrapLogger();

try
{
    var builder = WebApplication.CreateBuilder(args);

    // Replace the default MEL provider with Serilog, and read the real
    // configuration from appsettings.json.
    builder.Host.UseSerilog((context, services, config) => config
        .ReadFrom.Configuration(context.Configuration)
        .ReadFrom.Services(services)
        .Enrich.FromLogContext());

    var app = builder.Build();

    // Adds request logging: one structured event per HTTP request with
    // method, path, status code, and elapsed ms.
    app.UseSerilogRequestLogging();

    app.MapGet("/", () => "Hello");
    app.Run();
}
catch (Exception ex)
{
    Log.Fatal(ex, "Application terminated unexpectedly");
}
finally
{
    Log.CloseAndFlush();
}

{
  "Serilog": {
    "Using": [
      "Serilog.Sinks.Console",
      "Serilog.Sinks.Seq",
      "Serilog.Sinks.File"
    ],
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "Microsoft.Hosting.Lifetime": "Information",
        "System": "Warning"
      }
    },
    "Enrich": [ "FromLogContext", "WithMachineName", "WithThreadId", "WithEnvironmentName" ],
    "Properties": {
      "Application": "OrderService"
    },
    "WriteTo": [
      { "Name": "Console" },
      {
        "Name": "File",
        "Args": {
          "path": "logs/app-.log",
          "rollingInterval": "Day",
          "retainedFileCountLimit": 14
        }
      },
      {
        "Name": "Seq",
        "Args": {
          "serverUrl": "https://seq.internal.example.com",
          "apiKey": "REPLACE_ME_WITH_APP_SPECIFIC_KEY"
        }
      }
    ]
  }
}

// Very first line of Program.cs, before any logger call
Serilog.Debugging.SelfLog.Enable(msg => Console.Error.WriteLine(msg));

_logger.LogInformation(
    "Charged {Amount} to card ending {Last4} for order {OrderId}",
    84.20m, "1234", 4211);

// In Seq you can now query:
//   Amount > 50 and Last4 = '1234'

var order = new { Id = 4211, Total = 84.20m, Items = 3 };

// Without @: "Placed order { Id = 4211, Total = 84.20, Items = 3 }"
_logger.LogInformation("Placed order {Order}", order);

// With @: Order becomes a nested object in Seq — queryable as Order.Total > 50
_logger.LogInformation("Placed order {@Order}", order);

_logger.LogInformation("User connected from {$Endpoint}", ipEndpoint);

using (LogContext.PushProperty("CustomerId", customerId))
using (LogContext.PushProperty("Correlation", Guid.NewGuid()))
{
    _logger.LogInformation("Processing checkout");   // has CustomerId + Correlation
    await _payments.ChargeAsync(...);                // any logs inside also have them
    _logger.LogInformation("Checkout complete");
}

using (_logger.BeginScope(new Dictionary<string, object>
{
    ["CustomerId"] = customerId,
    ["Correlation"] = correlationId
}))
{
    _logger.LogInformation("Processing checkout");
}

"Enrich": [
  "FromLogContext",
  "WithMachineName",
  "WithEnvironmentName",
  "WithProcessId",
  "WithThreadId"
]

"Properties": {
  "Application": "OrderService",
  "Version": "3.2.1"
}

public sealed class HttpContextEnricher : ILogEventEnricher
{
    private readonly IHttpContextAccessor _accessor;
    public HttpContextEnricher(IHttpContextAccessor accessor) => _accessor = accessor;

    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory pf)
    {
        var http = _accessor.HttpContext;
        if (http is null) return;

        logEvent.AddPropertyIfAbsent(pf.CreateProperty("RequestPath",   http.Request.Path.Value));
        logEvent.AddPropertyIfAbsent(pf.CreateProperty("RequestMethod", http.Request.Method));

        var user = http.User?.Identity?.Name;
        if (!string.IsNullOrEmpty(user))
            logEvent.AddPropertyIfAbsent(pf.CreateProperty("User", user));
    }
}

// Program.cs
builder.Services.AddHttpContextAccessor();
builder.Services.AddSingleton<ILogEventEnricher, HttpContextEnricher>();

// The .ReadFrom.Services(services) call in your Serilog setup
// picks up any ILogEventEnricher registered in DI.

public sealed class BuildInfoEnricher : ILogEventEnricher
{
    private static readonly string _version =
        typeof(BuildInfoEnricher).Assembly.GetName().Version?.ToString() ?? "0.0.0";
    private static readonly string _commit =
        Environment.GetEnvironmentVariable("GIT_COMMIT") ?? "local";

    public void Enrich(LogEvent e, ILogEventPropertyFactory pf)
    {
        e.AddPropertyIfAbsent(pf.CreateProperty("AppVersion", _version));
        e.AddPropertyIfAbsent(pf.CreateProperty("GitCommit", _commit));
    }
}

{
  "Name": "Seq",
  "Args": {
    "serverUrl": "https://seq.internal.example.com",
    "apiKey": "REPLACE_ME",
    "restrictedToMinimumLevel": "Information",
    "batchPostingLimit": 500,
    "period": "00:00:02",
    "bufferBaseFilename": "./logs/seq-buffer/buffer",
    "bufferSizeLimitBytes": 268435456
  }
}

.WriteTo.Seq(
    serverUrl:                "https://seq.internal.example.com",
    apiKey:                    builder.Configuration["Seq:ApiKey"],
    restrictedToMinimumLevel:  LogEventLevel.Information,
    bufferBaseFilename:        "./logs/seq-buffer/buffer")

Application:  OrderService
Environment:  Production
Team:         Fulfilment
Datacenter:   eu-west-1

# Everything from OrderService in prod
Application = 'OrderService' and Environment = 'Production'

# All errors from any app on the Payments team
Team = 'Payments' and @Level = 'Error'

# One customer's activity across every service
CustomerId = 'cus_42' and Environment = 'Production'

# Compare error rates: two apps side by side
Application in ['OrderService', 'PaymentApi'] and @Level in ['Error', 'Fatal']

// appsettings.json still declares the Seq sink, but the apiKey stays out.
// We inject it from configuration/env vars at bootstrap.

builder.Host.UseSerilog((context, services, config) =>
{
    config
        .ReadFrom.Configuration(context.Configuration)
        .ReadFrom.Services(services)
        .Enrich.FromLogContext();

    // Override the API key from a secure source.
    var apiKey = context.Configuration["Seq:ApiKey"];
    if (string.IsNullOrEmpty(apiKey))
        throw new InvalidOperationException("Seq API key is not configured.");

    config.WriteTo.Seq(
        serverUrl: context.Configuration["Seq:ServerUrl"]!,
        apiKey:    apiKey,
        bufferBaseFilename: "./logs/seq-buffer/buffer");
});

public sealed class CorrelationMiddleware
{
    private const string Header = "X-Correlation-ID";
    private readonly RequestDelegate _next;
    public CorrelationMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext ctx)
    {
        var correlationId = ctx.Request.Headers.TryGetValue(Header, out var v)
            && !string.IsNullOrWhiteSpace(v)
                ? v.ToString()
                : Guid.NewGuid().ToString("N");

        ctx.Response.Headers[Header] = correlationId;

        using (LogContext.PushProperty("CorrelationId", correlationId))
        using (LogContext.PushProperty("TraceId", Activity.Current?.TraceId.ToString()))
        {
            await _next(ctx);
        }
    }
}

// Program.cs
app.UseMiddleware<CorrelationMiddleware>();
app.UseSerilogRequestLogging();  // request logging sees the correlation too

public sealed class CorrelationHandler : DelegatingHandler
{
    private readonly IHttpContextAccessor _accessor;
    public CorrelationHandler(IHttpContextAccessor accessor) => _accessor = accessor;

    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken ct)
    {
        var correlationId = _accessor.HttpContext?.Response.Headers["X-Correlation-ID"].ToString();
        if (!string.IsNullOrEmpty(correlationId))
            request.Headers.TryAddWithoutValidation("X-Correlation-ID", correlationId);
        return base.SendAsync(request, ct);
    }
}

// Program.cs
builder.Services.AddHttpContextAccessor();
builder.Services.AddTransient<CorrelationHandler>();
builder.Services
    .AddHttpClient("payments", c => c.BaseAddress = new Uri("https://payments.internal"))
    .AddHttpMessageHandler<CorrelationHandler>();

CorrelationId = '9f2b8d1c4e7a4a67b1'

var levelSwitch = new LoggingLevelSwitch(LogEventLevel.Information);

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.ControlledBy(levelSwitch)
    .Enrich.FromLogContext()
    .WriteTo.Seq(
        serverUrl:          "https://seq.internal.example.com",
        apiKey:              apiKey,
        controlLevelSwitch:  levelSwitch)   // Seq now controls this
    .CreateLogger();

"MinimumLevel": {
  "Default": "Information",
  "Override": {
    "Microsoft.AspNetCore.Mvc":           "Warning",
    "Microsoft.EntityFrameworkCore":      "Warning",
    "Microsoft.AspNetCore.Hosting":       "Warning",
    "Microsoft.AspNetCore.Routing":       "Warning",
    "System.Net.Http.HttpClient":         "Warning"
  }
}

public sealed class CustomerDestructurer : IDestructuringPolicy
{
    public bool TryDestructure(object value, ILogEventPropertyValueFactory f, out LogEventPropertyValue? result)
    {
        if (value is not Customer c) { result = null; return false; }
        result = f.CreatePropertyValue(new
        {
            c.Id,
            EmailMasked = Mask(c.Email),
            // Password, SSN, etc: not included at all
        }, destructureObjects: true);
        return true;
    }

    private static string Mask(string s) =>
        s.Length < 4 ? "***" : s[..2] + "***" + s[^2..];
}

// Serilog config
.Destructure.With<CustomerDestructurer>()