feat: enable Logs for Google-Cloud-Functions

Author: Flash0ver

samples/Sentry.Samples.Google.Cloud.Functions/Function.cs

@@ -16,6 +16,7 @@ public class Function : IHttpFunction
 
     public Task HandleAsync(HttpContext context)
     {
+        _logger.LogTrace("LogLevel.Trace is not configured to be sent as structured log");
         _logger.LogInformation("Useful info that is added to the breadcrumb list.");
         throw new Exception("Bad function");
     }

samples/Sentry.Samples.Google.Cloud.Functions/appsettings.json

@@ -1,8 +1,19 @@
 {
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug"
+    },
+    "Sentry": {
+      "LogLevel": {
+        "Default": "Information"
+      }
+    }
+  },
   "Sentry": {
     //"Dsn": "TODO: Configure your DSN here and uncomment this line",
     "MaxRequestBodySize": "Always",
     "SendDefaultPii": true,
-    "EnableTracing": true
+    "EnableTracing": true,
+    "EnableLogs" : true
   }
 }

src/Sentry.Google.Cloud.Functions/SentryStartup.cs

@@ -57,10 +57,17 @@ public override void ConfigureLogging(WebHostBuilderContext context, ILoggingBui
 
         logging.Services.AddSingleton<IConfigureOptions<SentryAspNetCoreOptions>, SentryAspNetCoreOptionsSetup>();
         logging.Services.AddSingleton<ILoggerProvider, SentryAspNetCoreLoggerProvider>();
+        logging.Services.AddSingleton<ILoggerProvider, SentryAspNetCoreStructuredLoggerProvider>();
 
-        logging.AddFilter<SentryAspNetCoreLoggerProvider>(
-            "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware",
-            LogLevel.None);
+        // Add a delegate rule in order to ignore Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+        logging.AddFilter<SentryAspNetCoreLoggerProvider>(static (string? categoryName, LogLevel logLevel) =>
+        {
+            return categoryName is null
+                   || categoryName != "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware";
+        });
+        // Add non-delegate rules in order to respect Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+        logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.ISentryClient", LogLevel.None);
+        logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.AspNetCore.SentryMiddleware", LogLevel.None);
 
         logging.Services.AddSentry();
     }

test/Sentry.Google.Cloud.Functions.Tests/SentryStartupTests.cs

@@ -96,7 +96,7 @@ public void ConfigureLogging_SentryAspNetCoreOptions_FlushOnCompletedRequestTrue
     }
 
     [Theory, MemberData(nameof(ExpectedServices))]
-    public void UseSentry_Parameterless_ServicesRegistered(Action<IServiceCollection> assert)
+    public void ConfigureLogging_Parameterless_ServicesRegistered(Action<IServiceCollection> assert)
     {
         var sut = new SentryStartup();
         sut.ConfigureLogging(WebHostBuilderContext, LoggingBuilder);
@@ -121,4 +121,64 @@ public static IEnumerable<object[]> ExpectedServices()
             new Action<IServiceCollection>(c =>
                 Assert.Single(c, d => d.ImplementationType == typeof(AspNetCoreEventProcessor)))};
     }
+
+    [Fact]
+    public void ConfigureLogging_Logging_AddLoggerProviders()
+    {
+        LoggingBuilder.Services.Configure<SentryAspNetCoreOptions>(options =>
+        {
+            options.EnableLogs = true;
+            options.InitializeSdk = false;
+        });
+
+        var sut = new SentryStartup();
+        sut.ConfigureLogging(WebHostBuilderContext, LoggingBuilder);
+
+        using var serviceProvider = LoggingBuilder.Services.BuildServiceProvider();
+        var providers = serviceProvider.GetRequiredService<IEnumerable<ILoggerProvider>>().ToArray();
+
+        providers.Should().HaveCount(2);
+        providers[0].Should().BeOfType<SentryAspNetCoreLoggerProvider>();
+        providers[1].Should().BeOfType<SentryAspNetCoreStructuredLoggerProvider>();
+    }
+
+    [Fact]
+    public void ConfigureLogging_Logging_AddLoggerFilterRules()
+    {
+        LoggingBuilder.Services.Configure<SentryAspNetCoreOptions>(options =>
+        {
+            options.EnableLogs = true;
+            options.InitializeSdk = false;
+        });
+
+        var sut = new SentryStartup();
+        sut.ConfigureLogging(WebHostBuilderContext, LoggingBuilder);
+
+        using var serviceProvider = LoggingBuilder.Services.BuildServiceProvider();
+        var loggerFilterOptions = serviceProvider.GetRequiredService<IOptions<LoggerFilterOptions>>().Value;
+
+        loggerFilterOptions.Rules.Should().HaveCount(3);
+        var one = loggerFilterOptions.Rules[0];
+        var two = loggerFilterOptions.Rules[1];
+        var three = loggerFilterOptions.Rules[2];
+
+        one.ProviderName.Should().Be(typeof(SentryAspNetCoreLoggerProvider).FullName);
+        one.CategoryName.Should().BeNull();
+        one.LogLevel.Should().BeNull();
+        one.Filter.Should().NotBeNull();
+        one.Filter!.Invoke(null, null, LogLevel.None).Should().BeTrue();
+        one.Filter.Invoke("", "", LogLevel.None).Should().BeTrue();
+        one.Filter.Invoke("type", "category", LogLevel.None).Should().BeTrue();
+        one.Filter.Invoke(null, typeof(Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware).FullName, LogLevel.None).Should().BeFalse();
+
+        two.ProviderName.Should().Be(typeof(SentryAspNetCoreStructuredLoggerProvider).FullName);
+        two.CategoryName.Should().Be(typeof(ISentryClient).FullName);
+        two.LogLevel.Should().Be(LogLevel.None);
+        two.Filter.Should().BeNull();
+
+        three.ProviderName.Should().Be(typeof(SentryAspNetCoreStructuredLoggerProvider).FullName);
+        three.CategoryName.Should().Be(typeof(SentryMiddleware).FullName);
+        three.LogLevel.Should().Be(LogLevel.None);
+        three.Filter.Should().BeNull();
+    }
 }