natas_hw
/
slf4j
mirror of https://github.com/qos-ch/slf4j
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

API consolidation

This commit is contained in:
Ceki Gulcu 2019-09-07 10:57:35 +02:00
parent c1c8d21bc4
commit a9f84d58b3
13 changed files with 1232 additions and 1857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java
View File

@ -2,9 +2,8 @@ package org.slf4j.event;
import java.util.Queue;
import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.helpers.MessageFormatter;
import org.slf4j.helpers.AbstractLogger;
import org.slf4j.helpers.SubstituteLogger;
/**
@ -17,7 +16,7 @@ import org.slf4j.helpers.SubstituteLogger;
* @author Wessel van Norel
*
*/
public class EventRecodingLogger implements Logger {
public class EventRecodingLogger extends AbstractLogger {
String name;
SubstituteLogger logger;
@ -40,272 +39,46 @@ public class EventRecodingLogger implements Logger {
return RECORD_ALL_EVENTS;
}
public void trace(String msg) {
recordEvent_0Args(Level.TRACE, null, msg, null);
}
public void trace(String format, Object arg) {
recordEvent_1Args(Level.TRACE, null, format, arg);
}
public void trace(String format, Object arg1, Object arg2) {
recordEvent2Args(Level.TRACE, null, format, arg1, arg2);
}
public void trace(String format, Object... arguments) {
recordEventArgArray(Level.TRACE, null, format, arguments);
}
public void trace(String msg, Throwable t) {
recordEvent_0Args(Level.TRACE, null, msg, t);
}
public boolean isTraceEnabled(Marker marker) {
return RECORD_ALL_EVENTS;
}
public void trace(Marker marker, String msg) {
recordEvent_0Args(Level.TRACE, marker, msg, null);
}
public void trace(Marker marker, String format, Object arg) {
recordEvent_1Args(Level.TRACE, marker, format, arg);
}
public void trace(Marker marker, String format, Object arg1, Object arg2) {
recordEvent2Args(Level.TRACE, marker, format, arg1, arg2);
}
public void trace(Marker marker, String format, Object... argArray) {
recordEventArgArray(Level.TRACE, marker, format, argArray);
}
public void trace(Marker marker, String msg, Throwable t) {
recordEvent_0Args(Level.TRACE, marker, msg, t);
}
public boolean isDebugEnabled() {
return RECORD_ALL_EVENTS;
}
public void debug(String msg) {
recordEvent_0Args(Level.DEBUG, null, msg, null);
}
public void debug(String format, Object arg) {
recordEvent_1Args(Level.DEBUG, null, format, arg);
}
public void debug(String format, Object arg1, Object arg2) {
recordEvent2Args(Level.DEBUG, null, format, arg1, arg2);
}
public void debug(String format, Object... arguments) {
recordEventArgArray(Level.DEBUG, null, format, arguments);
}
public void debug(String msg, Throwable t) {
recordEvent_0Args(Level.DEBUG, null, msg, t);
}
public boolean isDebugEnabled(Marker marker) {
return RECORD_ALL_EVENTS;
}
public void debug(Marker marker, String msg) {
recordEvent_0Args(Level.DEBUG, marker, msg, null);
}
public void debug(Marker marker, String format, Object arg) {
recordEvent_1Args(Level.DEBUG, marker, format, arg);
}
public void debug(Marker marker, String format, Object arg1, Object arg2) {
recordEvent2Args(Level.DEBUG, marker, format, arg1, arg2);
}
public void debug(Marker marker, String format, Object... arguments) {
recordEventArgArray(Level.DEBUG, marker, format, arguments);
}
public void debug(Marker marker, String msg, Throwable t) {
recordEvent_0Args(Level.DEBUG, marker, msg, t);
}
public boolean isInfoEnabled() {
return RECORD_ALL_EVENTS;
}
public void info(String msg) {
recordEvent_0Args(Level.INFO, null, msg, null);
}
public void info(String format, Object arg) {
recordEvent_1Args(Level.INFO, null, format, arg);
}
public void info(String format, Object arg1, Object arg2) {
recordEvent2Args(Level.INFO, null, format, arg1, arg2);
}
public void info(String format, Object... arguments) {
recordEventArgArray(Level.INFO, null, format, arguments);
}
public void info(String msg, Throwable t) {
recordEvent_0Args(Level.INFO, null, msg, t);
}
public boolean isInfoEnabled(Marker marker) {
return RECORD_ALL_EVENTS;
}
public void info(Marker marker, String msg) {
recordEvent_0Args(Level.INFO, marker, msg, null);
}
public void info(Marker marker, String format, Object arg) {
recordEvent_1Args(Level.INFO, marker, format, arg);
}
public void info(Marker marker, String format, Object arg1, Object arg2) {
recordEvent2Args(Level.INFO, marker, format, arg1, arg2);
}
public void info(Marker marker, String format, Object... arguments) {
recordEventArgArray(Level.INFO, marker, format, arguments);
}
public void info(Marker marker, String msg, Throwable t) {
recordEvent_0Args(Level.INFO, marker, msg, t);
}
public boolean isWarnEnabled() {
return RECORD_ALL_EVENTS;
}
public void warn(String msg) {
recordEvent_0Args(Level.WARN, null, msg, null);
}
public void warn(String format, Object arg) {
recordEvent_1Args(Level.WARN, null, format, arg);
}
public void warn(String format, Object arg1, Object arg2) {
recordEvent2Args(Level.WARN, null, format, arg1, arg2);
}
public void warn(String format, Object... arguments) {
recordEventArgArray(Level.WARN, null, format, arguments);
}
public void warn(String msg, Throwable t) {
recordEvent_0Args(Level.WARN, null, msg, t);
}
public boolean isWarnEnabled(Marker marker) {
return RECORD_ALL_EVENTS;
}
public void warn(Marker marker, String msg) {
recordEvent_0Args(Level.WARN, marker, msg, null);
}
public void warn(Marker marker, String format, Object arg) {
recordEvent_1Args(Level.WARN, marker, format, arg);
}
public void warn(Marker marker, String format, Object arg1, Object arg2) {
recordEvent2Args(Level.WARN, marker, format, arg1, arg2);
}
public void warn(Marker marker, String format, Object... arguments) {
recordEventArgArray(Level.WARN, marker, format, arguments);
}
public void warn(Marker marker, String msg, Throwable t) {
recordEvent_0Args(Level.WARN, marker, msg, t);
}
public boolean isErrorEnabled() {
return RECORD_ALL_EVENTS;
}
public void error(String msg) {
recordEvent_0Args(Level.ERROR, null, msg, null);
}
public void error(String format, Object arg) {
recordEvent_1Args(Level.ERROR, null, format, arg);
}
public void error(String format, Object arg1, Object arg2) {
recordEvent2Args(Level.ERROR, null, format, arg1, arg2);
}
public void error(String format, Object... arguments) {
recordEventArgArray(Level.ERROR, null, format, arguments);
}
public void error(String msg, Throwable t) {
recordEvent_0Args(Level.ERROR, null, msg, t);
}
public boolean isErrorEnabled(Marker marker) {
return RECORD_ALL_EVENTS;
}
public void error(Marker marker, String msg) {
recordEvent_0Args(Level.ERROR, marker, msg, null);
}
public void error(Marker marker, String format, Object arg) {
recordEvent_1Args(Level.ERROR, marker, format, arg);
}
public void error(Marker marker, String format, Object arg1, Object arg2) {
recordEvent2Args(Level.ERROR, marker, format, arg1, arg2);
}
public void error(Marker marker, String format, Object... arguments) {
recordEventArgArray(Level.ERROR, marker, format, arguments);
}
public void error(Marker marker, String msg, Throwable t) {
recordEvent_0Args(Level.ERROR, marker, msg, t);
}
private void recordEvent_0Args(Level level, Marker marker, String msg, Throwable t) {
recordEvent(level, marker, msg, null, t);
}
private void recordEvent_1Args(Level level, Marker marker, String msg, Object arg1) {
recordEvent(level, marker, msg, new Object[] { arg1 }, null);
}
private void recordEvent2Args(Level level, Marker marker, String msg, Object arg1, Object arg2) {
if (arg2 instanceof Throwable) {
recordEvent(level, marker, msg, new Object[] { arg1 }, (Throwable) arg2);
} else {
recordEvent(level, marker, msg, new Object[] { arg1, arg2 }, null);
}
}
private void recordEventArgArray(Level level, Marker marker, String msg, Object[] args) {
Throwable throwableCandidate = MessageFormatter.getThrowableCandidate(args);
if (throwableCandidate != null) {
Object[] trimmedCopy = MessageFormatter.trimmedCopy(args);
recordEvent(level, marker, msg, trimmedCopy, throwableCandidate);
} else {
recordEvent(level, marker, msg, args, null);
}
}
// WARNING: this method assumes that any throwable is properly extracted
private void recordEvent(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);

50
slf4j-api/src/main/java/org/slf4j/event/Level.java
View File

@ -15,25 +15,43 @@ import static org.slf4j.event.EventConstants.WARN_INT;
*/
public enum Level {
ERROR(ERROR_INT, "ERROR"), WARN(WARN_INT, "WARN"), INFO(INFO_INT, "INFO"), DEBUG(DEBUG_INT, "DEBUG"), TRACE(TRACE_INT, "TRACE");
ERROR(ERROR_INT, "ERROR"), WARN(WARN_INT, "WARN"), INFO(INFO_INT, "INFO"), DEBUG(DEBUG_INT, "DEBUG"),
TRACE(TRACE_INT, "TRACE");
private int levelInt;
private String levelStr;
private int levelInt;
private String levelStr;
Level(int i, String s) {
levelInt = i;
levelStr = s;
}
Level(int i, String s) {
levelInt = i;
levelStr = s;
}
public int toInt() {
return levelInt;
}
public int toInt() {
return levelInt;
}
/**
* Returns the string representation of this Level.
*/
public String toString() {
return levelStr;
}
public static Level intToLevel(int levelInt) {
switch (levelInt) {
case (TRACE_INT):
return TRACE;
case (DEBUG_INT):
return DEBUG;
case (INFO_INT):
return INFO;
case (WARN_INT):
return WARN;
case (ERROR_INT):
return ERROR;
default:
throw new IllegalArgumentException("Level integer [" + levelInt + "] not recognized.");
}
}
/**
* Returns the string representation of this Level.
*/
public String toString() {
return levelStr;
}
}

423
slf4j-api/src/main/java/org/slf4j/helpers/AbstractLogger.java Normal file
View File

@ -0,0 +1,423 @@
/**
* Copyright (c) 2004-2019 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.helpers;
import java.io.ObjectStreamException;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.event.Level;
/**
* An abstract implementation which delegates actual logging work to the
* {@link #handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable)} method.
*
* @author Ceki Gülcü
* @since 2.0
*/
public abstract class AbstractLogger implements Logger, Serializable {
private static final long serialVersionUID = -2529255052481744503L;
protected String name;
public String getName() {
return name;
}
/**
* Replace this instance with a homonymous (same name) logger returned
* by LoggerFactory. Note that this method is only called during
* deserialization.
*
* <p>
* This approach will work well if the desired ILoggerFactory is the one
* references by LoggerFactory. However, if the user manages its logger hierarchy
* through a different (non-static) mechanism, e.g. dependency injection, then
* this approach would be mostly counterproductive.
*
* @return logger with same name as returned by LoggerFactory
* @throws ObjectStreamException
*/
protected Object readResolve() throws ObjectStreamException {
// using getName() instead of this.name works even for
// NOPLogger
return LoggerFactory.getLogger(getName());
}
@Override
public void trace(String msg) {
if (isTraceEnabled()) {
handle_0ArgsCall(Level.TRACE, null, msg, null);
}
}
@Override
public void trace(String format, Object arg) {
if (isTraceEnabled()) {
handle_1ArgsCall(Level.TRACE, null, format, arg);
}
}
@Override
public void trace(String format, Object arg1, Object arg2) {
if (isTraceEnabled()) {
handle2ArgsCall(Level.TRACE, null, format, arg1, arg2);
}
}
@Override
public void trace(String format, Object... arguments) {
if (isTraceEnabled()) {
handleArgArrayCall(Level.TRACE, null, format, arguments);
}
}
@Override
public void trace(String msg, Throwable t) {
if (isTraceEnabled()) {
handle_0ArgsCall(Level.TRACE, null, msg, t);
}
}
@Override
public void trace(Marker marker, String msg) {
if (isTraceEnabled(marker)) {
handle_0ArgsCall(Level.TRACE, marker, msg, null);
}
}
@Override
public void trace(Marker marker, String format, Object arg) {
if (isTraceEnabled(marker)) {
handle_1ArgsCall(Level.TRACE, marker, format, arg);
}
}
@Override
public void trace(Marker marker, String format, Object arg1, Object arg2) {
if (isTraceEnabled(marker)) {
handle2ArgsCall(Level.TRACE, marker, format, arg1, arg2);
}
}
@Override
public void trace(Marker marker, String format, Object... argArray) {
if (isTraceEnabled(marker)) {
handleArgArrayCall(Level.TRACE, marker, format, argArray);
}
}
public void trace(Marker marker, String msg, Throwable t) {
if (isTraceEnabled(marker)) {
handle_0ArgsCall(Level.TRACE, marker, msg, t);
}
}
public void debug(String msg) {
if (isDebugEnabled()) {
handle_0ArgsCall(Level.DEBUG, null, msg, null);
}
}
public void debug(String format, Object arg) {
if (isDebugEnabled()) {
handle_1ArgsCall(Level.DEBUG, null, format, arg);
}
}
public void debug(String format, Object arg1, Object arg2) {
if (isDebugEnabled()) {
handle2ArgsCall(Level.DEBUG, null, format, arg1, arg2);
}
}
public void debug(String format, Object... arguments) {
if (isDebugEnabled()) {
handleArgArrayCall(Level.DEBUG, null, format, arguments);
}
}
public void debug(String msg, Throwable t) {
if (isDebugEnabled()) {
handle_0ArgsCall(Level.DEBUG, null, msg, t);
}
}
public void debug(Marker marker, String msg) {
if (isDebugEnabled(marker)) {
handle_0ArgsCall(Level.DEBUG, marker, msg, null);
}
}
public void debug(Marker marker, String format, Object arg) {
if (isDebugEnabled(marker)) {
handle_1ArgsCall(Level.DEBUG, marker, format, arg);
}
}
public void debug(Marker marker, String format, Object arg1, Object arg2) {
if (isDebugEnabled(marker)) {
handle2ArgsCall(Level.DEBUG, marker, format, arg1, arg2);
}
}
public void debug(Marker marker, String format, Object... arguments) {
if (isDebugEnabled(marker)) {
handleArgArrayCall(Level.DEBUG, marker, format, arguments);
}
}
public void debug(Marker marker, String msg, Throwable t) {
if (isDebugEnabled(marker)) {
handle_0ArgsCall(Level.DEBUG, marker, msg, t);
}
}
public void info(String msg) {
if (isInfoEnabled()) {
handle_0ArgsCall(Level.INFO, null, msg, null);
}
}
public void info(String format, Object arg) {
if (isInfoEnabled()) {
handle_1ArgsCall(Level.INFO, null, format, arg);
}
}
public void info(String format, Object arg1, Object arg2) {
if (isInfoEnabled()) {
handle2ArgsCall(Level.INFO, null, format, arg1, arg2);
}
}
public void info(String format, Object... arguments) {
if (isInfoEnabled()) {
handleArgArrayCall(Level.INFO, null, format, arguments);
}
}
public void info(String msg, Throwable t) {
if (isInfoEnabled()) {
handle_0ArgsCall(Level.INFO, null, msg, t);
}
}
public void info(Marker marker, String msg) {
if (isInfoEnabled(marker)) {
handle_0ArgsCall(Level.INFO, marker, msg, null);
}
}
public void info(Marker marker, String format, Object arg) {
if (isInfoEnabled(marker)) {
handle_1ArgsCall(Level.INFO, marker, format, arg);
}
}
public void info(Marker marker, String format, Object arg1, Object arg2) {
if (isInfoEnabled(marker)) {
handle2ArgsCall(Level.INFO, marker, format, arg1, arg2);
}
}
public void info(Marker marker, String format, Object... arguments) {
if (isInfoEnabled(marker)) {
handleArgArrayCall(Level.INFO, marker, format, arguments);
}
}
public void info(Marker marker, String msg, Throwable t) {
if (isInfoEnabled(marker)) {
handle_0ArgsCall(Level.INFO, marker, msg, t);
}
}
public void warn(String msg) {
if (isWarnEnabled()) {
handle_0ArgsCall(Level.WARN, null, msg, null);
}
}
public void warn(String format, Object arg) {
if (isWarnEnabled()) {
handle_1ArgsCall(Level.WARN, null, format, arg);
}
}
public void warn(String format, Object arg1, Object arg2) {
if (isWarnEnabled()) {
handle2ArgsCall(Level.WARN, null, format, arg1, arg2);
}
}
public void warn(String format, Object... arguments) {
if (isWarnEnabled()) {
handleArgArrayCall(Level.WARN, null, format, arguments);
}
}
public void warn(String msg, Throwable t) {
if (isWarnEnabled()) {
handle_0ArgsCall(Level.WARN, null, msg, t);
}
}
public void warn(Marker marker, String msg) {
if (isWarnEnabled(marker)) {
handle_0ArgsCall(Level.WARN, marker, msg, null);
}
}
public void warn(Marker marker, String format, Object arg) {
if (isWarnEnabled(marker)) {
handle_1ArgsCall(Level.WARN, marker, format, arg);
}
}
public void warn(Marker marker, String format, Object arg1, Object arg2) {
if (isWarnEnabled(marker)) {
handle2ArgsCall(Level.WARN, marker, format, arg1, arg2);
}
}
public void warn(Marker marker, String format, Object... arguments) {
if (isWarnEnabled(marker)) {
handleArgArrayCall(Level.WARN, marker, format, arguments);
}
}
public void warn(Marker marker, String msg, Throwable t) {
if (isWarnEnabled(marker)) {
handle_0ArgsCall(Level.WARN, marker, msg, t);
}
}
public void error(String msg) {
if (isErrorEnabled()) {
handle_0ArgsCall(Level.ERROR, null, msg, null);
}
}
public void error(String format, Object arg) {
if (isErrorEnabled()) {
handle_1ArgsCall(Level.ERROR, null, format, arg);
}
}
public void error(String format, Object arg1, Object arg2) {
if (isErrorEnabled()) {
handle2ArgsCall(Level.ERROR, null, format, arg1, arg2);
}
}
public void error(String format, Object... arguments) {
if (isErrorEnabled()) {
handleArgArrayCall(Level.ERROR, null, format, arguments);
}
}
public void error(String msg, Throwable t) {
if (isErrorEnabled()) {
handle_0ArgsCall(Level.ERROR, null, msg, t);
}
}
public void error(Marker marker, String msg) {
if (isErrorEnabled(marker)) {
handle_0ArgsCall(Level.ERROR, marker, msg, null);
}
}
public void error(Marker marker, String format, Object arg) {
if (isErrorEnabled(marker)) {
handle_1ArgsCall(Level.ERROR, marker, format, arg);
}
}
public void error(Marker marker, String format, Object arg1, Object arg2) {
if (isErrorEnabled(marker)) {
handle2ArgsCall(Level.ERROR, marker, format, arg1, arg2);
}
}
public void error(Marker marker, String format, Object... arguments) {
if (isErrorEnabled(marker)) {
handleArgArrayCall(Level.ERROR, marker, format, arguments);
}
}
public void error(Marker marker, String msg, Throwable t) {
if (isErrorEnabled(marker)) {
handle_0ArgsCall(Level.ERROR, marker, msg, t);
}
}
private void handle_0ArgsCall(Level level, Marker marker, String msg, Throwable t) {
handleNormalizedLoggingCall(level, marker, msg, null, t);
}
private void handle_1ArgsCall(Level level, Marker marker, String msg, Object arg1) {
handleNormalizedLoggingCall(level, marker, msg, new Object[] { arg1 }, null);
}
private void handle2ArgsCall(Level level, Marker marker, String msg, Object arg1, Object arg2) {
if (arg2 instanceof Throwable) {
handleNormalizedLoggingCall(level, marker, msg, new Object[] { arg1 }, (Throwable) arg2);
} else {
handleNormalizedLoggingCall(level, marker, msg, new Object[] { arg1, arg2 }, null);
}
}
private void handleArgArrayCall(Level level, Marker marker, String msg, Object[] args) {
Throwable throwableCandidate = MessageFormatter.getThrowableCandidate(args);
if (throwableCandidate != null) {
Object[] trimmedCopy = MessageFormatter.trimmedCopy(args);
handleNormalizedLoggingCall(level, marker, msg, trimmedCopy, throwableCandidate);
} else {
handleNormalizedLoggingCall(level, marker, msg, args, null);
}
}
abstract protected String getFullyQualifiedCallerName();
/**
* Given various arguments passed as parameters perform actual logging.
*
* <p>This method assumes that the separation of the args array into actual
* objects and a throwable has been already operated.
*
* @param level
* @param marker
* @param msg
* @param arguments
* @param throwable
*/
abstract protected void handleNormalizedLoggingCall(Level level, Marker marker, String msg, Object[] arguments, Throwable throwable);
}

38
slf4j-api/src/main/java/org/slf4j/helpers/LegacyAbstractLogger.java Normal file
View File

@ -0,0 +1,38 @@
package org.slf4j.helpers;
import org.slf4j.Marker;
abstract public class LegacyAbstractLogger extends AbstractLogger {
private static final long serialVersionUID = -7041884104854048950L;
@Override
public boolean isTraceEnabled(Marker marker) {
return isTraceEnabled();
}
@Override
public boolean isDebugEnabled(Marker marker) {
return isDebugEnabled();
}
@Override
public boolean isInfoEnabled(Marker marker) {
return isInfoEnabled();
}
@Override
public boolean isWarnEnabled(Marker marker) {
return isWarnEnabled();
}
@Override
public boolean isErrorEnabled(Marker marker) {
return isErrorEnabled();
}
}

1
slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java
View File

@ -34,6 +34,7 @@ import org.slf4j.Marker;
* any marker data passed as argument.
*
* @author Ceki Gulcu
* @deprecated
*/
public abstract class MarkerIgnoringBase extends NamedLoggerBase implements Logger {

38
slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java
View File

@ -161,6 +161,17 @@ final public class MessageFormatter {
return arrayFormat(messagePattern, args, throwableCandidate);
}
/**
* Assumes that argArray only contains arguments with no throwable as last element.
*
* @param messagePattern
* @param argArray
*/
final public static String basicArrayFormat(final String messagePattern, final Object[] argArray) {
FormattingTuple ft = arrayFormat(messagePattern, argArray, null);
return ft.getMessage();
}
final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray, Throwable throwable) {
if (messagePattern == null) {
@ -398,18 +409,9 @@ final public class MessageFormatter {
* otherwise it returns null
*/
public static Throwable getThrowableCandidate(final Object[] argArray) {
if (argArray == null || argArray.length == 0) {
return null;
}
return ParameterNormalizer.getThrowableCandidate(argArray);
}
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
*
@ -419,19 +421,7 @@ final public class MessageFormatter {
* @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;
return ParameterNormalizer.trimmedCopy(argArray);
}
}

1
slf4j-api/src/main/java/org/slf4j/helpers/NamedLoggerBase.java
View File

@ -37,6 +37,7 @@ import org.slf4j.LoggerFactory;
* @author Ceki Gulcu
* @see #readResolve
* @since 1.5.3
* @deprecated
*/
abstract class NamedLoggerBase implements Logger, Serializable {

40
slf4j-api/src/main/java/org/slf4j/helpers/NormalizedParameters.java Normal file
View File

@ -0,0 +1,40 @@
package org.slf4j.helpers;
/**
* Holds normalized calling call 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;
this.throwable = throwable;
}
public NormalizedParameters(String message, Object[] arguments) {
this(message, arguments, null);
}
public String getMessage() {
return message;
}
public Object[] getArguments() {
return arguments;
}
public Throwable getThrowable() {
return throwable;
}
}

79
slf4j-api/src/main/java/org/slf4j/helpers/ParameterNormalizer.java Normal file
View File

@ -0,0 +1,79 @@
package org.slf4j.helpers;
/**
* This class 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.
*
* @author ceki
* @since 2.0
*/
public class ParameterNormalizer {
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 = getThrowableCandidate(arguments);
if (throwableCandidate != null) {
Object[] trimmedArguments = MessageFormatter.trimmedCopy(arguments);
return new NormalizedParameters(msg, trimmedArguments, throwableCandidate);
} else {
return new NormalizedParameters(msg, arguments);
}
}
/**
* 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;
}
}

3
slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java
View File

@ -51,9 +51,12 @@ public interface LocationAwareLogger extends Logger {
* Printing method with support for location information.
*
* @param marker The marker to be used for this event, may be null.
*
* @param fqcn The fully qualified class name of the <b>logger instance</b>,
* typically the logger class, logger bridge or a logger wrapper.
*
* @param level One of the level integers defined in this interface
*
* @param message The message for the log event
* @param t Throwable associated with the log event, may be null.
*/

900
slf4j-jdk14/src/main/java/org/slf4j/jul/JDK14LoggerAdapter.java
View File

@ -31,9 +31,12 @@ import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.event.EventConstants;
import org.slf4j.event.LoggingEvent;
import org.slf4j.helpers.AbstractLogger;
import org.slf4j.helpers.FormattingTuple;
import org.slf4j.helpers.MarkerIgnoringBase;
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;
@ -46,667 +49,258 @@ import org.slf4j.spi.LocationAwareLogger;
* @author Ceki G&uuml;lc&uuml;
* @author Peter Royal
*/
public final class JDK14LoggerAdapter extends MarkerIgnoringBase implements LocationAwareLogger {
public final class JDK14LoggerAdapter extends LegacyAbstractLogger implements LocationAwareLogger {
private static final long serialVersionUID = -8053026990503422791L;
private static final long serialVersionUID = -8053026990503422791L;
transient final java.util.logging.Logger logger;
transient final java.util.logging.Logger logger;
// WARN: JDK14LoggerAdapter constructor should have only package access so
// that only JDK14LoggerFactory be able to create one.
JDK14LoggerAdapter(java.util.logging.Logger logger) {
this.logger = logger;
this.name = logger.getName();
}
/**
* Is this logger instance enabled for the FINEST level?
*
* @return True if this Logger is enabled for level FINEST, false otherwise.
*/
public boolean isTraceEnabled() {
return logger.isLoggable(Level.FINEST);
}
/**
* Log a message object at level FINEST.
*
* @param msg
* - the message object to be logged
*/
public void trace(String msg) {
if (logger.isLoggable(Level.FINEST)) {
log(SELF, Level.FINEST, msg, null);
}
}
/**
* Log a message at level FINEST according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for level FINEST.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void trace(String format, Object arg) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.FINEST, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINEST according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the FINEST level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void trace(String format, Object arg1, Object arg2) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
log(SELF, Level.FINEST, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINEST according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the FINEST level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void trace(String format, Object... argArray) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.FINEST, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at level FINEST with an accompanying message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void trace(String msg, Throwable t) {
if (logger.isLoggable(Level.FINEST)) {
log(SELF, Level.FINEST, msg, t);
}
}
/**
* Is this logger instance enabled for the FINE level?
*
* @return True if this Logger is enabled for level FINE, false otherwise.
*/
public boolean isDebugEnabled() {
return logger.isLoggable(Level.FINE);
}
/**
* Log a message object at level FINE.
*
* @param msg
* - the message object to be logged
*/
public void debug(String msg) {
if (logger.isLoggable(Level.FINE)) {
log(SELF, Level.FINE, msg, null);
}
}
/**
* Log a message at level FINE according to the specified format and argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for level FINE.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void debug(String format, Object arg) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.FINE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINE according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the FINE level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void debug(String format, Object arg1, Object arg2) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
log(SELF, Level.FINE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINE according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the FINE level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void debug(String format, Object... argArray) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.FINE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at level FINE with an accompanying message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void debug(String msg, Throwable t) {
if (logger.isLoggable(Level.FINE)) {
log(SELF, Level.FINE, msg, t);
}
}
/**
* Is this logger instance enabled for the INFO level?
*
* @return True if this Logger is enabled for the INFO level, false otherwise.
*/
public boolean isInfoEnabled() {
return logger.isLoggable(Level.INFO);
}
/**
* Log a message object at the INFO level.
*
* @param msg
* - the message object to be logged
*/
public void info(String msg) {
if (logger.isLoggable(Level.INFO)) {
log(SELF, Level.INFO, msg, null);
}
}
/**
* Log a message at level INFO according to the specified format and argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void info(String format, Object arg) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the INFO level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void info(String format, Object arg1, Object arg2) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
log(SELF, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level INFO according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void info(String format, Object... argArray) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the INFO level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void info(String msg, Throwable t) {
if (logger.isLoggable(Level.INFO)) {
log(SELF, Level.INFO, msg, t);
}
}
/**
* Is this logger instance enabled for the WARNING level?
*
* @return True if this Logger is enabled for the WARNING level, false
* otherwise.
*/
public boolean isWarnEnabled() {
return logger.isLoggable(Level.WARNING);
}
/**
* Log a message object at the WARNING level.
*
* @param msg
* - the message object to be logged
*/
public void warn(String msg) {
if (logger.isLoggable(Level.WARNING)) {
log(SELF, Level.WARNING, msg, null);
}
}
/**
* Log a message at the WARNING level according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void warn(String format, Object arg) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.WARNING, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the WARNING level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void warn(String format, Object arg1, Object arg2) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
log(SELF, Level.WARNING, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level WARNING according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void warn(String format, Object... argArray) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.WARNING, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the WARNING level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void warn(String msg, Throwable t) {
if (logger.isLoggable(Level.WARNING)) {
log(SELF, Level.WARNING, msg, t);
}
}
/**
* Is this logger instance enabled for level SEVERE?
*
* @return True if this Logger is enabled for level SEVERE, false otherwise.
*/
public boolean isErrorEnabled() {
return logger.isLoggable(Level.SEVERE);
}
/**
* Log a message object at the SEVERE level.
*
* @param msg
* - the message object to be logged
*/
public void error(String msg) {
if (logger.isLoggable(Level.SEVERE)) {
log(SELF, Level.SEVERE, msg, null);
}
}
/**
* Log a message at the SEVERE level according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void error(String format, Object arg) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.SEVERE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the SEVERE level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void error(String format, Object arg1, Object arg2) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
log(SELF, Level.SEVERE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level SEVERE according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param arguments
* an array of arguments
*/
public void error(String format, Object... arguments) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
log(SELF, Level.SEVERE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the SEVERE level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void error(String msg, Throwable t) {
if (logger.isLoggable(Level.SEVERE)) {
log(SELF, Level.SEVERE, msg, t);
}
}
/**
* Log the message at the specified level with the specified throwable if any.
* This method creates a LogRecord and fills in caller date before calling
* this instance's JDK14 logger.
*
* See bug report #13 for more details.
*
* @param level
* @param msg
* @param t
*/
private void log(String callerFQCN, Level level, String msg, Throwable t) {
// millis and thread are filled by the constructor
LogRecord record = new LogRecord(level, msg);
record.setLoggerName(getName());
record.setThrown(t);
// Note: parameters in record are not set because SLF4J only
// supports a single formatting style
fillCallerData(callerFQCN, record);
logger.log(record);
}
static String SELF = JDK14LoggerAdapter.class.getName();
static String SUPER = MarkerIgnoringBase.class.getName();
static String SUBSTITUE = SubstituteLogger.class.getName();
static String BARRIER_CLASSES[] = new String[] {SELF, SUPER, SUBSTITUE};
/**
* Fill in caller data if possible.
*
* @param record
* The record to update
*/
final private void fillCallerData(String callerFQCN, LogRecord record) {
StackTraceElement[] steArray = new Throwable().getStackTrace();
int selfIndex = -1;
for (int i = 0; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (barrierMatch(callerFQCN, className)) {
selfIndex = i;
break;
}
}
int found = -1;
for (int i = selfIndex + 1; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (!(barrierMatch(callerFQCN, className))) {
found = i;
break;
}
}
if (found != -1) {
StackTraceElement ste = steArray[found];
// setting the class name has the side effect of setting
// the needToInferCaller variable to false.
record.setSourceClassName(ste.getClassName());
record.setSourceMethodName(ste.getMethodName());
}
}
private boolean barrierMatch(String callerFQCN, String candidateClassName) {
if(candidateClassName.equals(callerFQCN))
return true;
for(String barrierClassName: BARRIER_CLASSES) {
if(barrierClassName.equals(candidateClassName)) {
return true;
}
}
return false;
// WARN: JDK14LoggerAdapter constructor should have only package access so
// that only JDK14LoggerFactory be able to create one.
JDK14LoggerAdapter(java.util.logging.Logger logger) {
this.logger = logger;
this.name = logger.getName();
}
public void log(Marker marker, String callerFQCN, int level, String message, Object[] argArray, Throwable t) {
Level julLevel = slf4jLevelIntToJULLevel(level);
// the logger.isLoggable check avoids the unconditional
// construction of location data for disabled log
// statements. As of 2008-07-31, callers of this method
// do not perform this check. See also
// http://jira.qos.ch/browse/SLF4J-81
if (logger.isLoggable(julLevel)) {
log(callerFQCN, julLevel, message, t);
}
}
/**
* Is this logger instance enabled for the FINEST level?
*
* @return True if this Logger is enabled for level FINEST, false otherwise.
*/
public boolean isTraceEnabled() {
return logger.isLoggable(Level.FINEST);
}
private Level slf4jLevelIntToJULLevel(int slf4jLevelInt) {
Level julLevel;
switch (slf4jLevelInt) {
case LocationAwareLogger.TRACE_INT:
julLevel = Level.FINEST;
break;
case LocationAwareLogger.DEBUG_INT:
julLevel = Level.FINE;
break;
case LocationAwareLogger.INFO_INT:
julLevel = Level.INFO;
break;
case LocationAwareLogger.WARN_INT:
julLevel = Level.WARNING;
break;
case LocationAwareLogger.ERROR_INT:
julLevel = Level.SEVERE;
break;
default:
throw new IllegalStateException("Level number " + slf4jLevelInt + " is not recognized.");
}
return julLevel;
}
/**
* Is this logger instance enabled for the FINE level?
*
* @return True if this Logger is enabled for level FINE, false otherwise.
*/
public boolean isDebugEnabled() {
return logger.isLoggable(Level.FINE);
}
/**
* @since 1.7.15
*/
public void log(LoggingEvent event) {
// assumes that the invocation is made from a substitute logger
// this assumption might change in the future with the advent of a fluent API
Level julLevel = slf4jLevelIntToJULLevel(event.getLevel().toInt());
if (logger.isLoggable(julLevel)) {
LogRecord record = eventToRecord(event, julLevel);
logger.log(record);
}
}
/**
* Is this logger instance enabled for the INFO level?
*
* @return True if this Logger is enabled for the INFO level, false otherwise.
*/
public boolean isInfoEnabled() {
return logger.isLoggable(Level.INFO);
}
private LogRecord eventToRecord(LoggingEvent event, Level julLevel) {
String format = event.getMessage();
Object[] arguments = event.getArgumentArray();
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
if (ft.getThrowable() != null && event.getThrowable() != null) {
throw new IllegalArgumentException("both last element in argument array and last argument are of type Throwable");
}
/**
* Is this logger instance enabled for the WARNING level?
*
* @return True if this Logger is enabled for the WARNING level, false
* otherwise.
*/
public boolean isWarnEnabled() {
return logger.isLoggable(Level.WARNING);
}
Throwable t = event.getThrowable();
if (ft.getThrowable() != null) {
t = ft.getThrowable();
throw new IllegalStateException("fix above code");
}
/**
* Is this logger instance enabled for level SEVERE?
*
* @return True if this Logger is enabled for level SEVERE, false otherwise.
*/
public boolean isErrorEnabled() {
return logger.isLoggable(Level.SEVERE);
}
LogRecord record = new LogRecord(julLevel, ft.getMessage());
record.setLoggerName(event.getLoggerName());
record.setMillis(event.getTimeStamp());
record.setSourceClassName(EventConstants.NA_SUBST);
record.setSourceMethodName(EventConstants.NA_SUBST);
// /**
// * Log the message at the specified level with the specified throwable if any.
// * This method creates a LogRecord and fills in caller date before calling
// * this instance's JDK14 logger.
// *
// * See bug report #13 for more details.
// *
// * @param level
// * @param msg
// * @param t
// */
// private void log(String callerFQCN, Level level, String msg, Throwable t) {
// // millis and thread are filled by the constructor
// LogRecord record = new LogRecord(level, msg);
// record.setLoggerName(getName());
// record.setThrown(t);
// // Note: parameters in record are not set because SLF4J only
// // supports a single formatting style
// fillCallerData(callerFQCN, record);
// logger.log(record);
// }
/**
* Log the message at the specified level with the specified throwable if any.
* This method creates a LogRecord and fills in caller date before calling this
* instance's JDK14 logger.
*/
@Override
protected void handleNormalizedLoggingCall(org.slf4j.event.Level level, Marker marker, String msg, Object[] args,
Throwable throwable) {
innerNormalizedLoggingCallHandler(getFullyQualifiedCallerName(), level, marker, msg, args, throwable);
}
private void innerNormalizedLoggingCallHandler(String fqcn, org.slf4j.event.Level level, Marker marker, String msg, Object[] args,
Throwable throwable) {
// millis and thread are filled by the constructor
Level julLevel = slf4jLevelToJULLevel(level);
String formattedMessage = MessageFormatter.basicArrayFormat(msg, args);
LogRecord record = new LogRecord(julLevel, formattedMessage);
// https://jira.qos.ch/browse/SLF4J-13
record.setLoggerName(getName());
record.setThrown(throwable);
// Note: parameters in record are not set because SLF4J only
// supports a single formatting style
// See also https://jira.qos.ch/browse/SLF4J-10
fillCallerData(fqcn, record);
logger.log(record);
}
@Override
protected String getFullyQualifiedCallerName() {
return SELF;
}
@Override
public void log(Marker marker, String callerFQCN, int slf4jLevelInt, String message, Object[] arguments,
Throwable throwable) {
org.slf4j.event.Level slf4jLevel = org.slf4j.event.Level.intToLevel(slf4jLevelInt);
Level julLevel = slf4jLevelIntToJULLevel(slf4jLevelInt);
if (logger.isLoggable(julLevel)) {
NormalizedParameters np = ParameterNormalizer.normalize(message, arguments, throwable);
innerNormalizedLoggingCallHandler(callerFQCN, slf4jLevel, marker, np.getMessage(), np.getArguments(), np.getThrowable());
}
}
/**
* Fill in caller data if possible.
*
* @param record The record to update
*/
final private void fillCallerData(String callerFQCN, LogRecord record) {
StackTraceElement[] steArray = new Throwable().getStackTrace();
int selfIndex = -1;
for (int i = 0; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (barrierMatch(callerFQCN, className)) {
selfIndex = i;
break;
}
}
int found = -1;
for (int i = selfIndex + 1; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (!(barrierMatch(callerFQCN, className))) {
found = i;
break;
}
}
if (found != -1) {
StackTraceElement ste = steArray[found];
// setting the class name has the side effect of setting
// the needToInferCaller variable to false.
record.setSourceClassName(ste.getClassName());
record.setSourceMethodName(ste.getMethodName());
}
}
static String SELF = JDK14LoggerAdapter.class.getName();
static String SUPER = LegacyAbstractLogger.class.getName();
static String SUPER_OF_SUPER = AbstractLogger.class.getName();
static String SUBSTITUE = SubstituteLogger.class.getName();
static String BARRIER_CLASSES[] = new String[] { SUPER_OF_SUPER, SUPER, SELF, SUBSTITUE };
private boolean barrierMatch(String callerFQCN, String candidateClassName) {
if (candidateClassName.equals(callerFQCN))
return true;
for (String barrierClassName : BARRIER_CLASSES) {
if (barrierClassName.equals(candidateClassName)) {
return true;
}
}
return false;
}
private static Level slf4jLevelIntToJULLevel(int levelInt) {
org.slf4j.event.Level slf4jLevel = org.slf4j.event.Level.intToLevel(levelInt);
return slf4jLevelToJULLevel(slf4jLevel);
}
private static Level slf4jLevelToJULLevel(org.slf4j.event.Level slf4jLevel) {
Level julLevel;
switch (slf4jLevel) {
case TRACE:
julLevel = Level.FINEST;
break;
case DEBUG:
julLevel = Level.FINE;
break;
case INFO:
julLevel = Level.INFO;
break;
case WARN:
julLevel = Level.WARNING;
break;
case ERROR:
julLevel = Level.SEVERE;
break;
default:
throw new IllegalStateException("Level " + slf4jLevel + " is not recognized.");
}
return julLevel;
}
/**
* @since 1.7.15
*/
public void log(LoggingEvent event) {
// assumes that the invocation is made from a substitute logger
// this assumption might change in the future with the advent of a fluent API
Level julLevel = slf4jLevelToJULLevel(event.getLevel());
if (logger.isLoggable(julLevel)) {
LogRecord record = eventToRecord(event, julLevel);
logger.log(record);
}
}
private LogRecord eventToRecord(LoggingEvent event, Level julLevel) {
String format = event.getMessage();
Object[] arguments = event.getArgumentArray();
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
if (ft.getThrowable() != null && event.getThrowable() != null) {
throw new IllegalArgumentException(
"both last element in argument array and last argument are of type Throwable");
}
Throwable t = event.getThrowable();
if (ft.getThrowable() != null) {
t = ft.getThrowable();
throw new IllegalStateException("fix above code");
}
LogRecord record = new LogRecord(julLevel, ft.getMessage());
record.setLoggerName(event.getLoggerName());
record.setMillis(event.getTimeStamp());
record.setSourceClassName(EventConstants.NA_SUBST);
record.setSourceMethodName(EventConstants.NA_SUBST);
record.setThrown(t);
return record;
}
record.setThrown(t);
return record;
}
}

525
slf4j-log4j12/src/main/java/org/slf4j/log4j12/Log4jLoggerAdapter.java
View File

@ -34,9 +34,11 @@ import org.apache.log4j.spi.ThrowableInformation;
import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.event.LoggingEvent;
import org.slf4j.helpers.FormattingTuple;
import org.slf4j.helpers.MarkerIgnoringBase;
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;
/**
@ -57,7 +59,7 @@ import org.slf4j.spi.LocationAwareLogger;
*
* @author Ceki G&uuml;lc&uuml;
*/
public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements LocationAwareLogger, Serializable {
public final class Log4jLoggerAdapter extends LegacyAbstractLogger implements LocationAwareLogger, Serializable {
private static final long serialVersionUID = 6182834493563598289L;
@ -104,93 +106,6 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
}
}
/**
* Log a message object at level TRACE.
*
* @param msg
* - the message object to be logged
*/
public void trace(String msg) {
logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msg, null);
}
/**
* Log a message at level TRACE according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for level TRACE.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void trace(String format, Object arg) {
if (isTraceEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg);
logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level TRACE according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the TRACE level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void trace(String format, Object arg1, Object arg2) {
if (isTraceEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level TRACE according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the TRACE level.
*
*
* @param format
* the format string
* @param arguments
* an array of arguments
*/
public void trace(String format, Object... arguments) {
if (isTraceEnabled()) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at level TRACE with an accompanying message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void trace(String msg, Throwable t) {
logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msg, t);
}
/**
* Is this logger instance enabled for the DEBUG level?
*
@ -200,91 +115,6 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
return logger.isDebugEnabled();
}
/**
* Log a message object at level DEBUG.
*
* @param msg
* - the message object to be logged
*/
public void debug(String msg) {
logger.log(FQCN, Level.DEBUG, msg, null);
}
/**
* Log a message at level DEBUG according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for level DEBUG.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void debug(String format, Object arg) {
if (logger.isDebugEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg);
logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level DEBUG according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the DEBUG level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void debug(String format, Object arg1, Object arg2) {
if (logger.isDebugEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level DEBUG according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the DEBUG level.
*
*
* @param format
* the format string
* @param arguments an array of arguments
*/
public void debug(String format, Object... arguments) {
if (logger.isDebugEnabled()) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at level DEBUG with an accompanying message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void debug(String msg, Throwable t) {
logger.log(FQCN, Level.DEBUG, msg, t);
}
/**
* Is this logger instance enabled for the INFO level?
@ -295,93 +125,6 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
return logger.isInfoEnabled();
}
/**
* Log a message object at the INFO level.
*
* @param msg
* - the message object to be logged
*/
public void info(String msg) {
logger.log(FQCN, Level.INFO, msg, null);
}
/**
* Log a message at level INFO according to the specified format and argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void info(String format, Object arg) {
if (logger.isInfoEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg);
logger.log(FQCN, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the INFO level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void info(String format, Object arg1, Object arg2) {
if (logger.isInfoEnabled()) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
logger.log(FQCN, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level INFO according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void info(String format, Object... argArray) {
if (logger.isInfoEnabled()) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
logger.log(FQCN, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the INFO level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void info(String msg, Throwable t) {
logger.log(FQCN, Level.INFO, msg, t);
}
/**
* Is this logger instance enabled for the WARN level?
*
@ -391,93 +134,6 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
return logger.isEnabledFor(Level.WARN);
}
/**
* Log a message object at the WARN level.
*
* @param msg
* - the message object to be logged
*/
public void warn(String msg) {
logger.log(FQCN, Level.WARN, msg, null);
}
/**
* Log a message at the WARN level according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARN level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void warn(String format, Object arg) {
if (logger.isEnabledFor(Level.WARN)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
logger.log(FQCN, Level.WARN, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the WARN level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARN level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void warn(String format, Object arg1, Object arg2) {
if (logger.isEnabledFor(Level.WARN)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
logger.log(FQCN, Level.WARN, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level WARN according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the WARN level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void warn(String format, Object... argArray) {
if (logger.isEnabledFor(Level.WARN)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
logger.log(FQCN, Level.WARN, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the WARN level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void warn(String msg, Throwable t) {
logger.log(FQCN, Level.WARN, msg, t);
}
/**
* Is this logger instance enabled for level ERROR?
@ -488,102 +144,59 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
return logger.isEnabledFor(Level.ERROR);
}
/**
* Log a message object at the ERROR level.
*
* @param msg
* - the message object to be logged
*/
public void error(String msg) {
logger.log(FQCN, Level.ERROR, msg, null);
}
/**
* Log a message at the ERROR level according to the specified format and
* argument.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the ERROR level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
public void error(String format, Object arg) {
if (logger.isEnabledFor(Level.ERROR)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
logger.log(FQCN, Level.ERROR, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the ERROR level according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the ERROR level.
*
*
* @param format
* the format string
* @param arg1
* the first argument
* @param arg2
* the second argument
*/
public void error(String format, Object arg1, Object arg2) {
if (logger.isEnabledFor(Level.ERROR)) {
FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
logger.log(FQCN, Level.ERROR, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level ERROR according to the specified format and
* arguments.
*
* <p>
* This form avoids superfluous object creation when the logger is disabled
* for the ERROR level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
public void error(String format, Object... argArray) {
if (logger.isEnabledFor(Level.ERROR)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
logger.log(FQCN, Level.ERROR, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log an exception (throwable) at the ERROR level with an accompanying
* message.
*
* @param msg
* the message accompanying the exception
* @param t
* the exception (throwable) to log
*/
public void error(String msg, Throwable t) {
logger.log(FQCN, Level.ERROR, msg, t);
}
public void log(Marker marker, String callerFQCN, int level, String msg, Object[] argArray, Throwable t) {
@Override
public void log(Marker marker, String callerFQCN, int level, String msg, Object[] arguments, Throwable t) {
Level log4jLevel = toLog4jLevel(level);
logger.log(callerFQCN, log4jLevel, msg, t);
NormalizedParameters np = ParameterNormalizer.normalize(msg, arguments, t);
String formattedMessage = MessageFormatter.basicArrayFormat(np.getMessage(), np.getArguments());
logger.log(callerFQCN, log4jLevel, formattedMessage, np.getThrowable());
}
private Level toLog4jLevel(int level) {
@Override
protected void handleNormalizedLoggingCall(org.slf4j.event.Level level, Marker marker, String msg, Object[] arguments,
Throwable throwable) {
Level log4jLevel = toLog4jLevel(level.toInt());
String formattedMessage = MessageFormatter.basicArrayFormat(msg, arguments);
logger.log(getFullyQualifiedCallerName(), log4jLevel, formattedMessage, throwable);
}
/**
* Called by {@link SubstituteLogger}
* @param event
*/
public void log(LoggingEvent event) {
Level log4jLevel = toLog4jLevel(event.getLevel().toInt());
if (!logger.isEnabledFor(log4jLevel))
return;
org.apache.log4j.spi.LoggingEvent log4jevent = toLog4jEvent(event, log4jLevel);
logger.callAppenders(log4jevent);
}
private org.apache.log4j.spi.LoggingEvent toLog4jEvent(LoggingEvent event, Level log4jLevel) {
String formattedMessage = MessageFormatter.basicArrayFormat(event.getMessage(), event.getArgumentArray());
LocationInfo locationInfo = new LocationInfo(NA_SUBST, NA_SUBST, NA_SUBST, "0");
ThrowableInformation ti = null;
Throwable t = event.getThrowable();
if (t != null)
ti = new ThrowableInformation(t);
org.apache.log4j.spi.LoggingEvent log4jEvent = new org.apache.log4j.spi.LoggingEvent(FQCN, logger, event.getTimeStamp(), log4jLevel, formattedMessage,
event.getThreadName(), ti, null, locationInfo, null);
return log4jEvent;
}
private Level toLog4jLevel(int slf4jLevelInt) {
Level log4jLevel;
switch (level) {
switch (slf4jLevelInt) {
case LocationAwareLogger.TRACE_INT:
log4jLevel = traceCapable ? Level.TRACE : Level.DEBUG;
break;
@ -600,36 +213,14 @@ public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements Loca
log4jLevel = Level.ERROR;
break;
default:
throw new IllegalStateException("Level number " + level + " is not recognized.");
throw new IllegalStateException("Level number " + slf4jLevelInt + " is not recognized.");
}
return log4jLevel;
}
public void log(LoggingEvent event) {
Level log4jLevel = toLog4jLevel(event.getLevel().toInt());
if (!logger.isEnabledFor(log4jLevel))
return;
org.apache.log4j.spi.LoggingEvent log4jevent = toLog4jEvent(event, log4jLevel);
logger.callAppenders(log4jevent);
}
private org.apache.log4j.spi.LoggingEvent toLog4jEvent(LoggingEvent event, Level log4jLevel) {
FormattingTuple ft = MessageFormatter.format(event.getMessage(), event.getArgumentArray(), event.getThrowable());
LocationInfo locationInfo = new LocationInfo(NA_SUBST, NA_SUBST, NA_SUBST, "0");
ThrowableInformation ti = null;
Throwable t = ft.getThrowable();
if (t != null)
ti = new ThrowableInformation(t);
org.apache.log4j.spi.LoggingEvent log4jEvent = new org.apache.log4j.spi.LoggingEvent(FQCN, logger, event.getTimeStamp(), log4jLevel, ft.getMessage(),
event.getThreadName(), ti, null, locationInfo, null);
return log4jEvent;
}
@Override
protected String getFullyQualifiedCallerName() {
return FQCN;
}
}

758
slf4j-simple/src/main/java/org/slf4j/simple/SimpleLogger.java
View File

@ -28,10 +28,15 @@ import java.io.PrintStream;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.event.Level;
import org.slf4j.event.LoggingEvent;
import org.slf4j.helpers.AbstractLogger;
import org.slf4j.helpers.FormattingTuple;
import org.slf4j.helpers.MarkerIgnoringBase;
import org.slf4j.helpers.MessageFormatter;
import org.slf4j.helpers.NormalizedParameters;
import org.slf4j.helpers.ParameterNormalizer;
import org.slf4j.spi.LocationAwareLogger;
/**
@ -49,11 +54,10 @@ import org.slf4j.spi.LocationAwareLogger;
* <li><code>org.slf4j.simpleLogger.cacheOutputStream</code> - 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
* <code>System.out/err</code> 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
* <code>System.out/err</code>.
* </li>
* <code>System.out/err</code> 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
* <code>System.out/err</code>.</li>
*
* <li><code>org.slf4j.simpleLogger.defaultLogLevel</code> - Default log level
* for all instances of SimpleLogger. Must be one of ("trace", "debug", "info",
@ -140,467 +144,287 @@ import org.slf4j.spi.LocationAwareLogger;
* @author Robert Burrell Donkin
* @author C&eacute;drik LIME
*/
public class SimpleLogger extends MarkerIgnoringBase {
private static final long serialVersionUID = -632788891211436180L;
private static 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;
// 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 SimpleLoggerConfiguration CONFIG_PARAMS = null;
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 = new SimpleLoggerConfiguration();
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 <code>SimpleLogger</code> start with this
* prefix
*/
public static final String SYSTEM_PREFIX = "org.slf4j.simpleLogger.";
public static final String LOG_KEY_PREFIX = SimpleLogger.SYSTEM_PREFIX + "log.";
public static final String CACHE_OUTPUT_STREAM_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "cacheOutputStream";
public static final String WARN_LEVEL_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "warnLevelString";
public static final String LEVEL_IN_BRACKETS_KEY = SimpleLogger.SYSTEM_PREFIX + "levelInBrackets";
public static final String LOG_FILE_KEY = SimpleLogger.SYSTEM_PREFIX + "logFile";
public static final String SHOW_SHORT_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showShortLogName";
public static final String SHOW_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showLogName";
public static final String SHOW_THREAD_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showThreadName";
public static final String DATE_TIME_FORMAT_KEY = SimpleLogger.SYSTEM_PREFIX + "dateTimeFormat";
public static final String SHOW_DATE_TIME_KEY = SimpleLogger.SYSTEM_PREFIX + "showDateTime";
public static final String DEFAULT_LOG_LEVEL_KEY = SimpleLogger.SYSTEM_PREFIX + "defaultLogLevel";
/**
* Package access allows only {@link SimpleLoggerFactory} to instantiate
* SimpleLogger instances.
*/
SimpleLogger(String name) {
this.name = name;
String levelString = recursivelyComputeLevelString();
if (levelString != null) {
this.currentLogLevel = SimpleLoggerConfiguration.stringToLevel(levelString);
} else {
this.currentLogLevel = CONFIG_PARAMS.defaultLogLevel;
}
}
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(SimpleLogger.LOG_KEY_PREFIX + tempName, null);
indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
}
return levelString;
}
/**
* This is our internal implementation for logging regular
* (non-parameterized) log messages.
*
* @param level
* One of the LOG_LEVEL_XXX constants defining the log level
* @param message
* The message itself
* @param t
* The exception whose stack trace should be logged
*/
private void log(int level, String message, Throwable t) {
if (!isLevelEnabled(level)) {
return;
}
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(' ');
} else {
buf.append(System.currentTimeMillis() - START_TIME);
buf.append(' ');
}
}
// Append current thread name if so configured
if (CONFIG_PARAMS.showThreadName) {
buf.append('[');
buf.append(Thread.currentThread().getName());
buf.append("] ");
}
if (CONFIG_PARAMS.levelInBrackets)
buf.append('[');
// Append a readable representation of the log level
String levelStr = renderLevel(level);
buf.append(levelStr);
if (CONFIG_PARAMS.levelInBrackets)
buf.append(']');
buf.append(' ');
// 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(" - ");
}
// Append the message
buf.append(message);
write(buf, t);
}
protected String renderLevel(int level) {
switch (level) {
case LOG_LEVEL_TRACE:
return "TRACE";
case LOG_LEVEL_DEBUG:
return ("DEBUG");
case LOG_LEVEL_INFO:
return "INFO";
case LOG_LEVEL_WARN:
return CONFIG_PARAMS.warnLevelString;
case LOG_LEVEL_ERROR:
return "ERROR";
}
throw new IllegalStateException("Unrecognized level [" + level + "]");
}
void write(StringBuilder buf, Throwable t) {
PrintStream targetStream = CONFIG_PARAMS.outputChoice.getTargetPrintStream();
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);
}
/**
* A simple implementation which logs messages of level TRACE according to
* the format outlined above.
*/
public void trace(String msg) {
log(LOG_LEVEL_TRACE, msg, null);
}
/**
* Perform single parameter substitution before logging the message of level
* TRACE according to the format outlined above.
*/
public void trace(String format, Object param1) {
formatAndLog(LOG_LEVEL_TRACE, format, param1, null);
}
/**
* Perform double parameter substitution before logging the message of level
* TRACE according to the format outlined above.
*/
public void trace(String format, Object param1, Object param2) {
formatAndLog(LOG_LEVEL_TRACE, format, param1, param2);
}
/**
* Perform double parameter substitution before logging the message of level
* TRACE according to the format outlined above.
*/
public void trace(String format, Object... argArray) {
formatAndLog(LOG_LEVEL_TRACE, format, argArray);
}
/** Log a message of level TRACE, including an exception. */
public void trace(String msg, Throwable t) {
log(LOG_LEVEL_TRACE, msg, t);
}
/** Are {@code debug} messages currently enabled? */
public boolean isDebugEnabled() {
return isLevelEnabled(LOG_LEVEL_DEBUG);
}
/**
* A simple implementation which logs messages of level DEBUG according to
* the format outlined above.
*/
public void debug(String msg) {
log(LOG_LEVEL_DEBUG, msg, null);
}
/**
* Perform single parameter substitution before logging the message of level
* DEBUG according to the format outlined above.
*/
public void debug(String format, Object param1) {
formatAndLog(LOG_LEVEL_DEBUG, format, param1, null);
}
/**
* Perform double parameter substitution before logging the message of level
* DEBUG according to the format outlined above.
*/
public void debug(String format, Object param1, Object param2) {
formatAndLog(LOG_LEVEL_DEBUG, format, param1, param2);
}
/**
* Perform double parameter substitution before logging the message of level
* DEBUG according to the format outlined above.
*/
public void debug(String format, Object... argArray) {
formatAndLog(LOG_LEVEL_DEBUG, format, argArray);
}
/** Log a message of level DEBUG, including an exception. */
public void debug(String msg, Throwable t) {
log(LOG_LEVEL_DEBUG, msg, t);
}
/** Are {@code info} messages currently enabled? */
public boolean isInfoEnabled() {
return isLevelEnabled(LOG_LEVEL_INFO);
}
/**
* A simple implementation which logs messages of level INFO according to
* the format outlined above.
*/
public void info(String msg) {
log(LOG_LEVEL_INFO, msg, null);
}
/**
* Perform single parameter substitution before logging the message of level
* INFO according to the format outlined above.
*/
public void info(String format, Object arg) {
formatAndLog(LOG_LEVEL_INFO, format, arg, null);
}
/**
* Perform double parameter substitution before logging the message of level
* INFO according to the format outlined above.
*/
public void info(String format, Object arg1, Object arg2) {
formatAndLog(LOG_LEVEL_INFO, format, arg1, arg2);
}
/**
* Perform double parameter substitution before logging the message of level
* INFO according to the format outlined above.
*/
public void info(String format, Object... argArray) {
formatAndLog(LOG_LEVEL_INFO, format, argArray);
}
/** Log a message of level INFO, including an exception. */
public void info(String msg, Throwable t) {
log(LOG_LEVEL_INFO, msg, t);
}
/** Are {@code warn} messages currently enabled? */
public boolean isWarnEnabled() {
return isLevelEnabled(LOG_LEVEL_WARN);
}
/**
* A simple implementation which always logs messages of level WARN
* according to the format outlined above.
*/
public void warn(String msg) {
log(LOG_LEVEL_WARN, msg, null);
}
/**
* Perform single parameter substitution before logging the message of level
* WARN according to the format outlined above.
*/
public void warn(String format, Object arg) {
formatAndLog(LOG_LEVEL_WARN, format, arg, null);
}
/**
* Perform double parameter substitution before logging the message of level
* WARN according to the format outlined above.
*/
public void warn(String format, Object arg1, Object arg2) {
formatAndLog(LOG_LEVEL_WARN, format, arg1, arg2);
}
/**
* Perform double parameter substitution before logging the message of level
* WARN according to the format outlined above.
*/
public void warn(String format, Object... argArray) {
formatAndLog(LOG_LEVEL_WARN, format, argArray);
}
/** Log a message of level WARN, including an exception. */
public void warn(String msg, Throwable t) {
log(LOG_LEVEL_WARN, msg, t);
}
/** Are {@code error} messages currently enabled? */
public boolean isErrorEnabled() {
return isLevelEnabled(LOG_LEVEL_ERROR);
}
/**
* A simple implementation which always logs messages of level ERROR
* according to the format outlined above.
*/
public void error(String msg) {
log(LOG_LEVEL_ERROR, msg, null);
}
/**
* Perform single parameter substitution before logging the message of level
* ERROR according to the format outlined above.
*/
public void error(String format, Object arg) {
formatAndLog(LOG_LEVEL_ERROR, format, arg, null);
}
/**
* Perform double parameter substitution before logging the message of level
* ERROR according to the format outlined above.
*/
public void error(String format, Object arg1, Object arg2) {
formatAndLog(LOG_LEVEL_ERROR, format, arg1, arg2);
}
/**
* Perform double parameter substitution before logging the message of level
* ERROR according to the format outlined above.
*/
public void error(String format, Object... argArray) {
formatAndLog(LOG_LEVEL_ERROR, format, argArray);
}
/** Log a message of level ERROR, including an exception. */
public void error(String msg, Throwable t) {
log(LOG_LEVEL_ERROR, msg, t);
}
public void log(LoggingEvent event) {
int levelInt = event.getLevel().toInt();
if (!isLevelEnabled(levelInt)) {
return;
}
FormattingTuple tp = MessageFormatter.arrayFormat(event.getMessage(), event.getArgumentArray(), event.getThrowable());
log(levelInt, tp.getMessage(), event.getThrowable());
}
public class SimpleLogger extends AbstractLogger {
private static final long serialVersionUID = -632788891211436180L;
private static 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 = ' ';
// 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 SimpleLoggerConfiguration CONFIG_PARAMS = null;
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 = new SimpleLoggerConfiguration();
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 <code>SimpleLogger</code> start with this
* prefix
*/
public static final String SYSTEM_PREFIX = "org.slf4j.simpleLogger.";
public static final String LOG_KEY_PREFIX = SimpleLogger.SYSTEM_PREFIX + "log.";
public static final String CACHE_OUTPUT_STREAM_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "cacheOutputStream";
public static final String WARN_LEVEL_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "warnLevelString";
public static final String LEVEL_IN_BRACKETS_KEY = SimpleLogger.SYSTEM_PREFIX + "levelInBrackets";
public static final String LOG_FILE_KEY = SimpleLogger.SYSTEM_PREFIX + "logFile";
public static final String SHOW_SHORT_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showShortLogName";
public static final String SHOW_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showLogName";
public static final String SHOW_THREAD_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showThreadName";
public static final String DATE_TIME_FORMAT_KEY = SimpleLogger.SYSTEM_PREFIX + "dateTimeFormat";
public static final String SHOW_DATE_TIME_KEY = SimpleLogger.SYSTEM_PREFIX + "showDateTime";
public static final String DEFAULT_LOG_LEVEL_KEY = SimpleLogger.SYSTEM_PREFIX + "defaultLogLevel";
/**
* Package access allows only {@link SimpleLoggerFactory} to instantiate
* SimpleLogger instances.
*/
SimpleLogger(String name) {
this.name = name;
String levelString = recursivelyComputeLevelString();
if (levelString != null) {
this.currentLogLevel = SimpleLoggerConfiguration.stringToLevel(levelString);
} else {
this.currentLogLevel = CONFIG_PARAMS.defaultLogLevel;
}
}
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(SimpleLogger.LOG_KEY_PREFIX + tempName, null);
indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
}
return levelString;
}
void write(StringBuilder buf, Throwable t) {
PrintStream targetStream = CONFIG_PARAMS.outputChoice.getTargetPrintStream();
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);
}
/**
* This is our internal implementation for logging regular (non-parameterized)
* log messages.
*
* @param level One of the LOG_LEVEL_XXX constants defining the log level
* @param message The message itself
* @param t The exception whose stack trace should be logged
*/
@Override
protected void handleNormalizedLoggingCall(Level level, Marker marker, String messagePattern, Object[] arguments,
Throwable t) {
first convert to an event and then log
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(' ');
} else {
buf.append(System.currentTimeMillis() - START_TIME);
buf.append(' ');
}
}
// Append current thread name if so configured
if (CONFIG_PARAMS.showThreadName) {
buf.append('[');
buf.append(Thread.currentThread().getName());
buf.append("] ");
}
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(' ');
// 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(" - ");
}
buf.append(SP).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 = ParameterNormalizer.normalize(event);
FormattingTuple tp = MessageFormatter.arrayFormat(event.getMessage(), event.getArgumentArray(),
event.getThrowable());
handleNormalizedLoggingCall(level, event.getMarkers(), messagePattern, arguments, t);
log(event.getLevel(), tp.getMessage(), event.getThrowable());
}
@Override
protected String getFullyQualifiedCallerName() {
return null;
}
}