Adding Serilog stops Sentry from reporting Scope properties

[georgiosd]

Package

Sentry.Serilog

.NET Flavor

.NET Core

.NET Version

8.0.0

OS

Windows

SDK Version

4.10.1

Self-Hosted Sentry Version

No response

Steps to Reproduce

Scaffold new project:

dotnet new webapi -o SentryScopeApi

Edit .csproj:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Sentry.AspNetCore" Version="4.10.1" />
    <PackageReference Include="Sentry.Serilog" Version="4.10.1" />
    <PackageReference Include="Serilog.AspNetCore" Version="8.0.2" />
  </ItemGroup>

</Project>

Edit Program.cs

using Serilog;

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

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseSentry(s =>
{
    s.Dsn = "...";
});

builder.Services.AddSerilog(s => s.WriteTo.Sentry()); // if we remove this, it all goes according to plan

var app = builder.Build();

var logger = app.Services.GetRequiredService<ILogger<Program>>();
var sentry = app.Services.GetRequiredService<IHub>();

using (logger.BeginScope(new Dictionary<string, object> { ["Key1"] = "Value" }))
{
    sentry.CaptureException(new InvalidOperationException(DateTime.Now.ToString()));
}

app.Run();

Expected Result

Sentry issue contains "Key1" value.

Actual Result

Sentry issue does not contain "Key1" value.

[georgiosd]

Would be great if the fix (or a workaround) was ported for use with net6.0 projects.

[bruno-garcia]

Thanks for reporting. net6.0 is still supported by the main line so should be ok to add the fix to it too

[jamescrosswell]

I think I can see why this happens. When using MEL, we register SentryLogger which overrides the BeginScope method like so:

sentry-dotnet/src/Sentry.Extensions.Logging/SentryLogger.cs

Lines 26 to 31 in eb73e2e

	#if NET8_0_OR_GREATER
	public IDisposable BeginScope<TState>(TState state) where TState : notnull
	=> _hub.PushScope(state);
	#else
	public IDisposable BeginScope<TState>(TState state) => _hub.PushScope(state);
	#endif

Effectively that provides a way to synchronize the scope between MEL and Sentry.

In the case of the SeriLog integration, SeriLog provides the Logger and we merely implement a Sink for SeriLog... so the scope doesn't get synced.

We'll see if we can find an alternate way to sync the scope in Serilog (hopefully it has some hooks or something that we could use).

[georgiosd]

That would be great :) For now I solved it by creating a scope in both Serilog and Sentry.

[jamescrosswell]

We'll see if we can find an alternate way to sync the scope in Serilog (hopefully it has some hooks or something that we could use).

This doesn't appear to be possible.

The implementation of SerilogLogger.BeginScope simply delegates to the logger provider:

    public IDisposable BeginScope<TState>(TState state) where TState : notnull
    {
        return _provider.BeginScope(state);
    }

And the implementation of SerilogLoggerProvider.BeginScope looks like this:

    /// <inheritdoc cref="IDisposable" />
    public IDisposable BeginScope<T>(T state)
    {
        if (CurrentScope != null)
            return new SerilogLoggerScope(this, state);

        // The outermost scope pushes and pops the Serilog `LogContext` - once
        // this enricher is on the stack, the `CurrentScope` property takes care
        // of the rest of the `BeginScope()` stack.
        var popSerilogContext = LogContext.Push(this);
        return new SerilogLoggerScope(this, state, popSerilogContext);
    }

The only artefact of this method is from the call to LogContext.Push, which results in a stack of IEnumerable<ILogEventEnricher>. It's possible to retrieve an aggregation of this by calling var enricher = Serilog.Context.LogContext.Clone();, which gives you back an ILogEventEnricher. However, ILogEventEnricher is not very useful:

public interface ILogEventEnricher
{
    void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory);
}

So I can't see any extension points for SeriLog that would enable us to synchronise the scope to Sentry.