Merge branch 'feat/logs-flush' into feat/logback-spring-boot

Author: adinauer

sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java

@@ -16,12 +16,15 @@
 import io.sentry.InitPriority;
 import io.sentry.ScopesAdapter;
 import io.sentry.Sentry;
+import io.sentry.SentryAttribute;
+import io.sentry.SentryAttributes;
 import io.sentry.SentryEvent;
 import io.sentry.SentryIntegrationPackageStorage;
 import io.sentry.SentryLevel;
 import io.sentry.SentryLogLevel;
 import io.sentry.SentryOptions;
 import io.sentry.exception.ExceptionMechanismException;
+import io.sentry.logger.SentryLogParameters;
 import io.sentry.protocol.Mechanism;
 import io.sentry.protocol.Message;
 import io.sentry.protocol.SdkVersion;
@@ -177,14 +180,20 @@ protected void append(@NotNull ILoggingEvent eventObject) {
   protected void captureLog(@NotNull ILoggingEvent loggingEvent) {
     final @NotNull SentryLogLevel sentryLevel = toSentryLogLevel(loggingEvent.getLevel());
 
-    //    // if encoder is set we treat message+params as PII as encoders may be used to mask/strip
-    // PII
-    //    if (encoder == null || options.isSendDefaultPii()) {
-    //      message.setMessage(loggingEvent.getMessage());
-    //      message.setParams(toParams(loggingEvent.getArgumentArray()));
-    //    }
+    @Nullable Object[] arguments = null;
+    final @NotNull SentryAttributes attributes = SentryAttributes.of();
 
-    Sentry.logger().log(sentryLevel, formatted(loggingEvent), loggingEvent.getArgumentArray());
+    // if encoder is set we treat message+params as PII as encoders may be used to mask/strip PII
+    if (encoder == null || options.isSendDefaultPii()) {
+      attributes.add(
+          SentryAttribute.stringAttribute("sentry.message.template", loggingEvent.getMessage()));
+      arguments = loggingEvent.getArgumentArray();
+    }
+
+    final @NotNull String formattedMessage = formatted(loggingEvent);
+    final @NotNull SentryLogParameters params = SentryLogParameters.create(attributes);
+
+    Sentry.logger().log(sentryLevel, params, formattedMessage, arguments);
   }
 
   private String formatted(@NotNull ILoggingEvent loggingEvent) {

sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt

@@ -386,6 +386,83 @@ class SentryAppenderTest {
         )
     }
 
+    @Test
+    fun `sends formatted log message if no encoder`() {
+        fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true)
+        fixture.logger.trace("Testing {} level", "TRACE")
+
+        Sentry.flush(1000)
+
+        verify(fixture.transport).send(
+            checkLogs { logs ->
+                val log = logs.items.first()
+                assertEquals("Testing TRACE level", log.body)
+                val attributes = log.attributes!!
+                assertEquals("Testing {} level", attributes["sentry.message.template"]?.value)
+                assertEquals("TRACE", attributes["sentry.message.parameter.0"]?.value)
+            }
+        )
+    }
+
+    @Test
+    fun `does not send formatted log message if encoder is available but sendDefaultPii is off`() {
+        var encoder = PatternLayoutEncoder()
+        encoder.pattern = "encoderadded %msg"
+        fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true, encoder = encoder)
+        fixture.logger.trace("Testing {} level", "TRACE")
+
+        Sentry.flush(1000)
+
+        verify(fixture.transport).send(
+            checkLogs { logs ->
+                val log = logs.items.first()
+                assertEquals("encoderadded Testing TRACE level", log.body)
+                val attributes = log.attributes!!
+                assertNull(attributes["sentry.message.template"])
+                assertNull(attributes["sentry.message.parameter.0"])
+            }
+        )
+    }
+
+    @Test
+    fun `sends formatted log message if encoder is available and sendDefaultPii is on but encoder throws`() {
+        var encoder = ThrowingEncoder()
+        fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true, sendDefaultPii = true, encoder = encoder)
+        fixture.logger.trace("Testing {} level", "TRACE")
+
+        Sentry.flush(1000)
+
+        verify(fixture.transport).send(
+            checkLogs { logs ->
+                val log = logs.items.first()
+                assertEquals("Testing TRACE level", log.body)
+                val attributes = log.attributes!!
+                assertEquals("Testing {} level", attributes["sentry.message.template"]?.value)
+                assertEquals("TRACE", attributes["sentry.message.parameter.0"]?.value)
+            }
+        )
+    }
+
+    @Test
+    fun `sends formatted log message if encoder is available and sendDefaultPii is on`() {
+        var encoder = PatternLayoutEncoder()
+        encoder.pattern = "encoderadded %msg"
+        fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true, sendDefaultPii = true, encoder = encoder)
+        fixture.logger.trace("Testing {} level", "TRACE")
+
+        Sentry.flush(1000)
+
+        verify(fixture.transport).send(
+            checkLogs { logs ->
+                val log = logs.items.first()
+                assertEquals("encoderadded Testing TRACE level", log.body)
+                val attributes = log.attributes!!
+                assertEquals("Testing {} level", attributes["sentry.message.template"]?.value)
+                assertEquals("TRACE", attributes["sentry.message.parameter.0"]?.value)
+            }
+        )
+    }
+
     @Test
     fun `attaches thread information`() {
         fixture = Fixture(minimumEventLevel = Level.WARN)

sentry/src/main/java/io/sentry/logger/LoggerApi.java

@@ -184,9 +184,11 @@ private void captureLog(
         i++;
       }
       if (i > 0) {
-        attributes.put(
-            "sentry.message.template",
-            new SentryLogEventAttributeValue(SentryAttributeType.STRING, message));
+        if (attributes.get("sentry.message.template") == null) {
+          attributes.put(
+              "sentry.message.template",
+              new SentryLogEventAttributeValue(SentryAttributeType.STRING, message));
+        }
       }
     }