Repository: logging-log4j2 Updated Branches: refs/heads/master 1896c0e24 -> 3295f1138
New for 2.6 traceEntry() method now return a message which can be passed to a traceExit() call. Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/3295f113 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/3295f113 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/3295f113 Branch: refs/heads/master Commit: 3295f11382438175bdfca66b9e7e0efa4898f30b Parents: 1896c0e Author: ggregory <[email protected]> Authored: Fri Feb 12 22:39:15 2016 -0800 Committer: ggregory <[email protected]> Committed: Fri Feb 12 22:39:15 2016 -0800 ---------------------------------------------------------------------- .../java/org/apache/logging/log4j/Logger.java | 112 +++++++++- .../logging/log4j/message/EntryMessage.java | 26 +++ .../logging/log4j/message/ExitMessage.java | 26 +++ .../logging/log4j/message/FlowMessage.java | 30 +++ .../logging/log4j/spi/AbstractLogger.java | 216 +++++++++++++++---- .../org/apache/logging/log4j/LoggerTest.java | 117 ++++++++-- 6 files changed, 455 insertions(+), 72 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java ---------------------------------------------------------------------- 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 347718a..7f88b05 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 @@ -16,6 +16,7 @@ */ package org.apache.logging.log4j; +import org.apache.logging.log4j.message.EntryMessage; import org.apache.logging.log4j.message.Message; import org.apache.logging.log4j.message.MessageFactory; import org.apache.logging.log4j.util.MessageSupplier; @@ -1696,8 +1697,11 @@ public interface Logger { /** * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be * logged. + * + * @return built message + * @since 2.6 */ - void traceEntry(); + EntryMessage traceEntry(); /** * Logs entry to a method along with its parameters. For example, @@ -1708,11 +1712,22 @@ public interface Logger { * // do something * } * </pre> + * or: + * <pre> + * public int doSomething(String foo, int bar) { + * Message m = LOGGER.traceEntry("doSomething(foo={}, bar={})", foo, bar); + * // do something + * return traceExit(value, m); + * } + * </pre> * * @param format The format String for the parameters. * @param params The parameters to the method. + * @return The built Message + * + * @since 2.6 */ - void traceEntry(final String format, final Object... params); + EntryMessage traceEntry(String format, Object... params); /** * Logs entry to a method along with its parameters. For example, @@ -1725,8 +1740,11 @@ public interface Logger { * </pre> * * @param paramSuppliers The Suppliers for the parameters to the method. + * @return built message + * + * @since 2.6 */ - void traceEntry(final Supplier<?>... paramSuppliers); + EntryMessage traceEntry(Supplier<?>... paramSuppliers); /** * Logs entry to a method along with its parameters. For example, @@ -1740,8 +1758,11 @@ public interface Logger { * * @param format The format String for the parameters. * @param paramSuppliers The Suppliers for the parameters to the method. + * @return built message + * + * @since 2.6 */ - void traceEntry(final String format, final Supplier<?>... paramSuppliers); + EntryMessage traceEntry(String format, Supplier<?>... paramSuppliers); /** * Logs entry to a method using a Message to describe the parameters. @@ -1753,8 +1774,11 @@ public interface Logger { * </pre> * * @param message The message. + * @return the built message + * + * @since 2.6 */ - void traceEntry(final Message message); + EntryMessage traceEntry(Message message); /** * Logs entry to a method using a Message to describe the parameters. @@ -1766,11 +1790,35 @@ public interface Logger { * </pre> * * @param msgSupplier The Supplier of the Message. + * @return built message + * + * @since 2.6 */ - void traceEntry(final MessageSupplier msgSupplier); + EntryMessage traceEntry(MessageSupplier msgSupplier); + + /** + * Logs entry to a method along with its parameters. For example, + * + * <pre> + * public void doSomething(String foo, int bar) { + * LOGGER.traceEntry("Parameters: {} and {}", ()->gson.toJson(foo), ()-> bar); + * // do something + * } + * </pre> + * + * @param format The format String for the parameters. + * @param params The message suppliers for the parameters to the method. + * @param paramSuppliers The Suppliers for the parameters to the method. + * @return built message + * + * @since 2.6 + */ + EntryMessage traceEntry(String format, MessageSupplier... params); /** * Logs exit from a method. Used for methods that do not return anything. + * + * @since 2.6 */ void traceExit(); @@ -1784,6 +1832,8 @@ public interface Logger { * @param <R> The type of the parameter and object being returned. * @param result The result being returned from the method call. * @return the result. + * + * @since 2.6 */ <R> R traceExit(R result); @@ -1798,8 +1848,10 @@ public interface Logger { * @param format The format String for the result. * @param result The result being returned from the method call. * @return the result. + * + * @since 2.6 */ - <R> R traceExit(final String format, final R result); + <R> R traceExit(String format, R result); /** * Logs exiting from a method with the result. Used when construction of the Message might be @@ -1814,8 +1866,48 @@ public interface Logger { * @param result The result being returned from the method call. * @param messageSupplier The supplier of the Message. * @return the result. + * + * @since 2.6 + */ + <R> R traceExit(R result, MessageSupplier messageSupplier); + + /** + * Logs exiting from a method with the result. Used when construction of the Message might be + * expensive. This may be coded as: + * + * <pre> + * return LOGGER.traceExit(myResult, () -> new ParameterizedMessage("MyResult: field1: {}, field2: {}", + * myResult.field1.toString(), myResult.field2.toString()); + * </pre> + * + * @param <R> The type of the parameter and object being returned. + * @param result The result being returned from the method call. + * @param supplier The supplier of the Message. + * @return the result. + * + * @since 2.6 + */ + <R> R traceExit(R result, Supplier<? extends Message> supplier); + + /** + * Logs exiting from a method with the result. Allows custom formatting of the result. This may be coded as: + * + * <pre> + * public long doSomething(int a, int b) { + * EntryMessage m = traceEntry("doSomething(a={}, b={})", a, b); + * // ... + * return LOGGER.traceExit(myResult, m); + * } + * </pre> + * + * @param <R> The type of the parameter and object being returned. + * @param result The result being returned from the method call. + * @param message The Message containing the formatted result. + * @return the result. + * + * @since 2.6 */ - <R> R traceExit(final R result, final MessageSupplier messageSupplier); + <R> R traceExit(R result, EntryMessage message); /** * Logs exiting from a method with the result. Allows custom formatting of the result. This may be coded as: @@ -1828,8 +1920,10 @@ public interface Logger { * @param result The result being returned from the method call. * @param message The Message containing the formatted result. * @return the result. + * + * @since 2.6 */ - <R> R traceExit(final R result, final Message message); + <R> R traceExit(R result, Message message); /** * Logs a message with the specific Marker at the {@link Level#WARN WARN} level. http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/main/java/org/apache/logging/log4j/message/EntryMessage.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/EntryMessage.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/EntryMessage.java new file mode 100644 index 0000000..c00bd4c --- /dev/null +++ b/log4j-api/src/main/java/org/apache/logging/log4j/message/EntryMessage.java @@ -0,0 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache license, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the license for the specific language governing permissions and + * limitations under the license. + */ +package org.apache.logging.log4j.message; + +/** + * Entry flow messages + * + * @since 2.6 + */ +public interface EntryMessage extends FlowMessage { + // empty +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/main/java/org/apache/logging/log4j/message/ExitMessage.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/ExitMessage.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/ExitMessage.java new file mode 100644 index 0000000..48722f6 --- /dev/null +++ b/log4j-api/src/main/java/org/apache/logging/log4j/message/ExitMessage.java @@ -0,0 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache license, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the license for the specific language governing permissions and + * limitations under the license. + */ +package org.apache.logging.log4j.message; + +/** + * Exit flow messages + * + * @since 2.6 + */ +public interface ExitMessage extends FlowMessage { + // empty +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessage.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessage.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessage.java new file mode 100644 index 0000000..80dced4 --- /dev/null +++ b/log4j-api/src/main/java/org/apache/logging/log4j/message/FlowMessage.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache license, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the license for the specific language governing permissions and + * limitations under the license. + */ +package org.apache.logging.log4j.message; + +/** + * Flow messages + * + * @since 2.6 + */ +public interface FlowMessage extends Message { + + String getText(); + + Message getMessage(); + // empty +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java ---------------------------------------------------------------------- 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 df7a4b9..7acb4f7 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 @@ -21,6 +21,9 @@ import java.io.Serializable; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.Marker; import org.apache.logging.log4j.MarkerManager; +import org.apache.logging.log4j.message.EntryMessage; +import org.apache.logging.log4j.message.ExitMessage; +import org.apache.logging.log4j.message.FlowMessage; import org.apache.logging.log4j.message.Message; import org.apache.logging.log4j.message.MessageFactory; import org.apache.logging.log4j.message.ParameterizedMessageFactory; @@ -302,10 +305,12 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { * @param format Format String for the parameters. * @param paramSuppliers The Suppliers of the parameters. */ - protected void enter(final String fqcn, final String format, final Supplier<?>... paramSuppliers) { + protected EntryMessage enter(final String fqcn, final String format, final Supplier<?>... paramSuppliers) { + EntryMessage entryMsg = null; if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) { - logMessage(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg(format, paramSuppliers), null); + logMessage(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, paramSuppliers), null); } + return entryMsg; } /** @@ -315,10 +320,27 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { * @param format The format String for the parameters. * @param params The parameters to the method. */ - protected void enter(final String fqcn, final String format, final Object... params) { + protected EntryMessage enter(final String fqcn, final String format, final MessageSupplier... paramSuppliers) { + EntryMessage entryMsg = null; if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) { - logMessage(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg(format, params), null); + logMessage(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, paramSuppliers), null); } + return entryMsg; + } + + /** + * Logs entry to a method with location information. + * + * @param fqcn The fully qualified class name of the <b>caller</b>. + * @param format The format String for the parameters. + * @param params The parameters to the method. + */ + protected EntryMessage enter(final String fqcn, final String format, final Object... params) { + EntryMessage entryMsg = null; + if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) { + logMessage(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, params), null); + } + return entryMsg; } /** @@ -327,10 +349,12 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { * @param fqcn The fully qualified class name of the <b>caller</b>. * @param msgSupplier The Supplier of the Message. */ - protected void enter(final String fqcn, final MessageSupplier msgSupplier) { + protected EntryMessage enter(final String fqcn, final MessageSupplier msgSupplier) { + SimpleEntryMessage message = null; if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) { - logMessage(fqcn, Level.TRACE, ENTRY_MARKER, new EntryMessage(msgSupplier.get()), null); + logMessage(fqcn, Level.TRACE, ENTRY_MARKER, message = new SimpleEntryMessage(msgSupplier.get()), null); } + return message; } @Override @@ -359,34 +383,43 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { } } - protected Message entryMsg(final String format, final Object... params) { + 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 messageFactory.newMessage("entry"); + return new SimpleEntryMessage(null); } - return messageFactory.newMessage("entry: " + format); + return new SimpleEntryMessage(messageFactory.newMessage(format)); } - final StringBuilder sb = new StringBuilder("entry"); + final StringBuilder sb = new StringBuilder(); if (format != null) { - sb.append(": ").append(format); - return messageFactory.newMessage(sb.toString(), params); + sb.append(format); + return new SimpleEntryMessage(messageFactory.newMessage(sb.toString(), params)); } - sb.append(" params("); + sb.append("params("); for (int i = 0; i < count; i++) { - Object parm = params[i]; + final Object parm = params[i]; sb.append(parm != null ? parm.toString() : "null"); if (i + 1 < params.length) { sb.append(", "); } } sb.append(')'); - return messageFactory.newMessage(sb.toString()); + return new SimpleEntryMessage(messageFactory.newMessage(sb.toString())); + } + + protected EntryMessage entryMsg(final String format, final MessageSupplier... 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(); + } + return entryMsg(format, params); } - protected Message entryMsg(final String format, final Supplier<?>... paramSuppliers) { + protected EntryMessage entryMsg(final String format, final Supplier<?>... paramSuppliers) { final int count = paramSuppliers == null ? 0 : paramSuppliers.length; - Object[] params = new Object[count]; + final Object[] params = new Object[count]; for (int i = 0; i < count; i++) { params[i] = paramSuppliers[i].get(); } @@ -1274,35 +1307,43 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { } @Override - public void traceEntry() { - enter(FQCN, null, (Object[]) null); + public EntryMessage traceEntry() { + return enter(FQCN, null, (Object[]) null); } @Override - public void traceEntry(final String format, final Object... params) { - enter(FQCN, format, params); + public EntryMessage traceEntry(final String format, final Object... params) { + return enter(FQCN, format, params); } - @Override - public void traceEntry(final Supplier<?>... paramSuppliers) { - enter(FQCN, null, paramSuppliers); + public EntryMessage traceEntry(final String format, final MessageSupplier... params) { + return enter(FQCN, format, params); } @Override - public void traceEntry(final String format, final Supplier<?>... paramSuppliers) { - enter(FQCN, format, paramSuppliers); + public EntryMessage traceEntry(final Supplier<?>... paramSuppliers) { + return enter(FQCN, null, paramSuppliers); } + @Override + public EntryMessage traceEntry(final String format, final Supplier<?>... paramSuppliers) { + return enter(FQCN, format, paramSuppliers); + } @Override - public void traceEntry(final Message message) { - enter(FQCN, new MessageSupplier() { @Override public Message get() { return message; }}); + public EntryMessage traceEntry(final Message message) { + return enter(FQCN, new MessageSupplier() { + @Override + public Message get() { + return message; + } + }); } @Override - public void traceEntry(final MessageSupplier msgSupplier) { - enter(FQCN, msgSupplier); + public EntryMessage traceEntry(final MessageSupplier msgSupplier) { + return enter(FQCN, msgSupplier); } @Override @@ -1320,25 +1361,57 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { return exit(FQCN, format, result); } - @Override public <R> R traceExit(final R result, final MessageSupplier messageSupplier) { if (isEnabled(Level.TRACE, EXIT_MARKER, messageSupplier, null)) { logMessage(FQCN, Level.TRACE, EXIT_MARKER, new MessageSupplier() { - public Message get() { return new ExitMessage(messageSupplier.get()); }; }, null); + @Override + public Message get() { + return new SimpleExitMessage(result, messageSupplier.get()); + }; + }, null); } return result; } @Override - public <R> R traceExit(final R result, final Message message) { + public <R> R traceExit(final R result, final Supplier<? extends Message> messageSupplier) { + if (isEnabled(Level.TRACE, EXIT_MARKER, messageSupplier, null)) { + logMessage(FQCN, Level.TRACE, EXIT_MARKER, new MessageSupplier() { + @Override + public Message get() { + return new SimpleExitMessage(result, messageSupplier.get()); + }; + }, null); + } + return result; + } + + @Override + public <R> R traceExit(final R result, final EntryMessage message) { if (isEnabled(Level.TRACE, EXIT_MARKER, message, null)) { logMessage(FQCN, Level.TRACE, EXIT_MARKER, new MessageSupplier() { - public Message get() { return new ExitMessage(message); }; }, null); + @Override + public Message get() { + return new SimpleExitMessage(result, message); + }; + }, null); } return result; } + @Override + public <R> R traceExit(final R result, final Message message) { + if (isEnabled(Level.TRACE, EXIT_MARKER, message, null)) { + logMessage(FQCN, Level.TRACE, EXIT_MARKER, new MessageSupplier() { + @Override + public Message get() { + return new SimpleExitMessage(result, message); + }; + }, null); + } + return result; + } @Override public void warn(final Marker marker, final Message msg) { @@ -1460,13 +1533,13 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { logIfEnabled(FQCN, Level.WARN, null, msgSupplier, t); } - private static class FlowMessage implements Message { + private static class AbstactFlowMessage implements FlowMessage { - private static final long serialVersionUID = 7580175170272152912L; - private Message message; + private static final long serialVersionUID = 1L; + private final Message message; private final String text; - FlowMessage(String text, Message message) { + AbstactFlowMessage(final String text, final Message message) { this.message = message; this.text = text; } @@ -1474,7 +1547,7 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { @Override public String getFormattedMessage() { if (message != null) { - return text + ": " + message.getFormattedMessage(); + return text + " " + message.getFormattedMessage(); } return text; } @@ -1502,21 +1575,74 @@ public abstract class AbstractLogger implements ExtendedLogger, Serializable { } return null; } + + @Override + public Message getMessage() { + return message; + } + + @Override + public String getText() { + return text; + } + + @Override + public String toString() { + final StringBuilder builder = new StringBuilder(); + builder.append(getClass().getSimpleName()); + builder.append(" [text="); + builder.append(text); + builder.append(", message="); + builder.append(message); + builder.append("]"); + return builder.toString(); + } } - private static class EntryMessage extends FlowMessage { + private static final class SimpleEntryMessage extends AbstactFlowMessage implements EntryMessage { + + private static final String DEAULT_TEXT = "entry"; + private static final long serialVersionUID = 1L; - EntryMessage(Message message) { - super("entry", message); + SimpleEntryMessage(final Message message) { + super(DEAULT_TEXT, message); } } + private static final class SimpleExitMessage extends AbstactFlowMessage implements ExitMessage { + + private static final String DEAULT_TEXT = "exit"; + private static final long serialVersionUID = 1L; + + private final Object result; + private final boolean isVoid; + + SimpleExitMessage(final Object result, final EntryMessage message) { + super(DEAULT_TEXT, message.getMessage()); + this.result = result; + isVoid = false; + } + + SimpleExitMessage(final Object result, final Message message) { + super(DEAULT_TEXT, message); + this.result = result; + isVoid = false; + } - private static class ExitMessage extends FlowMessage { + SimpleExitMessage(final Message message) { + super(DEAULT_TEXT, message); + this.result = null; + isVoid = true; + } - ExitMessage(Message message) { - super("exit", message); + @Override + public String getFormattedMessage() { + final String formattedMessage = super.getFormattedMessage(); + if (isVoid) { + return formattedMessage; + } + return formattedMessage + ": " + result; } } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/3295f113/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java index 8e4d915..c3229bd 100644 --- a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java +++ b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java @@ -16,24 +16,31 @@ */ package org.apache.logging.log4j; +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.startsWith; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + import java.util.Date; import java.util.List; import java.util.Locale; +import org.apache.logging.log4j.message.EntryMessage; import org.apache.logging.log4j.message.JsonMessage; import org.apache.logging.log4j.message.Message; +import org.apache.logging.log4j.message.ObjectMessage; import org.apache.logging.log4j.message.ParameterizedMessageFactory; import org.apache.logging.log4j.message.SimpleMessageFactory; import org.apache.logging.log4j.message.StringFormatterMessageFactory; import org.apache.logging.log4j.message.StructuredDataMessage; import org.apache.logging.log4j.util.MessageSupplier; import org.apache.logging.log4j.util.Strings; +import org.apache.logging.log4j.util.Supplier; import org.junit.Before; import org.junit.Test; - -import static org.hamcrest.CoreMatchers.*; - -import static org.junit.Assert.*; /** * */ @@ -61,19 +68,10 @@ public class LoggerTest { } @Test - public void flowTracingMessageSupplier() { - logger.traceEntry(new MessageSupplier() { - @Override - public Message get() { - return new JsonMessage(System.getProperties()); - } - }); + public void flowTracingMessage() { + logger.traceEntry(new JsonMessage(System.getProperties())); final Response response = new Response(-1, "Generic error"); - logger.traceExit(response, new MessageSupplier() { - @Override public Message get() { - return new JsonMessage(response); - } - }); + logger.traceExit(response, new JsonMessage(response)); assertEquals(2, results.size()); assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); assertThat("Missing entry data", results.get(0), containsString("\"java.runtime.name\":")); @@ -82,7 +80,7 @@ public class LoggerTest { } @Test - public void flowTracingStringObjectArray() { + public void flowTracingString_ObjectArray1() { logger.traceEntry("doFoo(a={}, b={})", 1, 2); logger.traceExit("doFoo(a=1, b=2): {}", 3); assertEquals(2, results.size()); @@ -93,7 +91,18 @@ public class LoggerTest { } @Test - public void flowTracing() { + public void flowTracingString_ObjectArray2() { + EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", 1, 2); + logger.traceExit(3, msg); + assertEquals(2, results.size()); + assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); + 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")); + } + + @Test + public void flowTracingNoExitArgs() { logger.traceEntry(); logger.traceExit(); assertEquals(2, results.size()); @@ -102,6 +111,78 @@ public class LoggerTest { } @Test + public void flowTracingNoArgs() { + final EntryMessage message = logger.traceEntry(); + logger.traceExit(message); + assertEquals(2, results.size()); + assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); + assertThat("Incorrect Exit", results.get(1), startsWith("EXIT[ FLOW ] TRACE exit")); + } + + @Test + public void flowTracingString_MessageSupplierOfObjectMessages() { + EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", new MessageSupplier() { + @Override + public Message get() { + return new ObjectMessage(1); + } + }, new MessageSupplier() { + @Override + public Message get() { + return new ObjectMessage(2); + } + }); + logger.traceExit(3, msg); + assertEquals(2, results.size()); + assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); + 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")); + } + + @Test + public void flowTracingString_SupplierOfObjectMessages() { + EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", new Supplier<Message>() { + @Override + public Message get() { + return new ObjectMessage(1); + } + }, new Supplier<Message>() { + @Override + public Message get() { + return new ObjectMessage(2); + } + }); + logger.traceExit(3, msg); + assertEquals(2, results.size()); + assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); + 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")); + } + + @Test + public void flowTracingString_SupplierOfStrings() { + EntryMessage msg = logger.traceEntry("doFoo(a={}, b={})", new Supplier<String>() { + @Override + public String get() { + return "1"; + } + }, new Supplier<String>() { + @Override + public String get() { + return "2"; + } + }); + logger.traceExit(3, msg); + assertEquals(2, results.size()); + assertThat("Incorrect Entry", results.get(0), startsWith("ENTRY[ FLOW ] TRACE entry")); + 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")); + } + + @Test public void catching() { try { throw new NullPointerException();
