Send Logback logs to Sentry as logs (#4502)

* Add user id, username and email to log attributes

* wip

* Check log event count before sending envelope

* changelog

* Min event level config option; enable logs in logback sample

* review feedback

* treat unformatted message and params as pii if logback encoder is present

* changelog

Author: adinauer

CHANGELOG.md

@@ -11,6 +11,40 @@
 - No longer send out empty log envelopes ([#4497](https://github.com/getsentry/sentry-java/pull/4497))
 - Session Replay: Expand fix for crash on devices to all Unisoc/Spreadtrum chipsets ([#4510](https://github.com/getsentry/sentry-java/pull/4510))
 
+### Features
+
+- Send Logback logs to Sentry as logs ([#4502](https://github.com/getsentry/sentry-java/pull/4502))
+  - You need to enable the logs feature and can also set the `minimumLevel` for log events:
+    ```xml
+    <appender name="sentry" class="io.sentry.logback.SentryAppender">
+      <options>
+        <!-- NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard -->
+        <dsn>https://[email protected]/5428563</dsn>
+        <logs>
+          <enabled>true</enabled>
+        </logs>
+      </options>
+      <!-- Demonstrates how to modify the minimum values -->
+      <!-- Default for Events is ERROR -->
+      <minimumEventLevel>WARN</minimumEventLevel>
+      <!-- Default for Breadcrumbs is INFO -->
+      <minimumBreadcrumbLevel>DEBUG</minimumBreadcrumbLevel>
+      <!-- Default for Breadcrumbs is INFO -->
+      <minimumLevel>INFO</minimumLevel>
+    </appender>
+    ```
+  - If you manually initialize Sentry, you may also enable logs on `Sentry.init`:
+    ```java
+    Sentry.init(options -> {
+      ...
+      options.getLogs().setEnabled(true);
+    });
+    ```
+  - Enabling via `sentry.properties` is also possible:
+    ```properties
+    logs.enabled=true
+    ```
+
 ### Dependencies
 
 - Bump Gradle from v8.14.1 to v8.14.2 ([#4473](https://github.com/getsentry/sentry-java/pull/4473))

sentry-logback/api/sentry-logback.api

@@ -8,13 +8,16 @@ public class io/sentry/logback/SentryAppender : ch/qos/logback/core/Unsynchroniz
 	public fun <init> ()V
 	protected fun append (Lch/qos/logback/classic/spi/ILoggingEvent;)V
 	protected synthetic fun append (Ljava/lang/Object;)V
+	protected fun captureLog (Lch/qos/logback/classic/spi/ILoggingEvent;)V
 	protected fun createBreadcrumb (Lch/qos/logback/classic/spi/ILoggingEvent;)Lio/sentry/Breadcrumb;
 	protected fun createEvent (Lch/qos/logback/classic/spi/ILoggingEvent;)Lio/sentry/SentryEvent;
 	public fun getMinimumBreadcrumbLevel ()Lch/qos/logback/classic/Level;
 	public fun getMinimumEventLevel ()Lch/qos/logback/classic/Level;
+	public fun getMinimumLevel ()Lch/qos/logback/classic/Level;
 	public fun setEncoder (Lch/qos/logback/core/encoder/Encoder;)V
 	public fun setMinimumBreadcrumbLevel (Lch/qos/logback/classic/Level;)V
 	public fun setMinimumEventLevel (Lch/qos/logback/classic/Level;)V
+	public fun setMinimumLevel (Lch/qos/logback/classic/Level;)V
 	public fun setOptions (Lio/sentry/SentryOptions;)V
 	public fun start ()V
 }

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

@@ -16,11 +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;
@@ -46,6 +50,7 @@ public class SentryAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {
   private @Nullable ITransportFactory transportFactory;
   private @NotNull Level minimumBreadcrumbLevel = Level.INFO;
   private @NotNull Level minimumEventLevel = Level.ERROR;
+  private @NotNull Level minimumLevel = Level.INFO;
   private @Nullable Encoder<ILoggingEvent> encoder;
 
   static {
@@ -78,6 +83,9 @@ public void start() {
 
   @Override
   protected void append(@NotNull ILoggingEvent eventObject) {
+    if (options.getLogs().isEnabled() && eventObject.getLevel().isGreaterOrEqual(minimumLevel)) {
+      captureLog(eventObject);
+    }
     if (eventObject.getLevel().isGreaterOrEqual(minimumEventLevel)) {
       final Hint hint = new Hint();
       hint.set(SENTRY_SYNTHETIC_EXCEPTION, eventObject);
@@ -162,6 +170,32 @@ protected void append(@NotNull ILoggingEvent eventObject) {
     return event;
   }
 
+  /**
+   * Captures a Sentry log from Logback's {@link ILoggingEvent}.
+   *
+   * @param loggingEvent the logback event
+   */
+  // for the Android compatibility we must use old Java Date class
+  @SuppressWarnings("JdkObsolete")
+  protected void captureLog(@NotNull ILoggingEvent loggingEvent) {
+    final @NotNull SentryLogLevel sentryLevel = toSentryLogLevel(loggingEvent.getLevel());
+
+    @Nullable Object[] arguments = null;
+    final @NotNull SentryAttributes attributes = SentryAttributes.of();
+
+    // 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) {
     if (encoder != null) {
       try {
@@ -218,6 +252,26 @@ private String formatted(@NotNull ILoggingEvent loggingEvent) {
     }
   }
 
+  /**
+   * Transforms a {@link Level} into an {@link SentryLogLevel}.
+   *
+   * @param level original level as defined in log4j.
+   * @return log level used within sentry.
+   */
+  private static @NotNull SentryLogLevel toSentryLogLevel(@NotNull Level level) {
+    if (level.isGreaterOrEqual(Level.ERROR)) {
+      return SentryLogLevel.ERROR;
+    } else if (level.isGreaterOrEqual(Level.WARN)) {
+      return SentryLogLevel.WARN;
+    } else if (level.isGreaterOrEqual(Level.INFO)) {
+      return SentryLogLevel.INFO;
+    } else if (level.isGreaterOrEqual(Level.DEBUG)) {
+      return SentryLogLevel.DEBUG;
+    } else {
+      return SentryLogLevel.TRACE;
+    }
+  }
+
   private @NotNull SdkVersion createSdkVersion(@NotNull SentryOptions sentryOptions) {
     SdkVersion sdkVersion = sentryOptions.getSdkVersion();
 
@@ -258,6 +312,16 @@ public void setMinimumEventLevel(final @Nullable Level minimumEventLevel) {
     return minimumEventLevel;
   }
 
+  public void setMinimumLevel(final @Nullable Level minimumLevel) {
+    if (minimumLevel != null) {
+      this.minimumLevel = minimumLevel;
+    }
+  }
+
+  public @NotNull Level getMinimumLevel() {
+    return minimumLevel;
+  }
+
   @ApiStatus.Internal
   void setTransportFactory(final @Nullable ITransportFactory transportFactory) {
     this.transportFactory = transportFactory;

sentry-samples/sentry-samples-logback/src/main/resources/logback.xml

@@ -13,12 +13,17 @@
       <dsn>https://[email protected]/5428563</dsn>
       <contextTag>userId</contextTag>
       <contextTag>requestId</contextTag>
+      <logs>
+        <enabled>true</enabled>
+      </logs>
     </options>
     <!-- Demonstrates how to modify the minimum values -->
     <!-- Default for Events is ERROR -->
     <minimumEventLevel>WARN</minimumEventLevel>
     <!-- Default for Breadcrumbs is INFO -->
     <minimumBreadcrumbLevel>DEBUG</minimumBreadcrumbLevel>
+    <!-- Default for Breadcrumbs is INFO -->
+    <minimumLevel>INFO</minimumLevel>
   </appender>
 
   <!-- it's important to set logger level to equal or lower than minimumBreadcrumbLevel and minimumEventLevel -->

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

sentry/src/test/java/io/sentry/ScopesTest.kt

@@ -2880,6 +2880,53 @@ class ScopesTest {
       )
   }
 
+  @Test
+  fun `missing user does not break attributes`() {
+    val (sut, mockClient) =
+      getEnabledScopes {
+        it.logs.isEnabled = true
+        it.isSendDefaultPii = true
+      }
+
+    sut.logger().log(SentryLogLevel.WARN, "log message")
+
+    verify(mockClient)
+      .captureLog(
+        check {
+          assertEquals("log message", it.body)
+
+          assertNull(it.attributes?.get("user.id"))
+          assertNull(it.attributes?.get("user.name"))
+          assertNull(it.attributes?.get("user.email"))
+        },
+        anyOrNull(),
+      )
+  }
+
+  @Test
+  fun `missing user fields do not break attributes`() {
+    val (sut, mockClient) =
+      getEnabledScopes {
+        it.logs.isEnabled = true
+        it.isSendDefaultPii = true
+      }
+
+    sut.configureScope { scope -> scope.user = User() }
+    sut.logger().log(SentryLogLevel.WARN, "log message")
+
+    verify(mockClient)
+      .captureLog(
+        check {
+          assertEquals("log message", it.body)
+
+          assertNull(it.attributes?.get("user.id"))
+          assertNull(it.attributes?.get("user.name"))
+          assertNull(it.attributes?.get("user.email"))
+        },
+        anyOrNull(),
+      )
+  }
+
   // endregion
 
   @Test