May 2019 - slf4j-dev - mailman3.qos.ch

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 31 May '19

31 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Federico Fissore commented on SLF4J-371: ---------------------------------------- @Robert @Eric I wasn't aware of that use case. I've just published version 0.13.0 of slf4j-fluent which adds support to message suppliers. Yes, it's a custom extension, but Ceki preferred to go solo on implementing the fluent API, so slf4j-fluent might be better than waiting for slf4j 2.0 to come out > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > Fix For: 2.0 > > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

JDK 13 - Early Access build 23 is available
by Rory O'Donnell 31 May '19

31 May '19

Hi Ceki, *OpenJDK builds *- JDK 13 - Early Access build 23 is available at http://jdk.java.net/13/ * These early-access , open-source builds are provided under the o GNU General Public License, version 2, with the Classpath Exception <http://openjdk.java.net/legal/gplv2+ce.html>. * Changes in this build <http://hg.openjdk.java.net/jdk/jdk/log?rev=reverse%28%22jdk-13%2B22%22%3A%3…> * Release notes [1] *Significant changes since the last availability email* * build 23 o Support for Unicode 12.1 (JDK-8221431 <https://bugs.openjdk.java.net/browse/JDK-8221431>) o Add new keytool -showinfo -tls command for displaying TLS configuration information (JDK-8219861 <https://bugs.openjdk.java.net/browse/JDK-8219861>) * build 22 o New methods for creating DOM and SAX factories with Namespace support (JDK-8219692 <https://bugs.openjdk.java.net/browse/JDK-8219692>) o Removal of two DocuSign root CA certificates (JDK-8223499 <https://bugs.openjdk.java.net/browse/JDK-8223499>) * build 21 o JDWP support for IPv6 (JDK-8184770 <https://bugs.openjdk.java.net/browse/JDK-8184770>) o Change the mechanism by which JDK loads the platform-specific AWT Toolkit (JDK-8212700 <https://bugs.openjdk.java.net/browse/JDK-8212700>) o Upgrade CLDR to Version 35.1 (JDK-8221432 <https://bugs.openjdk.java.net/browse/JDK-8221432>) o xConfigurable Read Timeout for CRLs (JDK-8191808 <https://bugs.openjdk.java.net/browse/JDK-8191808>) o Removal of two Comodo root CA certificates (JDK-8222136 <https://bugs.openjdk.java.net/browse/JDK-8222136>) Bug fixes for issues reported by Open Source Projects * build 22 o OutOfMemory on compiling with darcula.jar in classpath (JDK-8222807 <https://bugs.openjdk.java.net/browse/JDK-8222807>) * build 21 o java -version output and certain system properties contain "null" text in their values (JDK-8223695 <https://bugs.openjdk.java.net/browse/JDK-8223695>) * build 20 o assert(Compile::current()->live_nodes() < Compile::current()->max_node_limit()) failed: Live Node limit exceeded limit (JDK-8219520 <https://bugs.openjdk.java.net/browse/JDK-8219520>) o C2: MemNode::can_see_stored_value() ignores casts which carry control dependency (JDK-8219902 <https://bugs.openjdk.java.net/browse/JDK-8219902>) o New fix of the deadlock in sun.security.ssl.SSLSocketImpl (JDK-8219991 <https://bugs.openjdk.java.net/browse/JDK-8219991>) JEP updates since last email * JEP 350: Dynamic CDS Archives <http://openjdk.java.net/jeps/350> was *Integrated*. * JEP 351: ZGC: Uncommit Unused Memory <http://openjdk.java.net/jeps/351> was *Integrated*. * JEP 353: Reimplement the Legacy Socket API <http://openjdk.java.net/jeps/353> was*Targetted* JDK 13. * JEP 355: Text Blocks (Preview) <http://openjdk.java.net/jeps/355> was *Proposed to target* JDK 13. Rgds,Rory [1] http://jdk.java.net/13/release-notes -- Rgds, Rory O'Donnell Quality Engineering Manager Oracle EMEA, Dublin, Ireland

1 0

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 30 May '19

30 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Eric Deandrea commented on SLF4J-371: ------------------------------------- We also had our own wrapper around the logger implementation which did log sanitization/CRLF injection prevention/etc. > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 30 May '19

30 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Robert P Thornton commented on SLF4J-371: ----------------------------------------- @Eric Deandrea, I really like that solution. It would just be really nice if it were a part of the core org.slf4j.Logger interface so that my organization wouldn't have to rely on a custom extension or manage our own implementation. > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 30 May '19

30 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Eric Deandrea commented on SLF4J-371: ------------------------------------- At my last company to get around this we built our own interface that extended org.slf4j.Logger with these methods: {code:java} // code placeholder import java.util.function.Supplier; import java.util.stream.Stream; import org.slf4j.Marker; public interface Logger extends org.slf4j.Logger { default void trace(Supplier<String> message) { if (isTraceEnabled()) { trace(message.get()); } } default void trace(Marker marker, Supplier<String> message) { if (isTraceEnabled(marker)) { trace(marker, message.get()); } } default void trace(Supplier<String> message, Throwable throwable) { if (isTraceEnabled()) { trace(message.get(), throwable); } } default void trace(Marker marker, Supplier<String> message, Throwable throwable) { if (isTraceEnabled(marker)) { trace(marker, message.get(), throwable); } } default void trace(String format, Supplier<?> arg) { if (isTraceEnabled()) { trace(format, arg.get()); } } default void trace(String format, Supplier<?> arg1, Supplier<?> arg2) { if (isTraceEnabled()) { trace(format, arg1.get(), arg2.get()); } } default void trace(String format, Supplier<?>... arguments) { if (isTraceEnabled()) { trace(format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void trace(Marker marker, String format, Supplier<?> arg) { if (isTraceEnabled(marker)) { trace(marker, format, arg.get()); } } default void trace(Marker marker, String format, Supplier<?> arg1, Supplier<?> arg2) { if (isTraceEnabled(marker)) { trace(marker, format, arg1.get(), arg2.get()); } } default void trace(Marker marker, String format, Supplier<?>... arguments) { if (isTraceEnabled(marker)) { trace(marker, format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void debug(Supplier<String> message) { if (isDebugEnabled()) { debug(message.get()); } } default void debug(Marker marker, Supplier<String> message) { if (isDebugEnabled(marker)) { debug(marker, message.get()); } } default void debug(Supplier<String> message, Throwable throwable) { if (isDebugEnabled()) { debug(message.get(), throwable); } } default void debug(Marker marker, Supplier<String> message, Throwable throwable) { if (isDebugEnabled(marker)) { debug(marker, message.get(), throwable); } } default void debug(String format, Supplier<?> arg) { if (isDebugEnabled()) { debug(format, arg.get()); } } default void debug(String format, Supplier<?> arg1, Supplier<?> arg2) { if (isDebugEnabled()) { debug(format, arg1.get(), arg2.get()); } } default void debug(String format, Supplier<?>... arguments) { if (isDebugEnabled()) { debug(format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void debug(Marker marker, String format, Supplier<?> arg) { if (isDebugEnabled(marker)) { debug(marker, format, arg.get()); } } default void debug(Marker marker, String format, Supplier<?> arg1, Supplier<?> arg2) { Assert.notNull(arg1, "Argument1 supplier should not be null"); Assert.notNull(arg2, "Argument2 supplier should not be null"); if (isDebugEnabled(marker)) { debug(marker, format, arg1.get(), arg2.get()); } } default void debug(Marker marker, String format, Supplier<?>... arguments) { if (isDebugEnabled(marker)) { debug(marker, format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void info(Supplier<String> message) { if (isInfoEnabled()) { info(message.get()); } } default void info(Marker marker, Supplier<String> message) { if (isInfoEnabled(marker)) { info(marker, message.get()); } } default void info(Supplier<String> message, Throwable throwable) { if (isInfoEnabled()) { info(message.get(), throwable); } } default void info(Marker marker, Supplier<String> message, Throwable throwable) { if (isInfoEnabled(marker)) { info(marker, message.get(), throwable); } } default void info(String format, Supplier<?> arg) { if (isInfoEnabled()) { info(format, arg.get()); } } default void info(String format, Supplier<?> arg1, Supplier<?> arg2) { if (isInfoEnabled()) { info(format, arg1.get(), arg2.get()); } } default void info(String format, Supplier<?>... arguments) { if (isInfoEnabled()) { info(format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void info(Marker marker, String format, Supplier<?> arg) { if (isInfoEnabled(marker)) { info(marker, format, arg.get()); } } default void info(Marker marker, String format, Supplier<?> arg1, Supplier<?> arg2) { if (isInfoEnabled(marker)) { info(marker, format, arg1.get(), arg2.get()); } } default void info(Marker marker, String format, Supplier<?>... arguments) { if (isInfoEnabled(marker)) { info(marker, format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void warn(Supplier<String> message) { if (isWarnEnabled()) { warn(message.get()); } } default void warn(Marker marker, Supplier<String> message) { if (isWarnEnabled(marker)) { warn(marker, message.get()); } } default void warn(Supplier<String> message, Throwable throwable) { if (isWarnEnabled()) { warn(message.get(), throwable); } } default void warn(Marker marker, Supplier<String> message, Throwable throwable) { if (isWarnEnabled(marker)) { warn(marker, message.get(), throwable); } } default void warn(String format, Supplier<?> arg) { if (isWarnEnabled()) { warn(format, arg.get()); } } default void warn(String format, Supplier<?> arg1, Supplier<?> arg2) { if (isWarnEnabled()) { warn(format, arg1.get(), arg2.get()); } } default void warn(String format, Supplier<?>... arguments) { if (isWarnEnabled()) { warn(format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void warn(Marker marker, String format, Supplier<?> arg) { if (isWarnEnabled(marker)) { warn(marker, format, arg.get()); } } default void warn(Marker marker, String format, Supplier<?> arg1, Supplier<?> arg2) { if (isWarnEnabled(marker)) { warn(marker, format, arg1.get(), arg2.get()); } } default void warn(Marker marker, String format, Supplier<?>... arguments) { if (isWarnEnabled(marker)) { warn(marker, format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void error(Supplier<String> message) { if (isErrorEnabled()) { error(message.get()); } } default void error(Marker marker, Supplier<String> message) { if (isErrorEnabled(marker)) { error(marker, message.get()); } } default void error(Supplier<String> message, Throwable throwable) { if (isErrorEnabled()) { error(message.get(), throwable); } } default void error(Marker marker, Supplier<String> message, Throwable throwable) { if (isErrorEnabled(marker)) { error(marker, message.get(), throwable); } } default void error(String format, Supplier<?> arg) { if (isErrorEnabled()) { error(format, arg.get()); } } default void error(String format, Supplier<?> arg1, Supplier<?> arg2) { if (isErrorEnabled()) { error(format, arg1.get(), arg2.get()); } } default void error(String format, Supplier<?>... arguments) { if (isErrorEnabled()) { error(format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } default void error(Marker marker, String format, Supplier<?> arg) { if (isErrorEnabled(marker)) { error(marker, format, arg.get()); } } default void error(Marker marker, String format, Supplier<?> arg1, Supplier<?> arg2) { if (isErrorEnabled(marker)) { error(marker, format, arg1.get(), arg2.get()); } } default void error(Marker marker, String format, Supplier<?>... arguments) { if (isErrorEnabled(marker)) { error(marker, format, Stream.of(arguments).map(Supplier::get).toArray(Object[]::new)); } } }{code} > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 30 May '19

30 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Robert P Thornton commented on SLF4J-371: ----------------------------------------- JVM languages such as kotlin that support string templates at the language level would be much better able to make use of SLF4J using with the whole message provided via supplier rather than just the arguments. For example: {code:java} logger.warn(() -> "Some message: ${Json.serialize(arg)}") {code} > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-371) Support the lambda expression in the Logger
by QOS.CH (JIRA) 30 May '19

30 May '19

[ https://jira.qos.ch/browse/SLF4J-371?page=com.atlassian.jira.plugin.system.… ] Robert P Thornton commented on SLF4J-371: ----------------------------------------- The above PR does not seem adequate to support what JUL provides. It appears to only wrap individual arguments in a supplier which I think would be rarely useful. To provide parity with the JUL logging via supplier, the `org.slf4j.Logger` interface should provide operations like the following: ```java public void error(Supplier<String> msg,); public void error(Supplier<String> msg, Throwable t); public void warn(Supplier<String> msg,); public void warn(Supplier<String> msg, Throwable t); public void info(Supplier<String> msg,); public void info(Supplier<String> msg, Throwable t); public void debug(Supplier<String> msg,); public void debug(Supplier<String> msg, Throwable t); public void trace(Supplier<String> msg,); public void trace(Supplier<String> msg, Throwable t); ``` > Support the lambda expression in the Logger > ------------------------------------------- > > Key: SLF4J-371 > URL: https://jira.qos.ch/browse/SLF4J-371 > Project: SLF4J > Issue Type: Improvement > Components: Core API > Affects Versions: 1.7.22 > Reporter: MiNG > Assignee: SLF4J developers list > > In some cases, we don't want to calculate the expression for logging eagerly cause the performance reason. Then, we would write the code like the following: > {code:java} > if (LOGGER.isWarnEnabled()) > { > LOGGER.warn("some message: {}", Json.serialize(obj)); > }{code} > Before JDK8, there is no way to encapsulate the above code, because the expression is always calculated before passed as an argument. So, many "if"s appear in the code and smell badly. > Now, the lambda expression is supported by JDK8, the above could be simplified like following: > {code:java} > LOGGER.warn(formatter -> formatter.format("some message: {}", Json.serialize(obj)));{code} > With the default method definition in the org.slf4j.Logger: > {code:java} > public interface Logger > { > default void warn(Function<MessageFormatter, String> messageSupplier) > { > if (this.isWarnEnabled()) > { > /* Calculate the expression only if the WARN level logging is enabled. */ > this.warn(messageSupplier.apply(this.getFormatter())); > } > } > }{code} -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-432) log4j-over-slf4j calls wrong methods when marker parameter is null
by QOS.CH (JIRA) 26 May '19

26 May '19

[ https://jira.qos.ch/browse/SLF4J-432?page=com.atlassian.jira.plugin.system.… ] Rufus Andrews commented on SLF4J-432: ------------------------------------- @ceki PTAL - with respect, the delay on addressing this is getting slightly ridiculous. Thanks. > log4j-over-slf4j calls wrong methods when marker parameter is null > ------------------------------------------------------------------ > > Key: SLF4J-432 > URL: https://jira.qos.ch/browse/SLF4J-432 > Project: SLF4J > Issue Type: Bug > Components: log4j-over-slf4j > Reporter: Rufus Andrews > Assignee: SLF4J developers list > Priority: Minor > > The org.slf4j.Logger interface has with-Marker and without-Marker versions of each logging method, > e.g. > public void trace(Marker marker, String format, Object arg); > vs > public void trace(String format, Object arg); > > However, the differentiatedLog method in log4j-over-slf4j ignores this and always calls the method *with* the Marker argument, even when there is no Marker. Logger implementations are then forced to defensively check for null Markers because of this error. > log4j-over-slf4j should instead call the correct (without-Marker) method when there is no Marker. > > Patch: https://github.com/qos-ch/slf4j/pull/190/ -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

[JIRA] (SLF4J-458) More Multiple Argument Variants for Debug and Trace Statements
by QOS.CH (JIRA) 16 May '19

16 May '19

[ https://jira.qos.ch/browse/SLF4J-458?page=com.atlassian.jira.plugin.system.… ] DAVID MOLLITOR commented on SLF4J-458: -------------------------------------- Woops. Thanks. Adding more arguments will cut down on the number of arrays being created. Updating should give customers a performance boost. > More Multiple Argument Variants for Debug and Trace Statements > -------------------------------------------------------------- > > Key: SLF4J-458 > URL: https://jira.qos.ch/browse/SLF4J-458 > Project: SLF4J > Issue Type: Improvement > Reporter: DAVID MOLLITOR > Assignee: SLF4J developers list > Fix For: 2.0 > > > [https://www.slf4j.org/faq.html#logging_performance] > {quote} > A two argument variant is also available. For example, you can write: > logger.debug("The new entry is {}. It replaces {}.", entry, oldEntry); > If three or more arguments need to be passed, you can make use of the Object... variant of the printing methods. For example, you can write: > logger.debug("Value {} was inserted between {} and {}.", newVal, below, above); > This form incurs the hidden cost of construction of an Object[] (object array) which is usually very small. The one and two argument variants do not incur this hidden cost and exist solely for this reason (efficiency). The slf4j-api would be smaller/cleaner with only the Object... variant. > {quote} > Please create a 3 and 4 argument variant for {{debug}} and {{trace}} statements. -- This message was sent by Atlassian JIRA (v7.3.1#73012)

1 0

LocationAwareLogger#log(...) not working with slf4j-jdk14.jar
by O.K.U. 14 May '19

14 May '19

Hello everyone. I posted same message to slf4j-user mailing list 2 months ago, but I have no answer yet. I think that "LocationAwareLogger#log(...)" function in "slf4j-jdk14.jar" is not working. --------------------------------------------------------------------------------- logger.log(null, "test.Test", INFO_INT , "Hello {}", "World"); --------------------------------------------------------------------------------- prints "Hello {}", not "Hello World". in JDK14LoggerAdapter.java, "argArray" parameter is not used in the function. ------------------------------------------------------------------------------------------------------------------------------------------------ public void log(Marker marker, String callerFQCN, int level, String message, Object[] argArray, Throwable t) { Level julLevel = slf4jLevelIntToJULLevel(level); // the logger.isLoggable check avoids the unconditional // construction of location data for disabled log // statements. As of 2008-07-31, callers of this method // do not perform this check. See also // http://jira.qos.ch/browse/SLF4J-81 if (logger.isLoggable(julLevel)) { log(callerFQCN, julLevel, message, t); } } ------------------------------------------------------------------------------------------------------------------------------------------------ Is this a bug? -- I'm Sorry , and thanks for reading my poor English.

1 0