When Application Includes a Refit Assembly, Many System.IO.IOExceptions Are Thrown

[Mike-E-angelo]

Package

Sentry

.NET Flavor

.NET

.NET Version

10.0.103

OS

Windows

OS Version

Windows 11

Development Environment

Visual Studio v18.x

SDK Version

6.1.0

Self-Hosted Sentry Version

No response

Workload Versions

Workload version: 10.0.200-manifests.796b3495

Installed Workload Id Manifest Version Installation Source

android 36.1.30/10.0.100 VS 18.3.11512.155, VS 18.4.11513.90
ios 26.2.10197/10.0.100 VS 18.3.11512.155, VS 18.4.11513.90
maccatalyst 26.2.10197/10.0.100 VS 18.3.11512.155, VS 18.4.11513.90
maui-windows 10.0.20/10.0.100 VS 18.3.11512.155, VS 18.4.11513.90

UseSentry or SentrySdk.Init call

"Serilog": {
"WriteTo": [
{
"Name": "Sentry",
"Args": {
"enableLogs": true,
"environment": "Development",
"minimumEventLevel": "Debug",
"minimumBreadcrumbLevel": "Debug"
}
}
]
},

Steps to Reproduce

When using Sentry 6.1.0 with a Refit assembly, System.IO.IOExceptions are thrown due to attempting to load the assembly, but it is in memory:

Expected Result

No exceptions are thrown

Actual Result

Many exceptions are thrown and caught, leaving messages in the debug window:

[linear]

NET-591

[jamescrosswell]

@Mike-E-angelo I'm not familiar with Refit. Are you able to provide a small reproduction of the issue (e.g. as a github repository) so that we can investigate?

[Mike-E-angelo]

Hi @jamescrosswell pardon my confusion here but this was not Refit after all. The error said RefEmit which is something completely different. 🤦 The issue has to do with dynamic-created/compiled delegates and I have a reproduction for you below:

public sealed class Program
{
    public static void Main(string[] args) => BuildWebApp(args).Run();

    public static WebApplication BuildWebApp(string[] args)
    {
	    var builder = WebApplication.CreateBuilder(args);
        builder.Host.UseSerilog((_, c) =>
            c.Enrich.FromLogContext()
                .MinimumLevel.Verbose()
                .WriteTo.Console()
                // Add Sentry integration with Serilog
                // Two levels are used to configure it.
                // One sets which log level is minimally required to keep a log message as breadcrumbs
                // The other sets the minimum level for messages to be sent out as events to Sentry
                .WriteTo.Sentry(s =>
                {
                    s.Dsn                    = SamplesShared.Dsn;
                    s.EnableLogs             = true;
                    s.MinimumBreadcrumbLevel = LogEventLevel.Debug;
                    s.MinimumEventLevel      = LogEventLevel.Debug;
                }));

        // Add Sentry integration
        // It can be defined via configuration (including `appsettings.json`)
        // or coded explicitly, via parameter like:
        // .UseSentry("dsn") or .UseSentry(o => o.Dsn = ""; o.Release = "1.0"; ...)
#if !SENTRY_DSN_DEFINED_IN_ENV
        builder.WebHost.UseSentry(SamplesShared.Dsn);
#else
        builder.WebHost.UseSentry(EnvironmentVariables.Dsn);
#endif

        // The App:
        var webApplication = builder.Build();
        Configure(webApplication);

        return webApplication;
    }

    static void Configure(IApplicationBuilder app)
    {
	    // Create a DynamicMethod NOT associated with a type/module → hosted in Anonymously Hosted DynamicMethods Assembly
	    var dynMethod = new DynamicMethod("DynamicThrower", // Name
	                                      typeof(void),     // Return type
	                                      Type.EmptyTypes   // Parameters
	                                     );

	    // Emit IL to throw an exception (so the frame is in the stack trace)
	    var il = dynMethod.GetILGenerator();
	    il.Emit(OpCodes.Ldstr, "Test exception thrown from dynamic method");                 // Message
	    il.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new[] { typeof(string) })); // New Exception
	    il.Emit(OpCodes.Throw);                                                              // Throw it

	    // Create delegate and invoke to put it in the call stack
	    var throwAction = (Action)dynMethod.CreateDelegate(typeof(Action));

	    // An example ASP.NET Core middleware that throws an
        // exception when serving a request to path: /throw
        app.Use(async (context, next) =>
        {
            // See MinimumBreadcrumbLevel set at the Serilog configuration above
            Log.Logger.Debug("Static Serilog logger debug log stored as breadcrumbs.");

            var log = context.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger<Program>();

            try
            {
	            throwAction(); // This will throw, with dynamic frame at top of stack
            }
            catch (Exception ex)
            {
	            // Capture to Sentry → forces DebugStackTrace to process the dynamic assembly frame
	            SentrySdk.CaptureException(ex);
	            Console.WriteLine("Exception captured. Check console for Sentry debug logs + any ArgumentNullException.");
            }

            log.LogInformation("Handling some request...");

            // Sends an event which includes the info and debug messages above
            Log.Logger.Error("Logging using static Serilog directly also goes to Sentry.");

            if (context.Request.Path == "/greetings")
            {
                context.Response.ContentType = "text/plain";
                await context.Response.WriteAsync("Hello, World!");
            }
            else if (context.Request.Path == "/throw")
            {
                var hub = context.RequestServices.GetRequiredService<IHub>();
                hub.ConfigureScope(s =>
                {
                    // More data can be added to the scope like this:
                    s.SetTag("Sample", "ASP.NET Core"); // indexed by Sentry
                    s.SetExtra("Extra!", "Some extra information");
                });

                // Logging through the ASP.NET Core `ILogger` while using Serilog
                log.LogInformation("Logging info...");
                log.LogWarning("Logging some warning!");

                // The following exception will be captured by the SDK and the event
                // will include the Log messages and any custom scope modifications
                // as exemplified above.
                throw new Exception("An exception thrown from the ASP.NET Core pipeline");
            }
            else
            {
                await next();
            }
        });
    }
}

If you run the above (from your aforementioned sample), you should get an IOException that occurs in the SentrySdk.CaptureException(ex); call above in the try/catch.

[jamescrosswell]

If you run the above (from your aforementioned sample), you should get an IOException that occurs in the SentrySdk.CaptureException(ex); call above in the try/catch.

Hi @Mike-E-angelo ,

I'm not sure I'm able to reproduce the issue you're describing. When I run the code above, I do see an IO exception thrown internally in Sentry, but it's caught here:

sentry-dotnet/src/Sentry/Internal/DebugStackTrace.cs

Lines 538 to 542 in fc117ae

	catch (Exception)
	{
	assemblyName = null;
	return null;
	}

And then I hit the second breakpoint that I have configured below, which implies the SentrySdk.CaptureException method is not throwing any exceptions (at least not any that it doesn't catch internally).

What is the behaviour you're seeing and what are you expecting to happen instead?