net.sf.eBus.logging.AsyncLogger Maven / Gradle / Ivy
The newest version!
//
// Copyright 2024 Charles W. Rapp
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package net.sf.eBus.logging;
import net.sf.eBus.client.EClient;
import net.sf.eBus.client.EObject;
import org.slf4j.Logger;
import org.slf4j.Marker;
/**
* This class implements {@link Logger} interface with the goal
* of performing the actual logging asynchronously on an eBus
* run queue thread. Normally a logger outputs the log message
* in-line to the application code which can be an issue for
* low-latency performance. Off-loading this logging to a
* separate thread addresses the issue. The downside to this
* solution is that the actual logging takes place some time
* after the logging call. This means that trying to match
* logging messages to when an application event occurred can be
* problematic.
*
* An {@code AsyncLogger} instance is created using
* {@link AsyncLoggerFactory} {@code getLogger} method.
*
*
* By default tasks dispatched to the {@code AsyncLoggerObject}
* instance are run on the default eBus run queue. If there is a
* need to associate {@code AsyncLoggerObject} with a different
* eBus run queue, this can be achieved by adding the following
* configuration to the {@code dispatchers} list in your eBus
* JSON configuration file:
*
* {
name : logDispatcher
numberThreads : 1
priority : 2
quantum : 500 millis
isDefault : false
classes : [ "net.sf.eBus.logging.AsyncLogger$AsyncLoggerObject" ]
}
*
* Please note that the logging methods first verify that the log
* message level is enabled before dispatching the
* logging task. This check is deemed cheap enough not impact
* application performance.
*
*
* @see AsyncLoggerFactory
*
* @author Charles W. Rapp
*/
public final class AsyncLogger
implements Logger
{
//---------------------------------------------------------------
// Member data.
//
//-----------------------------------------------------------
// Statics.
//
/**
* Post logging tasks to this async logger object.
*/
private static final AsyncLoggerObject sAsyncLogger =
new AsyncLoggerObject();
//-----------------------------------------------------------
// Locals.
//
/**
* Create a {@code Runnable} task containing this logger to
* perform a logging task asynchronously.
*/
private final Logger mNestedLogger;
//---------------------------------------------------------------
// Member methods.
//
//-----------------------------------------------------------
// Constructors.
//
/**
* Creates a new asynchronous logger containing the given
* nested logger.
* @param logger nested logger.
*/
/* package */ AsyncLogger(final Logger logger)
{
mNestedLogger = logger;
} // end of AsyncLogger(Logger)
//
// end of Constructors.
//-----------------------------------------------------------
//-----------------------------------------------------------
// Logger Interface Implementation.
//
/**
* Returns logger instance's name.
* @return logger instance name.
*/
@Override
public String getName()
{
return (mNestedLogger.getName());
} // end of getName()
@Override
public boolean isTraceEnabled()
{
return (mNestedLogger.isTraceEnabled());
} // end of isTraceEnabled()
@Override
public void trace(final String message)
{
// Is trace logging enabled?
if (mNestedLogger.isTraceEnabled())
{
// Yes.
EClient.dispatch(
() -> mNestedLogger.trace(message),
sAsyncLogger);
}
} // end of trace(String)
@Override
public void trace(final String format,
final Object arg)
{
if (mNestedLogger.isTraceEnabled())
{
EClient.dispatch(
() -> mNestedLogger.trace(format, arg),
sAsyncLogger);
}
} // end of trace(String, Object)
@Override
public void trace(final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isTraceEnabled())
{
EClient.dispatch(
() -> mNestedLogger.trace(format, arg0, arg1),
sAsyncLogger);
}
} // end of trace(String, Object, Object)
@Override
public void trace(final String format,
final Object... args)
{
if (mNestedLogger.isTraceEnabled())
{
EClient.dispatch(
() -> mNestedLogger.trace(format, args),
sAsyncLogger);
}
} // end of trace(String, Object...)
@Override
public void trace(final String msg,
final Throwable t)
{
if (mNestedLogger.isTraceEnabled())
{
EClient.dispatch(
() -> mNestedLogger.trace(msg, t),
sAsyncLogger);
}
} // end of trace(String, Throwable)
@Override
public boolean isTraceEnabled(final Marker marker)
{
return (mNestedLogger.isTraceEnabled(marker));
} // end of isTraceEnabled(Marker)
@Override
public void trace(final Marker marker,
final String msg)
{
if (mNestedLogger.isTraceEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.trace(marker, msg),
sAsyncLogger);
}
} // end of trace(Marker, String)
@Override
public void trace(final Marker marker,
final String format,
final Object arg)
{
if (mNestedLogger.isTraceEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.trace(marker, format, arg),
sAsyncLogger);
}
} // end of trace(Marker, String, Object)
@Override
public void trace(final Marker marker,
final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isTraceEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.trace(marker,
format,
arg0,
arg1),
sAsyncLogger);
}
} // end of trace(Marker, String, Object, Object)
@Override
public void trace(final Marker marker,
final String format,
final Object... args)
{
if (mNestedLogger.isTraceEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.trace(marker, format, args),
sAsyncLogger);
}
} // end of trace(Marker, String, Object...)
@Override
public void trace(final Marker marker,
final String msg,
final Throwable t)
{
if (mNestedLogger.isTraceEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.trace(marker, msg, t),
sAsyncLogger);
}
} // end of trace(Marker, String, Throwable)
@Override
public boolean isDebugEnabled()
{
return (mNestedLogger.isDebugEnabled());
} // end of isDebugEnabled()
@Override
public void debug(final String msg)
{
if (mNestedLogger.isDebugEnabled())
{
EClient.dispatch(
() -> mNestedLogger.debug(msg),
sAsyncLogger);
}
} // end of debug(String)
@Override
public void debug(final String format,
final Object arg)
{
if (mNestedLogger.isDebugEnabled())
{
EClient.dispatch(
() -> mNestedLogger.debug(format, arg),
sAsyncLogger);
}
} // end of debug(String, Object)
@Override
public void debug(final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isDebugEnabled())
{
EClient.dispatch(
() -> mNestedLogger.debug(format, arg0, arg1),
sAsyncLogger);
}
} // end of debug(String, Object, Object)
@Override
public void debug(final String format,
final Object... args)
{
if (mNestedLogger.isDebugEnabled())
{
EClient.dispatch(
() -> mNestedLogger.debug(format, args),
sAsyncLogger);
}
} // end of debug(String, Object...)
@Override
public void debug(final String msg,
final Throwable t)
{
if (mNestedLogger.isDebugEnabled())
{
EClient.dispatch(
() -> mNestedLogger.debug(msg, t),
sAsyncLogger);
}
} // end of debug(String, Throwable)
@Override
public boolean isDebugEnabled(final Marker marker)
{
return (mNestedLogger.isDebugEnabled(marker));
} // end of isDebugEnabled(Marker)
@Override
public void debug(final Marker marker,
final String msg)
{
if (mNestedLogger.isDebugEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.debug(marker, msg),
sAsyncLogger);
}
} // end of debug(Marker, String)
@Override
public void debug(final Marker marker,
final String format,
final Object arg)
{
if (mNestedLogger.isDebugEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.debug(marker, format, arg),
sAsyncLogger);
}
} // end of debug(Marker, String, Object)
@Override
public void debug(final Marker marker,
final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isDebugEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.debug(marker,
format,
arg0,
arg1),
sAsyncLogger);
}
} // end of debug(Marker, String, Object, Object)
@Override
public void debug(final Marker marker,
final String format,
final Object... args)
{
if (mNestedLogger.isDebugEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.debug(marker, format, args),
sAsyncLogger);
}
} // end of debug(Marker, String, Object...)
@Override
public void debug(final Marker marker,
final String msg,
final Throwable t)
{
if (mNestedLogger.isDebugEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.debug(marker, msg, t),
sAsyncLogger);
}
} // end of debug(Marker, String, Throwable)
@Override
public boolean isInfoEnabled()
{
return (mNestedLogger.isInfoEnabled());
} // end of isInfoEnabled()
@Override
public void info(final String msg)
{
if (mNestedLogger.isInfoEnabled())
{
EClient.dispatch(
() -> mNestedLogger.info(msg),
sAsyncLogger);
}
} // end of info(String)
@Override
public void info(final String format,
final Object arg)
{
if (mNestedLogger.isInfoEnabled())
{
EClient.dispatch(
() -> mNestedLogger.info(format, arg),
sAsyncLogger);
}
} // end of info(String, Object)
@Override
public void info(final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isInfoEnabled())
{
EClient.dispatch(
() -> mNestedLogger.info(format, arg0, arg1),
sAsyncLogger);
}
} // end of info(String, Object, Object)
@Override
public void info(final String format,
final Object... args)
{
if (mNestedLogger.isInfoEnabled())
{
EClient.dispatch(
() -> mNestedLogger.info(format, args),
sAsyncLogger);
}
} // end of info(String, Object...)
@Override
public void info(final String msg,
final Throwable t)
{
if (mNestedLogger.isInfoEnabled())
{
EClient.dispatch(
() -> mNestedLogger.info(msg, t),
sAsyncLogger);
}
} // end of info(String, Throwable)
@Override
public boolean isInfoEnabled(final Marker marker)
{
return (mNestedLogger.isInfoEnabled(marker));
} // end of isInfoEnabled(Marker)
@Override
public void info(final Marker marker,
final String msg)
{
if (mNestedLogger.isInfoEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.info(marker, msg),
sAsyncLogger);
}
} // end of info(Marker, String)
@Override
public void info(final Marker marker,
final String format,
final Object arg)
{
if (mNestedLogger.isInfoEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.info(marker, format, arg),
sAsyncLogger);
}
} // end of info(Marker, String, Object)
@Override
public void info(final Marker marker,
final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isInfoEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.info(marker,
format,
arg0,
arg1),
sAsyncLogger);
}
} // end of info(Marker, String, Object, Object)
@Override
public void info(final Marker marker,
final String format,
final Object... args)
{
if (mNestedLogger.isInfoEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.info(marker, format, args),
sAsyncLogger);
}
} // end of info(Marker, String, Object...)
@Override
public void info(final Marker marker,
final String msg,
final Throwable t)
{
if (mNestedLogger.isInfoEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.info(marker, msg, t),
sAsyncLogger);
}
} // end of info(Marker, String, Throwable)
@Override
public boolean isWarnEnabled()
{
return (mNestedLogger.isInfoEnabled());
} // end of isWarnEnabled()
@Override
public void warn(final String msg)
{
if (mNestedLogger.isWarnEnabled())
{
EClient.dispatch(
() -> mNestedLogger.warn(msg),
sAsyncLogger);
}
} // end of warn(String)
@Override
public void warn(final String format,
final Object arg)
{
if (mNestedLogger.isWarnEnabled())
{
EClient.dispatch(
() -> mNestedLogger.warn(format, arg),
sAsyncLogger);
}
} // end of warn(String, Object)
@Override
public void warn(final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isWarnEnabled())
{
EClient.dispatch(
() -> mNestedLogger.warn(format, arg0, arg1),
sAsyncLogger);
}
} // end of warn(String, object, Object)
@Override
public void warn(final String format,
final Object... args)
{
if (mNestedLogger.isWarnEnabled())
{
EClient.dispatch(
() -> mNestedLogger.warn(format, args),
sAsyncLogger);
}
} // end of warn(String, Object...)
@Override
public void warn(final String msg,
final Throwable t)
{
if (mNestedLogger.isWarnEnabled())
{
EClient.dispatch(
() -> mNestedLogger.warn(msg, t),
sAsyncLogger);
}
} // end of warn(String, Throwable)
@Override
public boolean isWarnEnabled(final Marker marker)
{
return (mNestedLogger.isInfoEnabled(marker));
} // end of isWarnEnabled(Marker)
@Override
public void warn(final Marker marker,
final String msg)
{
if (mNestedLogger.isWarnEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.warn(marker, msg),
sAsyncLogger);
}
} // end of warn(Marker, String)
@Override
public void warn(final Marker marker,
final String format,
final Object arg)
{
if (mNestedLogger.isWarnEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.warn(marker, format, arg),
sAsyncLogger);
}
} // end of warn(Marker, String, Object)
@Override
public void warn(final Marker marker,
final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isWarnEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.warn(marker,
format,
arg0,
arg1),
sAsyncLogger);
}
} // end of warn(Marker, String, Object, Object)
@Override
public void warn(final Marker marker,
final String format,
final Object... args)
{
if (mNestedLogger.isWarnEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.warn(marker, format, args),
sAsyncLogger);
}
} // end of warn(Marker, String, Object...)
@Override
public void warn(final Marker marker,
final String msg,
final Throwable t)
{
if (mNestedLogger.isWarnEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.warn(marker, msg, t),
sAsyncLogger);
}
} // end of warn(Marker, String, Throwable)
@Override
public boolean isErrorEnabled()
{
return (mNestedLogger.isErrorEnabled());
} // end of isErrorEnabled()
@Override
public void error(final String msg)
{
if (mNestedLogger.isErrorEnabled())
{
EClient.dispatch(
() -> mNestedLogger.error(msg),
sAsyncLogger);
}
} // end of error(String)
@Override
public void error(final String format,
final Object arg)
{
if (mNestedLogger.isErrorEnabled())
{
EClient.dispatch(
() -> mNestedLogger.error(format, arg),
sAsyncLogger);
}
} // end of error(String, Object)
@Override
public void error(final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isErrorEnabled())
{
EClient.dispatch(
() -> mNestedLogger.error(format, arg0, arg1),
sAsyncLogger);
}
} // end of error(String, Object, Object)
@Override
public void error(final String format,
final Object... args)
{
if (mNestedLogger.isErrorEnabled())
{
EClient.dispatch(
() -> mNestedLogger.error(format, args),
sAsyncLogger);
}
} // end of error(String, Object...)
@Override
public void error(final String msg,
final Throwable t)
{
if (mNestedLogger.isErrorEnabled())
{
EClient.dispatch(
() -> mNestedLogger.error(msg, t),
sAsyncLogger);
}
} // end of error(String, Throwable)
@Override
public boolean isErrorEnabled(final Marker marker)
{
return (mNestedLogger.isErrorEnabled(marker));
} // end of isErrorEnabled(Marker)
@Override
public void error(final Marker marker,
final String msg)
{
if (mNestedLogger.isErrorEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.error(marker, msg),
sAsyncLogger);
}
} // end of error(Marker, String)
@Override
public void error(final Marker marker,
final String format,
final Object arg)
{
if (mNestedLogger.isErrorEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.error(marker, format, arg),
sAsyncLogger);
}
} // end of error(Marker, String, Object)
@Override
public void error(final Marker marker,
final String format,
final Object arg0,
final Object arg1)
{
if (mNestedLogger.isErrorEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.error(marker,
format,
arg0,
arg1),
sAsyncLogger);
}
} // end of error(Marker, String, Object, Object)
@Override
public void error(final Marker marker,
final String format,
final Object... args)
{
if (mNestedLogger.isErrorEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.error(marker, format, args),
sAsyncLogger);
}
} // end of error(Marker, String, Object...)
@Override
public void error(final Marker marker,
final String msg,
final Throwable t)
{
if (mNestedLogger.isErrorEnabled(marker))
{
EClient.dispatch(
() -> mNestedLogger.error(marker, msg, t),
sAsyncLogger);
}
} // end of error(Marker, String, Throwable)
//
// end of Logger Interface Implementation.
//-----------------------------------------------------------
//-----------------------------------------------------------
// Get Methods.
//
/**
* Returns nested logger. Allows nested logger to be
* configured independently of this asynchronous logger.
* @return nested logger.
*/
public Logger nestedLogger()
{
return (mNestedLogger);
} // end of nestedLogger()
//
// end of Get Methods.
//-----------------------------------------------------------
//---------------------------------------------------------------
// Inner classes.
//
/**
* Logs messages using the nested logger instance. This
* class actually does nothing. All logging work is performed
* by the {@code Runnable} task posted to this eBus object's
* task queue. This class is public to allow users to
* associate {@code AsyncLoggerObject} to a specific eBus
* run queue thread rather than the default run queue thread.
*/
public static final class AsyncLoggerObject
implements EObject
{
//-----------------------------------------------------------
// Member data.
//
//-----------------------------------------------------------
// Member methods.
//
//-------------------------------------------------------
// Constructors.
//
/**
* Private constructor to restrict instantiation to
* {@code AsyncLogger}.
*/
private AsyncLoggerObject()
{}
//
// end of Constructors.
//-------------------------------------------------------
} // end of class AsyncLoggerObject
} // end of class AsyncLogger
© 2015 - 2025 Weber Informatics LLC | Privacy Policy