com.github.czyzby.kiwi.log.LoggerService Maven / Gradle / Ivy
Show all versions of gdx-kiwi Show documentation
package com.github.czyzby.kiwi.log;
import com.badlogic.gdx.Application;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.ObjectMap;
import com.badlogic.gdx.utils.async.AsyncExecutor;
import com.github.czyzby.kiwi.log.formatter.TextFormatter;
import com.github.czyzby.kiwi.log.impl.AsynchronousLogger.AsynchronousLoggerFactory;
import com.github.czyzby.kiwi.log.impl.DefaultLogger.DefaultLoggerFactory;
import com.github.czyzby.kiwi.util.gdx.asset.Disposables;
import com.github.czyzby.kiwi.util.gdx.collection.GdxMaps;
/** Manages loggers. Default instance is accessible through {@link #INSTANCE} field and static methods.
*
*
* Even through services are {@link Disposable}, {@link #dispose()} method should be called only if you use asynchronous
* loggers.
*
* @author MJ
* @since 1.2 */
public class LoggerService implements Disposable {
/** Main logger service, used by static methods. */
public static final LoggerService INSTANCE = new LoggerService();
private final ObjectMap, Logger> loggers = GdxMaps.newObjectMap();
private final TextFormatter formatter = new TextFormatter();
private volatile AsyncExecutor executor;
// Settings:
private LoggerFactory factory = new DefaultLoggerFactory();
private boolean debugOn = true, infoOn = true, errorOn = true;
private boolean logTime;
private boolean useSimpleClassNames;
public LoggerService() {
// Services manage their own settings, we need to override default settings to turn on all logging levels.
Gdx.app.setLogLevel(Application.LOG_DEBUG);
}
/** @param forClass will be included in logs of the returned logger.
* @return logger connected with the selected class, created with the current settings. This always returns the same
* logger instance for same class. */
public Logger getLoggerForClass(final Class forClass) {
if (!loggers.containsKey(forClass)) {
final Logger logger = factory.newLogger(this, forClass);
loggers.put(forClass, logger);
return logger;
}
return loggers.get(forClass);
}
/** @return an instance of {@link AsyncExecutor}, used by asynchronous loggers. */
public AsyncExecutor getExecutor() {
if (executor == null) {
synchronized (this) {
if (executor == null) {
executor = new AsyncExecutor(1);
}
}
}
return executor;
}
/** @return formatter used to format messages with arguments. */
public TextFormatter getFormatter() {
return formatter;
}
/** @return true if debug messages are logged. */
public boolean isDebugOn() {
return debugOn;
}
/** @param debugOn if true, debug messages will be logged. */
public void setDebugOn(final boolean debugOn) {
this.debugOn = debugOn;
}
/** @return true if info messages are logged. */
public boolean isInfoOn() {
return infoOn;
}
/** @param infoOn if true, info messages will be logged. */
public void setInfoOn(final boolean infoOn) {
this.infoOn = infoOn;
}
/** @return true if error messages are logged. */
public boolean isErrorOn() {
return errorOn;
}
/** @param errorOn if true, error messages will be logged. */
public void setErrorOn(final boolean errorOn) {
this.errorOn = errorOn;
}
/** @return true if time is included in logs. */
public boolean isLoggingTime() {
return logTime;
}
/** @param logTime if true, current time will be included in logs. This does add some logging overhead. Defaults to
* false. */
public void setLoggingTime(final boolean logTime) {
this.logTime = logTime;
}
/** @param useSimpleClassNames if true, simple class names are used instead of full class names. Defaults to false.
* This value should be set BEFORE any loggers are returned, as it affects logger's creation. */
public void setUseSimpleClassNames(final boolean useSimpleClassNames) {
this.useSimpleClassNames = useSimpleClassNames;
}
/** @return true if simple class names are used instead of full class names. */
public boolean isUsingSimpleClassNames() {
return useSimpleClassNames;
}
/** @param useAsynchronousLoggers if true, asynchronous loggers will be used. While it delegates logging calls to a
* single thread, it has to create an instance of asynchronous task each time logging method is called
* and it has practically no gain on GWT. Use asynchronous loggers if you use multiple threads and
* regular logging causes delays or starvation. Defaults to false and should generally should not be set
* to true, unless justified. Note that this setting should be changed BEFORE any loggers are obtained,
* as it changes the way loggers are created. Note that invoking this method modifies internal
* {@link LoggerFactory} instance. */
public void setUseAsynchronousLoggers(final boolean useAsynchronousLoggers) {
setFactory(useAsynchronousLoggers ? new AsynchronousLoggerFactory() : new DefaultLoggerFactory());
}
/** @return {@link LoggerFactory} used to create new loggers. */
public LoggerFactory getFactory() {
return factory;
}
/** @param factory will be used to create new loggers. Note that this method should be invoked BEFORE any loggers
* are created, as any loggers created with previous factory will still be cached. */
public void setFactory(final LoggerFactory factory) {
this.factory = factory;
}
/** Removes all currently cached loggers. Note that loggers still used by other objects will not be disposed or
* garbage collected - this method only affects internal logger service cache. */
public void clearLoggersCache() {
loggers.clear();
}
/** Disposes of {@link AsyncExecutor}. Should be called only if using asynchronous loggers. */
@Override
public void dispose() {
Disposables.disposeOf(executor);
}
/** @param forClass its name will be included in logs.
* @return an instance of {@link Logger} linked with the selected class. This method always returns the same logger
* instance for the same class. */
public static Logger forClass(final Class forClass) {
return INSTANCE.getLoggerForClass(forClass);
}
/** Turns off all logging levels in the static logger service instance. Will disable all logging. */
public static void disable() {
debug(false);
info(false);
error(false);
}
/** @param debugOn if true, debug messages will be logged. */
public static void debug(final boolean debugOn) {
INSTANCE.setDebugOn(debugOn);
}
/** @param infoOn if true, info messages will be logged. */
public static void info(final boolean infoOn) {
INSTANCE.setInfoOn(infoOn);
}
/** @param errorOn if true, error messages will be logged. */
public static void error(final boolean errorOn) {
INSTANCE.setErrorOn(errorOn);
}
/** @param useAsynchronousLoggers if true, asynchronous loggers will be used. While it delegates logging calls to a
* single thread, it has to create an instance of asynchronous task each time logging method is called
* and it has practically no gain on GWT. Use asynchronous loggers if you use multiple threads and
* regular logging causes delays or starvation. Defaults to false and should generally should not be set
* to true, unless justified. Note that this setting should be changed BEFORE any loggers are obtained,
* as it changes the way loggers are created. */
public static void asynchronous(final boolean useAsynchronousLoggers) {
INSTANCE.setUseAsynchronousLoggers(useAsynchronousLoggers);
}
/** @param logTime if true, current time will be included in logs. This does add some logging overhead. Defaults to
* false. */
public static void logTime(final boolean logTime) {
INSTANCE.setLoggingTime(logTime);
}
/** @param useSimpleClassNames if true, simple class names are used instead of full class names. Defaults to false.
* This value should be set BEFORE any loggers are returned, as it affects logger's creation. */
public static void simpleClassNames(final boolean useSimpleClassNames) {
INSTANCE.setUseSimpleClassNames(useSimpleClassNames);
}
}