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;