ongoing work on fluent api

slf4j-api/src/main/java/org/slf4j/Logger.java

@@ -25,7 +25,11 @@
 
 package org.slf4j;
 
+import static org.slf4j.event.Level.DEBUG;
+import static org.slf4j.event.Level.ERROR;
+import static org.slf4j.event.Level.INFO;
 import static org.slf4j.event.Level.TRACE;
+import static org.slf4j.event.Level.WARN;
 
 import org.slf4j.spi.DefaultLoggingEventBuilder;
 import org.slf4j.spi.LoggingEventBuilder;
@@ -165,7 +169,7 @@ public interface Logger {
     public boolean isTraceEnabled(Marker marker);
 
     /**
-     * 
+     * Entry point for fluent-logging for {@link TRACE} level. 
      *  
      * @return LoggingEventBuilder instance as appropriate for level TRACE
      */
@@ -359,6 +363,20 @@ default public LoggingEventBuilder atTrace() {
      */
     public void debug(Marker marker, String msg, Throwable t);
 
+
+    /**
+     * Entry point for fluent-logging for {@link DEBUG} level. 
+     *  
+     * @return LoggingEventBuilder instance as appropriate for level DEBUG
+     */
+    default public LoggingEventBuilder atDebug() {
+    	if(isDebugEnabled()) {
+    		return new DefaultLoggingEventBuilder(DEBUG, this);
+    	} else {
+    		return NOPLoggingEventBuilder.singleton();
+    	}
+    }
+
     /**
      * Is the logger instance enabled for the INFO level?
      *
@@ -484,6 +502,20 @@ default public LoggingEventBuilder atTrace() {
      */
     public void info(Marker marker, String msg, Throwable t);
 
+    /**
+     * Entry point for fluent-logging for {@link INFO} level. 
+     *  
+     * @return LoggingEventBuilder instance as appropriate for level INFO
+     */
+    default public LoggingEventBuilder atInfo() {
+    	if(isInfoEnabled()) {
+    		return new DefaultLoggingEventBuilder(INFO, this);
+    	} else {
+    		return NOPLoggingEventBuilder.singleton();
+    	}
+    }
+
+
     /**
      * Is the logger instance enabled for the WARN level?
      *
@@ -610,6 +642,21 @@ default public LoggingEventBuilder atTrace() {
      */
     public void warn(Marker marker, String msg, Throwable t);
 
+
+    /**
+     * Entry point for fluent-logging for {@link WARN} level. 
+     *  
+     * @return LoggingEventBuilder instance as appropriate for level WARN
+     */
+    default public LoggingEventBuilder atWarn() {
+    	if(isWarnEnabled()) {
+    		return new DefaultLoggingEventBuilder(WARN, this);
+    	} else {
+    		return NOPLoggingEventBuilder.singleton();
+    	}
+    }
+
+
     /**
      * Is the logger instance enabled for the ERROR level?
      *
@@ -736,5 +783,20 @@ default public LoggingEventBuilder atTrace() {
      * @param t      the exception (throwable) to log
      */
     public void error(Marker marker, String msg, Throwable t);
+
+
+
+    /**
+     * Entry point for fluent-logging for {@link ERROR} level. 
+     *  
+     * @return LoggingEventBuilder instance as appropriate for level ERROR
+     */
+    default public LoggingEventBuilder atError() {
+    	if(isErrorEnabled()) {
+    		return new DefaultLoggingEventBuilder(ERROR, this);
+    	} else {
+    		return NOPLoggingEventBuilder.singleton();
+    	}
+    }
 
 }

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

@@ -0,0 +1,117 @@
+package org.slf4j.event;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public class DefaultLoggingEvent implements LoggingEvent {
+
+	Logger logger;
+	Level level;
+
+	List<Marker> markers;
+	List<Object> parameters;
+	List<KeyValuePair> keyValuePairs;
+
+	Throwable cause;
+	String threadName;
+
+	public DefaultLoggingEvent(Level level, Logger logger) {
+		this.logger = logger;
+		this.level = level;
+	}
+
+	public void addMarker(Marker marker) {
+		getMarkers().add(marker);
+	}
+
+	@Override
+	public List<Marker> getMarkers() {
+		if(markers == null) {
+			markers = new ArrayList<>(5);
+		}
+		return markers;
+	}
+
+
+	public void addParameter(Object p) {
+		getParameters().add(p);
+	}
+
+	private List<Object> getParameters() {
+
+		if(parameters == null) {
+			parameters = new ArrayList<>(5);
+		}
+		return parameters;
+	}
+
+	public void addKeyValue(String key, Object value) {
+		getKeyValuePairs().add(new KeyValuePair(key, value));
+	}
+
+
+	private List<KeyValuePair> getKeyValuePairs() {
+		if(keyValuePairs == null) {
+			keyValuePairs = new ArrayList<>(4);
+		}
+		return keyValuePairs;
+	}
+
+
+	public void setCause(Throwable cause) {
+		this.cause = cause;
+	}
+
+	@Override
+	public Level getLevel() {
+		return level;
+	}
+
+
+	public void setThreadName(String threadName) {
+		this.threadName = threadName;
+	}
+
+
+	@Override
+	public String getThreadName() {
+		return threadName;
+	}
+
+	@Override
+	public String getLoggerName() {
+		return logger.getName();
+	}
+
+
+
+	@Override
+	public String getMessage() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+
+
+	@Override
+	public Object[] getArgumentArray() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public long getTimeStamp() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public Throwable getThrowable() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}

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

@@ -0,0 +1,14 @@
+package org.slf4j.event;
+
+public class KeyValuePair {
+
+	final String key;
+	final Object value;
+
+
+	public KeyValuePair(String key, Object value) {
+		this.key = key;
+		this.value = value;
+	}
+
+}

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

@@ -1,5 +1,7 @@
 package org.slf4j.event;
 
+import java.util.List;
+
 import org.slf4j.Marker;
 
 /**
@@ -11,7 +13,7 @@ public interface LoggingEvent {
 
     Level getLevel();
 
-    Marker getMarker();
+    List<Marker> getMarkers();
 
     String getLoggerName();
 

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

@@ -1,12 +1,15 @@
 package org.slf4j.event;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.slf4j.Marker;
 import org.slf4j.helpers.SubstituteLogger;
 
 public class SubstituteLoggingEvent implements LoggingEvent {
 
     Level level;
-    Marker marker;
+    List<Marker> markers;
     String loggerName;
     SubstituteLogger logger;
     String threadName;
@@ -23,12 +26,15 @@ public void setLevel(Level level) {
         this.level = level;
     }
 
-    public Marker getMarker() {
-        return marker;
+    public List<Marker> getMarkers() {
+    	if(markers == null) {
+			markers = new ArrayList<>(5);
+		}
+		return markers;
     }
 
-    public void setMarker(Marker marker) {
-        this.marker = marker;
+    public void addMarker(Marker marker) {
+        getMarkers().add(marker);
     }
 
     public String getLoggerName() {

slf4j-api/src/main/java/org/slf4j/spi/DefaultLoggingEventBuilder.java

@@ -4,60 +4,69 @@
 
 import org.slf4j.Logger;
 import org.slf4j.Marker;
+import org.slf4j.event.DefaultLoggingEvent;
 import org.slf4j.event.Level;
 
 public class DefaultLoggingEventBuilder implements LoggingEventBuilder {
 
-	Logger logger;
-	Level level;
-
-	Marker marker;
-	Throwable cause;
-	Object parameter;
+	DefaultLoggingEvent logggingEvent;
 
 
 	public DefaultLoggingEventBuilder(Level level, Logger logger) {
-		this.logger = logger;
-		this.level = level;
+		logggingEvent = new DefaultLoggingEvent(level, logger);
+		logggingEvent.setThreadName(Thread.currentThread().getName());
 	}
+
+	/**
+	 * Add a marker to the current logging event being built.
+	 * 
+	 * It is possible to add multiple markers to the same logging event.
+	 *
+	 * @param marker the marker to add
+	 */
 	@Override
 	public LoggingEventBuilder addMarker(Marker marker) {
-		this.marker = marker;
+		logggingEvent.addMarker(marker);
 		return this;
 	}
-
+
+
 	@Override
 	public LoggingEventBuilder setCause(Throwable cause) {
-		this.cause = cause;
+		logggingEvent.setCause(cause);
 		return this;
 	}
 
 	@Override
 	public LoggingEventBuilder addParameter(Object p) {
-		this.parameter = p;
+		logggingEvent.addParameter(p);
 		return this;
 	}
 
 	@Override
 	public void log(String message) {
+
 	}
 
 	@Override
 	public void log(Supplier<String> messageSupplier) {
-
 	}
+
 	@Override
 	public LoggingEventBuilder addParameter(Supplier<Object> objectSupplier) {
+		logggingEvent.addParameter(objectSupplier.get());
 		return this;
 	}
+
 	@Override
 	public LoggingEventBuilder addKeyValue(String key, Object value) {
-		// TODO Auto-generated method stub
+		logggingEvent.addKeyValue(key, value);
 		return this;
 	}
+
 	@Override
 	public LoggingEventBuilder addKeyValue(String key, Supplier<Object> value) {
-		// TODO Auto-generated method stub
+		logggingEvent.addKeyValue(key, value.get());
 		return this;
 	}
 

slf4j-api/src/test/java/org/slf4j/LoggerUsage.java

@@ -7,7 +7,7 @@ public class LoggerUsage {
 	@Test
 	public void test() {
 		org.slf4j.Logger logger = LoggerFactory.getLogger("aa");
-		logger.atTrace().setCause(new Throwable()).addKeyValue("a", "n").log("aa");;
+		logger.atTrace().addKeyValue("a", "n").setCause(new Throwable()).log("aa");
 	}
 
 }

slf4j-api/src/test/java/org/slf4j/helpers/SubstitutableLoggerTest.java

@@ -47,7 +47,7 @@
  */
 public class SubstitutableLoggerTest {
 	// atTrace excluded during development of 2.0 API
-    private static final Set<String> EXCLUDED_METHODS = new HashSet<String>(Arrays.asList("getName", "atTrace"));
+    private static final Set<String> EXCLUDED_METHODS = new HashSet<String>(Arrays.asList("getName", "atTrace", "atDebug", "atInfo", "atWarn", "atError"));
 
     @Test
     public void testDelegate() throws Exception {