### Example Serilog Output

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

This is an example of the log output you might see with Serilog configured for ASP.NET Core, including application start messages and request information.

```text
[12:01:43 INF] Starting web application
[12:01:44 INF] Now listening on: http://localhost:5000
[12:01:44 INF] Application started. Press Ctrl+C to shut down.
[12:01:44 INF] Hosting environment: Development
[12:01:44 INF] Content root path: serilog-aspnetcore/samples/Sample
[12:01:47 WRN] Failed to determine the https port for redirect.
[12:01:47 INF] Hello, world!
[12:01:47 INF] HTTP GET / responded 200 in 95.0581 ms
```

--------------------------------

### Add Serilog.AspNetCore NuGet Package

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Install the Serilog.AspNetCore NuGet package using the .NET CLI.

```shell
dotnet add package Serilog.AspNetCore
```

--------------------------------

### Two-Stage Initialization with Bootstrap Logger

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Implement two-stage initialization by creating a temporary bootstrap logger for startup errors, then replacing it with a fully-configured logger once ASP.NET Core services are available. This allows access to configuration and DI for the final logger setup.

```csharp
using Serilog;
using Serilog.Events;

// Bootstrap logger for startup - catches early errors
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    .CreateBootstrapLogger();

Log.Information("Starting up!");

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

    // Replace bootstrap logger with fully-configured logger
    builder.Services.AddSerilog((services, lc) => lc
        .ReadFrom.Configuration(builder.Configuration)
        .ReadFrom.Services(services)
        .Enrich.FromLogContext()
        .WriteTo.Console());

    builder.Services.AddControllersWithViews();

    var app = builder.Build();
    app.UseSerilogRequestLogging();
    app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");

    await app.RunAsync();
    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "An unhandled exception occurred during bootstrapping");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}
```

--------------------------------

### Configure Minimum Log Levels for ASP.NET Core Sources

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Set the minimum level for noisy ASP.NET Core log sources to Warning to reduce log verbosity. This configuration is typically done in logger setup or appsettings.json.

```csharp
.MinimumLevel.Override("Microsoft.AspNetCore.Hosting", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Mvc", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Routing", LogEventLevel.Warning)
```

--------------------------------

### Configure Bootstrap Logger

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Use CreateBootstrapLogger to initialize logging before the host is fully loaded, allowing for early exception capture.

```csharp
using Serilog;
using Serilog.Events;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    .CreateBootstrapLogger(); // <-- Change this line!
```

--------------------------------

### Configure Serilog via appsettings.json

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Enables runtime configuration changes and environment-specific settings using the Serilog.Settings.Configuration package.

```json
{
  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft.AspNetCore.Mvc": "Warning",
        "Microsoft.AspNetCore.Routing": "Warning",
        "Microsoft.AspNetCore.Hosting": "Warning",
        "System.Net.Http.HttpClient": "Warning"
      }
    },
    "WriteTo": [
      {
        "Name": "Console",
        "Args": {
          "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"
        }
      },
      {
        "Name": "File",
        "Args": {
          "path": "./logs/app-.txt",
          "rollingInterval": "Day",
          "retainedFileCountLimit": 7,
          "fileSizeLimitBytes": 10485760,
          "rollOnFileSizeLimit": true
        }
      }
    ],
    "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId"]
  }
}
```

--------------------------------

### Configure Minimum Level Overrides in C#

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Reduces verbose framework logging while maintaining application-level detail. Requires Serilog.AspNetCore.

```csharp
using Serilog;
using Serilog.Events;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    // Suppress noisy ASP.NET Core framework logs
    .MinimumLevel.Override("Microsoft.AspNetCore.Hosting", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Mvc", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Routing", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.StaticFiles", LogEventLevel.Warning)
    // Keep Entity Framework SQL logging at Information for debugging
    .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Information)
    .Enrich.FromLogContext()
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {SourceContext}: {Message:lj}{NewLine}{Exception}")
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSerilog();

var app = builder.Build();
app.UseSerilogRequestLogging();
app.UseStaticFiles(); // Static file requests won't generate verbose logs
app.MapControllers();
app.Run();
```

--------------------------------

### Read Serilog Configuration in Program.cs

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Initializes Serilog to read settings from the application configuration provider.

```csharp
// Program.cs - Read configuration from appsettings.json
using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateBootstrapLogger();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSerilog((services, lc) => lc
    .ReadFrom.Configuration(builder.Configuration)
    .ReadFrom.Services(services));

var app = builder.Build();
app.UseSerilogRequestLogging();
app.Run();
```

--------------------------------

### Configure Serilog in Program.cs

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Configure Serilog before building the application and add `builder.Services.AddSerilog()` to integrate Serilog with ASP.NET Core's logging pipeline. A try-catch block is recommended for robust configuration.

```csharp
using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateLogger();

try
{
    Log.Information("Starting web application");

    var builder = WebApplication.CreateBuilder(args);
    builder.Services.AddSerilog(); // <-- Add this line
    
    var app = builder.Build();
    app.MapGet("/", () => "Hello World!");

    app.Run();
}
catch (Exception ex)
{
    Log.Fatal(ex, "Application terminated unexpectedly");
}
finally
{
    Log.CloseAndFlush();
}
```

--------------------------------

### Configure JSON Output

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Enable newline-delimited JSON output by passing a formatter to the sink configuration.

```csharp
    .WriteTo.Console(new RenderedCompactJsonFormatter())
```

--------------------------------

### Configure Final Logger with Services

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Pass a callback to AddSerilog to finalize the logger configuration using host services and configuration.

```csharp
builder.Services.AddSerilog((services, lc) => lc
    .ReadFrom.Configuration(builder.Configuration)
    .ReadFrom.Services(services)
    .Enrich.FromLogContext()
    .WriteTo.Console());
```

--------------------------------

### Implement JSON Structured Logging

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Configures Serilog to output logs in compact JSON format, suitable for log aggregation tools.

```csharp
using Serilog;
using Serilog.Formatting.Compact;

Log.Logger = new LoggerConfiguration()
    .Enrich.FromLogContext()
    .Enrich.WithProperty("Application", "MyWebApp")
    .Enrich.WithProperty("Environment", Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"))
    // Console output in compact JSON format
    .WriteTo.Console(new CompactJsonFormatter())
    // File output with rendered messages (includes formatted message text)
    .WriteTo.File(
        new RenderedCompactJsonFormatter(),
        "logs/app.json",
        rollingInterval: RollingInterval.Day)
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSerilog();

var app = builder.Build();
app.UseSerilogRequestLogging();

app.MapGet("/api/process", (ILogger<Program> logger) =>
{
    logger.LogInformation("Processing request with {ItemCount} items", 42);
    return Results.Ok(new { processed = 42 });
});

app.Run();

// JSON output:
// {"@t":"2024-01-15T10:30:45.1234567Z","@mt":"Processing request with {ItemCount} items","ItemCount":42,"Application":"MyWebApp","Environment":"Production"}
// {"@t":"2024-01-15T10:30:45.2345678Z","@mt":"HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms","RequestMethod":"GET","RequestPath":"/api/process","StatusCode":200,"Elapsed":15.6789}
```

--------------------------------

### Push Properties to Log Context

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Add properties to log events using either Microsoft.Extensions.Logging scopes or Serilog's LogContext.

```csharp
// Microsoft.Extensions.Logging ILogger<T>
// Yes, it's required to use a dictionary. See https://nblumhardt.com/2016/11/ilogger-beginscope/
using (logger.BeginScope(new Dictionary<string, object>
{
    ["UserId"] = "svrooij",
    ["OperationType"] = "update",
}))
{
   // UserId and OperationType are set for all logging events in these brackets
}
```

```csharp
// Serilog LogContext
using (LogContext.PushProperty("UserId", "svrooij"))
using (LogContext.PushProperty("OperationType", "update"))
{
    // UserId and OperationType are set for all logging events in these brackets
}
```

--------------------------------

### Customize Request Logging Options

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Configure Serilog's request logging middleware by customizing the message template, defining dynamic log levels, enriching diagnostic context, and optionally including the query string in the request path.

```csharp
using Serilog;
using Serilog.Events;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSerilog();

var app = builder.Build();

app.UseSerilogRequestLogging(options =>
{
    // Customize the message template
    options.MessageTemplate = "HTTP {RequestMethod} {RequestPath} [{StatusCode}] in {Elapsed:0.0000}ms - Host: {RequestHost}";

    // Determine log level based on response status and exceptions
    options.GetLevel = (httpContext, elapsed, ex) =>
    {
        if (ex != null) return LogEventLevel.Error;
        if (httpContext.Response.StatusCode >= 500) return LogEventLevel.Error;
        if (httpContext.Response.StatusCode >= 400) return LogEventLevel.Warning;
        if (elapsed > 5000) return LogEventLevel.Warning; // Slow requests
        return LogEventLevel.Information;
    };

    // Add additional properties to the request completion event
    options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
    {
        diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
        diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);
        diagnosticContext.Set("UserAgent", httpContext.Request.Headers["User-Agent"].ToString());
        diagnosticContext.Set("ClientIP", httpContext.Connection.RemoteIpAddress?.ToString());
    };

    // Include query string in logged path
    options.IncludeQueryInRequestPath = true;
});

app.MapGet("/search", (string q) => $
```

```csharp
Results for: {q}");
app.Run();

// Output for GET /search?q=serilog:
// [16:05:54 INF] HTTP GET /search?q=serilog [200] in 5.1234ms - Host: localhost:5000

```

--------------------------------

### Configure Azure Diagnostics Log Stream

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Enable Azure diagnostics by configuring the file sink with shared access and specific flush intervals.

```csharp
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    // Add this line:
    .WriteTo.File(
       System.IO.Path.Combine(Environment.GetEnvironmentVariable("HOME"), "LogFiles", "Application", "diagnostics.txt"),
       rollingInterval: RollingInterval.Day,
       fileSizeLimitBytes: 10 * 1024 * 1024,
       retainedFileCountLimit: 2,
       rollOnFileSizeLimit: true,
       shared: true,
       flushToDiskInterval: TimeSpan.FromSeconds(1))
    .CreateLogger();
```

--------------------------------

### Customize Serilog Request Logging Options

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Configure advanced options for Serilog request logging, including modifying the message template, changing the event level, and enriching the diagnostic context with custom properties.

```csharp
app.UseSerilogRequestLogging(options =>
{
    // Customize the message template
    options.MessageTemplate = "Handled {RequestPath}";
    
    // Emit debug-level events instead of the defaults
    options.GetLevel = (httpContext, elapsed, ex) => LogEventLevel.Debug;
    
    // Attach additional properties to the request completion event
    options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
    {
        diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
        diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);
    };
});
```

--------------------------------

### Configure Azure Diagnostics Log Stream with Serilog File Sink

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Configure Serilog to write logs to a file in the Azure App Service diagnostics log directory, using `shared: true` and `flushToDiskInterval` for near real-time log visibility in the Azure portal.

```csharp
using Serilog;
using Serilog.Events;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    // Azure Diagnostics Log Stream - writes to D:\home\LogFiles\
    .WriteTo.File(
        Path.Combine(Environment.GetEnvironmentVariable("HOME") ?? ".", "LogFiles", "Application", "diagnostics.txt"),
        rollingInterval: RollingInterval.Day,
        fileSizeLimitBytes: 10 * 1024 * 1024,  // 10 MB
        retainedFileCountLimit: 2,
        rollOnFileSizeLimit: true,
        shared: true,                           // Required for Azure
        flushToDiskInterval: TimeSpan.FromSeconds(1))  // Frequent flushing for real-time viewing
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSerilog();

var app = builder.Build();
app.UseSerilogRequestLogging();
app.MapControllers();
app.Run();
```

--------------------------------

### Register Serilog Services with AddSerilog()

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Register Serilog as the logging provider for ASP.NET Core's dependency injection container. This ensures all ILogger<T> calls are routed through Serilog. Ensure Log.CloseAndFlush() is called in the finally block.

```csharp
using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateLogger();

try
{
    Log.Information("Starting web application");

    var builder = WebApplication.CreateBuilder(args);

    // Register Serilog as the logging provider
    builder.Services.AddSerilog();

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

--------------------------------

### Add Serilog Request Logging Middleware

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Integrate the Serilog request logging middleware into your ASP.NET Core application pipeline. Ensure this call precedes handlers like MVC for proper logging and timing.

```csharp
var app = builder.Build();

    app.UseSerilogRequestLogging(); // <-- Add this line

    // Other app configuration
```

--------------------------------

### UseSerilogRequestLogging Middleware

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Add the UseSerilogRequestLogging middleware to condense ASP.NET Core request logging into a single event per request. Place this middleware before handlers you wish to log.

```csharp
using Serilog;
using Serilog.Events;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSerilog();

var app = builder.Build();

// Add request logging middleware - place before handlers to log
app.UseSerilogRequestLogging();

app.MapGet("/api/users", () => new[] { "Alice", "Bob" });
app.MapGet("/api/health", () => "OK");

app.Run();

// Output for GET /api/users:
// [16:05:54 INF] HTTP GET /api/users responded 200 in 12.3456 ms

// JSON output format (with CompactJsonFormatter):
// {
//   "@t": "2019-06-26T06:05:54.6881162Z",
//   "@mt": "HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms",
//   "RequestMethod": "GET",
//   "RequestPath": "/api/users",
//   "StatusCode": 200,
//   "Elapsed": 12.3456,
//   "RequestId": "0HLNPVG1HI42T:00000001",
//   "ConnectionId": "0HLNPVG1HI42T"
// }
```

--------------------------------

### Add Scoped Properties with LogContext in ASP.NET Core

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Use `LogContext.PushProperty` to add properties like CorrelationId and UserId to all log events within a specific scope, such as an HTTP request. Ensure `Enrich.FromLogContext()` is configured in Serilog.

```csharp
using Serilog;
using Serilog.Context;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSerilog ((services, lc) => lc
    .Enrich.FromLogContext() // Required for LogContext properties
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u}] [{UserId}] [{CorrelationId}] {Message:lj}{NewLine}{Exception}"));

var app = builder.Build();
app.UseSerilogRequestLogging();

app.Use(async (context, next) =>
{
    // Add correlation ID to all logs within this request
    var correlationId = context.Request.Headers["X-Correlation-ID"].FirstOrDefault()
        ?? Guid.NewGuid().ToString("N")[..8];

    using (LogContext.PushProperty("CorrelationId", correlationId))
    using (LogContext.PushProperty("UserId", context.User?.Identity?.Name ?? "anonymous"))
    {
        context.Response.Headers["X-Correlation-ID"] = correlationId;
        await next();
    }
});

app.MapGet("/api/orders", (ILogger<Program> logger) =>
{
    logger.LogInformation("Fetching orders");
    logger.LogInformation("Found {OrderCount} orders", 5);
    return Results.Ok();
});

app.Run();

// Output (all events share the same CorrelationId and UserId):
// [10:30:45 INF] [user@example.com] [a1b2c3d4] Fetching orders
// [10:30:45 INF] [user@example.com] [a1b2c3d4] Found 5 orders
// [10:30:45 INF] [user@example.com] [a1b2c3d4] HTTP GET /api/orders responded 200 in 23.4567 ms
```

--------------------------------

### Add Properties During Request Processing with IDiagnosticContext

Source: https://context7.com/serilog/serilog-aspnetcore/llms.txt

Utilize the `IDiagnosticContext` service to add custom properties to the request completion log event from anywhere within your request processing logic. These properties are automatically included in the final log event.

```csharp
using Microsoft.AspNetCore.Mvc;
using Serilog;

public class OrdersController : Controller
{
    private readonly ILogger<OrdersController> _logger;
    private readonly IDiagnosticContext _diagnosticContext;
    private readonly IOrderService _orderService;

    public OrdersController(
        ILogger<OrdersController> logger,
        IDiagnosticContext diagnosticContext,
        IOrderService orderService)
    {
        _logger = logger;
        _diagnosticContext = diagnosticContext;
        _orderService = orderService;
    }

    [HttpGet("/orders/{id}")]
    public async Task<IActionResult> GetOrder(int id)
    {
        // These properties will appear in the request completion event
        _diagnosticContext.Set("OrderId", id);

        var stopwatch = Stopwatch.StartNew();
        var order = await _orderService.GetOrderAsync(id);
        stopwatch.Stop();

        _diagnosticContext.Set("DatabaseQueryTime", stopwatch.ElapsedMilliseconds);
        _diagnosticContext.Set("OrderStatus", order?.Status ?? "NotFound");
        _diagnosticContext.Set("CustomerId", order?.CustomerId);

        if (order == null)
        {
            _logger.LogWarning("Order {OrderId} not found", id);
            return NotFound();
        }

        return Ok(order);
    }
}

// Request completion log event includes all diagnostic context properties:
// {
//   "@t": "2024-01-15T10:30:45.123Z",
//   "@mt": "HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms",
//   "RequestMethod": "GET",
//   "RequestPath": "/orders/12345",
//   "StatusCode": 200,
//   "Elapsed": 45.6789,
//   "OrderId": 12345,
//   "DatabaseQueryTime": 23,
//   "OrderStatus": "Shipped",
//   "CustomerId": 9876
// }

```

--------------------------------

### Enrich Request Log Events with Custom Properties

Source: https://github.com/serilog/serilog-aspnetcore/blob/dev/README.md

Use IDiagnosticContext.Set() within your application logic to attach custom properties to the request completion log event. This helps in correlating request details with other data.

```csharp
public class HomeController : Controller
    {
        readonly IDiagnosticContext _diagnosticContext;

        public HomeController(IDiagnosticContext diagnosticContext)
        {
            _diagnosticContext = diagnosticContext ??
                throw new ArgumentNullException(nameof(diagnosticContext));
        }

        public IActionResult Index()
        {
            // The request completion event will carry this property
            _diagnosticContext.Set("CatalogLoadTime", 1423);

            return View();
        }
    }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.