/* * Copyright 2015-2020 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors * * 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.dv8tion.jda.internal.utils; import org.slf4j.helpers.FormattingTuple; import org.slf4j.helpers.MarkerIgnoringBase; import org.slf4j.helpers.MessageFormatter; import org.slf4j.helpers.Util; import org.slf4j.spi.LocationAwareLogger; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.InputStream; import java.io.PrintStream; import java.security.AccessController; import java.security.PrivilegedAction; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Properties; class SimpleLogger extends MarkerIgnoringBase { private static final long serialVersionUID = -632788891211436180L; private static final String CONFIGURATION_FILE = "Loggerger.properties"; private static long START_TIME = System.currentTimeMillis(); private static final Properties SIMPLE_LOGGER_PROPS = new Properties(); private static final int LOG_LEVEL_TRACE = LocationAwareLogger.TRACE_INT; private static final int LOG_LEVEL_DEBUG = LocationAwareLogger.DEBUG_INT; private static final int LOG_LEVEL_INFO = LocationAwareLogger.INFO_INT; private static final int LOG_LEVEL_WARN = LocationAwareLogger.WARN_INT; private static final int LOG_LEVEL_ERROR = LocationAwareLogger.ERROR_INT; private static boolean INITIALIZED = false; private static int DEFAULT_LOG_LEVEL = LOG_LEVEL_INFO; private static boolean SHOW_DATE_TIME = false; private static String DATE_TIME_FORMAT_STR = null; private static DateFormat DATE_FORMATTER = null; private static boolean SHOW_THREAD_NAME = true; private static boolean SHOW_LOG_NAME = true; private static boolean SHOW_SHORT_LOG_NAME = false; private static String LOG_FILE = "System.err"; private static PrintStream TARGET_STREAM = null; private static boolean LEVEL_IN_BRACKETS = false; private static String WARN_LEVEL_STRING = "WARN"; public static final String SYSTEM_PREFIX = "org.slf4j.Loggerger."; public static final String DEFAULT_LOG_LEVEL_KEY = SYSTEM_PREFIX + "defaultLogLevel"; public static final String SHOW_DATE_TIME_KEY = SYSTEM_PREFIX + "showDateTime"; public static final String DATE_TIME_FORMAT_KEY = SYSTEM_PREFIX + "dateTimeFormat"; public static final String SHOW_THREAD_NAME_KEY = SYSTEM_PREFIX + "showThreadName"; public static final String SHOW_LOG_NAME_KEY = SYSTEM_PREFIX + "showLogName"; public static final String SHOW_SHORT_LOG_NAME_KEY = SYSTEM_PREFIX + "showShortLogName"; public static final String LOG_FILE_KEY = SYSTEM_PREFIX + "logFile"; public static final String LEVEL_IN_BRACKETS_KEY = SYSTEM_PREFIX + "levelInBrackets"; public static final String WARN_LEVEL_STRING_KEY = SYSTEM_PREFIX + "warnLevelString"; public static final String LOG_KEY_PREFIX = SYSTEM_PREFIX + "log."; private static String getStringProperty(String name) { String prop = null; try { prop = System.getProperty(name); } catch (SecurityException e) { ; // Ignore } return (prop == null) ? SIMPLE_LOGGER_PROPS.getProperty(name) : prop; } private static String getStringProperty(String name, String defaultValue) { String prop = getStringProperty(name); return (prop == null) ? defaultValue : prop; } private static boolean getBooleanProperty(String name, boolean defaultValue) { String prop = getStringProperty(name); return (prop == null) ? defaultValue : "true".equalsIgnoreCase(prop); } static void init() { INITIALIZED = true; loadProperties(); String defaultLogLevelString = getStringProperty(DEFAULT_LOG_LEVEL_KEY, null); if (defaultLogLevelString != null) DEFAULT_LOG_LEVEL = stringToLevel(defaultLogLevelString); SHOW_LOG_NAME = getBooleanProperty(SHOW_LOG_NAME_KEY, SHOW_LOG_NAME); SHOW_SHORT_LOG_NAME = getBooleanProperty(SHOW_SHORT_LOG_NAME_KEY, SHOW_SHORT_LOG_NAME); SHOW_DATE_TIME = getBooleanProperty(SHOW_DATE_TIME_KEY, SHOW_DATE_TIME); SHOW_THREAD_NAME = getBooleanProperty(SHOW_THREAD_NAME_KEY, SHOW_THREAD_NAME); DATE_TIME_FORMAT_STR = getStringProperty(DATE_TIME_FORMAT_KEY, DATE_TIME_FORMAT_STR); LEVEL_IN_BRACKETS = getBooleanProperty(LEVEL_IN_BRACKETS_KEY, LEVEL_IN_BRACKETS); WARN_LEVEL_STRING = getStringProperty(WARN_LEVEL_STRING_KEY, WARN_LEVEL_STRING); LOG_FILE = getStringProperty(LOG_FILE_KEY, LOG_FILE); TARGET_STREAM = computeTargetStream(LOG_FILE); if (DATE_TIME_FORMAT_STR != null) { try { DATE_FORMATTER = new SimpleDateFormat(DATE_TIME_FORMAT_STR); } catch (IllegalArgumentException e) { Util.report("Bad date format in " + CONFIGURATION_FILE + "; will output relative time", e); } } } private static PrintStream computeTargetStream(String logFile) { if ("System.err".equalsIgnoreCase(logFile)) return System.err; else if ("System.out".equalsIgnoreCase(logFile)) { return System.out; } else { try { FileOutputStream fos = new FileOutputStream(logFile); PrintStream printStream = new PrintStream(fos); return printStream; } catch (FileNotFoundException e) { Util.report("Could not open [" + logFile + "]. Defaulting to System.err", e); return System.err; } } } private static void loadProperties() { // Add props from the resource Loggerger.properties InputStream in = AccessController.doPrivileged(new PrivilegedAction<InputStream>() { public InputStream run() { ClassLoader threadCL = Thread.currentThread().getContextClassLoader(); if (threadCL != null) { return threadCL.getResourceAsStream(CONFIGURATION_FILE); } else { return ClassLoader.getSystemResourceAsStream(CONFIGURATION_FILE); } } }); if (null != in) { try { SIMPLE_LOGGER_PROPS.load(in); in.close(); } catch (java.io.IOException e) { // ignored } } } protected int currentLogLevel = LOG_LEVEL_INFO; private transient String shortLogName = null; SimpleLogger(String name) { if (!INITIALIZED) { init(); } this.name = name; String levelString = recursivelyComputeLevelString(); if (levelString != null) { this.currentLogLevel = stringToLevel(levelString); } else { this.currentLogLevel = DEFAULT_LOG_LEVEL; } } String recursivelyComputeLevelString() { String tempName = name; String levelString = null; int indexOfLastDot = tempName.length(); while ((levelString == null) && (indexOfLastDot > -1)) { tempName = tempName.substring(0, indexOfLastDot); levelString = getStringProperty(LOG_KEY_PREFIX + tempName, null); indexOfLastDot = String.valueOf(tempName).lastIndexOf("."); } return levelString; } private static int stringToLevel(String levelStr) { if ("trace".equalsIgnoreCase(levelStr)) { return LOG_LEVEL_TRACE; } else if ("debug".equalsIgnoreCase(levelStr)) { return LOG_LEVEL_DEBUG; } else if ("info".equalsIgnoreCase(levelStr)) { return LOG_LEVEL_INFO; } else if ("warn".equalsIgnoreCase(levelStr)) { return LOG_LEVEL_WARN; } else if ("error".equalsIgnoreCase(levelStr)) { return LOG_LEVEL_ERROR; } // assume INFO by default return LOG_LEVEL_INFO; } 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 (SHOW_DATE_TIME) { if (DATE_FORMATTER != null) { buf.append(getFormattedDate()); buf.append(' '); } else { buf.append(System.currentTimeMillis() - START_TIME); buf.append(' '); } } // Append current thread name if so configured if (SHOW_THREAD_NAME) { buf.append('['); buf.append(Thread.currentThread().getName()); buf.append("] "); } if (LEVEL_IN_BRACKETS) buf.append('['); // Append a readable representation of the log level switch (level) { case LOG_LEVEL_TRACE: buf.append("TRACE"); break; case LOG_LEVEL_DEBUG: buf.append("DEBUG"); break; case LOG_LEVEL_INFO: buf.append("INFO"); break; case LOG_LEVEL_WARN: buf.append(WARN_LEVEL_STRING); break; case LOG_LEVEL_ERROR: buf.append("ERROR"); break; } if (LEVEL_IN_BRACKETS) buf.append(']'); buf.append(' '); // Append the name of the log instance if so configured if (SHOW_SHORT_LOG_NAME) { if (shortLogName == null) shortLogName = computeShortName(); buf.append(String.valueOf(shortLogName)).append(" - "); } else if (SHOW_LOG_NAME) { buf.append(String.valueOf(name)).append(" - "); } // Append the message buf.append(message); write(buf, t); } void write(StringBuilder buf, Throwable t) { TARGET_STREAM.println(buf.toString()); if (t != null) { t.printStackTrace(TARGET_STREAM); } TARGET_STREAM.flush(); } private String getFormattedDate() { Date now = new Date(); String dateText; synchronized (DATE_FORMATTER) { dateText = DATE_FORMATTER.format(now); } return dateText; } private String computeShortName() { return name.substring(name.lastIndexOf(".") + 1); } 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()); } 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()); } protected boolean isLevelEnabled(int logLevel) { // log level are numerically ordered so can use simple numeric // comparison return (logLevel >= currentLogLevel); } public boolean isTraceEnabled() { return isLevelEnabled(LOG_LEVEL_TRACE); } public void trace(String msg) { log(LOG_LEVEL_TRACE, msg, null); } public void trace(String format, Object param1) { formatAndLog(LOG_LEVEL_TRACE, format, param1, null); } public void trace(String format, Object param1, Object param2) { formatAndLog(LOG_LEVEL_TRACE, format, param1, param2); } public void trace(String format, Object... argArray) { formatAndLog(LOG_LEVEL_TRACE, format, argArray); } public void trace(String msg, Throwable t) { log(LOG_LEVEL_TRACE, msg, t); } public boolean isDebugEnabled() { return isLevelEnabled(LOG_LEVEL_DEBUG); } public void debug(String msg) { log(LOG_LEVEL_DEBUG, msg, null); } public void debug(String format, Object param1) { formatAndLog(LOG_LEVEL_DEBUG, format, param1, null); } public void debug(String format, Object param1, Object param2) { formatAndLog(LOG_LEVEL_DEBUG, format, param1, param2); } public void debug(String format, Object... argArray) { formatAndLog(LOG_LEVEL_DEBUG, format, argArray); } public void debug(String msg, Throwable t) { log(LOG_LEVEL_DEBUG, msg, t); } public boolean isInfoEnabled() { return isLevelEnabled(LOG_LEVEL_INFO); } public void info(String msg) { log(LOG_LEVEL_INFO, msg, null); } public void info(String format, Object arg) { formatAndLog(LOG_LEVEL_INFO, format, arg, null); } public void info(String format, Object arg1, Object arg2) { formatAndLog(LOG_LEVEL_INFO, format, arg1, arg2); } public void info(String format, Object... argArray) { formatAndLog(LOG_LEVEL_INFO, format, argArray); } public void info(String msg, Throwable t) { log(LOG_LEVEL_INFO, msg, t); } public boolean isWarnEnabled() { return isLevelEnabled(LOG_LEVEL_WARN); } public void warn(String msg) { log(LOG_LEVEL_WARN, msg, null); } public void warn(String format, Object arg) { formatAndLog(LOG_LEVEL_WARN, format, arg, null); } public void warn(String format, Object arg1, Object arg2) { formatAndLog(LOG_LEVEL_WARN, format, arg1, arg2); } public void warn(String format, Object... argArray) { formatAndLog(LOG_LEVEL_WARN, format, argArray); } public void warn(String msg, Throwable t) { log(LOG_LEVEL_WARN, msg, t); } public boolean isErrorEnabled() { return isLevelEnabled(LOG_LEVEL_ERROR); } public void error(String msg) { log(LOG_LEVEL_ERROR, msg, null); } public void error(String format, Object arg) { formatAndLog(LOG_LEVEL_ERROR, format, arg, null); } public void error(String format, Object arg1, Object arg2) { formatAndLog(LOG_LEVEL_ERROR, format, arg1, arg2); } public void error(String format, Object... argArray) { formatAndLog(LOG_LEVEL_ERROR, format, argArray); } public void error(String msg, Throwable t) { log(LOG_LEVEL_ERROR, msg, t); } }