'fix build, other changes

slf4j-api/src/main/java/org/slf4j/event/DefaultLoggingEvent.java

@@ -35,14 +35,14 @@ public DefaultLoggingEvent(Level level, Logger logger) {
 	}
 
 	public void addMarker(Marker marker) {
-		getMarkers().add(marker);
+    	if(markers == null) {
+			markers = new ArrayList<>(2);
+		}
+		markers.add(marker);
 	}
 
 	@Override
 	public List<Marker> getMarkers() {
-		if (markers == null) {
-			markers = new ArrayList<>(5);
-		}
 		return markers;
 	}
 

slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java

@@ -1,9 +1,10 @@
 package org.slf4j.event;
 
 import java.util.Queue;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.slf4j.Marker;
-import org.slf4j.helpers.AbstractLogger;
+import org.slf4j.helpers.LegacyAbstractLogger;
 import org.slf4j.helpers.SubstituteLogger;
 
 /**
@@ -16,7 +17,9 @@
  * @author Wessel van Norel
  *
  */
-public class EventRecodingLogger extends AbstractLogger  {
+public class EventRecodingLogger extends LegacyAbstractLogger {
+
+	private static final long serialVersionUID = -176083308134819629L;
 
 	String name;
 	SubstituteLogger logger;
@@ -39,58 +42,45 @@ public boolean isTraceEnabled() {
 		return RECORD_ALL_EVENTS;
 	}
 
-	public boolean isTraceEnabled(Marker marker) {
-		return RECORD_ALL_EVENTS;
-	}
-
-
 	public boolean isDebugEnabled() {
 		return RECORD_ALL_EVENTS;
 	}
 
-	public boolean isDebugEnabled(Marker marker) {
-		return RECORD_ALL_EVENTS;
-	}
-
 	public boolean isInfoEnabled() {
 		return RECORD_ALL_EVENTS;
 	}
 
-	public boolean isInfoEnabled(Marker marker) {
-		return RECORD_ALL_EVENTS;
-	}
-
 	public boolean isWarnEnabled() {
 		return RECORD_ALL_EVENTS;
 	}
 
-	public boolean isWarnEnabled(Marker marker) {
-		return RECORD_ALL_EVENTS;
-	}
-
-
 	public boolean isErrorEnabled() {
 		return RECORD_ALL_EVENTS;
 	}
 
-	public boolean isErrorEnabled(Marker marker) {
-		return RECORD_ALL_EVENTS;
-	}
-
 	// WARNING: this method assumes that any throwable is properly extracted
-	protected void handleNormalizedLoggingCall(Level level, Marker marker, String msg, Object[] args, Throwable throwable) {
+	protected void handleNormalizedLoggingCall(Level level, Marker marker, String msg, Object[] args,
+			Throwable throwable) {
 		SubstituteLoggingEvent loggingEvent = new SubstituteLoggingEvent();
 		loggingEvent.setTimeStamp(System.currentTimeMillis());
 		loggingEvent.setLevel(level);
 		loggingEvent.setLogger(logger);
 		loggingEvent.setLoggerName(name);
-		loggingEvent.addMarker(marker);
+		if (marker != null) {
+			loggingEvent.addMarker(marker);
+		}
 		loggingEvent.setMessage(msg);
 		loggingEvent.setThreadName(Thread.currentThread().getName());
 
 		loggingEvent.setArgumentArray(args);
 		loggingEvent.setThrowable(throwable);
 
 		eventQueue.add(loggingEvent);
+
+	}
+
+	@Override
+	protected String getFullyQualifiedCallerName() {
+		return null;
 	}
 }

slf4j-api/src/main/java/org/slf4j/event/SubstituteLoggingEvent.java

@@ -30,14 +30,18 @@ public void setLevel(Level level) {
     }
 
     public List<Marker> getMarkers() {
-    	if(markers == null) {
-			markers = new ArrayList<>(5);
-		}
 		return markers;
     }
 
     public void addMarker(Marker marker) {
-        getMarkers().add(marker);
+    	if(marker == null)
+    		return;
+
+    	if(markers == null) {
+			markers = new ArrayList<>(2);
+		}
+
+    	markers.add(marker);
     }
 
     public String getLoggerName() {

slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java

@@ -172,6 +172,10 @@ final public static String basicArrayFormat(final String messagePattern, final O
     	return ft.getMessage();
     }
 
+    public static String basicArrayFormat(NormalizedParameters np) {
+		return basicArrayFormat(np.getMessage(), np.getArguments());
+	}
+
     final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray, Throwable throwable) {
 
         if (messagePattern == null) {
@@ -409,7 +413,7 @@ private static void doubleArrayAppend(StringBuilder sbuf, double[] a) {
 	 *          otherwise it returns null
 	 */
 	public static Throwable getThrowableCandidate(final Object[] argArray) {
-		return ParameterNormalizer.getThrowableCandidate(argArray);
+		return NormalizedParameters.getThrowableCandidate(argArray);
     }
 
 	/**
@@ -421,7 +425,9 @@ public static Throwable getThrowableCandidate(final Object[] argArray) {
 	 * @return a copy of the array without the last element
 	 */
 	public static Object[] trimmedCopy(final Object[] argArray) {
-		return ParameterNormalizer.trimmedCopy(argArray);
+		return NormalizedParameters.trimmedCopy(argArray);
 	}
 
+
+
 }

slf4j-api/src/main/java/org/slf4j/helpers/NormalizedParameters.java

@@ -1,18 +1,21 @@
 package org.slf4j.helpers;
 
+import org.slf4j.event.LoggingEvent;
+
 /**
  * Holds normalized calling call parameters.
  * 
+ * Includes utility methods such as {@link #normalize(String, Object[], Throwable)} to help the normalization of parameters.
+ * 
  * @author ceki
  * @since 2.0
  */
 public class NormalizedParameters {
 
-
 	final String message;
 	final Object[] arguments;
 	final Throwable throwable;
-	
+
 	public NormalizedParameters(String message, Object[] arguments, Throwable throwable) {
 		this.message = message;
 		this.arguments = arguments;
@@ -35,6 +38,79 @@ public Throwable getThrowable() {
 		return throwable;
 	}
 
+	/**
+	 * Helper method to determine if an {@link Object} array contains a
+	 * {@link Throwable} as last element
+	 *
+	 * @param argArray The arguments off which we want to know if it contains a
+	 *                 {@link Throwable} as last element
+	 * @return if the last {@link Object} in argArray is a {@link Throwable} this
+	 *         method will return it, otherwise it returns null
+	 */
+	public static Throwable getThrowableCandidate(final Object[] argArray) {
+		if (argArray == null || argArray.length == 0) {
+			return null;
+		}
+
+		final Object lastEntry = argArray[argArray.length - 1];
+		if (lastEntry instanceof Throwable) {
+			return (Throwable) lastEntry;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Helper method to get all but the last element of an array
+	 *
+	 * @param argArray The arguments from which we want to remove the last element
+	 *
+	 * @return a copy of the array without the last element
+	 */
+	public static Object[] trimmedCopy(final Object[] argArray) {
+		if (argArray == null || argArray.length == 0) {
+			throw new IllegalStateException("non-sensical empty or null argument array");
+		}
+
+		final int trimmedLen = argArray.length - 1;
+
+		Object[] trimmed = new Object[trimmedLen];
+
+		if (trimmedLen > 0) {
+			System.arraycopy(argArray, 0, trimmed, 0, trimmedLen);
+		}
+
+		return trimmed;
+	}
+
+	/**
+	 * This method serves to normalize logging call invocation parameters.
+	 * 
+	 * More specifically, if a throwable argument is not supplied directly, it
+	 * attempts to extract it from the argument array.
+	 */
+	public static NormalizedParameters normalize(String msg, Object[] arguments, Throwable t) {
+
+		if (t != null) {
+			return new NormalizedParameters(msg, arguments, t);
+		}
+
+		if (arguments == null || arguments.length == 0) {
+			return new NormalizedParameters(msg, arguments, t);
+		}
+
+		Throwable throwableCandidate = NormalizedParameters.getThrowableCandidate(arguments);
+		if (throwableCandidate != null) {
+			Object[] trimmedArguments = MessageFormatter.trimmedCopy(arguments);
+			return new NormalizedParameters(msg, trimmedArguments, throwableCandidate);
+		} else {
+			return new NormalizedParameters(msg, arguments);
+		}
+
+	}
+
+	public static NormalizedParameters normalize(LoggingEvent event) {
+		return normalize(event.getMessage(), event.getArgumentArray(), event.getThrowable());
+	}
 
-
 }

slf4j-jdk14/src/main/java/org/slf4j/jul/JDK14LoggerAdapter.java

@@ -36,7 +36,6 @@
 import org.slf4j.helpers.LegacyAbstractLogger;
 import org.slf4j.helpers.MessageFormatter;
 import org.slf4j.helpers.NormalizedParameters;
-import org.slf4j.helpers.ParameterNormalizer;
 import org.slf4j.helpers.SubstituteLogger;
 import org.slf4j.spi.LocationAwareLogger;
 
@@ -174,7 +173,7 @@ public void log(Marker marker, String callerFQCN, int slf4jLevelInt, String mess
 		Level julLevel = slf4jLevelIntToJULLevel(slf4jLevelInt);
 
 		if (logger.isLoggable(julLevel)) {
-			NormalizedParameters np = ParameterNormalizer.normalize(message, arguments, throwable);
+			NormalizedParameters np = NormalizedParameters.normalize(message, arguments, throwable);
 			innerNormalizedLoggingCallHandler(callerFQCN, slf4jLevel, marker, np.getMessage(), np.getArguments(), np.getThrowable());
 		}
 	}

slf4j-log4j12/src/main/java/org/slf4j/log4j12/Log4jLoggerAdapter.java

@@ -37,7 +37,6 @@
 import org.slf4j.helpers.LegacyAbstractLogger;
 import org.slf4j.helpers.MessageFormatter;
 import org.slf4j.helpers.NormalizedParameters;
-import org.slf4j.helpers.ParameterNormalizer;
 import org.slf4j.helpers.SubstituteLogger;
 import org.slf4j.spi.LocationAwareLogger;
 
@@ -148,7 +147,7 @@ public boolean isErrorEnabled() {
     @Override
     public void log(Marker marker, String callerFQCN, int level, String msg, Object[] arguments, Throwable t) {
         Level log4jLevel = toLog4jLevel(level);
-        NormalizedParameters np = ParameterNormalizer.normalize(msg, arguments, t);
+        NormalizedParameters np = NormalizedParameters.normalize(msg, arguments, t);
         String formattedMessage = MessageFormatter.basicArrayFormat(np.getMessage(), np.getArguments());
         logger.log(callerFQCN, log4jLevel, formattedMessage, np.getThrowable());
     }