using (_logger.TimeDebug("Sending notification to Slack channel {Channel} with {WebhookUrl}", _slackOptions.Channel, _slackOptions.WebhookUrl))using (_metrics.TimeIO("http", "slack", "send_message")){
}

public TheThing(ILogger logger){    _logger = logger?.ForContext<TheThing>() ?? throw new ArgumentNullException(nameof(_logger));}

HTTP POST /payments responded 201 in 1348.6188 ms

public void Configure(IApplicationBuilder app){    app.UseHealthAndMetricsMiddleware();    app.UseSerilogRequestLogging();    app.UseAuthentication();    app.UseMvc();}

public static string GetMetricsCurrentResourceName(this HttpContext httpContext){    if (httpContext == null)        throw new ArgumentNullException(nameof(httpContext));
    Endpoint endpoint = httpContext.Features.Get<IEndpointFeature>()?.Endpoint;
#if NETCOREAPP3_1    return endpoint?.Metadata.GetMetadata<EndpointNameMetadata>()?.EndpointName;#else    return endpoint?.Metadata.GetMetadata<IRouteValuesAddressMetadata>()?.RouteName;#endif}

{  "Serilog": {    "Using": [      "Serilog.Sinks.Console"    ],    "MinimumLevel": {      "Default": "Information"    },    "WriteTo": [      {        "Name": "Console"      }    ],    "Enrich": [      "FromLogContext",      "WithMachineName"    ],    "Properties": {      "ApplicationName": "Gateway API"    }  }}

loggerConfiguration.ReadFrom.Configuration(hostContext.Configuration)    .EnrichWithEventType()    .Enrich.WithProperty("Version", ReflectionUtils.GetAssemblyVersion<Program>());

public static string GetCorrelationId(this HttpContext httpContext){    httpContext.Request.Headers.TryGetValue("Cko-Correlation-Id", out StringValues correlationId);    return correlationId.FirstOrDefault() ?? httpContext.TraceIdentifier;}

public class RequestLogContextMiddleware{    private readonly RequestDelegate _next;
    public RequestLogContextMiddleware(RequestDelegate next)    {        _next = next;    }
    public Task Invoke(HttpContext context)    {        using (LogContext.PushProperty("CorrelationId", context.GetCorrelationId()))        {            return _next.Invoke(context);        }    }}

_logger.Information("Storing payment state in Couchbase for Payment ID {PaymentId} and current state {State}", paymentId, state);

_logger    .ForContext("PaymentId", paymentId)    .ForContext("State", state)    .Information("Storing payment state in Couchbase");

_logger.Information("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);

Log.Information("The time is " + DateTime.Now);

Log.Information("The time is {Now}", DateTime.Now);

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();    }

public static IHostBuilder CreateHostBuilder(string[] args) =>    Host.CreateDefaultBuilder(args)        .UseSerilog((hostContext, loggerConfiguration) =>        {            loggerConfiguration.ReadFrom.Configuration(hostContext.Configuration);        })        .ConfigureAppConfiguration((hostingContext, config) =>        {            config                .AddEnvironmentVariables(prefix: "FLOW_")                .AddAwsSecrets();        })        .ConfigureWebHostDefaults(webBuilder =>        {            webBuilder.UseStartup<Startup>();          });

{  "Serilog": {    "Using": [      "Serilog.Sinks.Console",      "Serilog.Sinks.Datadog.Logs"    ],    "MinimumLevel": {      "Default": "Information"    },    "WriteTo": [      {        "Name": "Console"      }    ],    "Enrich": [      "FromLogContext",      "WithMachineName"    ],    "Properties": {      "ApplicationName": "Flow API"    }  }}

version: "3.5"
services:
seq:    image: datalust/seq:latest    container_name: seq    ports:    - '5341:80'    environment:    - ACCEPT_EULA=Y    networks:    - gateway-network
networks:gateway-network:    name: gateway-network

{  "Serilog": {    "Using": [      "Serilog.Sinks.Console",      "Serilog.Sinks.Seq"    ],    "MinimumLevel": {      "Default": "Debug",      "Override": {        "Microsoft": "Warning"      }    },    "WriteTo": [      {        "Name": "Console"      },      {        "Name": "Seq",        "Args": {          "serverUrl": "http://localhost:5341",          "apiKey": "none"        }      }    ]  }}

internal class EventTypeEnricher : ILogEventEnricher{    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)    {        if (logEvent is null)            throw new ArgumentNullException(nameof(logEvent));
        if (propertyFactory is null)            throw new ArgumentNullException(nameof(propertyFactory));
        Murmur32 murmur = MurmurHash.Create32();        byte[] bytes = Encoding.UTF8.GetBytes(logEvent.MessageTemplate.Text);        byte[] hash = murmur.ComputeHash(bytes);        string hexadecimalHash = BitConverter.ToString(hash).Replace("-", "");        LogEventProperty eventId = propertyFactory.CreateProperty("EventType", hexadecimalHash);        logEvent.AddPropertyIfAbsent(eventId);    }}

public class PropertyBagEnricher : ILogEventEnricher{    private readonly Dictionary<string, Tuple<object, bool>> _properties;
    /// <summary>    /// Creates a new <see cref="PropertyBagEnricher" /> instance.    /// </summary>    public PropertyBagEnricher()    {        _properties = new Dictionary<string, Tuple<object, bool>>(StringComparer.OrdinalIgnoreCase);    }
    /// <summary>    /// Enriches the <paramref name="logEvent" /> using the values from the property bag.    /// </summary>    /// <param name="logEvent">The log event to enrich.</param>    /// <param name="propertyFactory">The factory used to create the property.</param>    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)    {        foreach (KeyValuePair<string, Tuple<object, bool>> prop in _properties)        {            logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(prop.Key, prop.Value.Item1, prop.Value.Item2));        }    }
    /// <summary>    /// Add a property that will be added to all log events enriched by this enricher.    /// </summary>    /// <param name="key">The property key.</param>    /// <param name="value">The property value.</param>    /// <param name="destructureObject">    /// Whether to destructure the value. See https://github.com/serilog/serilog/wiki/Structured-Data    /// </param>    /// <returns>The enricher instance, for chaining Add operations together.</returns>    public PropertyBagEnricher Add(string key, object value, bool destructureObject = false)    {        if (string.IsNullOrEmpty(key)) throw new ArgumentNullException(nameof(key));
        if (!_properties.ContainsKey(key)) _properties.Add(key, Tuple.Create(value, destructureObject));
        return this;    }}

_logger    .ForContext(      new PropertyBagEnricher()        .Add("ResponseCode", response?.ResponseCode)        .Add("EnrollmentStatus", response?.Enrolled)    )    .Warning("Malfunction when processing 3DS enrollment verification");

public static class LogEnricher{    /// <summary>    /// Enriches the HTTP request log with additional data via the Diagnostic Context    /// </summary>    /// <param name="diagnosticContext">The Serilog diagnostic context</param>    /// <param name="httpContext">The current HTTP Context</param>    public static void EnrichFromRequest(IDiagnosticContext diagnosticContext, HttpContext httpContext)    {        diagnosticContext.Set("ClientIP", httpContext.Connection.RemoteIpAddress.ToString());        diagnosticContext.Set("UserAgent", httpContext.Request.Headers["User-Agent"].FirstOrDefault());        diagnosticContext.Set("Resource", httpContext.GetMetricsCurrentResourceName());    }}

app.UseSerilogRequestLogging(opts  => opts.EnrichDiagnosticContext = LogEnricher.EnrichFromRequest);