[Logs 15] Add more tests and handle Exception in String.format for logs (#4396)

adinauer · getsentry-bot · web-flow · commit 2a4f3dd989c9 · 2025-05-13T16:34:33.000Z
* Add Log feature to Java SDK

* Rate limit for log items

* Add options for logs

* Add batch processor for logs

* Use a separate ExecutorService for log batching

* Reduce locking when log event is created

* Add system tests for Logs

* Separate enum for SentryLogLevel

* Remove logsSampleRate option

* Move logs options out of experimental namespace

* Add severity_number to SentryLogItem

* Logs review feedback

* mark captureBatchedLogEvents internal

* remove hint for logs

* Attach server.address to logs

* Add io.sentry.logs.enabled to Manifest

* Allow null for log event attribute value

* More tests; handle String.format exception

* not null

* Format code

---------

Co-authored-by: Sentry Github Bot &lt;bot+github-bot@sentry.io&gt;
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
@@ -3078,7 +3078,9 @@ public final class io/sentry/SentryLogEvent$JsonKeys {
 
 public final class io/sentry/SentryLogEventAttributeValue : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun getType ()Ljava/lang/String;
 	public fun getUnknown ()Ljava/util/Map;
+	public fun getValue ()Ljava/lang/Object;
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V
 	public fun setUnknown (Ljava/util/Map;)V
 }
diff --git a/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java b/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java
@@ -18,6 +18,14 @@ public SentryLogEventAttributeValue(final @NotNull String type, final @Nullable
     this.value = value;
   }
 
+  public @NotNull String getType() {
+    return type;
+  }
+
+  public @Nullable Object getValue() {
+    return value;
+  }
+
   // region json
   public static final class JsonKeys {
     public static final String TYPE = "type";
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerApi.java b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
@@ -105,7 +105,7 @@ private void captureLog(
 
       final @NotNull SentryDate timestampToUse =
           timestamp == null ? options.getDateProvider().now() : timestamp;
-      final @NotNull String messageToUse = args == null ? message : String.format(message, args);
+      final @NotNull String messageToUse = maybeFormatMessage(message, args);
 
       final @NotNull IScope combinedScope = scopes.getCombinedScopeView();
       final @NotNull PropagationContext propagationContext = combinedScope.getPropagationContext();
@@ -128,6 +128,23 @@ private void captureLog(
     }
   }
 
+  private @NotNull String maybeFormatMessage(
+      final @NotNull String message, final @Nullable Object[] args) {
+    if (args == null || args.length == 0) {
+      return message;
+    }
+
+    try {
+      return String.format(message, args);
+    } catch (Throwable t) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.ERROR, "Error while running log through String.format", t);
+      return message;
+    }
+  }
+
   private @NotNull HashMap<String, SentryLogEventAttributeValue> createAttributes(
       final @NotNull String message, final @NotNull SpanId spanId, final @Nullable Object... args) {
     final @NotNull HashMap<String, SentryLogEventAttributeValue> attributes = new HashMap<>();
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt
@@ -2430,6 +2430,256 @@ class ScopesTest {
 
     //endregion
 
+    //region logs
+
+    @Test
+    fun `when captureLog is called on disabled client, do nothing`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+        sut.close()
+
+        sut.logger().warn("test message")
+        verify(mockClient, never()).captureLog(any(), anyOrNull())
+    }
+
+    @Test
+    fun `when logging is not enabled, do nothing`() {
+        val (sut, mockClient) = getEnabledScopes()
+
+        sut.logger().warn("test message")
+        verify(mockClient, never()).captureLog(any(), anyOrNull())
+    }
+
+    @Test
+    fun `capturing null log does nothing`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().warn(null)
+        verify(mockClient, never()).captureLog(any(), anyOrNull())
+    }
+
+    @Test
+    fun `creating trace log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().trace("trace log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("trace log message", it.body)
+                assertEquals(SentryLogLevel.TRACE, it.level)
+                assertEquals(1, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating debug log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().debug("debug log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("debug log message", it.body)
+                assertEquals(SentryLogLevel.DEBUG, it.level)
+                assertEquals(5, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating a info log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().info("info log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("info log message", it.body)
+                assertEquals(SentryLogLevel.INFO, it.level)
+                assertEquals(9, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating warn log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().warn("warn log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("warn log message", it.body)
+                assertEquals(SentryLogLevel.WARN, it.level)
+                assertEquals(13, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating error log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().error("error log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("error log message", it.body)
+                assertEquals(SentryLogLevel.ERROR, it.level)
+                assertEquals(17, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating fatal log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().fatal("fatal log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("fatal log message", it.body)
+                assertEquals(SentryLogLevel.FATAL, it.level)
+                assertEquals(21, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating log works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().log(SentryLogLevel.WARN, "log message")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("log message", it.body)
+                assertEquals(SentryLogLevel.WARN, it.level)
+                assertEquals(13, it.severityNumber)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating log with format string works`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+            it.environment = "testenv"
+            it.release = "1.0"
+            it.serverName = "srv1"
+        }
+
+        sut.logger().log(SentryLogLevel.WARN, "log %s", "arg1")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("log arg1", it.body)
+                assertEquals(SentryLogLevel.WARN, it.level)
+                assertEquals(13, it.severityNumber)
+
+                val template = it.attributes?.get("sentry.message.template")!!
+                assertEquals("log %s", template.value)
+                assertEquals("string", template.type)
+
+                val param0 = it.attributes?.get("sentry.message.parameter.0")!!
+                assertEquals("arg1", param0.value)
+                assertEquals("string", param0.type)
+
+                val environment = it.attributes?.get("sentry.environment")!!
+                assertEquals("testenv", environment.value)
+                assertEquals("string", environment.type)
+
+                val release = it.attributes?.get("sentry.release")!!
+                assertEquals("1.0", release.value)
+                assertEquals("string", release.type)
+
+                val server = it.attributes?.get("server.address")!!
+                assertEquals("srv1", server.value)
+                assertEquals("string", server.type)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `creating log with without args does not add template attribute`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().log(SentryLogLevel.WARN, "log %s")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("log %s", it.body)
+                assertEquals(SentryLogLevel.WARN, it.level)
+                assertEquals(13, it.severityNumber)
+
+                val template = it.attributes?.get("sentry.message.template")
+                assertNull(template)
+
+                val param0 = it.attributes?.get("sentry.message.parameter.0")
+                assertNull(param0)
+            },
+            anyOrNull()
+        )
+    }
+
+    @Test
+    fun `captures format string on format error`() {
+        val (sut, mockClient) = getEnabledScopes {
+            it.logs.isEnabled = true
+        }
+
+        sut.logger().log(SentryLogLevel.WARN, "log %d", "arg1")
+
+        verify(mockClient).captureLog(
+            check {
+                assertEquals("log %d", it.body)
+                assertEquals(SentryLogLevel.WARN, it.level)
+                assertEquals(13, it.severityNumber)
+
+                val template = it.attributes?.get("sentry.message.template")!!
+                assertEquals("log %d", template.value)
+                assertEquals("string", template.type)
+
+                val param0 = it.attributes?.get("sentry.message.parameter.0")!!
+                assertEquals("arg1", param0.value)
+                assertEquals("string", param0.type)
+            },
+            anyOrNull()
+        )
+    }
+
+    //endregion
+
     @Test
     fun `null tags do not cause NPE`() {
         val scopes = generateScopes()
@@ -2467,7 +2717,7 @@ class ScopesTest {
         return createScopes(options)
     }
 
-    private fun getEnabledScopes(): Triple<Scopes, ISentryClient, ILogger> {
+    private fun getEnabledScopes(optionsConfiguration: Sentry.OptionsConfiguration<SentryOptions>? = null): Triple<Scopes, ISentryClient, ILogger> {
         val logger = mock<ILogger>()
 
         val options = SentryOptions()
@@ -2477,6 +2727,7 @@ class ScopesTest {
         options.tracesSampleRate = 1.0
         options.isDebug = true
         options.setLogger(logger)
+        optionsConfiguration?.configure(options)
 
         val sut = createScopes(options)
         val mockClient = createSentryClientMock()
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt

Original file line number	Diff line number	Diff line change
`@@ -3078,7 +3078,9 @@ public final class io/sentry/SentryLogEvent$JsonKeys {`
`3078`	`3078`
`3079`	`3079`	`public final class io/sentry/SentryLogEventAttributeValue : io/sentry/JsonSerializable, io/sentry/JsonUnknown {`
`3080`	`3080`	`public fun <init> (Ljava/lang/String;Ljava/lang/Object;)V`
	`3081`	`+ public fun getType ()Ljava/lang/String;`
`3081`	`3082`	`public fun getUnknown ()Ljava/util/Map;`
	`3083`	`+ public fun getValue ()Ljava/lang/Object;`
`3082`	`3084`	`public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V`
`3083`	`3085`	`public fun setUnknown (Ljava/util/Map;)V`
`3084`	`3086`	`}`