You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by pk...@apache.org on 2022/12/31 19:28:30 UTC
[logging-log4j2] branch release-2.x updated: [LOG4J2-3645] Minimal changes to allow flow tracing with LogBuilder
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch release-2.x
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
The following commit(s) were added to refs/heads/release-2.x by this push:
new 9080ac6c5e [LOG4J2-3645] Minimal changes to allow flow tracing with LogBuilder
9080ac6c5e is described below
commit 9080ac6c5e8eaca0e01aabd46c74d6c22e65fab5
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Sat Dec 31 19:09:19 2022 +0100
[LOG4J2-3645] Minimal changes to allow flow tracing with LogBuilder
This PR adds a minimal amount of methods to simplify flow
tracing with `LogBuilder`. E.g.:
```
logger.traceEntry("a={}, b={}", 1, 42);
```
can be now rewrittent as:
```
logger.atTrace()
.withMarker(AbstractLogger.ENTRY_MARKER)
.logAndGet(() -> {
LoggingSystem.getFlowMessageFactory()
.newEntryMessage("a={}, b={}", 1, 42);
});
```
The latter can be easily perfomed by a bytecode manipulation tool.
---
.../java/org/apache/logging/log4j/LoggerTest.java | 83 ++++++++++------------
.../java/org/apache/logging/log4j/LogBuilder.java | 11 +++
.../main/java/org/apache/logging/log4j/Logger.java | 9 +++
.../logging/log4j/internal/DefaultLogBuilder.java | 11 ++-
.../log4j/message/DefaultFlowMessageFactory.java | 83 +++++++++++++++++++---
.../logging/log4j/message/FlowMessageFactory.java | 31 +++++++-
.../apache/logging/log4j/spi/AbstractLogger.java | 62 ++++------------
.../logging/log4j/jul/AbstractLoggerTest.java | 1 -
8 files changed, 186 insertions(+), 105 deletions(-)
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/LoggerTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/LoggerTest.java
index 0eb5f8d6d5..a147fd2a75 100644
--- a/log4j-api-test/src/test/java/org/apache/logging/log4j/LoggerTest.java
+++ b/log4j-api-test/src/test/java/org/apache/logging/log4j/LoggerTest.java
@@ -43,8 +43,8 @@ import org.junit.jupiter.api.parallel.ResourceAccessMode;
import org.junit.jupiter.api.parallel.ResourceLock;
import org.junitpioneer.jupiter.ReadsSystemProperty;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.endsWith;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -88,8 +88,8 @@ public class LoggerTest {
logger.entry();
logger.exit();
assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), equalTo("ENTER[ FLOW ] TRACE Enter"));
- assertThat("incorrect Exit", results.get(1), equalTo("EXIT[ FLOW ] TRACE Exit"));
+ assertThat(results.get(0)).isEqualTo("ENTER[ FLOW ] TRACE Enter");
+ assertThat(results.get(1)).isEqualTo("EXIT[ FLOW ] TRACE Exit");
}
@@ -100,95 +100,90 @@ public class LoggerTest {
logger.traceEntry(new JsonMessage(props));
final Response response = new Response(-1, "Generic error");
logger.traceExit(new JsonMessage(response), response);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("\"foo\":\"bar\""));
- assertThat("incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("\"message\":\"Generic error\""));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("\"foo\":\"bar\"");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("\"message\":\"Generic error\"");
}
@Test
public void flowTracingString_ObjectArray1() {
logger.traceEntry("doFoo(a={}, b={})", 1, 2);
logger.traceExit("doFoo(a=1, b=2): {}", 3);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("doFoo(a=1, b=2): 3"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("doFoo(a=1, b=2): 3");
}
@Test
public void flowTracingExitValueOnly() {
logger.traceEntry("doFoo(a={}, b={})", 1, 2);
logger.traceExit(3);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("3"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("3");
}
@Test
public void flowTracingString_ObjectArray2() {
final EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", 1, 2);
logger.traceExit(msg, 3);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("doFoo(a=1, b=2): 3"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("doFoo(a=1, b=2): 3");
}
@Test
public void flowTracingVoidReturn() {
final EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", 1, 2);
logger.traceExit(msg);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), endsWith("doFoo(a=1, b=2)"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").endsWith("doFoo(a=1, b=2)");
}
@Test
public void flowTracingNoExitArgs() {
logger.traceEntry();
logger.traceExit();
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit");
}
@Test
public void flowTracingNoArgs() {
final EntryMessage message = logger.traceEntry();
logger.traceExit(message);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit");
}
@Test
public void flowTracingString_SupplierOfObjectMessages() {
final EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", (Supplier<Message>) () -> new ObjectMessage(1), (Supplier<Message>) () -> new ObjectMessage(2));
logger.traceExit(msg, 3);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("doFoo(a=1, b=2): 3"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("doFoo(a=1, b=2): 3");
}
@Test
public void flowTracingString_SupplierOfStrings() {
final EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", (Supplier<String>) () -> "1", (Supplier<String>) () -> "2");
logger.traceExit(msg, 3);
- assertEquals(2, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("doFoo(a=1, b=2)"));
- assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE Exit"));
- assertThat("Missing exit data", results.get(1), containsString("doFoo(a=1, b=2): 3"));
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).startsWith("ENTER[ FLOW ] TRACE Enter").contains("doFoo(a=1, b=2)");
+ assertThat(results.get(1)).startsWith("EXIT[ FLOW ] TRACE Exit").contains("doFoo(a=1, b=2): 3");
+ }
+
+ @Test
+ public void flowTracingNoFormat() {
+ logger.traceEntry(null, 1, "2", new ObjectMessage(3));
+ logger.traceExit((String) null, 4);
+ assertThat(results).hasSize(2);
+ assertThat(results.get(0)).isEqualTo("ENTER[ FLOW ] TRACE Enter params(1, 2, 3)");
+ assertThat(results.get(1)).isEqualTo("EXIT[ FLOW ] TRACE Exit with(4)");
}
@Test
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/LogBuilder.java b/log4j-api/src/main/java/org/apache/logging/log4j/LogBuilder.java
index b6f612c7ac..75af9a387f 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/LogBuilder.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/LogBuilder.java
@@ -112,6 +112,17 @@ public interface LogBuilder {
default void log(Supplier<Message> messageSupplier) {
}
+ /**
+ * Causes all the data collected to be logged along with the message.
+ *
+ * @param messageSupplier The supplier of the message to log.
+ * @return the message logger or {@literal null} if no logging occurred.
+ * @since 2.20
+ */
+ default Message logAndGet(final Supplier<Message> messageSupplier) {
+ return null;
+ }
+
/**
* Causes all the data collected to be logged along with the message. Interface default method does nothing.
* @param message The message to log.
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java b/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java
index 07df43625a..d86c358e76 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java
@@ -17,6 +17,7 @@
package org.apache.logging.log4j;
import org.apache.logging.log4j.message.EntryMessage;
+import org.apache.logging.log4j.message.FlowMessageFactory;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.MessageFactory;
import org.apache.logging.log4j.message.MessageFactory2;
@@ -1746,6 +1747,14 @@ public interface Logger {
*/
<MF extends MessageFactory> MF getMessageFactory();
+ /**
+ * Gets the flow message factory used to convert messages into flow messages.
+ *
+ * @return the flow message factory, as an instance of {@link FlowMessageFactory}.
+ * @since 2.20
+ */
+ FlowMessageFactory getFlowMessageFactory();
+
/**
* Gets the logger name.
*
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/internal/DefaultLogBuilder.java b/log4j-api/src/main/java/org/apache/logging/log4j/internal/DefaultLogBuilder.java
index 11fb11b8f2..2d64266641 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/internal/DefaultLogBuilder.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/internal/DefaultLogBuilder.java
@@ -115,7 +115,16 @@ public class DefaultLogBuilder implements BridgeAware, LogBuilder {
}
@Override
- public void log(CharSequence message) {
+ public Message logAndGet(Supplier<Message> messageSupplier) {
+ Message message = null;
+ if (isValid()) {
+ logMessage(message = messageSupplier.get());
+ }
+ return message;
+ }
+
+ @Override
+ public void log(final CharSequence message) {
if (isValid()) {
logMessage(logger.getMessageFactory().newMessage(message));
}
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/DefaultFlowMessageFactory.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/DefaultFlowMessageFactory.java
index 567a02f315..30c237a48d 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/message/DefaultFlowMessageFactory.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/message/DefaultFlowMessageFactory.java
@@ -18,6 +18,11 @@ package org.apache.logging.log4j.message;
import java.io.Serializable;
+import org.apache.logging.log4j.spi.AbstractLogger;
+import org.apache.logging.log4j.util.StringBuilderFormattable;
+import org.apache.logging.log4j.util.StringBuilders;
+import org.apache.logging.log4j.util.Strings;
+
/**
* Default factory for flow messages.
*
@@ -31,6 +36,7 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
private final String entryText;
private final String exitText;
+ private final MessageFactory messageFactory;
/**
* Constructs a message factory with {@code "Enter"} and {@code "Exit"} as the default flow strings.
@@ -47,9 +53,18 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
public DefaultFlowMessageFactory(final String entryText, final String exitText) {
this.entryText = entryText;
this.exitText = exitText;
+ this.messageFactory = createDefaultMessageFactory();
+ }
+
+ private static MessageFactory createDefaultMessageFactory() {
+ try {
+ return AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS.newInstance();
+ } catch (final InstantiationException | IllegalAccessException e) {
+ throw new IllegalStateException(e);
+ }
}
- private static class AbstractFlowMessage implements FlowMessage {
+ private static class AbstractFlowMessage implements FlowMessage, StringBuilderFormattable {
private static final long serialVersionUID = 1L;
private final Message message;
@@ -71,7 +86,7 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
@Override
public String getFormat() {
if (message != null) {
- return text + ": " + message.getFormat();
+ return text + " " + message.getFormat();
}
return text;
}
@@ -101,6 +116,15 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
public String getText() {
return text;
}
+
+ @Override
+ public void formatTo(StringBuilder buffer) {
+ buffer.append(text);
+ if (message != null) {
+ buffer.append(" ");
+ StringBuilders.appendValue(buffer, message);
+ }
+ }
}
private static final class SimpleEntryMessage extends AbstractFlowMessage implements EntryMessage {
@@ -121,15 +145,17 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
private final boolean isVoid;
SimpleExitMessage(final String exitText, final EntryMessage message) {
- super(exitText, message.getMessage());
+ this(exitText, message.getMessage());
+ }
+
+ SimpleExitMessage(final String exitText, final Message message) {
+ super(exitText, message);
this.result = null;
isVoid = true;
}
SimpleExitMessage(final String exitText, final Object result, final EntryMessage message) {
- super(exitText, message.getMessage());
- this.result = result;
- isVoid = false;
+ this(exitText, result, message.getMessage());
}
SimpleExitMessage(final String exitText, final Object result, final Message message) {
@@ -164,6 +190,28 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
return exitText;
}
+ @Override
+ public EntryMessage newEntryMessage(String format, Object... params) {
+ final boolean hasFormat = Strings.isNotEmpty(format);
+ final Message message;
+ if (params == null || params.length == 0) {
+ message = hasFormat ? messageFactory.newMessage(format) : null;
+ } else if (hasFormat) {
+ message = messageFactory.newMessage(format, params);
+ } else {
+ final StringBuilder sb = new StringBuilder("params(");
+ for (int i = 0; i < params.length; i++) {
+ if (i > 0) {
+ sb.append(", ");
+ }
+ sb.append("{}");
+ }
+ sb.append(")");
+ message = messageFactory.newMessage(sb.toString(), params);
+ }
+ return newEntryMessage(message);
+ }
+
/*
* (non-Javadoc)
*
@@ -175,10 +223,27 @@ public class DefaultFlowMessageFactory implements FlowMessageFactory, Serializab
}
private Message makeImmutable(final Message message) {
- if (!(message instanceof ReusableMessage)) {
- return message;
+ if (message instanceof ReusableMessage) {
+ return ((ReusableMessage) message).memento();
+ }
+ return message;
+ }
+
+ @Override
+ public ExitMessage newExitMessage(String format, Object result) {
+ final boolean hasFormat = Strings.isNotEmpty(format);
+ final Message message;
+ if (result == null) {
+ message = hasFormat ? messageFactory.newMessage(format) : null;
+ } else {
+ message = messageFactory.newMessage(hasFormat ? format : "with({})", result);
}
- return new SimpleMessage(message.getFormattedMessage());
+ return newExitMessage(message);
+ }
+
+ @Override
+ public ExitMessage newExitMessage(Message message) {
+ return new SimpleExitMessage(exitText, message);
}
/*
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessageFactory.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessageFactory.java
index 56ce7e7133..079b602e03 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessageFactory.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessageFactory.java
@@ -21,7 +21,17 @@ package org.apache.logging.log4j.message;
* @since 2.6
*/
public interface FlowMessageFactory {
-
+
+ /**
+ * Creates a new entry message based on a format string with parameters.
+ *
+ * @param message format string
+ * @param params parameters
+ * @return the new entry message
+ * @since 2.20
+ */
+ EntryMessage newEntryMessage(String message, Object... params);
+
/**
* Creates a new entry message based on an existing message.
*
@@ -30,6 +40,25 @@ public interface FlowMessageFactory {
*/
EntryMessage newEntryMessage(Message message);
+ /**
+ * Creates a new exit message based on a return value and a forma string.
+ *
+ * @param format a format string
+ * @param result the return value
+ * @return the new exit message
+ * @since 2.20
+ */
+ ExitMessage newExitMessage(String format, Object result);
+
+ /**
+ * Creates a new exit message based on no return value and an existing message.
+ *
+ * @param message the original entry message
+ * @return the new exit message
+ * @since 2.20
+ */
+ ExitMessage newExitMessage(Message message);
+
/**
* Creates a new exit message based on a return value and an existing message.
*
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java b/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java
index 76bfead28e..a85077dd9e 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java
@@ -33,10 +33,8 @@ import org.apache.logging.log4j.message.FlowMessageFactory;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.MessageFactory;
import org.apache.logging.log4j.message.MessageFactory2;
-import org.apache.logging.log4j.message.ParameterizedMessage;
import org.apache.logging.log4j.message.ParameterizedMessageFactory;
import org.apache.logging.log4j.message.ReusableMessageFactory;
-import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.message.StringFormattedMessage;
import org.apache.logging.log4j.status.StatusLogger;
import org.apache.logging.log4j.util.Constants;
@@ -46,7 +44,6 @@ import org.apache.logging.log4j.util.MessageSupplier;
import org.apache.logging.log4j.util.PerformanceSensitive;
import org.apache.logging.log4j.util.PropertiesUtil;
import org.apache.logging.log4j.util.StackLocatorUtil;
-import org.apache.logging.log4j.util.Strings;
import org.apache.logging.log4j.util.Supplier;
/**
@@ -518,7 +515,8 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
protected EntryMessage enter(final String fqcn, final String format, final Supplier<?>... paramSuppliers) {
EntryMessage entryMsg = null;
if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
- logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, paramSuppliers), null);
+ logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER,
+ entryMsg = flowMessageFactory.newEntryMessage(format, LambdaUtil.getAll(paramSuppliers)), null);
}
return entryMsg;
}
@@ -549,7 +547,7 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
protected EntryMessage enter(final String fqcn, final String format, final Object... params) {
EntryMessage entryMsg = null;
if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
- logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, params), null);
+ logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = flowMessageFactory.newEntryMessage(format, params), null);
}
return entryMsg;
}
@@ -616,27 +614,7 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
}
protected EntryMessage entryMsg(final String format, final Object... params) {
- final int count = params == null ? 0 : params.length;
- if (count == 0) {
- if (Strings.isEmpty(format)) {
- return flowMessageFactory.newEntryMessage(null);
- }
- return flowMessageFactory.newEntryMessage(new SimpleMessage(format));
- }
- if (format != null) {
- return flowMessageFactory.newEntryMessage(new ParameterizedMessage(format, params));
- }
- final StringBuilder sb = new StringBuilder();
- sb.append("params(");
- for (int i = 0; i < count; i++) {
- if (i > 0) {
- sb.append(", ");
- }
- final Object parm = params[i];
- sb.append(parm instanceof Message ? ((Message) parm).getFormattedMessage() : String.valueOf(parm));
- }
- sb.append(')');
- return flowMessageFactory.newEntryMessage(new SimpleMessage(sb));
+ return flowMessageFactory.newEntryMessage(format, params);
}
protected EntryMessage entryMsg(final String format, final MessageSupplier... paramSuppliers) {
@@ -644,21 +622,12 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
final Object[] params = new Object[count];
for (int i = 0; i < count; i++) {
params[i] = paramSuppliers[i].get();
- params[i] = params[i] != null ? ((Message) params[i]).getFormattedMessage() : null;
}
return entryMsg(format, params);
}
protected EntryMessage entryMsg(final String format, final Supplier<?>... paramSuppliers) {
- final int count = paramSuppliers == null ? 0 : paramSuppliers.length;
- final Object[] params = new Object[count];
- for (int i = 0; i < count; i++) {
- params[i] = paramSuppliers[i].get();
- if (params[i] instanceof Message) {
- params[i] = ((Message) params[i]).getFormattedMessage();
- }
- }
- return entryMsg(format, params);
+ return entryMsg(format, LambdaUtil.getAll(paramSuppliers));
}
@Override
@@ -940,7 +909,7 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
*/
protected <R> R exit(final String fqcn, final R result) {
if (isEnabled(Level.TRACE, EXIT_MARKER, (CharSequence) null, null)) {
- logMessageSafely(fqcn, Level.TRACE, EXIT_MARKER, exitMsg(null, result), null);
+ logMessageSafely(fqcn, Level.TRACE, EXIT_MARKER, flowMessageFactory.newExitMessage(null, result), null);
}
return result;
}
@@ -955,23 +924,13 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
*/
protected <R> R exit(final String fqcn, final String format, final R result) {
if (isEnabled(Level.TRACE, EXIT_MARKER, (CharSequence) null, null)) {
- logMessageSafely(fqcn, Level.TRACE, EXIT_MARKER, exitMsg(format, result), null);
+ logMessageSafely(fqcn, Level.TRACE, EXIT_MARKER, flowMessageFactory.newExitMessage(format, result), null);
}
return result;
}
protected Message exitMsg(final String format, final Object result) {
- if (result == null) {
- if (format == null) {
- return messageFactory.newMessage("Exit");
- }
- return messageFactory.newMessage("Exit: " + format);
- }
- if (format == null) {
- return messageFactory.newMessage("Exit with(" + result + ')');
- }
- return messageFactory.newMessage("Exit: " + format, result);
-
+ return flowMessageFactory.newExitMessage(format, result);
}
@Override
@@ -1236,6 +1195,11 @@ public abstract class AbstractLogger implements ExtendedLogger, LocationAwareLog
return (MF) messageFactory;
}
+ @Override
+ public FlowMessageFactory getFlowMessageFactory() {
+ return flowMessageFactory;
+ }
+
@Override
public String getName() {
return name;
diff --git a/log4j-jul/src/test/java/org/apache/logging/log4j/jul/AbstractLoggerTest.java b/log4j-jul/src/test/java/org/apache/logging/log4j/jul/AbstractLoggerTest.java
index 263765235b..b93b4a88e7 100644
--- a/log4j-jul/src/test/java/org/apache/logging/log4j/jul/AbstractLoggerTest.java
+++ b/log4j-jul/src/test/java/org/apache/logging/log4j/jul/AbstractLoggerTest.java
@@ -14,7 +14,6 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
-
package org.apache.logging.log4j.jul;
import java.util.List;