From 588f0f50ab7bfcbf7ef4558395b79d7418b5f058 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Fri, 29 Aug 2025 12:13:31 +0200 Subject: [PATCH 01/13] Only set log template if message differs from template --- CHANGELOG.md | 4 ++++ .../src/main/java/io/sentry/jul/SentryHandler.java | 7 +++++-- .../main/java/io/sentry/log4j2/SentryAppender.java | 11 +++++++---- .../main/java/io/sentry/logback/SentryAppender.java | 9 ++++++--- 4 files changed, 22 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ce808f2be5e..686e61daa2c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Fixes + +- Only set log template for logging integrations if formatted message differs from template ([#4682](https://github.com/getsentry/sentry-java/pull/4682)) + ### Features - Add support for Spring Boot 4 and Spring 7 ([#4601](https://github.com/getsentry/sentry-java/pull/4601)) diff --git a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java index 23cba406b16..812fdf184db 100644 --- a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java +++ b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java @@ -154,9 +154,12 @@ protected void captureLog(@NotNull LogRecord loggingEvent) { message = loggingEvent.getResourceBundle().getString(loggingEvent.getMessage()); } - attributes.add(SentryAttribute.stringAttribute("sentry.message.template", message)); - final @NotNull String formattedMessage = maybeFormatted(arguments, message); + + if (!formattedMessage.equals(message)) { + attributes.add(SentryAttribute.stringAttribute("sentry.message.template", message)); + } + final @NotNull SentryLogParameters params = SentryLogParameters.create(attributes); params.setOrigin("auto.log.jul"); diff --git a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java index 9e4cf0eed9f..7c35febd169 100644 --- a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java +++ b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java @@ -222,11 +222,14 @@ protected void captureLog(@NotNull LogEvent loggingEvent) { final @Nullable Object[] arguments = loggingEvent.getMessage().getParameters(); final @NotNull SentryAttributes attributes = SentryAttributes.of(); - attributes.add( - SentryAttribute.stringAttribute( - "sentry.message.template", loggingEvent.getMessage().getFormat())); - + final @Nullable String nonFormattedMessage = loggingEvent.getMessage().getFormat(); final @NotNull String formattedMessage = loggingEvent.getMessage().getFormattedMessage(); + + if (nonFormattedMessage != null && !formattedMessage.equals(nonFormattedMessage)) { + attributes.add( + SentryAttribute.stringAttribute("sentry.message.template", nonFormattedMessage)); + } + final @NotNull SentryLogParameters params = SentryLogParameters.create(attributes); params.setOrigin("auto.log.log4j2"); diff --git a/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java b/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java index 7d9d53c706d..65a849d72bc 100644 --- a/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java +++ b/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java @@ -183,15 +183,18 @@ protected void captureLog(@NotNull ILoggingEvent loggingEvent) { @Nullable Object[] arguments = null; final @NotNull SentryAttributes attributes = SentryAttributes.of(); + final @NotNull String formattedMessage = formatted(loggingEvent); // if encoder is set we treat message+params as PII as encoders may be used to mask/strip PII if (encoder == null || ScopesAdapter.getInstance().getOptions().isSendDefaultPii()) { - attributes.add( - SentryAttribute.stringAttribute("sentry.message.template", loggingEvent.getMessage())); + final @Nullable String nonFormattedMessage = loggingEvent.getMessage(); + if (nonFormattedMessage != null && !formattedMessage.equals(nonFormattedMessage)) { + attributes.add( + SentryAttribute.stringAttribute("sentry.message.template", nonFormattedMessage)); + } arguments = loggingEvent.getArgumentArray(); } - final @NotNull String formattedMessage = formatted(loggingEvent); final @NotNull SentryLogParameters params = SentryLogParameters.create(attributes); params.setOrigin("auto.log.logback"); From 540d9e75102dcae65bac3c9056f2a12127b48a6b Mon Sep 17 00:00:00 2001 From: lcian Date: Mon, 1 Sep 2025 18:11:24 +0200 Subject: [PATCH 02/13] test JUL --- .../java/io/sentry/jul/SentryHandler.java | 12 ++- .../kotlin/io/sentry/jul/SentryHandlerTest.kt | 92 +++++++++++++++++++ 2 files changed, 102 insertions(+), 2 deletions(-) diff --git a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java index 812fdf184db..d60977fc9a0 100644 --- a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java +++ b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java @@ -154,9 +154,16 @@ protected void captureLog(@NotNull LogRecord loggingEvent) { message = loggingEvent.getResourceBundle().getString(loggingEvent.getMessage()); } - final @NotNull String formattedMessage = maybeFormatted(arguments, message); + String formattedMessage = null; + boolean formattingFailed = false; + try { + formattedMessage = maybeFormatted(arguments, message); + } catch (RuntimeException e) { + formattedMessage = message; + formattingFailed = true; + } - if (!formattedMessage.equals(message)) { + if (formattingFailed || !formattedMessage.equals(message)) { attributes.add(SentryAttribute.stringAttribute("sentry.message.template", message)); } @@ -173,6 +180,7 @@ protected void captureLog(@NotNull LogRecord loggingEvent) { return formatMessage(message, arguments); } catch (RuntimeException e) { // local formatting failed, sending raw message instead of formatted message + throw e; } } diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt index 8f39c0d94a5..e067a84b4b4 100644 --- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt +++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt @@ -35,6 +35,7 @@ class SentryHandlerTest { val configureWithLogManager: Boolean = false, val transport: ITransport = mock(), contextTags: List? = null, + printfStyle: Boolean = true, ) { var logger: Logger var handler: SentryHandler @@ -49,6 +50,7 @@ class SentryHandlerTest { handler.setMinimumBreadcrumbLevel(minimumBreadcrumbLevel) handler.setMinimumEventLevel(minimumEventLevel) handler.setMinimumLevel(minimumLevel) + handler.setPrintfStyle(printfStyle) handler.level = Level.ALL logger.handlers.forEach { logger.removeHandler(it) } logger.addHandler(handler) @@ -476,4 +478,94 @@ class SentryHandlerTest { verify(fixture.transport) .send(checkLogs { event -> assertEquals(SentryLogLevel.ERROR, event.items.first().level) }) } + + @Test + fun `does not set template on log when logging message without parameters`() { + fixture = Fixture(minimumLevel = Level.SEVERE) + fixture.logger.severe("testing message without parameters") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message without parameters", log.body) + assertNull(log.attributes?.get("sentry.message.template")) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters`() { + fixture = Fixture(minimumLevel = Level.SEVERE) + fixture.logger.log(Level.SEVERE, "testing message {0}", arrayOf("param")) + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param", log.body) + assertEquals("testing message {0}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param", log.attributes?.get("sentry.message.parameter.0")?.value) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters and using printfStyle`() { + fixture = Fixture(minimumLevel = Level.SEVERE, printfStyle = true) + fixture.logger.log(Level.SEVERE, "testing message %s", arrayOf("param")) + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param", log.body) + assertEquals("testing message %s", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param", log.attributes?.get("sentry.message.parameter.0")?.value) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters and formatting fails`() { + fixture = Fixture(minimumLevel = Level.SEVERE) + fixture.logger.log(Level.SEVERE, "testing message {0} {1}", arrayOf(1)) + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message {0} {1}", log.body) + assertEquals("testing message {0} {1}", log.attributes?.get("sentry.message.template")?.value) + assertEquals(1, log.attributes?.get("sentry.message.parameter.0")?.value) + assertNull(log.attributes?.get("sentry.message.parameter.1")) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters and formatting fails due to 0 args`() { + fixture = Fixture(minimumLevel = Level.SEVERE, printfStyle = true) + fixture.logger.log(Level.SEVERE, "testing message %d", emptyArray()) + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message %d", log.body) + assertEquals("testing message %d", log.attributes?.get("sentry.message.template")?.value) + assertNull(log.attributes?.get("sentry.message.parameter.0")) + } + ) + } } From ce94c242abf2f1da75bbfe7e68106bed8cfb9517 Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Mon, 1 Sep 2025 16:14:23 +0000 Subject: [PATCH 03/13] Format code --- .../src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt index e067a84b4b4..9677e640f46 100644 --- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt +++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt @@ -544,7 +544,10 @@ class SentryHandlerTest { checkLogs { logs -> val log = logs.items.first() assertEquals("testing message {0} {1}", log.body) - assertEquals("testing message {0} {1}", log.attributes?.get("sentry.message.template")?.value) + assertEquals( + "testing message {0} {1}", + log.attributes?.get("sentry.message.template")?.value, + ) assertEquals(1, log.attributes?.get("sentry.message.parameter.0")?.value) assertNull(log.attributes?.get("sentry.message.parameter.1")) } From 367be5fbf0bcd850a97118511a2f2e7c0ca9fdf4 Mon Sep 17 00:00:00 2001 From: lcian Date: Mon, 1 Sep 2025 18:33:54 +0200 Subject: [PATCH 04/13] trigger CI From e6bd7a3b8e9ea1efcb2eb11410be710b8584215c Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 09:23:36 +0200 Subject: [PATCH 05/13] address cursor --- .../test/kotlin/io/sentry/jul/SentryHandlerTest.kt | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt index 9677e640f46..045f7819583 100644 --- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt +++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt @@ -35,7 +35,7 @@ class SentryHandlerTest { val configureWithLogManager: Boolean = false, val transport: ITransport = mock(), contextTags: List? = null, - printfStyle: Boolean = true, + printfStyle: Boolean? = null, ) { var logger: Logger var handler: SentryHandler @@ -50,7 +50,9 @@ class SentryHandlerTest { handler.setMinimumBreadcrumbLevel(minimumBreadcrumbLevel) handler.setMinimumEventLevel(minimumEventLevel) handler.setMinimumLevel(minimumLevel) - handler.setPrintfStyle(printfStyle) + if (printfStyle == true) { + handler.setPrintfStyle(printfStyle) + } handler.level = Level.ALL logger.handlers.forEach { logger.removeHandler(it) } logger.addHandler(handler) @@ -534,8 +536,8 @@ class SentryHandlerTest { @Test fun `sets template on log when logging message with parameters and formatting fails`() { - fixture = Fixture(minimumLevel = Level.SEVERE) - fixture.logger.log(Level.SEVERE, "testing message {0} {1}", arrayOf(1)) + fixture = Fixture(minimumLevel = Level.SEVERE, printfStyle = true) + fixture.logger.log(Level.SEVERE, "testing message %d %d", arrayOf(1)) Sentry.flush(1000) @@ -543,9 +545,9 @@ class SentryHandlerTest { .send( checkLogs { logs -> val log = logs.items.first() - assertEquals("testing message {0} {1}", log.body) + assertEquals("testing message %d %d", log.body) assertEquals( - "testing message {0} {1}", + "testing message %d %d", log.attributes?.get("sentry.message.template")?.value, ) assertEquals(1, log.attributes?.get("sentry.message.parameter.0")?.value) From b148e4587b9046e01fd5f98173d97b5c21d0c5da Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 10:15:46 +0200 Subject: [PATCH 06/13] test log4j2 --- .../io/sentry/log4j2/SentryAppenderTest.kt | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt index 9ddfdbd43be..456ccb7d01c 100644 --- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt +++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt @@ -29,6 +29,7 @@ import org.apache.logging.log4j.core.LoggerContext import org.apache.logging.log4j.core.config.AppenderRef import org.apache.logging.log4j.core.config.Configuration import org.apache.logging.log4j.core.config.LoggerConfig +import org.apache.logging.log4j.core.layout.PatternLayout import org.apache.logging.log4j.spi.ExtendedLogger import org.mockito.kotlin.any import org.mockito.kotlin.anyOrNull @@ -60,6 +61,7 @@ class SentryAppenderTest { } loggerContext.start() val config: Configuration = loggerContext.configuration + val appender = SentryAppender( "sentry", @@ -533,4 +535,59 @@ class SentryAppenderTest { fixture.getSut(debug = true) assertTrue(ScopesAdapter.getInstance().options.isDebug) } + + @Test + fun `does not set template on log when logging message without parameters`() { + val logger = fixture.getSut(minimumLevel = Level.ERROR) + logger.error("testing message without parameters") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message without parameters", log.body) + assertNull(log.attributes?.get("sentry.message.template")) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters`() { + val logger = fixture.getSut(minimumLevel = Level.ERROR) + logger.error("testing message {}", "param") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param", log.body) + assertEquals("testing message {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param", log.attributes?.get("sentry.message.parameter.0")?.value) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters and number of parameters is wrong`() { + val logger = fixture.getSut(minimumLevel = Level.ERROR) + logger.error("testing message {} {} {}", "param1", "param2") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param1 param2 {}", log.body) + assertEquals("testing message {} {} {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param1", log.attributes?.get("sentry.message.parameter.0")?.value) + assertEquals("param2", log.attributes?.get("sentry.message.parameter.1")?.value) + assertNull(log.attributes?.get("sentry.message.parameter.2")) + } + ) + } } From 869d3d07246e30ad67977dda4a60f4f9c9b87d49 Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Tue, 2 Sep 2025 08:19:08 +0000 Subject: [PATCH 07/13] Format code --- .../src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt index 456ccb7d01c..c74a96f3a59 100644 --- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt +++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt @@ -29,7 +29,6 @@ import org.apache.logging.log4j.core.LoggerContext import org.apache.logging.log4j.core.config.AppenderRef import org.apache.logging.log4j.core.config.Configuration import org.apache.logging.log4j.core.config.LoggerConfig -import org.apache.logging.log4j.core.layout.PatternLayout import org.apache.logging.log4j.spi.ExtendedLogger import org.mockito.kotlin.any import org.mockito.kotlin.anyOrNull @@ -583,7 +582,10 @@ class SentryAppenderTest { checkLogs { logs -> val log = logs.items.first() assertEquals("testing message param1 param2 {}", log.body) - assertEquals("testing message {} {} {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals( + "testing message {} {} {}", + log.attributes?.get("sentry.message.template")?.value, + ) assertEquals("param1", log.attributes?.get("sentry.message.parameter.0")?.value) assertEquals("param2", log.attributes?.get("sentry.message.parameter.1")?.value) assertNull(log.attributes?.get("sentry.message.parameter.2")) From 1b906177cb3ac232566d0180a15fd7b9bed7772c Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 11:57:18 +0200 Subject: [PATCH 08/13] trigger CI From e575f0d98e46762ca15e7db26e043493133de573 Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 11:57:29 +0200 Subject: [PATCH 09/13] trigger CI From 1fed21d5ce0d34f7fbb07cf0b28f8165db9a22c6 Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 13:05:01 +0200 Subject: [PATCH 10/13] logback tests --- .../io/sentry/logback/SentryAppenderTest.kt | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt index ffe84ed55df..78f44659047 100644 --- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt +++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt @@ -711,4 +711,99 @@ class SentryAppenderTest { anyOrNull(), ) } + + @Test + fun `does not set template on log when logging message without parameters`() { + fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true) + fixture.logger.error("testing message without parameters") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message without parameters", log.body) + assertNull(log.attributes?.get("sentry.message.template")) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters`() { + fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true) + fixture.logger.error("testing message {}", "param") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param", log.body) + assertEquals("testing message {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param", log.attributes?.get("sentry.message.parameter.0")?.value) + } + ) + } + + @Test + fun `sets template on log when logging message with parameters and number of parameters is wrong`() { + fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true) + fixture.logger.error("testing message {} {} {}", "param1", "param2") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("testing message param1 param2 {}", log.body) + assertEquals("testing message {} {} {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param1", log.attributes?.get("sentry.message.parameter.0")?.value) + assertEquals("param2", log.attributes?.get("sentry.message.parameter.1")?.value) + assertNull(log.attributes?.get("sentry.message.parameter.2")) + } + ) + } + + @Test + fun `does not set template or attributes on log with encoder when sendDefaultPii is false`() { + var encoder = PatternLayoutEncoder() + encoder.pattern = "encoded %msg" + fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true, encoder = encoder, sendDefaultPii = false) + fixture.logger.error("testing message {}", "param") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("encoded testing message param", log.body) + assertNull(log.attributes?.get("sentry.message.template")) + assertNull(log.attributes?.get("sentry.message.parameter.0")) + } + ) + } + + @Test + fun `sets template and attributes on log with encoder when sendDefaultPii is true`() { + var encoder = PatternLayoutEncoder() + encoder.pattern = "encoded %msg" + fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true, encoder = encoder, sendDefaultPii = true) + fixture.logger.error("testing message {}", "param") + + Sentry.flush(1000) + + verify(fixture.transport) + .send( + checkLogs { logs -> + val log = logs.items.first() + assertEquals("encoded testing message param", log.body) + assertEquals("testing message {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals("param", log.attributes?.get("sentry.message.parameter.0")?.value) + } + ) + } } From 199facca43fb369b6eff2b76facf48e7ce73fc8c Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Tue, 2 Sep 2025 11:09:04 +0000 Subject: [PATCH 11/13] Format code --- .../io/sentry/logback/SentryAppenderTest.kt | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt index 78f44659047..8c7acbc5725 100644 --- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt +++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt @@ -759,7 +759,10 @@ class SentryAppenderTest { checkLogs { logs -> val log = logs.items.first() assertEquals("testing message param1 param2 {}", log.body) - assertEquals("testing message {} {} {}", log.attributes?.get("sentry.message.template")?.value) + assertEquals( + "testing message {} {} {}", + log.attributes?.get("sentry.message.template")?.value, + ) assertEquals("param1", log.attributes?.get("sentry.message.parameter.0")?.value) assertEquals("param2", log.attributes?.get("sentry.message.parameter.1")?.value) assertNull(log.attributes?.get("sentry.message.parameter.2")) @@ -771,7 +774,13 @@ class SentryAppenderTest { fun `does not set template or attributes on log with encoder when sendDefaultPii is false`() { var encoder = PatternLayoutEncoder() encoder.pattern = "encoded %msg" - fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true, encoder = encoder, sendDefaultPii = false) + fixture = + Fixture( + minimumLevel = Level.ERROR, + enableLogs = true, + encoder = encoder, + sendDefaultPii = false, + ) fixture.logger.error("testing message {}", "param") Sentry.flush(1000) @@ -791,7 +800,13 @@ class SentryAppenderTest { fun `sets template and attributes on log with encoder when sendDefaultPii is true`() { var encoder = PatternLayoutEncoder() encoder.pattern = "encoded %msg" - fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true, encoder = encoder, sendDefaultPii = true) + fixture = + Fixture( + minimumLevel = Level.ERROR, + enableLogs = true, + encoder = encoder, + sendDefaultPii = true, + ) fixture.logger.error("testing message {}", "param") Sentry.flush(1000) From 315be848225a5fb655871ed289708bab10ebc532 Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 15:48:17 +0200 Subject: [PATCH 12/13] revert jul --- .../main/java/io/sentry/jul/SentryHandler.java | 12 ++---------- .../kotlin/io/sentry/jul/SentryHandlerTest.kt | 18 ------------------ 2 files changed, 2 insertions(+), 28 deletions(-) diff --git a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java index d60977fc9a0..812fdf184db 100644 --- a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java +++ b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java @@ -154,16 +154,9 @@ protected void captureLog(@NotNull LogRecord loggingEvent) { message = loggingEvent.getResourceBundle().getString(loggingEvent.getMessage()); } - String formattedMessage = null; - boolean formattingFailed = false; - try { - formattedMessage = maybeFormatted(arguments, message); - } catch (RuntimeException e) { - formattedMessage = message; - formattingFailed = true; - } + final @NotNull String formattedMessage = maybeFormatted(arguments, message); - if (formattingFailed || !formattedMessage.equals(message)) { + if (!formattedMessage.equals(message)) { attributes.add(SentryAttribute.stringAttribute("sentry.message.template", message)); } @@ -180,7 +173,6 @@ protected void captureLog(@NotNull LogRecord loggingEvent) { return formatMessage(message, arguments); } catch (RuntimeException e) { // local formatting failed, sending raw message instead of formatted message - throw e; } } diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt index 045f7819583..a002c986407 100644 --- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt +++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt @@ -555,22 +555,4 @@ class SentryHandlerTest { } ) } - - @Test - fun `sets template on log when logging message with parameters and formatting fails due to 0 args`() { - fixture = Fixture(minimumLevel = Level.SEVERE, printfStyle = true) - fixture.logger.log(Level.SEVERE, "testing message %d", emptyArray()) - - Sentry.flush(1000) - - verify(fixture.transport) - .send( - checkLogs { logs -> - val log = logs.items.first() - assertEquals("testing message %d", log.body) - assertEquals("testing message %d", log.attributes?.get("sentry.message.template")?.value) - assertNull(log.attributes?.get("sentry.message.parameter.0")) - } - ) - } } From abc22f71af8e85cfa0477ba1fdefadcfbeba57e5 Mon Sep 17 00:00:00 2001 From: lcian Date: Tue, 2 Sep 2025 15:55:04 +0200 Subject: [PATCH 13/13] improve --- .../src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt index c74a96f3a59..185972df905 100644 --- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt +++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt @@ -60,7 +60,6 @@ class SentryAppenderTest { } loggerContext.start() val config: Configuration = loggerContext.configuration - val appender = SentryAppender( "sentry",