org.mentalog.Log Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of menta-log Show documentation
A log library that embraces the kiss principle.
There is a newer version: 2.1.2
package org.mentalog;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TimeZone;

import org.mentaaffinity.Affinity;
import org.mentalog.config.BooleanConfigParam;
import org.mentalog.config.ByteArrayConfigParam;
import org.mentalog.config.BytesConfigParam;
import org.mentalog.config.ConfigParam;
import org.mentalog.config.FloatConfigParam;
import org.mentalog.config.IntegerConfigParam;
import org.mentalog.config.ListConfigParam;
import org.mentalog.config.LogConfigParam;
import org.mentalog.config.StringConfigParam;
import org.mentalog.config.StringsConfigParam;
import org.mentalog.encoder.Encoder;
import org.mentalog.interceptor.Interceptor;
import org.mentalog.timestamper.Timestamper;
import org.mentalog.util.Benchmarker;
import org.mentalog.util.DateTimeFormatter;
import org.mentalog.util.StringBuilderUtils;
import org.mentalog.util.SystemUtils;
import org.mentaqueue.wait.WaitStrategy;


/**
 * An enumeration with a log for each level. The levels are: Debug, Info, Warn, Error, Alert, Fatal.
 * 
 * Each level implement the Logger interface. You can also use the static method createLogger to create other logs not related to any level.
 * 
 * Refer to: http://mentalog.soliveirajr.com for documentations, recipes and more.
 * 
 * @author Sergio Oliveira Jr. - [email protected]
 */
public enum Log implements Logger, LogMessageBuilder {

	Debug(36), Info(32), Warn(35), Error(34), Alert(33), Fatal(31);
	
	// /// static stuff //////
	
	static final DateTimeFormatter DATETIME_FORMATTER = new DateTimeFormatter();

	private static final Log DEFAULT_LOG_LEVEL = Log.Info;
	private static final boolean DEFAULT_LOG_CONSOLE = true;
	private static final boolean DEFAULT_LOG_FILE = false;
	private static final Timestamper DEFAULT_TIMESTAMPER = Timestamper.MILLIS;
	private static final TimeZone DEFAULT_TIMEZONE = TimeZone.getDefault();
	private static final String DEFAULT_LOG_DIR = null;
	private static final boolean DEFAULT_SYNCHRONIZED = false;
	private static final boolean DEFAULT_USE_COLORS = false;
	private static final List DEFAULT_ENCODERS = new ArrayList(16);
	private static final boolean DEFAULT_LOG_BYPASSED_CONFIG = false;
	private static final Log DEFAULT_LOG_BYPASSED_CONFIG_LEVEL = Log.Warn;
	private static final boolean DEFAULT_NO_SPACE_AFTER_EQUAL_SIGN = true;
	private static final boolean DEFAULT_NO_SPACE_BETWEEN_OBJECTS= false;
	private static final boolean DEFAULT_LOG_CLASS_AND_LINE_NUMBER = false;
	private static final String DEFAULT_LOG_FILTER = null;
	private static final boolean DEFAULT_LOG_BENCHMARK = false;
	private static final String DEFAULT_LOG_BUFFER_SIZE = "10k";
	private static final String DEFAULT_MEMORY_MAPPED_BUFFER_SIZE = "50m";
	private static final float DEFAULT_MEMORY_MAPPED_BUFFER_THRESHOLD = 0.80f;
	private static final boolean DEFAULT_ALERT_ON_BUFFER_ROLL = false;
	private static final boolean DEFAULT_CACHE_ON_BUFFER_ROLL = true;
	private static final boolean DEFAULT_FORCE_ON_BUFFER_ROLL = false;
	private static final int DEFAULT_PROCESSOR_TO_BIND_CONSUMER = -1;
	private static final boolean DEFAULT_FORCE_ON_CLOSE = false;
	
	private static final boolean isExtended = ExtendedDefaultLogger.isExtension();

	static {
		
		DEFAULT_ENCODERS.add(Encoder.NULL);
		DEFAULT_ENCODERS.add(Encoder.CHAR_SEQUENCE);
		DEFAULT_ENCODERS.add(Encoder.BYTE_OR_CHAR_ARRAY);
		DEFAULT_ENCODERS.add(Encoder.THROWABLE);
		DEFAULT_ENCODERS.add(Encoder.ASCII);
	}

	private static BooleanConfigParam logConsole = new BooleanConfigParam("logConsole", DEFAULT_LOG_CONSOLE);
	private static BooleanConfigParam logFile = new BooleanConfigParam("logFile", DEFAULT_LOG_FILE);
	private static LogConfigParam logLevel = new LogConfigParam("logLevel", DEFAULT_LOG_LEVEL);
	private static StringConfigParam logDir = new StringConfigParam("logDir", DEFAULT_LOG_DIR);
	private static BooleanConfigParam isSynchronized = new BooleanConfigParam("logSynchronized", DEFAULT_SYNCHRONIZED);
	private static BooleanConfigParam useColors = new BooleanConfigParam("logColors", DEFAULT_USE_COLORS);
	private static ListConfigParam encoders = new ListConfigParam("logEncoders", "logAddEncoders, logAddEncoder", "logSetEncoders", DEFAULT_ENCODERS);
	private static ConfigParam timestamper = new ConfigParam("logTimestamper", DEFAULT_TIMESTAMPER);
	private static ConfigParam timeZone = new ConfigParam("logTimeZone", DEFAULT_TIMEZONE);
	private static BooleanConfigParam logBypassedConfig = new BooleanConfigParam("logShowBypassedConfig", DEFAULT_LOG_BYPASSED_CONFIG); // this option will log when a config value is bypassed
	private static LogConfigParam logBypassedConfigLevel = new LogConfigParam("logShowBypassedConfigLevel", DEFAULT_LOG_BYPASSED_CONFIG_LEVEL); // in what level (debug, info, etc.) the log above will be done?
	private static BooleanConfigParam noSpaceAfterEqualSign = new BooleanConfigParam("logNoSpaceAfterEqualSign", DEFAULT_NO_SPACE_AFTER_EQUAL_SIGN);
	private static BooleanConfigParam noSpaceBetweenObjects = new BooleanConfigParam("logNoSpaceBetweenObjects", DEFAULT_NO_SPACE_BETWEEN_OBJECTS);
	private static BooleanConfigParam logClassAndLineNumber = new BooleanConfigParam("logShowClassAndLineNumber", DEFAULT_LOG_CLASS_AND_LINE_NUMBER);
	private static StringsConfigParam logFilter = new StringsConfigParam("logFilter", DEFAULT_LOG_FILTER); // when defined, logger will only log things that happen inside the classes defined here... (wildcard '*' supported, ex: "com.mypackage.*")
	private static BooleanConfigParam logBenchmark = new BooleanConfigParam("logBenchmark", DEFAULT_LOG_BENCHMARK); // turn benchmark on and off
	private static BytesConfigParam logBufferSize = new BytesConfigParam("logBufferSize", DEFAULT_LOG_BUFFER_SIZE);

	private static BytesConfigParam logMemoryMappedBufferSize = new BytesConfigParam("logMemoryMappedBufferSize", DEFAULT_MEMORY_MAPPED_BUFFER_SIZE);
	private static FloatConfigParam logMemoryMappedBufferThreshold = new FloatConfigParam("logMemoryMappedBufferThreshold", DEFAULT_MEMORY_MAPPED_BUFFER_THRESHOLD); // threshold before rolling the memory mapped buffer into a new one...
	
	private static BooleanConfigParam logAlertOnBufferRoll = new BooleanConfigParam("logAlertOnBufferRoll", DEFAULT_ALERT_ON_BUFFER_ROLL);
	private static BooleanConfigParam logCacheOnBufferRoll = new BooleanConfigParam("logCacheOnBufferRoll", DEFAULT_CACHE_ON_BUFFER_ROLL);
	private static BooleanConfigParam logForceOnBufferRoll = new BooleanConfigParam("logForceOnBufferRoll", DEFAULT_FORCE_ON_BUFFER_ROLL);
	private static BooleanConfigParam logForceOnClose = new BooleanConfigParam("logForceOnClose", DEFAULT_FORCE_ON_CLOSE);
	
	private static IntegerConfigParam logAsynchronousQueueCapacity = new IntegerConfigParam("logAsynchronousQueueCapacity", -1);
	private static IntegerConfigParam logAsynchronousConsumerPriority = new IntegerConfigParam("logAsynchronousConsumerPriority", -1);
	
	private static IntegerConfigParam logProcToBindConsumer = new IntegerConfigParam("logProcToBindConsumer", DEFAULT_PROCESSOR_TO_BIND_CONSUMER);
	
	static {
		
		String configClassName = SystemUtils.getString("mentaLogConfigClass");
		
		if (configClassName != null) {
    		try {
    			Class klass = Class.forName(configClassName);
    			Configuration config = (Configuration) klass.newInstance();
    			ConfigParam.setForceMode(true);
    			config.configure();
    		} catch(Exception e) {
    			throw new IllegalStateException("Cannot load mentalog configuration: " + configClassName);
			} finally {
				ConfigParam.setForceMode(false);
    		}
		}
	}
	
	private synchronized static void initAsyncThread() {
		if (AsyncThread.thread() == null) {
			if (logAsynchronousConsumerPriority.value() > 0) {
				AsyncThread.setPriority(logAsynchronousConsumerPriority.value());
			}
			if (logAsynchronousQueueCapacity.value() > 0) {
				AsyncThread.setCapacity(logAsynchronousQueueCapacity.value());
			}
			AsyncThread.init();
			int procToBind = logProcToBindConsumer.value();
			if (procToBind != -1) {
				if (!Affinity.isAvailable()) {
					System.err.println("logProcToBindConsumer defined but menta affinity is not available! Check if running on linux and if JNA is in the classpath.");
				} else {
					Thread thread = AsyncThread.thread();
					Affinity.assignToProcessor(procToBind, thread);
				}
			}
			AsyncThread.start();
		}
	}
	
	public final static void setAsynchronousProducerWaitStrategy(WaitStrategy strategy) {
		AsyncThread.setProducerWaitStrategy(strategy);
	}
	
	public final static boolean isExtended() {
		return isExtended;
	}
	
	public final static void setAsynchronousConsumerWaitStrategy(WaitStrategy strategy) {
		AsyncThread.setConsumerWaitStrategy(strategy);
	}
	
	public synchronized static void stop() {
		if (isExtended && AsyncThread.thread() != null) {
			AsyncThread.drainAndStop();
		}
	}
	
	public static Log fromString(String s) {
		for(Log level : values()) {
			if (level.toString().equalsIgnoreCase(s)) {
				return level;
			}
		}
		return null;
	}
	
	public final static boolean isCacheOnBufferRoll() {
		return logCacheOnBufferRoll.bool();
	}
	
	public final static boolean isAlertOnBufferRoll() {
		return logAlertOnBufferRoll.bool();
	}
	
	public final static boolean isForceOnBufferRoll() {
		return logForceOnBufferRoll.bool();
	}
	
	public final static boolean isForceOnClose() {
		return logForceOnClose.bool();
	}
	
	public final static void setProcToBindConsumer(int x) {
		logProcToBindConsumer.set(x);
	}
	
	public final static void setAsynchronousQueueCapacity(int x) {
		logAsynchronousQueueCapacity.set(x);
	}
	
	public final static void setAsynchronousConsumerPriority(int x) {
		logAsynchronousConsumerPriority.set(x);
	}
	
	public final static void setCacheOnBufferRoll(boolean b) {
		logCacheOnBufferRoll.set(b);
	}
	
	public final static void setAlertOnBufferRoll(boolean b) {
		logAlertOnBufferRoll.set(b);
	}
	
	public final static void setForceOnBufferRoll(boolean b) {
		logForceOnBufferRoll.set(b);
	}
	
	public final static void setForceOnClose(boolean b) {
		logForceOnClose.set(b);
	}
	
	public final static float getMemoryMappedBufferThreshold() {
		return logMemoryMappedBufferThreshold.value();
	}
	
	public final static void setMemoryMappedBufferThreshold(float f) {
		logMemoryMappedBufferThreshold.set(f);
	}
	
	public static int getMemoryMappedBufferSize() {
		return logMemoryMappedBufferSize.value();
	}
	
	public static void setMemoryMappedBufferSize(int size) {
		logMemoryMappedBufferSize.set(size);
	}
	
	public static int getBufferSize() {
		return logBufferSize.value();
	}
	
	public static void setBufferSize(int size) {
		logBufferSize.set(size);
	}
	
	public static boolean isBenchmark() {
		return logBenchmark.bool();
	}
	
	public static void setBenchmark(boolean flag) {
		logBenchmark.set(flag);
	}
	
	public static String[] getFilter() {
		return logFilter.values();
	}
	
	public static void setFilter(String filter) {
		logFilter.set(filter);
	}
	
	public static boolean isShowClassAndLineNumber() {
		return logClassAndLineNumber.bool();
	}
	
	public static void setShowClassAndLineNumber(boolean flag) {
		logClassAndLineNumber.set(flag);
	}

	public static boolean isNoSpaceBetweenObjects() {
		return noSpaceBetweenObjects.bool();
	}

	public static void setNoSpaceBetweenObjects(boolean flag) {
		noSpaceBetweenObjects.set(flag);
	}

	public static boolean isNoSpaceAfterEqualSign() {
		return noSpaceAfterEqualSign.bool();
	}

	public static void setNoSpaceAfterEqualSign(boolean flag) {
		noSpaceAfterEqualSign.set(flag);
	}
	
	public static List getEncoders() {
		return encoders.values();
	}
	
	public static void add(Encoder encoder) {
		encoders.add(encoder);
	}
	
	public static void setEncoders(List encs) {
		encoders.set(encs);
	}
	
	public static boolean isColors() {
		return useColors.bool();
	}
	
	public static void setColors(boolean b) {

		boolean oldValue = useColors.bool();

		useColors.set(b);

		if (b != oldValue) {
			closeAll();
		}
	}
	
	public static boolean isSynchronized() {
		return isSynchronized.bool();
	}
	
	public static void setSynchronized(boolean flag) {

		boolean oldValue = isSynchronized.bool();

		isSynchronized.set(flag);

		if (flag != oldValue) {
			closeAll();
		}
	}

	public static boolean isConsole() {
		return logConsole.bool();
	}

	public static void setLevel(Log level) {
		logLevel.set(level);
	}

	public static Log getLevel() {
		return logLevel.value();
	}
	
	public static void setShowBypassedConfig(boolean flag, Log level) {
		logBypassedConfig.set(flag);
		logBypassedConfigLevel.set(level);
	}
	
	public static boolean isShowBypassedConfig() {
		return logBypassedConfig.bool();
	}
	
	public static Log getShowBypassedConfigLevel() {
		return logBypassedConfigLevel.value();
	}

	public static Timestamper getTimestamper() {
		return timestamper.value();
	}

	public static void setConsole(boolean flag) {

		if (logFile.isForced()) {
				ConfigParam.checkAndLog("logConsole", flag, logConsole.bool());
				return;
		}

		boolean oldValue = logConsole.bool();

		logConsole.set(flag);
		logFile.set(!flag);

		if (logConsole.bool() != oldValue) {
			closeAll();
		}
	}
	
	public static void setFile(boolean flag) {

		if (logConsole.isForced()) {
			ConfigParam.checkAndLog("logFile", flag, logFile.bool());
			return;
		}

		boolean oldValue = logFile.bool();

		logFile.set(flag);
		logConsole.set(!flag);

		if (logFile.bool() != oldValue) {
			closeAll();
		}
	}

	public static boolean isFile() {
		return logFile.bool();
	}

	public static void setTimestamper(Timestamper ts) {
		if (ts == null) {
			throw new LogException("Cannot set timestamper to null!");
		}
		
		Timestamper oldValue = timestamper.value();
		
		timestamper.set(ts);
		
		if (timestamper.value() != oldValue) {
			closeAll();
		}
	}
	
	public static void setTimeZone(TimeZone tz) {
		if (tz == null) {
			throw new LogException("Cannot set timezone to null!");
		}
		
		TimeZone oldValue = timeZone.value();
		
		timeZone.set(tz);

		if (timeZone.value() != oldValue) {
			DATETIME_FORMATTER.changeTimeZone(tz);
		}
	}

	public static TimeZone getTimeZone() {
		return timeZone.value();
	}

	public static void setDir(String dir) {

		String oldValue = logDir.str();

		logDir.set(dir);

		if (!logDir.str().equals(oldValue)) {
			closeAll();
		}
	}

	public static String getDir() {
		return logDir.str();
	}

	///////////////////////////

	private final String prefix;
	private final ByteArrayConfigParam color;
	private final StringConfigParam logFilename;
	private final BooleanConfigParam enabled;
	
	private Logger logger = null;

	private Log(int color) {
		String name = this.toString();
		prefix = name.toUpperCase();

		String defaultFilename = name.toUpperCase() + ".log";
		String logFileArgumentName = "log" + name + "Filename";
		this.logFilename = new StringConfigParam(logFileArgumentName, defaultFilename);
		
		String colorArgumentName = name.toLowerCase() + "Color";
		this.color = new ByteArrayConfigParam(colorArgumentName, getBytesFromColor(color));
		
		String enabledArgumentName = name.toLowerCase() + "Enabled";
		this.enabled = new BooleanConfigParam(enabledArgumentName, null);
	}

	private static byte[] getBytesFromColor(int color) {
		return ("\033[1;" + String.valueOf(color) + "m").getBytes();
	}
	
	@Override
	public void addInterceptor(Interceptor interceptor) { 
		Logger logger = getLogger();
		if (logger != null) {
			logger.addInterceptor(interceptor);
		}
	}
	
	@Override
	public void removeInterceptor(Interceptor interceptor) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.removeInterceptor(interceptor);
		}
	}
	
	public void setColor(int color) {
		if (color < 30 || color > 37) {
			throw new LogException("Color can only be in the range 30-37 !");
		}
		
		byte[] oldValue = this.color.bytes();
		
		this.color.set(getBytesFromColor(color));
		
		if ((isConsole() || !isFile()) && !Arrays.equals(oldValue, this.color.bytes())) {
			closeAll();
		}
	}
	
	public void setFilename(String filename) {
		
		String oldValue = logFilename.str();

		logFilename.set(filename);

		if (!oldValue.equals(logFilename.str())) {
			closeAll();
		}
	}

	public static void closeAll() {
		for(Log level: values()) {
			level.close();
		}
	}
	
	public static void add(Interceptor interceptor) {
		for(Log log: values()) {
			log.addInterceptor(interceptor);
		}
	}
	
	public static void remove(Interceptor interceptor) {
		for(Log log : values()) {
			log.removeInterceptor(interceptor);
		}
	}
	
	@Override
	public final void close() {
		if (logger != null) {
			logger.close();
			logger = null;
		}
	}
	
	public void logBenchmark() {
		StringBuilder sb = new StringBuilder(128);
		sb.append("Benchmarker=").append(Log.isBenchmark() ? "ON" : "OFF");
		sb.append(" Results=[").append(Benchmarker.instance().results()).append("]");
		log(sb);
	}
	
	public boolean isOn(Log level) {
		return this.ordinal() >= level.ordinal();
	}
	
	final Logger getLogger() {
		if (isSynchronized.bool()) {
			synchronized(this) {
				return getLoggerImpl();
			}
		} else {
			return getLoggerImpl();
		}
	}

	private final Logger getLoggerImpl() {
		if (isEnabled()) {
			if (logger == null) {
				logger = createLogger();
			}
			return logger;
		} else {
			close();
			return null;
		}
	}
	
	public static void enableAll(Boolean flag) {
		for (Log log : values()) {
			log.enable(flag);
		}
	}

	public final void enable(Boolean flag) {
		enabled.set(flag);
	}

	@Override
	public final boolean isEnabled() {

		if (enabled.value() != null && enabled.bool()) {
			return true;
		}
		
		if (enabled.value() != null && !enabled.bool()) {
			return false;
		}
		
		if (Log.getLevel() == null) {
			return false;
		}

		if (this.isOn(Log.getLevel())) {
			return true;
		}
		
		return false;
	}

	public static Logger createLogger(String dir, String filename, Timestamper timestamper, boolean isSynchronized, boolean isAsynchronous) {
		return createLogger(dir, filename, timestamper, isSynchronized, false, -1, encoders.values(), isAsynchronous);
	}
	
	public static Logger createLogger(String dir, String filename, boolean isSynchronized, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, false, -1, encoders.values(), isAsynchronous);
	}
	
	public static Logger createLogger(String dir, String filename, boolean isSynchronized, List encoders, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, false, -1, encoders, isAsynchronous);
	}
	
	public static Logger createMemoryMappedLogger(String dir, String filename, Timestamper timestamper, boolean isSynchronized, boolean isAsynchronous) {
		return createLogger(dir, filename, timestamper, isSynchronized, true, logMemoryMappedBufferSize.value(), encoders.values(), isAsynchronous);
	}
	
	public static Logger createMemoryMappedLogger(String dir, String filename, boolean isSynchronized, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, true, logMemoryMappedBufferSize.value(), encoders.values(), isAsynchronous);
	}
	
	public static Logger createMemoryMappedLogger(String dir, String filename, boolean isSynchronized, List encoders, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, true, logMemoryMappedBufferSize.value(), encoders, isAsynchronous);
	}	

	public static Logger createMemoryMappedLogger(String dir, String filename, Timestamper timestamper, boolean isSynchronized, int memoryMappedBufferSize, boolean isAsynchronous) {
		return createLogger(dir, filename, timestamper, isSynchronized, true, memoryMappedBufferSize, encoders.values(), isAsynchronous);
	}
	
	public static Logger createMemoryMappedLogger(String dir, String filename, boolean isSynchronized, int memoryMappedBufferSize, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, true, memoryMappedBufferSize, encoders.values(), isAsynchronous);
	}
	
	public static Logger createMemoryMappedLogger(String dir, String filename, boolean isSynchronized, List encoders, int memoryMappedBufferSize, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, true, memoryMappedBufferSize, encoders, isAsynchronous);
	}
	
	public static Logger createLogger(String dir, String filename, boolean isSynchronized, boolean isMemoryMapped, int memoryMappedBufferSize, boolean isAsynchronous) {
		return createLogger(dir, filename, DEFAULT_TIMESTAMPER, isSynchronized, isMemoryMapped, memoryMappedBufferSize, encoders.values(), isAsynchronous);
	}
	
	public static Logger createLogger(String dir, String filename, Timestamper timestamper, boolean isSynchronized, boolean isMemoryMapped, int memoryMappedBufferSize, List encoders, boolean isAsynchronous) {

		if (!(encoders instanceof ArrayList)) {
			// we will iterate using a for loop, not to waste iterators...
			// so make sure we have an ArrayList here not to be slow
			encoders = convertToArrayList(encoders);
		}

		try {
			createDir(dir);
			
			if (isAsynchronous) initAsyncThread();
			
			if (isExtended) {
				return new ExtendedDefaultLogger(dir, filename, timestamper, isSynchronized, isMemoryMapped, memoryMappedBufferSize, encoders, null, isAsynchronous);
			} else {
				return new DefaultLogger(dir, filename, timestamper, isSynchronized, isMemoryMapped, memoryMappedBufferSize, encoders, null, isAsynchronous);
			}
		} catch(Exception e) {
			throw new LogException("Cannot create logger!", e);
		}
	}
	
	private static List convertToArrayList(List encoders) {
		List list = new ArrayList(encoders.size());
		list.addAll(encoders);
		return list;
	}
	
	private static void createDir(String dir) {
		if (dir != null && !dir.equals("")) {
			File f = new File(dir);
			if (!f.exists()) {
				f.mkdirs();
			}
		}
	}
	
	private Logger createLogger() {
		
		try {

			if (logConsole.isForcedTrue() && logFile.isForcedTrue()) {
				throw new LogException("Cannot configure logConsole and logFile at the same time!");
			}
			
			if (logConsole.isForcedTrue() || logFile.isForcedFalse() || logConsole.bool() || !logFile.bool()) {
				
				byte[] c = null;
				
				if (useColors.bool()) {
					
					c = this.color.bytes();
				}

				if (isExtended) {
					return new ExtendedDefaultLogger(System.out, prefix, timestamper.value(), isSynchronized.bool(), c, encoders.values(), this, false);
				} else {
					return new DefaultLogger(System.out, prefix, timestamper.value(), isSynchronized.bool(), c, encoders.values(), this, false);
				}

			} else {

				String fn = logFilename.str();

				String dir = logDir.str();

				createDir(dir);
				
				if (isExtended) {
					return new ExtendedDefaultLogger(dir, fn, timestamper.value(), isSynchronized.bool(), false, -1, encoders.values(), this, false);
				} else {
					return new DefaultLogger(dir, fn, timestamper.value(), isSynchronized.bool(), false, -1, encoders.values(), this, false);
				}
			}

		} catch (IOException e) {
			throw new LogException("Error creating log!", e);
		}
	}
	
	@Override
	public final void roll() {

		Logger logger = getLogger();
		
		if (logger != null) {
			logger.roll();
		}
	}

	@Override
	public final void log(Object... objects) {
		
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(objects);
		}
	}
	
	public static void main(String[] args) {
		
		// command-line: java -cp target/classes/ -DuseColors=true org.mentalog.Log

		String s = "Hello MentaLog!";
		
		Log.setLevel(Log.Debug);

		for(Log log : Log.values()) {
			log.log(s);
		}
	}
	
	@Override
	public void log(boolean async, Object ... objects) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.log(async, objects);
		}
	}
	
	/////// VARARGS /////
	
	@Override
	public final void log(Object s1) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1);
		}
	}
	
	@Override
	public final void log(Object s1, Object s2) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2);
		}
	}
	
	@Override
	public final void log(Object s1, Object s2, Object s3) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11, Object s12) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11, Object s12, Object s13) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11, Object s12, Object s13, Object s14) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11, Object s12, Object s13, Object s14, Object s15) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15);
		}
	}

	@Override
	public final void log(Object s1, Object s2, Object s3, Object s4, Object s5, Object s6, Object s7, Object s8, Object s9, Object s10, Object s11, Object s12, Object s13, Object s14, Object s15, Object s16) {
		Logger logger = getLogger();

		if (logger != null) {
			logger.log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16);
		}
	}

	// Stuff for the StringBuilderUtils:

	public final static StringBuilder to_sb(int x) {
		return StringBuilderUtils.to_sb(x);
	}

	public final static StringBuilder to_sb(long x) {
		return StringBuilderUtils.to_sb(x);
	}

	public final static StringBuilder to_sb(byte b) {
		return StringBuilderUtils.to_sb(b);
	}

	public final static StringBuilder to_sb(short s) {
		return StringBuilderUtils.to_sb(s);
	}

	public final static StringBuilder to_sb(double x) {
		return StringBuilderUtils.to_sb(x);
	}

	public final static StringBuilder to_sb(boolean b) {
		return StringBuilderUtils.to_sb(b);
	}

	public final static StringBuilder to_sb(float f) {
		return StringBuilderUtils.to_sb(f);
	}

	public final static StringBuilder to_sb(char c) {
		return StringBuilderUtils.to_sb(c);
	}

	@Override
    public LogMessageBuilder add(AsciiEncodable cs) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(cs);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(char[] x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(byte[] x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(long x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(int x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(double x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(float x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(byte x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(short x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(char x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(boolean x) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(x);
		}
		return this;
    }

	@Override
    public LogMessageBuilder add(Object o) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(o);
		}
		return this;
    }
	
	@Override
    public LogMessageBuilder add(StringBuilder sb) {
		Logger logger = getLogger();
		if (logger != null) {
			logger.add(sb);
		}
		return this;
    }

	@Override
    public void flush() {
		Logger logger = getLogger();
		if (logger != null) {
			logger.flush();
		}
    }
	
	@Override
	public Object[] getVarargs(int size) {
		Logger logger = getLogger();
		if (logger != null) {
			return logger.getVarargs(size);
		}
		return null;
	}

}