parseToMap(String stringAsJson) {
- try {
- return new ObjectMapper().readValue(stringAsJson, Map.class);
- } catch (JsonProcessingException e) {
- fail("Failed parsing logger line " + stringAsJson);
- return emptyMap();
- }
- }
-
- private void setupContext() {
- when(context.getFunctionName()).thenReturn("testFunction");
- when(context.getInvokedFunctionArn()).thenReturn("testArn");
- when(context.getFunctionVersion()).thenReturn("1");
- when(context.getMemoryLimitInMB()).thenReturn(10);
- }
-}
\ No newline at end of file
diff --git a/powertools-logging/src/test/java/org/slf4j/test/OutputChoice.java b/powertools-logging/src/test/java/org/slf4j/test/OutputChoice.java
new file mode 100644
index 000000000..096fa7d83
--- /dev/null
+++ b/powertools-logging/src/test/java/org/slf4j/test/OutputChoice.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+package org.slf4j.test;
+
+import java.io.PrintStream;
+
+/**
+ * This class encapsulates the user's choice of output target.
+ *
+ * @author Ceki Gülcü
+ *
+ */
+class OutputChoice {
+
+ enum OutputChoiceType {
+ SYS_OUT, CACHED_SYS_OUT, SYS_ERR, CACHED_SYS_ERR, FILE;
+ }
+
+ final OutputChoiceType outputChoiceType;
+ final PrintStream targetPrintStream;
+
+ OutputChoice(OutputChoiceType outputChoiceType) {
+ if (outputChoiceType == OutputChoiceType.FILE) {
+ throw new IllegalArgumentException();
+ }
+ this.outputChoiceType = outputChoiceType;
+ if (outputChoiceType == OutputChoiceType.CACHED_SYS_OUT) {
+ this.targetPrintStream = System.out;
+ } else if (outputChoiceType == OutputChoiceType.CACHED_SYS_ERR) {
+ this.targetPrintStream = System.err;
+ } else {
+ this.targetPrintStream = null;
+ }
+ }
+
+ OutputChoice(PrintStream printStream) {
+ this.outputChoiceType = OutputChoiceType.FILE;
+ this.targetPrintStream = printStream;
+ }
+
+ PrintStream getTargetPrintStream() {
+ switch (outputChoiceType) {
+ case SYS_OUT:
+ return System.out;
+ case SYS_ERR:
+ return System.err;
+ case CACHED_SYS_ERR:
+ case CACHED_SYS_OUT:
+ case FILE:
+ return targetPrintStream;
+ default:
+ throw new IllegalArgumentException();
+ }
+
+ }
+
+}
diff --git a/powertools-logging/src/test/java/org/slf4j/test/TestLogger.java b/powertools-logging/src/test/java/org/slf4j/test/TestLogger.java
new file mode 100644
index 000000000..d54b51da4
--- /dev/null
+++ b/powertools-logging/src/test/java/org/slf4j/test/TestLogger.java
@@ -0,0 +1,467 @@
+/**
+ * Copyright (c) 2004-2022 QOS.ch Sarl (Switzerland)
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+package org.slf4j.test;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.event.LoggingEvent;
+import org.slf4j.helpers.LegacyAbstractLogger;
+import org.slf4j.helpers.MessageFormatter;
+import org.slf4j.helpers.NormalizedParameters;
+import org.slf4j.spi.LocationAwareLogger;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ *
+ * Simple implementation of {@link Logger} that sends all enabled log messages,
+ * for all defined loggers, to the console ({@code System.err}). The following
+ * system properties are supported to configure the behavior of this logger:
+ *
+ *
+ *
+ * org.slf4j.simpleLogger.logFile - The output target which can
+ * be the path to a file, or the special values "System.out" and
+ * "System.err". Default is "System.err".org.slf4j.simpleLogger.cacheOutputStream - If the output
+ * target is set to "System.out" or "System.err" (see preceding entry), by
+ * default, logs will be output to the latest value referenced by
+ * System.out/err variables. By setting this parameter to true, the
+ * output stream will be cached, i.e. assigned once at initialization time and
+ * re-used independently of the current value referenced by
+ * System.out/err.org.slf4j.simpleLogger.defaultLogLevel - Default log level
+ * for all instances of SimpleLogger. Must be one of ("trace", "debug", "info",
+ * "warn", "error" or "off"). If not specified, defaults to "info".org.slf4j.simpleLogger.log.a.b.c - Logging detail
+ * level for a SimpleLogger instance named "a.b.c". Right-side value must be one
+ * of "trace", "debug", "info", "warn", "error" or "off". When a SimpleLogger
+ * named "a.b.c" is initialized, its level is assigned from this property. If
+ * unspecified, the level of nearest parent logger will be used, and if none is
+ * set, then the value specified by
+ * org.slf4j.simpleLogger.defaultLogLevel will be used.org.slf4j.simpleLogger.showDateTime - Set to
+ * true if you want the current date and time to be included in
+ * output messages. Default is falseorg.slf4j.simpleLogger.dateTimeFormat - The date and time
+ * format to be used in the output messages. The pattern describing the date and
+ * time format is defined by
+ * SimpleDateFormat. If the format is not specified or is
+ * invalid, the number of milliseconds since start up will be output.org.slf4j.simpleLogger.showThreadName -Set to
+ * true if you want to output the current thread name. Defaults to
+ * true.- (since version 1.7.33 and 2.0.0-alpha6)
org.slf4j.simpleLogger.showThreadId -
+ * If you would like to output the current thread id, then set to
+ * true. Defaults to false.
+ *
+ * org.slf4j.simpleLogger.showLogName - Set to
+ * true if you want the Logger instance name to be included in
+ * output messages. Defaults to true.org.slf4j.simpleLogger.showShortLogName - Set to
+ * true if you want the last component of the name to be included
+ * in output messages. Defaults to false.org.slf4j.simpleLogger.levelInBrackets - Should the level
+ * string be output in brackets? Defaults to false.org.slf4j.simpleLogger.warnLevelString - The string value
+ * output for the warn level. Defaults to WARN.
+ *
+ *
+ * In addition to looking for system properties with the names specified above,
+ * this implementation also checks for a class loader resource named
+ * "simplelogger.properties", and includes any matching definitions
+ * from this resource (if it exists).
+ *
+ *
+ *
+ * With no configuration, the default output includes the relative time in
+ * milliseconds, thread name, the level, logger name, and the message followed
+ * by the line separator for the host. In log4j terms it amounts to the "%r [%t]
+ * %level %logger - %m%n" pattern.
+ *
+ *
+ * Sample output follows.
+ *
+ *
+ *
+ * 176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse order.
+ * 225 [main] INFO examples.SortAlgo - Entered the sort method.
+ * 304 [main] INFO examples.SortAlgo - Dump of integer array:
+ * 317 [main] INFO examples.SortAlgo - Element [0] = 0
+ * 331 [main] INFO examples.SortAlgo - Element [1] = 1
+ * 343 [main] INFO examples.Sort - The next log statement should be an error message.
+ * 346 [main] ERROR examples.SortAlgo - Tried to dump an uninitialized array.
+ * at org.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
+ * at org.log4j.examples.Sort.main(Sort.java:64)
+ * 467 [main] INFO examples.Sort - Exiting main method.
+ *
+ *
+ *
+ * This implementation is heavily inspired by
+ * Apache Commons Logging's
+ * SimpleLog.
+ *
+ *
+ * @author Ceki Gülcü
+ * @author Scott Sanders
+ * @author Rod Waldhoff
+ * @author Robert Burrell Donkin
+ * @author Cédrik LIME
+ */
+public class TestLogger extends LegacyAbstractLogger {
+
+ private static final long serialVersionUID = -632788891211436180L;
+
+ private static final long START_TIME = System.currentTimeMillis();
+
+ protected static final int LOG_LEVEL_TRACE = LocationAwareLogger.TRACE_INT;
+ protected static final int LOG_LEVEL_DEBUG = LocationAwareLogger.DEBUG_INT;
+ protected static final int LOG_LEVEL_INFO = LocationAwareLogger.INFO_INT;
+ protected static final int LOG_LEVEL_WARN = LocationAwareLogger.WARN_INT;
+ protected static final int LOG_LEVEL_ERROR = LocationAwareLogger.ERROR_INT;
+
+ static char SP = ' ';
+ static final String TID_PREFIX = "tid=";
+
+
+ // The OFF level can only be used in configuration files to disable logging.
+ // It has
+ // no printing method associated with it in o.s.Logger interface.
+ protected static final int LOG_LEVEL_OFF = LOG_LEVEL_ERROR + 10;
+
+ private static boolean INITIALIZED = false;
+ static final TestLoggerConfiguration CONFIG_PARAMS = new TestLoggerConfiguration();
+
+ static void lazyInit() {
+ if (INITIALIZED) {
+ return;
+ }
+ INITIALIZED = true;
+ init();
+ }
+
+ // external software might be invoking this method directly. Do not rename
+ // or change its semantics.
+ static void init() {
+ CONFIG_PARAMS.init();
+ }
+
+ /** The current log level */
+ protected int currentLogLevel = LOG_LEVEL_INFO;
+ /** The short name of this simple log instance */
+ private transient String shortLogName = null;
+
+ /**
+ * All system properties used by SimpleLogger start with this
+ * prefix
+ */
+ public static final String SYSTEM_PREFIX = "org.slf4j.simpleLogger.";
+
+ public static final String LOG_KEY_PREFIX = TestLogger.SYSTEM_PREFIX + "log.";
+
+ public static final String CACHE_OUTPUT_STREAM_STRING_KEY = TestLogger.SYSTEM_PREFIX + "cacheOutputStream";
+
+ public static final String WARN_LEVEL_STRING_KEY = TestLogger.SYSTEM_PREFIX + "warnLevelString";
+
+ public static final String LEVEL_IN_BRACKETS_KEY = TestLogger.SYSTEM_PREFIX + "levelInBrackets";
+
+ public static final String LOG_FILE_KEY = TestLogger.SYSTEM_PREFIX + "logFile";
+
+ public static final String SHOW_SHORT_LOG_NAME_KEY = TestLogger.SYSTEM_PREFIX + "showShortLogName";
+
+ public static final String SHOW_LOG_NAME_KEY = TestLogger.SYSTEM_PREFIX + "showLogName";
+
+ public static final String SHOW_THREAD_NAME_KEY = TestLogger.SYSTEM_PREFIX + "showThreadName";
+
+ public static final String SHOW_THREAD_ID_KEY = TestLogger.SYSTEM_PREFIX + "showThreadId";
+
+ public static final String DATE_TIME_FORMAT_KEY = TestLogger.SYSTEM_PREFIX + "dateTimeFormat";
+
+ public static final String SHOW_DATE_TIME_KEY = TestLogger.SYSTEM_PREFIX + "showDateTime";
+
+ public static final String DEFAULT_LOG_LEVEL_KEY = TestLogger.SYSTEM_PREFIX + "defaultLogLevel";
+
+ /**
+ * Package access allows only {@link TestLoggerFactory} to instantiate
+ * SimpleLogger instances.
+ */
+ TestLogger(String name) {
+ this.name = name;
+
+ String levelString = recursivelyComputeLevelString();
+ if (levelString != null) {
+ this.currentLogLevel = TestLoggerConfiguration.stringToLevel(levelString);
+ } else {
+ this.currentLogLevel = CONFIG_PARAMS.defaultLogLevel;
+ }
+ }
+
+ public void setLogLevel(String levelString) {
+ this.currentLogLevel = TestLoggerConfiguration.stringToLevel(levelString);
+ }
+
+ public int getLogLevel() {
+ return currentLogLevel;
+ }
+
+ String recursivelyComputeLevelString() {
+ String tempName = name;
+ String levelString = null;
+ int indexOfLastDot = tempName.length();
+ while ((levelString == null) && (indexOfLastDot > -1)) {
+ tempName = tempName.substring(0, indexOfLastDot);
+ levelString = CONFIG_PARAMS.getStringProperty(TestLogger.LOG_KEY_PREFIX + tempName, null);
+ indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
+ }
+ return levelString;
+ }
+
+ /**
+ * To avoid intermingling of log messages and associated stack traces, the two
+ * operations are done in a synchronized block.
+ *
+ * @param buf
+ * @param t
+ */
+ void write(StringBuilder buf, Throwable t) {
+ PrintStream targetStream = CONFIG_PARAMS.outputChoice.getTargetPrintStream();
+
+ synchronized (CONFIG_PARAMS) {
+ targetStream.println(buf.toString());
+ writeThrowable(t, targetStream);
+ targetStream.flush();
+ }
+
+ }
+
+ protected void writeThrowable(Throwable t, PrintStream targetStream) {
+ if (t != null) {
+ t.printStackTrace(targetStream);
+ }
+ }
+
+ private String getFormattedDate() {
+ Date now = new Date();
+ String dateText;
+ synchronized (CONFIG_PARAMS.dateFormatter) {
+ dateText = CONFIG_PARAMS.dateFormatter.format(now);
+ }
+ return dateText;
+ }
+
+ private String computeShortName() {
+ return name.substring(name.lastIndexOf(".") + 1);
+ }
+
+ // /**
+ // * For formatted messages, first substitute arguments and then log.
+ // *
+ // * @param level
+ // * @param format
+ // * @param arg1
+ // * @param arg2
+ // */
+ // private void formatAndLog(int level, String format, Object arg1, Object arg2) {
+ // if (!isLevelEnabled(level)) {
+ // return;
+ // }
+ // FormattingTuple tp = MessageFormatter.format(format, arg1, arg2);
+ // log(level, tp.getMessage(), tp.getThrowable());
+ // }
+
+ // /**
+ // * For formatted messages, first substitute arguments and then log.
+ // *
+ // * @param level
+ // * @param format
+ // * @param arguments
+ // * a list of 3 ore more arguments
+ // */
+ // private void formatAndLog(int level, String format, Object... arguments) {
+ // if (!isLevelEnabled(level)) {
+ // return;
+ // }
+ // FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
+ // log(level, tp.getMessage(), tp.getThrowable());
+ // }
+
+ /**
+ * Is the given log level currently enabled?
+ *
+ * @param logLevel is this level enabled?
+ * @return whether the logger is enabled for the given level
+ */
+ protected boolean isLevelEnabled(int logLevel) {
+ // log level are numerically ordered so can use simple numeric
+ // comparison
+ return (logLevel >= currentLogLevel);
+ }
+
+ /** Are {@code trace} messages currently enabled? */
+ public boolean isTraceEnabled() {
+ return isLevelEnabled(LOG_LEVEL_TRACE);
+ }
+
+ /** Are {@code debug} messages currently enabled? */
+ public boolean isDebugEnabled() {
+ return isLevelEnabled(LOG_LEVEL_DEBUG);
+ }
+
+ /** Are {@code info} messages currently enabled? */
+ public boolean isInfoEnabled() {
+ return isLevelEnabled(LOG_LEVEL_INFO);
+ }
+
+ /** Are {@code warn} messages currently enabled? */
+ public boolean isWarnEnabled() {
+ return isLevelEnabled(LOG_LEVEL_WARN);
+ }
+
+ /** Are {@code error} messages currently enabled? */
+ public boolean isErrorEnabled() {
+ return isLevelEnabled(LOG_LEVEL_ERROR);
+ }
+
+ /**
+ * SimpleLogger's implementation of
+ * {@link org.slf4j.helpers.AbstractLogger#handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable) AbstractLogger#handleNormalizedLoggingCall}
+ * }
+ *
+ * @param level the SLF4J level for this event
+ * @param marker The marker to be used for this event, may be null.
+ * @param messagePattern The message pattern which will be parsed and formatted
+ * @param arguments the array of arguments to be formatted, may be null
+ * @param throwable The exception whose stack trace should be logged, may be null
+ */
+ @Override
+ protected void handleNormalizedLoggingCall(Level level, Marker marker, String messagePattern, Object[] arguments, Throwable throwable) {
+
+ List markers = null;
+
+ if (marker != null) {
+ markers = new ArrayList<>();
+ markers.add(marker);
+ }
+
+ innerHandleNormalizedLoggingCall(level, markers, messagePattern, arguments, throwable);
+ }
+
+ private void innerHandleNormalizedLoggingCall(Level level, List markers, String messagePattern, Object[] arguments, Throwable t) {
+
+ StringBuilder buf = new StringBuilder(32);
+
+ // Append date-time if so configured
+ if (CONFIG_PARAMS.showDateTime) {
+ if (CONFIG_PARAMS.dateFormatter != null) {
+ buf.append(getFormattedDate());
+ buf.append(SP);
+ } else {
+ buf.append(System.currentTimeMillis() - START_TIME);
+ buf.append(SP);
+ }
+ }
+
+ // Append current thread name if so configured
+ if (CONFIG_PARAMS.showThreadName) {
+ buf.append('[');
+ buf.append(Thread.currentThread().getName());
+ buf.append("] ");
+ }
+
+ if (CONFIG_PARAMS.showThreadId) {
+ buf.append(TID_PREFIX);
+ buf.append(Thread.currentThread().getId());
+ buf.append(SP);
+ }
+
+ if (CONFIG_PARAMS.levelInBrackets)
+ buf.append('[');
+
+ // Append a readable representation of the log level
+ String levelStr = level.name();
+ buf.append(levelStr);
+ if (CONFIG_PARAMS.levelInBrackets)
+ buf.append(']');
+ buf.append(SP);
+
+ // Append the name of the log instance if so configured
+ if (CONFIG_PARAMS.showShortLogName) {
+ if (shortLogName == null)
+ shortLogName = computeShortName();
+ buf.append(String.valueOf(shortLogName)).append(" - ");
+ } else if (CONFIG_PARAMS.showLogName) {
+ buf.append(String.valueOf(name)).append(" - ");
+ }
+
+ if (markers != null) {
+ buf.append(SP);
+ for (Marker marker : markers) {
+ buf.append(marker.getName()).append(SP);
+ }
+ }
+
+ String formattedMessage = MessageFormatter.basicArrayFormat(messagePattern, arguments);
+
+ // Append the message
+ buf.append(formattedMessage);
+
+ write(buf, t);
+ }
+
+ public void log(LoggingEvent event) {
+ int levelInt = event.getLevel().toInt();
+
+ if (!isLevelEnabled(levelInt)) {
+ return;
+ }
+
+ NormalizedParameters np = NormalizedParameters.normalize(event);
+
+ innerHandleNormalizedLoggingCall(event.getLevel(), event.getMarkers(), np.getMessage(), np.getArguments(), event.getThrowable());
+ }
+
+ @Override
+ protected String getFullyQualifiedCallerName() {
+ return null;
+ }
+
+}
diff --git a/powertools-logging/src/test/java/org/slf4j/test/TestLoggerConfiguration.java b/powertools-logging/src/test/java/org/slf4j/test/TestLoggerConfiguration.java
new file mode 100644
index 000000000..b90b6d04a
--- /dev/null
+++ b/powertools-logging/src/test/java/org/slf4j/test/TestLoggerConfiguration.java
@@ -0,0 +1,215 @@
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+package org.slf4j.test;
+
+import org.slf4j.helpers.Util;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Properties;
+
+/**
+ * This class holds configuration values for {@link TestLogger}. The
+ * values are computed at runtime. See {@link TestLogger} documentation for
+ * more information.
+ *
+ *
+ * @author Ceki Gülcü
+ * @author Scott Sanders
+ * @author Rod Waldhoff
+ * @author Robert Burrell Donkin
+ * @author Cédrik LIME
+ *
+ * @since 1.7.25
+ */
+public class TestLoggerConfiguration {
+
+ private static final String CONFIGURATION_FILE = "testlogger.properties";
+
+ static int DEFAULT_LOG_LEVEL_DEFAULT = TestLogger.LOG_LEVEL_INFO;
+ int defaultLogLevel = DEFAULT_LOG_LEVEL_DEFAULT;
+
+ private static final boolean SHOW_DATE_TIME_DEFAULT = false;
+ boolean showDateTime = SHOW_DATE_TIME_DEFAULT;
+
+ private static final String DATE_TIME_FORMAT_STR_DEFAULT = null;
+ private static String dateTimeFormatStr = DATE_TIME_FORMAT_STR_DEFAULT;
+
+ DateFormat dateFormatter = null;
+
+ private static final boolean SHOW_THREAD_NAME_DEFAULT = true;
+ boolean showThreadName = SHOW_THREAD_NAME_DEFAULT;
+
+ /**
+ * See https://jira.qos.ch/browse/SLF4J-499
+ * @since 1.7.33 and 2.0.0-alpha6
+ */
+ private static final boolean SHOW_THREAD_ID_DEFAULT = false;
+ boolean showThreadId = SHOW_THREAD_ID_DEFAULT;
+
+ final static boolean SHOW_LOG_NAME_DEFAULT = true;
+ boolean showLogName = SHOW_LOG_NAME_DEFAULT;
+
+ private static final boolean SHOW_SHORT_LOG_NAME_DEFAULT = false;
+ boolean showShortLogName = SHOW_SHORT_LOG_NAME_DEFAULT;
+
+ private static final boolean LEVEL_IN_BRACKETS_DEFAULT = false;
+ boolean levelInBrackets = LEVEL_IN_BRACKETS_DEFAULT;
+
+ private static final String LOG_FILE_DEFAULT = "System.err";
+ private String logFile = LOG_FILE_DEFAULT;
+ OutputChoice outputChoice = null;
+
+ private static final boolean CACHE_OUTPUT_STREAM_DEFAULT = false;
+ private boolean cacheOutputStream = CACHE_OUTPUT_STREAM_DEFAULT;
+
+ private static final String WARN_LEVELS_STRING_DEFAULT = "WARN";
+ String warnLevelString = WARN_LEVELS_STRING_DEFAULT;
+
+ private final Properties properties = new Properties();
+
+ void init() {
+ loadProperties();
+
+ String defaultLogLevelString = getStringProperty(TestLogger.DEFAULT_LOG_LEVEL_KEY, null);
+ if (defaultLogLevelString != null)
+ defaultLogLevel = stringToLevel(defaultLogLevelString);
+
+ showLogName = getBooleanProperty(TestLogger.SHOW_LOG_NAME_KEY, TestLoggerConfiguration.SHOW_LOG_NAME_DEFAULT);
+ showShortLogName = getBooleanProperty(TestLogger.SHOW_SHORT_LOG_NAME_KEY, SHOW_SHORT_LOG_NAME_DEFAULT);
+ showDateTime = getBooleanProperty(TestLogger.SHOW_DATE_TIME_KEY, SHOW_DATE_TIME_DEFAULT);
+ showThreadName = getBooleanProperty(TestLogger.SHOW_THREAD_NAME_KEY, SHOW_THREAD_NAME_DEFAULT);
+ showThreadId = getBooleanProperty(TestLogger.SHOW_THREAD_ID_KEY, SHOW_THREAD_ID_DEFAULT);
+ dateTimeFormatStr = getStringProperty(TestLogger.DATE_TIME_FORMAT_KEY, DATE_TIME_FORMAT_STR_DEFAULT);
+ levelInBrackets = getBooleanProperty(TestLogger.LEVEL_IN_BRACKETS_KEY, LEVEL_IN_BRACKETS_DEFAULT);
+ warnLevelString = getStringProperty(TestLogger.WARN_LEVEL_STRING_KEY, WARN_LEVELS_STRING_DEFAULT);
+
+ logFile = getStringProperty(TestLogger.LOG_FILE_KEY, logFile);
+
+ cacheOutputStream = getBooleanProperty(TestLogger.CACHE_OUTPUT_STREAM_STRING_KEY, CACHE_OUTPUT_STREAM_DEFAULT);
+ outputChoice = computeOutputChoice(logFile, cacheOutputStream);
+
+ if (dateTimeFormatStr != null) {
+ try {
+ dateFormatter = new SimpleDateFormat(dateTimeFormatStr);
+ } catch (IllegalArgumentException e) {
+ Util.report("Bad date format in " + CONFIGURATION_FILE + "; will output relative time", e);
+ }
+ }
+ }
+
+ private void loadProperties() {
+ // Add props from the resource testlogger.properties
+ InputStream in = AccessController.doPrivileged((PrivilegedAction) () -> {
+ ClassLoader threadCL = Thread.currentThread().getContextClassLoader();
+ if (threadCL != null) {
+ return threadCL.getResourceAsStream(CONFIGURATION_FILE);
+ } else {
+ return ClassLoader.getSystemResourceAsStream(CONFIGURATION_FILE);
+ }
+ });
+ if (null != in) {
+ try {
+ properties.load(in);
+ } catch (java.io.IOException e) {
+ // ignored
+ } finally {
+ try {
+ in.close();
+ } catch (java.io.IOException e) {
+ // ignored
+ }
+ }
+ }
+ }
+
+ String getStringProperty(String name, String defaultValue) {
+ String prop = getStringProperty(name);
+ return (prop == null) ? defaultValue : prop;
+ }
+
+ boolean getBooleanProperty(String name, boolean defaultValue) {
+ String prop = getStringProperty(name);
+ return (prop == null) ? defaultValue : "true".equalsIgnoreCase(prop);
+ }
+
+ String getStringProperty(String name) {
+ String prop = null;
+ try {
+ prop = System.getProperty(name);
+ } catch (SecurityException e) {
+ ; // Ignore
+ }
+ return (prop == null) ? properties.getProperty(name) : prop;
+ }
+
+ static int stringToLevel(String levelStr) {
+ if ("trace".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_TRACE;
+ } else if ("debug".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_DEBUG;
+ } else if ("info".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_INFO;
+ } else if ("warn".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_WARN;
+ } else if ("error".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_ERROR;
+ } else if ("off".equalsIgnoreCase(levelStr)) {
+ return TestLogger.LOG_LEVEL_OFF;
+ }
+ // assume INFO by default
+ return TestLogger.LOG_LEVEL_INFO;
+ }
+
+ private static OutputChoice computeOutputChoice(String logFile, boolean cacheOutputStream) {
+ if ("System.err".equalsIgnoreCase(logFile))
+ if (cacheOutputStream)
+ return new OutputChoice(OutputChoice.OutputChoiceType.CACHED_SYS_ERR);
+ else
+ return new OutputChoice(OutputChoice.OutputChoiceType.SYS_ERR);
+ else if ("System.out".equalsIgnoreCase(logFile)) {
+ if (cacheOutputStream)
+ return new OutputChoice(OutputChoice.OutputChoiceType.CACHED_SYS_OUT);
+ else
+ return new OutputChoice(OutputChoice.OutputChoiceType.SYS_OUT);
+ } else {
+ try {
+ FileOutputStream fos = new FileOutputStream(logFile);
+ PrintStream printStream = new PrintStream(fos);
+ return new OutputChoice(printStream);
+ } catch (FileNotFoundException e) {
+ Util.report("Could not open [" + logFile + "]. Defaulting to System.err", e);
+ return new OutputChoice(OutputChoice.OutputChoiceType.SYS_ERR);
+ }
+ }
+ }
+
+}
diff --git a/powertools-logging/src/test/java/org/slf4j/test/TestLoggerFactory.java b/powertools-logging/src/test/java/org/slf4j/test/TestLoggerFactory.java
new file mode 100644
index 000000000..db057d714
--- /dev/null
+++ b/powertools-logging/src/test/java/org/slf4j/test/TestLoggerFactory.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+package org.slf4j.test;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * An implementation of {@link ILoggerFactory} which always returns
+ * {@link TestLogger} instances.
+ *
+ * @author Ceki Gülcü
+ */
+public class TestLoggerFactory implements ILoggerFactory {
+
+ ConcurrentMap loggerMap;
+
+ public TestLoggerFactory() {
+ loggerMap = new ConcurrentHashMap<>();
+ TestLogger.lazyInit();
+ }
+
+ public Map getLoggers() {
+ return loggerMap;
+ }
+
+ /**
+ * Return an appropriate {@link TestLogger} instance by name.
+ */
+ public Logger getLogger(String name) {
+ Logger simpleLogger = loggerMap.get(name);
+ if (simpleLogger != null) {
+ return simpleLogger;
+ } else {
+ Logger newInstance = new TestLogger(name);
+ Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
+ return oldInstance == null ? newInstance : oldInstance;
+ }
+ }
+
+ /**
+ * Clear the internal logger cache.
+ *
+ * This method is intended to be called by classes (in the same package) for
+ * testing purposes. This method is internal. It can be modified, renamed or
+ * removed at any time without notice.
+ *
+ * You are strongly discouraged from calling this method in production code.
+ */
+ void reset() {
+ loggerMap.clear();
+ }
+}
diff --git a/powertools-logging/src/test/java/org/slf4j/test/TestServiceProvider.java b/powertools-logging/src/test/java/org/slf4j/test/TestServiceProvider.java
new file mode 100644
index 000000000..62a0136ef
--- /dev/null
+++ b/powertools-logging/src/test/java/org/slf4j/test/TestServiceProvider.java
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+package org.slf4j.test;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.helpers.BasicMDCAdapter;
+import org.slf4j.helpers.BasicMarkerFactory;
+import org.slf4j.spi.MDCAdapter;
+import org.slf4j.spi.SLF4JServiceProvider;
+
+/**
+ * Copy of the org.slf4j.simple.SimpleServiceProvider, replacing the NoOpMDCAdapter with a BasicMDCAdapter to test the MDC
+ */
+public class TestServiceProvider implements SLF4JServiceProvider {
+ /**
+ * Declare the version of the SLF4J API this implementation is compiled against.
+ * The value of this field is modified with each major release.
+ */
+ // to avoid constant folding by the compiler, this field must *not* be final
+ public static String REQUESTED_API_VERSION = "2.0.99"; // !final
+
+ private ILoggerFactory loggerFactory;
+ private IMarkerFactory markerFactory;
+ private MDCAdapter mdcAdapter;
+
+ public ILoggerFactory getLoggerFactory() {
+ return loggerFactory;
+ }
+
+ @Override
+ public IMarkerFactory getMarkerFactory() {
+ return markerFactory;
+ }
+
+ @Override
+ public MDCAdapter getMDCAdapter() {
+ return mdcAdapter;
+ }
+
+ @Override
+ public String getRequestedApiVersion() {
+ return REQUESTED_API_VERSION;
+ }
+
+ @Override
+ public void initialize() {
+
+ loggerFactory = new TestLoggerFactory();
+ markerFactory = new BasicMarkerFactory();
+ mdcAdapter = new BasicMDCAdapter();
+ }
+
+}
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/LoggingUtilsTest.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/LoggingUtilsTest.java
index 91fea4c7a..348897e18 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/LoggingUtilsTest.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/LoggingUtilsTest.java
@@ -13,12 +13,12 @@
*/
package software.amazon.lambda.powertools.logging;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.apache.logging.log4j.ThreadContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.slf4j.MDC;
+
+import java.util.HashMap;
+import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
@@ -27,62 +27,62 @@ class LoggingUtilsTest {
@BeforeEach
void setUp() {
- ThreadContext.clearAll();
+ MDC.clear();
}
@Test
void shouldSetCustomKeyOnThreadContext() {
- LoggingUtils.appendKey("test", "value");
+ LoggingUtils.appendKey("org/slf4j/test", "value");
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(1)
- .containsEntry("test", "value");
+ .containsEntry("org/slf4j/test", "value");
}
@Test
void shouldSetCustomKeyAsMapOnThreadContext() {
Map customKeys = new HashMap<>();
- customKeys.put("test", "value");
+ customKeys.put("org/slf4j/test", "value");
customKeys.put("test1", "value1");
LoggingUtils.appendKeys(customKeys);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(2)
- .containsEntry("test", "value")
+ .containsEntry("org/slf4j/test", "value")
.containsEntry("test1", "value1");
}
@Test
void shouldRemoveCustomKeyOnThreadContext() {
- LoggingUtils.appendKey("test", "value");
+ LoggingUtils.appendKey("org/slf4j/test", "value");
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(1)
- .containsEntry("test", "value");
+ .containsEntry("org/slf4j/test", "value");
- LoggingUtils.removeKey("test");
+ LoggingUtils.removeKey("org/slf4j/test");
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.isEmpty();
}
@Test
void shouldRemoveCustomKeysOnThreadContext() {
Map customKeys = new HashMap<>();
- customKeys.put("test", "value");
+ customKeys.put("org/slf4j/test", "value");
customKeys.put("test1", "value1");
LoggingUtils.appendKeys(customKeys);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(2)
- .containsEntry("test", "value")
+ .containsEntry("org/slf4j/test", "value")
.containsEntry("test1", "value1");
- LoggingUtils.removeKeys("test", "test1");
+ LoggingUtils.removeKeys("org/slf4j/test", "test1");
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.isEmpty();
}
}
\ No newline at end of file
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolAlbCorrelationId.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolAlbCorrelationId.java
index 125c13e26..d1eb33392 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolAlbCorrelationId.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolAlbCorrelationId.java
@@ -16,16 +16,14 @@
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.ApplicationLoadBalancerRequestEvent;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import software.amazon.lambda.powertools.logging.CorrelationIdPathConstants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import software.amazon.lambda.powertools.logging.Logging;
-import static software.amazon.lambda.powertools.logging.CorrelationIdPathConstants.API_GATEWAY_REST;
import static software.amazon.lambda.powertools.logging.CorrelationIdPathConstants.APPLICATION_LOAD_BALANCER;
public class PowerLogToolAlbCorrelationId implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolAlbCorrelationId.class);
+ private final Logger LOG = LoggerFactory.getLogger(PowerLogToolAlbCorrelationId.class);
@Override
@Logging(correlationIdPath = APPLICATION_LOAD_BALANCER)
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayHttpApiCorrelationId.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayHttpApiCorrelationId.java
index 4e40e0f97..ac347c5c5 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayHttpApiCorrelationId.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayHttpApiCorrelationId.java
@@ -16,14 +16,14 @@
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPEvent;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import software.amazon.lambda.powertools.logging.Logging;
import static software.amazon.lambda.powertools.logging.CorrelationIdPathConstants.API_GATEWAY_HTTP;
public class PowerLogToolApiGatewayHttpApiCorrelationId implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolApiGatewayHttpApiCorrelationId.class);
+ private final Logger LOG = LoggerFactory.getLogger(PowerLogToolApiGatewayHttpApiCorrelationId.class);
@Override
@Logging(correlationIdPath = API_GATEWAY_HTTP)
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayRestApiCorrelationId.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayRestApiCorrelationId.java
index e3cadaf84..c8b782412 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayRestApiCorrelationId.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolApiGatewayRestApiCorrelationId.java
@@ -16,14 +16,14 @@
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import software.amazon.lambda.powertools.logging.Logging;
import static software.amazon.lambda.powertools.logging.CorrelationIdPathConstants.API_GATEWAY_REST;
public class PowerLogToolApiGatewayRestApiCorrelationId implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolApiGatewayRestApiCorrelationId.class);
+ private final Logger LOG = LoggerFactory.getLogger(PowerLogToolApiGatewayRestApiCorrelationId.class);
@Override
@Logging(correlationIdPath = API_GATEWAY_REST)
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabled.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabled.java
index e154bbcf3..b68fd4f2e 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabled.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabled.java
@@ -15,12 +15,12 @@
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import software.amazon.lambda.powertools.logging.Logging;
public class PowerLogToolEnabled implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolEnabled.class);
+ private final Logger LOG = LoggerFactory.getLogger(PowerLogToolEnabled.class);
@Override
@Logging
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabledWithClearState.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabledWithClearState.java
deleted file mode 100644
index 8fef32c94..000000000
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolEnabledWithClearState.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2020 Amazon.com, Inc. or its affiliates.
- * Licensed 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 software.amazon.lambda.powertools.logging.handlers;
-
-import com.amazonaws.services.lambda.runtime.Context;
-import com.amazonaws.services.lambda.runtime.RequestHandler;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import software.amazon.lambda.powertools.logging.Logging;
-import software.amazon.lambda.powertools.logging.LoggingUtils;
-
-public class PowerLogToolEnabledWithClearState implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolEnabledWithClearState.class);
- public static int COUNT = 1;
- @Override
- @Logging(clearState = true)
- public Object handleRequest(Object input, Context context) {
- if(COUNT == 1) {
- LoggingUtils.appendKey("TestKey", "TestValue");
- }
- LOG.info("Test event");
- COUNT++;
- return null;
- }
-}
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolSamplingEnabled.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolSamplingEnabled.java
index 9d3d68e2e..082fd6993 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolSamplingEnabled.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerLogToolSamplingEnabled.java
@@ -15,12 +15,12 @@
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import software.amazon.lambda.powertools.logging.Logging;
public class PowerLogToolSamplingEnabled implements RequestHandler {
- private final Logger LOG = LogManager.getLogger(PowerLogToolSamplingEnabled.class);
+ private final Logger LOG = LoggerFactory.getLogger(PowerLogToolSamplingEnabled.class);
@Override
@Logging(samplingRate = 1.0)
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolDisabledForStream.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolDisabledForStream.java
index f0f7f676e..15b39c6c5 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolDisabledForStream.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolDisabledForStream.java
@@ -13,12 +13,12 @@
*/
package software.amazon.lambda.powertools.logging.handlers;
-import java.io.InputStream;
-import java.io.OutputStream;
-
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
+import java.io.InputStream;
+import java.io.OutputStream;
+
public class PowerToolDisabledForStream implements RequestStreamHandler {
@Override
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabled.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabled.java
deleted file mode 100644
index 152eb284d..000000000
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabled.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright 2020 Amazon.com, Inc. or its affiliates.
- * Licensed 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 software.amazon.lambda.powertools.logging.handlers;
-
-import com.amazonaws.services.lambda.runtime.Context;
-import com.amazonaws.services.lambda.runtime.RequestHandler;
-import software.amazon.lambda.powertools.logging.Logging;
-
-public class PowerToolLogEventEnabled implements RequestHandler {
-
- @Logging(logEvent = true)
- @Override
- public Object handleRequest(Object input, Context context) {
- return null;
- }
-}
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledForStream.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledForStream.java
deleted file mode 100644
index 473042e6c..000000000
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledForStream.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2020 Amazon.com, Inc. or its affiliates.
- * Licensed 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 software.amazon.lambda.powertools.logging.handlers;
-
-import com.amazonaws.services.lambda.runtime.Context;
-import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import software.amazon.lambda.powertools.logging.Logging;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.Map;
-
-public class PowerToolLogEventEnabledForStream implements RequestStreamHandler {
-
- @Logging(logEvent = true)
- @Override
- public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException {
- ObjectMapper mapper = new ObjectMapper();
- mapper.writeValue(output, mapper.readValue(input, Map.class));
- }
-}
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledWithCustomMapper.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledWithCustomMapper.java
deleted file mode 100644
index d761c9ac0..000000000
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/handlers/PowerToolLogEventEnabledWithCustomMapper.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package software.amazon.lambda.powertools.logging.handlers;
-
-import java.io.IOException;
-
-import com.amazonaws.services.lambda.runtime.Context;
-import com.amazonaws.services.lambda.runtime.RequestHandler;
-import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification;
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializerProvider;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import com.fasterxml.jackson.databind.ser.std.StdSerializer;
-import software.amazon.lambda.powertools.logging.Logging;
-import software.amazon.lambda.powertools.logging.LoggingUtils;
-
-public class PowerToolLogEventEnabledWithCustomMapper implements RequestHandler {
-
- static {
- ObjectMapper objectMapper = new ObjectMapper();
- SimpleModule module = new SimpleModule();
- module.addSerializer(S3EventNotification.class, new S3EventNotificationSerializer());
- objectMapper.registerModule(module);
- LoggingUtils.defaultObjectMapper(objectMapper);
- }
-
- @Logging(logEvent = true)
- @Override
- public Object handleRequest(S3EventNotification input, Context context) {
- return null;
- }
-
- static class S3EventNotificationSerializer extends StdSerializer {
-
- public S3EventNotificationSerializer() {
- this(null);
- }
-
- public S3EventNotificationSerializer(Class t) {
- super(t);
- }
-
- @Override
- public void serialize(S3EventNotification o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
- jsonGenerator.writeStartObject();
- jsonGenerator.writeStringField("eventSource", o.getRecords().get(0).getEventSource());
- jsonGenerator.writeEndObject();
- }
- }
-}
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/LambdaLoggingAspectTest.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/LambdaLoggingAspectTest.java
index e2cb58453..6c1d055c9 100644
--- a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/LambdaLoggingAspectTest.java
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/LambdaLoggingAspectTest.java
@@ -13,72 +13,40 @@
*/
package software.amazon.lambda.powertools.logging.internal;
-import java.io.BufferedReader;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPEvent;
import com.amazonaws.services.lambda.runtime.events.ApplicationLoadBalancerRequestEvent;
-import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification;
import com.amazonaws.services.lambda.runtime.tests.annotations.Event;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.ThreadContext;
-import org.json.JSONException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.mockito.Mock;
import org.mockito.MockedStatic;
+import org.slf4j.MDC;
+import org.slf4j.event.Level;
import software.amazon.lambda.powertools.core.internal.LambdaHandlerProcessor;
import software.amazon.lambda.powertools.core.internal.SystemWrapper;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolAlbCorrelationId;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolApiGatewayHttpApiCorrelationId;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolApiGatewayRestApiCorrelationId;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolEnabled;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolEnabledForStream;
-import software.amazon.lambda.powertools.logging.handlers.PowerLogToolEnabledWithClearState;
-import software.amazon.lambda.powertools.logging.handlers.PowerToolDisabled;
-import software.amazon.lambda.powertools.logging.handlers.PowerToolDisabledForStream;
-import software.amazon.lambda.powertools.logging.handlers.PowerToolLogEventEnabled;
-import software.amazon.lambda.powertools.logging.handlers.PowerToolLogEventEnabledForStream;
-import software.amazon.lambda.powertools.logging.handlers.PowerToolLogEventEnabledWithCustomMapper;
-
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.RequestParametersEntity;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.ResponseElementsEntity;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3BucketEntity;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3Entity;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3EventNotificationRecord;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3ObjectEntity;
-import static com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.UserIdentityEntity;
-import static java.util.Collections.emptyMap;
-import static java.util.Collections.singletonList;
-import static java.util.stream.Collectors.joining;
+import software.amazon.lambda.powertools.logging.handlers.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.channels.FileChannel;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+
import static org.apache.commons.lang3.reflect.FieldUtils.writeStaticField;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.openMocks;
-import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
import static software.amazon.lambda.powertools.core.internal.SystemWrapper.getenv;
+import static software.amazon.lambda.powertools.logging.internal.PowertoolsLoggedFields.*;
class LambdaLoggingAspectTest {
@@ -92,7 +60,7 @@ class LambdaLoggingAspectTest {
@BeforeEach
void setUp() throws IllegalAccessException, IOException, NoSuchMethodException, InvocationTargetException {
openMocks(this);
- ThreadContext.clearAll();
+ MDC.clear();
writeStaticField(LambdaHandlerProcessor.class, "IS_COLD_START", null, true);
setupContext();
requestHandler = new PowerLogToolEnabled();
@@ -106,15 +74,15 @@ void setUp() throws IllegalAccessException, IOException, NoSuchMethodException,
void shouldSetLambdaContextWhenEnabled() {
requestHandler.handleRequest(new Object(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE)
- .containsEntry(DefaultLambdaFields.FUNCTION_ARN.getName(), "testArn")
- .containsEntry(DefaultLambdaFields.FUNCTION_MEMORY_SIZE.getName(), "10")
- .containsEntry(DefaultLambdaFields.FUNCTION_VERSION.getName(), "1")
- .containsEntry(DefaultLambdaFields.FUNCTION_NAME.getName(), "testFunction")
- .containsEntry(DefaultLambdaFields.FUNCTION_REQUEST_ID.getName(), "RequestId")
- .containsKey("coldStart")
- .containsKey("service");
+ .containsEntry(FUNCTION_ARN.getName(), "testArn")
+ .containsEntry(FUNCTION_MEMORY_SIZE.getName(), "10")
+ .containsEntry(FUNCTION_VERSION.getName(), "1")
+ .containsEntry(FUNCTION_NAME.getName(), "testFunction")
+ .containsEntry(FUNCTION_REQUEST_ID.getName(), "RequestId")
+ .containsKey(FUNCTION_COLD_START.getName())
+ .containsKey(SERVICE.getName());
}
@Test
@@ -123,30 +91,30 @@ void shouldSetLambdaContextForStreamHandlerWhenEnabled() throws IOException {
requestStreamHandler.handleRequest(new ByteArrayInputStream(new byte[]{}), new ByteArrayOutputStream(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE)
- .containsEntry(DefaultLambdaFields.FUNCTION_ARN.getName(), "testArn")
- .containsEntry(DefaultLambdaFields.FUNCTION_MEMORY_SIZE.getName(), "10")
- .containsEntry(DefaultLambdaFields.FUNCTION_VERSION.getName(), "1")
- .containsEntry(DefaultLambdaFields.FUNCTION_NAME.getName(), "testFunction")
- .containsEntry(DefaultLambdaFields.FUNCTION_REQUEST_ID.getName(), "RequestId")
- .containsKey("coldStart")
- .containsKey("service");
+ .containsEntry(FUNCTION_ARN.getName(), "testArn")
+ .containsEntry(FUNCTION_MEMORY_SIZE.getName(), "10")
+ .containsEntry(FUNCTION_VERSION.getName(), "1")
+ .containsEntry(FUNCTION_NAME.getName(), "testFunction")
+ .containsEntry(FUNCTION_REQUEST_ID.getName(), "RequestId")
+ .containsKey(FUNCTION_COLD_START.getName())
+ .containsKey(SERVICE.getName());
}
@Test
void shouldSetColdStartFlag() throws IOException {
requestStreamHandler.handleRequest(new ByteArrayInputStream(new byte[]{}), new ByteArrayOutputStream(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE)
- .containsEntry("coldStart", "true");
+ .containsEntry(FUNCTION_COLD_START.getName(), "true");
requestStreamHandler.handleRequest(new ByteArrayInputStream(new byte[]{}), new ByteArrayOutputStream(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE)
- .containsEntry("coldStart", "false");
+ .containsEntry(FUNCTION_COLD_START.getName(), "false");
}
@Test
@@ -155,8 +123,7 @@ void shouldNotSetLambdaContextWhenDisabled() {
requestHandler.handleRequest(new Object(), context);
- assertThat(ThreadContext.getImmutableContext())
- .isEmpty();
+ assertThat(MDC.getCopyOfContextMap()).isNull();
}
@Test
@@ -165,8 +132,7 @@ void shouldNotSetLambdaContextForStreamHandlerWhenDisabled() throws IOException
requestStreamHandler.handleRequest(null, null, context);
- assertThat(ThreadContext.getImmutableContext())
- .isEmpty();
+ assertThat(MDC.getCopyOfContextMap()).isNull();
}
@Test
@@ -175,63 +141,7 @@ void shouldHaveNoEffectIfNotUsedOnLambdaHandler() {
handler.anotherMethod();
- assertThat(ThreadContext.getImmutableContext())
- .isEmpty();
- }
-
- @Test
- void shouldLogEventForHandler() throws IOException, JSONException {
- requestHandler = new PowerToolLogEventEnabled();
- S3EventNotification s3EventNotification = s3EventNotification();
-
- requestHandler.handleRequest(s3EventNotification, context);
-
- Map log = parseToMap(Files.lines(Paths.get("target/logfile.json")).collect(joining()));
-
- String event = (String) log.get("message");
-
- String expectEvent = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/s3EventNotification.json")))
- .lines().collect(joining("\n"));
-
- assertEquals(expectEvent, event, false);
- }
-
- @Test
- void shouldLogEventForHandlerWithOverriddenObjectMapper() throws IOException, JSONException {
- RequestHandler handler = new PowerToolLogEventEnabledWithCustomMapper();
- S3EventNotification s3EventNotification = s3EventNotification();
-
- handler.handleRequest(s3EventNotification, context);
-
- Map log = parseToMap(Files.lines(Paths.get("target/logfile.json")).collect(joining()));
-
- String event = (String) log.get("message");
-
- String expectEvent = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/customizedLogEvent.json")))
- .lines().collect(joining("\n"));
-
- assertEquals(expectEvent, event, false);
- }
-
- @Test
- void shouldLogEventForStreamAndLambdaStreamIsValid() throws IOException, JSONException {
- requestStreamHandler = new PowerToolLogEventEnabledForStream();
- ByteArrayOutputStream output = new ByteArrayOutputStream();
- S3EventNotification s3EventNotification = s3EventNotification();
-
- requestStreamHandler.handleRequest(new ByteArrayInputStream(new ObjectMapper().writeValueAsBytes(s3EventNotification)), output, context);
-
- assertThat(new String(output.toByteArray(), StandardCharsets.UTF_8))
- .isNotEmpty();
-
- Map log = parseToMap(Files.lines(Paths.get("target/logfile.json")).collect(joining()));
-
- String event = (String) log.get("message");
-
- String expectEvent = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/s3EventNotification.json")))
- .lines().collect(joining("\n"));
-
- assertEquals(expectEvent, event, false);
+ assertThat(MDC.getCopyOfContextMap()).isNull();
}
@Test
@@ -239,9 +149,9 @@ void shouldLogServiceNameWhenEnvVarSet() throws IllegalAccessException {
writeStaticField(LambdaHandlerProcessor.class, "SERVICE_NAME", "testService", true);
requestHandler.handleRequest(new Object(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE)
- .containsEntry("service", "testService");
+ .containsEntry(SERVICE.getName(), "testService");
}
@Test
@@ -253,9 +163,9 @@ void shouldLogxRayTraceIdEnvVarSet() {
requestHandler.handleRequest(new Object(), context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE + 1)
- .containsEntry("xray_trace_id", xRayTraceId);
+ .containsEntry(FUNCTION_TRACE_ID.getName(), xRayTraceId);
}
}
@@ -265,7 +175,7 @@ void shouldLogCorrelationIdOnAPIGatewayProxyRequestEvent(APIGatewayProxyRequestE
RequestHandler handler = new PowerLogToolApiGatewayRestApiCorrelationId();
handler.handleRequest(event, context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE + 1)
.containsEntry("correlation_id", event.getRequestContext().getRequestId());
}
@@ -276,7 +186,7 @@ void shouldLogCorrelationIdOnAPIGatewayV2HTTPEvent(APIGatewayV2HTTPEvent event)
RequestHandler handler = new PowerLogToolApiGatewayHttpApiCorrelationId();
handler.handleRequest(event, context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE + 1)
.containsEntry("correlation_id", event.getRequestContext().getRequestId());
}
@@ -287,31 +197,11 @@ void shouldLogCorrelationIdOnALBEvent(ApplicationLoadBalancerRequestEvent event)
RequestHandler handler = new PowerLogToolAlbCorrelationId();
handler.handleRequest(event, context);
- assertThat(ThreadContext.getImmutableContext())
+ assertThat(MDC.getCopyOfContextMap())
.hasSize(EXPECTED_CONTEXT_SIZE + 1)
.containsEntry("correlation_id", event.getHeaders().get("x-amzn-trace-id"));
}
- @Test
- void shouldLogAndClearLogContextOnEachRequest() throws IOException {
- requestHandler = new PowerLogToolEnabledWithClearState();
- S3EventNotification s3EventNotification = s3EventNotification();
-
- requestHandler.handleRequest(s3EventNotification, context);
- requestHandler.handleRequest(s3EventNotification, context);
-
- List logLines = Files.lines(Paths.get("target/logfile.json")).collect(Collectors.toList());
- Map invokeLog = parseToMap(logLines.get(0));
-
- assertThat(invokeLog)
- .containsEntry("TestKey", "TestValue");
-
- invokeLog = parseToMap(logLines.get(1));
-
- assertThat(invokeLog)
- .doesNotContainKey("TestKey");
- }
-
private void setupContext() {
when(context.getFunctionName()).thenReturn("testFunction");
when(context.getInvokedFunctionArn()).thenReturn("testArn");
@@ -326,37 +216,4 @@ private void resetLogLevel(Level level) throws NoSuchMethodException, IllegalAcc
resetLogLevels.invoke(null, level);
writeStaticField(LambdaLoggingAspect.class, "LEVEL_AT_INITIALISATION", level, true);
}
-
- private S3EventNotification s3EventNotification() {
- S3EventNotificationRecord record = new S3EventNotificationRecord("us-west-2",
- "ObjectCreated:Put",
- "aws:s3",
- null,
- "2.1",
- new RequestParametersEntity("127.0.0.1"),
- new ResponseElementsEntity("C3D13FE58DE4C810", "FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD"),
- new S3Entity("testConfigRule",
- new S3BucketEntity("mybucket",
- new UserIdentityEntity("A3NL1KOZZKExample"),
- "arn:aws:s3:::mybucket"),
- new S3ObjectEntity("HappyFace.jpg",
- 1024L,
- "d41d8cd98f00b204e9800998ecf8427e",
- "096fKKXTRTtl3on89fVO.nfljtsv6qko",
- "0055AED6DCD90281E5"),
- "1.0"),
- new UserIdentityEntity("AIDAJDPLRKLG7UEXAMPLE")
- );
-
- return new S3EventNotification(singletonList(record));
- }
-
- private Map parseToMap(String stringAsJson) {
- try {
- return new ObjectMapper().readValue(stringAsJson, Map.class);
- } catch (JsonProcessingException e) {
- fail("Failed parsing logger line " + stringAsJson);
- return emptyMap();
- }
- }
}
\ No newline at end of file
diff --git a/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/TestLoggingManager.java b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/TestLoggingManager.java
new file mode 100644
index 000000000..17ace1689
--- /dev/null
+++ b/powertools-logging/src/test/java/software/amazon/lambda/powertools/logging/internal/TestLoggingManager.java
@@ -0,0 +1,31 @@
+package software.amazon.lambda.powertools.logging.internal;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+import org.slf4j.test.TestLogger;
+import org.slf4j.test.TestLoggerFactory;
+
+public class TestLoggingManager implements LoggingManager {
+
+ private final TestLoggerFactory loggerFactory;
+
+ public TestLoggingManager() {
+ ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
+ if (!(loggerFactory instanceof TestLoggerFactory)) {
+ throw new RuntimeException("LoggerFactory does not match required type: " + TestLoggerFactory.class.getName());
+ }
+ this.loggerFactory = (TestLoggerFactory) loggerFactory;
+ }
+
+ @Override
+ public void resetLogLevel(Level logLevel) {
+ loggerFactory.getLoggers().forEach( (key, logger) -> ((TestLogger) logger).setLogLevel(logLevel.toString()));
+ }
+
+ @Override
+ public Level getLogLevel(Logger logger) {
+ return org.slf4j.event.Level.intToLevel(((TestLogger) logger).getLogLevel());
+ }
+}
diff --git a/powertools-logging/src/test/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider b/powertools-logging/src/test/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider
new file mode 100644
index 000000000..ade4bb1e2
--- /dev/null
+++ b/powertools-logging/src/test/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider
@@ -0,0 +1 @@
+org.slf4j.test.TestServiceProvider
\ No newline at end of file
diff --git a/powertools-logging/src/test/resources/testlogger.properties b/powertools-logging/src/test/resources/testlogger.properties
new file mode 100644
index 000000000..84b7beaae
--- /dev/null
+++ b/powertools-logging/src/test/resources/testlogger.properties
@@ -0,0 +1,3 @@
+org.slf4j.simpleLogger.defaultLogLevel=warn
+org.slf4j.simpleLogger.log.software.amazon.lambda.powertools=info
+org.slf4j.simpleLogger.logFile=target/logfile.json
\ No newline at end of file
diff --git a/powertools-metrics/pom.xml b/powertools-metrics/pom.xml
index 1f83a6c19..dbc05b2f5 100644
--- a/powertools-metrics/pom.xml
+++ b/powertools-metrics/pom.xml
@@ -10,7 +10,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
AWS Lambda Powertools for Java library Metrics
diff --git a/powertools-parameters/pom.xml b/powertools-parameters/pom.xml
index fb05bf738..f2856eaaa 100644
--- a/powertools-parameters/pom.xml
+++ b/powertools-parameters/pom.xml
@@ -7,7 +7,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
powertools-parameters
diff --git a/powertools-serialization/pom.xml b/powertools-serialization/pom.xml
index 69176ea3a..640a1d526 100644
--- a/powertools-serialization/pom.xml
+++ b/powertools-serialization/pom.xml
@@ -7,7 +7,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
powertools-serialization
diff --git a/powertools-sqs/pom.xml b/powertools-sqs/pom.xml
index f3ebd5e58..3a76941d3 100644
--- a/powertools-sqs/pom.xml
+++ b/powertools-sqs/pom.xml
@@ -10,7 +10,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
AWS Lambda Powertools for Java library SQS
diff --git a/powertools-test-suite/pom.xml b/powertools-test-suite/pom.xml
index 95f9a8b22..adf199df5 100644
--- a/powertools-test-suite/pom.xml
+++ b/powertools-test-suite/pom.xml
@@ -10,7 +10,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
AWS Lambda Powertools for Java library Test Suite
diff --git a/powertools-tracing/pom.xml b/powertools-tracing/pom.xml
index 59221ac4d..dc3be7682 100644
--- a/powertools-tracing/pom.xml
+++ b/powertools-tracing/pom.xml
@@ -10,7 +10,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
AWS Lambda Powertools for Java library Tracing
diff --git a/powertools-validation/pom.xml b/powertools-validation/pom.xml
index c5a0a767c..0a3ec0f27 100644
--- a/powertools-validation/pom.xml
+++ b/powertools-validation/pom.xml
@@ -10,7 +10,7 @@
powertools-parent
software.amazon.lambda
- 1.12.3
+ 2.0.0-beta
AWS Lambda Powertools for Java validation library
diff --git a/spotbugs-exclude.xml b/spotbugs-exclude.xml
index 0c8d1d8f8..118fe54c4 100644
--- a/spotbugs-exclude.xml
+++ b/spotbugs-exclude.xml
@@ -12,22 +12,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -38,20 +22,12 @@
-
-
-
-
-
-
-
-
-
-
+
+
-
-
+
+