001/**
002 * Copyright (c) 2004-2022 QOS.ch Sarl (Switzerland)
003 * All rights reserved.
004 *
005 * Permission is hereby granted, free of charge, to any person obtaining
006 * a copy of this software and associated documentation files (the
007 * "Software"), to  deal in  the Software without  restriction, including
008 * without limitation  the rights to  use, copy, modify,  merge, publish,
009 * distribute,  sublicense, and/or sell  copies of  the Software,  and to
010 * permit persons to whom the Software  is furnished to do so, subject to
011 * the following conditions:
012 *
013 * The  above  copyright  notice  and  this permission  notice  shall  be
014 * included in all copies or substantial portions of the Software.
015 *
016 * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
017 * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
018 * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
019 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
020 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
021 * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
022 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
023 *
024 */
025package org.slf4j.simple;
026
027import java.io.PrintStream;
028import java.util.ArrayList;
029import java.util.Date;
030import java.util.List;
031
032import org.slf4j.Logger;
033import org.slf4j.Marker;
034import org.slf4j.event.Level;
035import org.slf4j.event.LoggingEvent;
036import org.slf4j.helpers.LegacyAbstractLogger;
037import org.slf4j.helpers.MessageFormatter;
038import org.slf4j.helpers.NormalizedParameters;
039import org.slf4j.spi.LocationAwareLogger;
040
041/**
042 * <p>
043 * Simple implementation of {@link Logger} that sends all enabled log messages,
044 * for all defined loggers, to the console ({@code System.err}). The following
045 * system properties are supported to configure the behavior of this logger:
046 * 
047 *
048 * <ul>
049 * <li><code>org.slf4j.simpleLogger.logFile</code> - The output target which can
050 * be the <em>path</em> to a file, or the special values "System.out" and
051 * "System.err". Default is "System.err".</li>
052 * 
053 * <li><code>org.slf4j.simpleLogger.cacheOutputStream</code> - If the output
054 * target is set to "System.out" or "System.err" (see preceding entry), by
055 * default, logs will be output to the latest value referenced by
056 * <code>System.out/err</code> variables. By setting this parameter to true, the
057 * output stream will be cached, i.e. assigned once at initialization time and
058 * re-used independently of the current value referenced by
059 * <code>System.out/err</code>.</li>
060 * 
061 * <li><code>org.slf4j.simpleLogger.defaultLogLevel</code> - Default log level
062 * for all instances of SimpleLogger. Must be one of ("trace", "debug", "info",
063 * "warn", "error" or "off"). If not specified, defaults to "info".</li>
064 *
065 * <li><code>org.slf4j.simpleLogger.log.<em>a.b.c</em></code> - Logging detail
066 * level for a SimpleLogger instance named "a.b.c". Right-side value must be one
067 * of "trace", "debug", "info", "warn", "error" or "off". When a SimpleLogger
068 * named "a.b.c" is initialized, its level is assigned from this property. If
069 * unspecified, the level of nearest parent logger will be used, and if none is
070 * set, then the value specified by
071 * <code>org.slf4j.simpleLogger.defaultLogLevel</code> will be used.</li>
072 *
073 * <li><code>org.slf4j.simpleLogger.showDateTime</code> - Set to
074 * <code>true</code> if you want the current date and time to be included in
075 * output messages. Default is <code>false</code></li>
076 *
077 * <li><code>org.slf4j.simpleLogger.dateTimeFormat</code> - The date and time
078 * format to be used in the output messages. The pattern describing the date and
079 * time format is defined by <a href=
080 * "http://docs.oracle.com/javase/1.5.0/docs/api/java/text/SimpleDateFormat.html">
081 * <code>SimpleDateFormat</code></a>. If the format is not specified or is
082 * invalid, the number of milliseconds since start up will be output.</li>
083 *
084 * <li><code>org.slf4j.simpleLogger.showThreadName</code> -Set to
085 * <code>true</code> if you want to output the current thread name. Defaults to
086 * <code>true</code>.</li>
087 * 
088 * <li>(since version 1.7.33 and 2.0.0-alpha6) <code>org.slf4j.simpleLogger.showThreadId</code> - 
089 * If you would like to output the current thread id, then set to
090 * <code>true</code>. Defaults to <code>false</code>.</li>
091 * 
092 * <li><code>org.slf4j.simpleLogger.showLogName</code> - Set to
093 * <code>true</code> if you want the Logger instance name to be included in
094 * output messages. Defaults to <code>true</code>.</li>
095 *
096 * <li><code>org.slf4j.simpleLogger.showShortLogName</code> - Set to
097 * <code>true</code> if you want the last component of the name to be included
098 * in output messages. Defaults to <code>false</code>.</li>
099 *
100 * <li><code>org.slf4j.simpleLogger.levelInBrackets</code> - Should the level
101 * string be output in brackets? Defaults to <code>false</code>.</li>
102 *
103 * <li><code>org.slf4j.simpleLogger.warnLevelString</code> - The string value
104 * output for the warn level. Defaults to <code>WARN</code>.</li>
105 * 
106 * </ul>
107 *
108 * <p>
109 * In addition to looking for system properties with the names specified above,
110 * this implementation also checks for a class loader resource named
111 * <code>"simplelogger.properties"</code>, and includes any matching definitions
112 * from this resource (if it exists).
113 * 
114 *
115 * <p>
116 * With no configuration, the default output includes the relative time in
117 * milliseconds, thread name, the level, logger name, and the message followed
118 * by the line separator for the host. In log4j terms it amounts to the "%r [%t]
119 * %level %logger - %m%n" pattern.
120 * 
121 * <p>
122 * Sample output follows.
123 * 
124 * 
125 * <pre>
126 * 176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse order.
127 * 225 [main] INFO examples.SortAlgo - Entered the sort method.
128 * 304 [main] INFO examples.SortAlgo - Dump of integer array:
129 * 317 [main] INFO examples.SortAlgo - Element [0] = 0
130 * 331 [main] INFO examples.SortAlgo - Element [1] = 1
131 * 343 [main] INFO examples.Sort - The next log statement should be an error message.
132 * 346 [main] ERROR examples.SortAlgo - Tried to dump an uninitialized array.
133 *   at org.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
134 *   at org.log4j.examples.Sort.main(Sort.java:64)
135 * 467 [main] INFO  examples.Sort - Exiting main method.
136 * </pre>
137 *
138 * <p>
139 * This implementation is heavily inspired by
140 * <a href="http://commons.apache.org/logging/">Apache Commons Logging</a>'s
141 * SimpleLog.
142 * 
143 *
144 * @author Ceki G&uuml;lc&uuml;
145 * @author Scott Sanders
146 * @author Rod Waldhoff
147 * @author Robert Burrell Donkin
148 * @author C&eacute;drik LIME
149 */
150public class SimpleLogger extends LegacyAbstractLogger {
151
152    private static final long serialVersionUID = -632788891211436180L;
153
154    private static final long START_TIME = System.currentTimeMillis();
155
156    protected static final int LOG_LEVEL_TRACE = LocationAwareLogger.TRACE_INT;
157    protected static final int LOG_LEVEL_DEBUG = LocationAwareLogger.DEBUG_INT;
158    protected static final int LOG_LEVEL_INFO = LocationAwareLogger.INFO_INT;
159    protected static final int LOG_LEVEL_WARN = LocationAwareLogger.WARN_INT;
160    protected static final int LOG_LEVEL_ERROR = LocationAwareLogger.ERROR_INT;
161
162    static char SP = ' ';
163    static final String TID_PREFIX = "tid=";
164
165
166    // The OFF level can only be used in configuration files to disable logging.
167    // It has
168    // no printing method associated with it in o.s.Logger interface.
169    protected static final int LOG_LEVEL_OFF = LOG_LEVEL_ERROR + 10;
170
171    private static boolean INITIALIZED = false;
172    static final SimpleLoggerConfiguration CONFIG_PARAMS = new SimpleLoggerConfiguration();
173    
174    static void lazyInit() {
175        if (INITIALIZED) {
176            return;
177        }
178        INITIALIZED = true;
179        init();
180    }
181
182    // external software might be invoking this method directly. Do not rename
183    // or change its semantics.
184    static void init() {
185        CONFIG_PARAMS.init();
186    }
187
188    /** The current log level */
189    protected int currentLogLevel = LOG_LEVEL_INFO;
190    /** The short name of this simple log instance */
191    private transient String shortLogName = null;
192
193    /**
194     * All system properties used by <code>SimpleLogger</code> start with this
195     * prefix
196     */
197    public static final String SYSTEM_PREFIX = "org.slf4j.simpleLogger.";
198
199    public static final String LOG_KEY_PREFIX = SimpleLogger.SYSTEM_PREFIX + "log.";
200
201    public static final String CACHE_OUTPUT_STREAM_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "cacheOutputStream";
202
203    public static final String WARN_LEVEL_STRING_KEY = SimpleLogger.SYSTEM_PREFIX + "warnLevelString";
204
205    public static final String LEVEL_IN_BRACKETS_KEY = SimpleLogger.SYSTEM_PREFIX + "levelInBrackets";
206
207    public static final String LOG_FILE_KEY = SimpleLogger.SYSTEM_PREFIX + "logFile";
208
209    public static final String SHOW_SHORT_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showShortLogName";
210
211    public static final String SHOW_LOG_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showLogName";
212
213    public static final String SHOW_THREAD_NAME_KEY = SimpleLogger.SYSTEM_PREFIX + "showThreadName";
214
215    public static final String SHOW_THREAD_ID_KEY = SimpleLogger.SYSTEM_PREFIX + "showThreadId";
216    
217    public static final String DATE_TIME_FORMAT_KEY = SimpleLogger.SYSTEM_PREFIX + "dateTimeFormat";
218
219    public static final String SHOW_DATE_TIME_KEY = SimpleLogger.SYSTEM_PREFIX + "showDateTime";
220
221    public static final String DEFAULT_LOG_LEVEL_KEY = SimpleLogger.SYSTEM_PREFIX + "defaultLogLevel";
222
223    /**
224     * Protected access allows only {@link SimpleLoggerFactory} and also derived classes to instantiate
225     * SimpleLogger instances.
226     */
227    protected SimpleLogger(String name) {
228        this.name = name;
229
230        String levelString = recursivelyComputeLevelString();
231        if (levelString != null) {
232            this.currentLogLevel = SimpleLoggerConfiguration.stringToLevel(levelString);
233        } else {
234            this.currentLogLevel = CONFIG_PARAMS.defaultLogLevel;
235        }
236    }
237
238    String recursivelyComputeLevelString() {
239        String tempName = name;
240        String levelString = null;
241        int indexOfLastDot = tempName.length();
242        while ((levelString == null) && (indexOfLastDot > -1)) {
243            tempName = tempName.substring(0, indexOfLastDot);
244            levelString = CONFIG_PARAMS.getStringProperty(SimpleLogger.LOG_KEY_PREFIX + tempName, null);
245            indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
246        }
247        return levelString;
248    }
249
250    /**
251     * To avoid intermingling of log messages and associated stack traces, the two
252     * operations are done in a synchronized block.
253     * 
254     * @param buf
255     * @param t
256     */
257    void write(StringBuilder buf, Throwable t) {
258        PrintStream targetStream = CONFIG_PARAMS.outputChoice.getTargetPrintStream();
259
260        synchronized (CONFIG_PARAMS) {
261            targetStream.println(buf.toString());
262            writeThrowable(t, targetStream);
263            targetStream.flush();
264        } 
265
266    }
267
268    protected void writeThrowable(Throwable t, PrintStream targetStream) {
269        if (t != null) {
270            t.printStackTrace(targetStream);
271        }
272    }
273
274    private String getFormattedDate() {
275        Date now = new Date();
276        String dateText;
277        synchronized (CONFIG_PARAMS.dateFormatter) {
278            dateText = CONFIG_PARAMS.dateFormatter.format(now);
279        }
280        return dateText;
281    }
282
283    private String computeShortName() {
284        return name.substring(name.lastIndexOf(".") + 1);
285    }
286
287    // /**
288    // * For formatted messages, first substitute arguments and then log.
289    // *
290    // * @param level
291    // * @param format
292    // * @param arg1
293    // * @param arg2
294    // */
295    // private void formatAndLog(int level, String format, Object arg1, Object arg2) {
296    // if (!isLevelEnabled(level)) {
297    // return;
298    // }
299    // FormattingTuple tp = MessageFormatter.format(format, arg1, arg2);
300    // log(level, tp.getMessage(), tp.getThrowable());
301    // }
302
303    // /**
304    // * For formatted messages, first substitute arguments and then log.
305    // *
306    // * @param level
307    // * @param format
308    // * @param arguments
309    // * a list of 3 ore more arguments
310    // */
311    // private void formatAndLog(int level, String format, Object... arguments) {
312    // if (!isLevelEnabled(level)) {
313    // return;
314    // }
315    // FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
316    // log(level, tp.getMessage(), tp.getThrowable());
317    // }
318
319    /**
320     * Is the given log level currently enabled?
321     *
322     * @param logLevel is this level enabled?
323     * @return whether the logger is enabled for the given level
324     */
325    protected boolean isLevelEnabled(int logLevel) {
326        // log level are numerically ordered so can use simple numeric
327        // comparison
328        return (logLevel >= currentLogLevel);
329    }
330
331    /** Are {@code trace} messages currently enabled? */
332    public boolean isTraceEnabled() {
333        return isLevelEnabled(LOG_LEVEL_TRACE);
334    }
335
336    /** Are {@code debug} messages currently enabled? */
337    public boolean isDebugEnabled() {
338        return isLevelEnabled(LOG_LEVEL_DEBUG);
339    }
340
341    /** Are {@code info} messages currently enabled? */
342    public boolean isInfoEnabled() {
343        return isLevelEnabled(LOG_LEVEL_INFO);
344    }
345
346    /** Are {@code warn} messages currently enabled? */
347    public boolean isWarnEnabled() {
348        return isLevelEnabled(LOG_LEVEL_WARN);
349    }
350
351    /** Are {@code error} messages currently enabled? */
352    public boolean isErrorEnabled() {
353        return isLevelEnabled(LOG_LEVEL_ERROR);
354    }
355
356    /**
357     * SimpleLogger's implementation of
358     * {@link org.slf4j.helpers.AbstractLogger#handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable) AbstractLogger#handleNormalizedLoggingCall}
359     * }
360     *
361     * @param level the SLF4J level for this event
362     * @param marker  The marker to be used for this event, may be null.
363     * @param messagePattern The message pattern which will be parsed and formatted
364     * @param arguments  the array of arguments to be formatted, may be null
365     * @param throwable  The exception whose stack trace should be logged, may be null
366     */
367    @Override
368    protected void handleNormalizedLoggingCall(Level level, Marker marker, String messagePattern, Object[] arguments, Throwable throwable) {
369
370        List<Marker> markers = null;
371
372        if (marker != null) {
373            markers = new ArrayList<>();
374            markers.add(marker);
375        }
376
377        innerHandleNormalizedLoggingCall(level, markers, messagePattern, arguments, throwable);
378    }
379
380    private void innerHandleNormalizedLoggingCall(Level level, List<Marker> markers, String messagePattern, Object[] arguments, Throwable t) {
381
382        StringBuilder buf = new StringBuilder(32);
383
384        // Append date-time if so configured
385        if (CONFIG_PARAMS.showDateTime) {
386            if (CONFIG_PARAMS.dateFormatter != null) {
387                buf.append(getFormattedDate());
388                buf.append(SP);
389            } else {
390                buf.append(System.currentTimeMillis() - START_TIME);
391                buf.append(SP);
392            }
393        }
394
395        // Append current thread name if so configured
396        if (CONFIG_PARAMS.showThreadName) {
397            buf.append('[');
398            buf.append(Thread.currentThread().getName());
399            buf.append("] ");
400        }
401        
402        if (CONFIG_PARAMS.showThreadId) {
403            buf.append(TID_PREFIX);
404            buf.append(Thread.currentThread().getId());
405            buf.append(SP);
406        }
407
408        if (CONFIG_PARAMS.levelInBrackets)
409            buf.append('[');
410
411        // Append a readable representation of the log level
412        String levelStr = renderLevel(level.toInt());
413        buf.append(levelStr);
414        if (CONFIG_PARAMS.levelInBrackets)
415            buf.append(']');
416        buf.append(SP);
417
418        // Append the name of the log instance if so configured
419        if (CONFIG_PARAMS.showShortLogName) {
420            if (shortLogName == null)
421                shortLogName = computeShortName();
422            buf.append(String.valueOf(shortLogName)).append(" - ");
423        } else if (CONFIG_PARAMS.showLogName) {
424            buf.append(String.valueOf(name)).append(" - ");
425        }
426
427        if (markers != null) {
428            buf.append(SP);
429            for (Marker marker : markers) {
430                buf.append(marker.getName()).append(SP);
431            }
432        }
433
434        String formattedMessage = MessageFormatter.basicArrayFormat(messagePattern, arguments);
435
436        // Append the message
437        buf.append(formattedMessage);
438
439        write(buf, t);
440    }
441
442    protected String renderLevel(int levelInt) {
443        switch (levelInt) {
444            case LOG_LEVEL_TRACE:
445                return "TRACE";
446            case LOG_LEVEL_DEBUG:
447                return("DEBUG");
448            case LOG_LEVEL_INFO:
449                return "INFO";
450            case LOG_LEVEL_WARN:
451                return "WARN";
452            case LOG_LEVEL_ERROR:
453                return "ERROR";
454        }
455        throw new IllegalStateException("Unrecognized level ["+levelInt+"]");
456    }
457
458    public void log(LoggingEvent event) {
459        int levelInt = event.getLevel().toInt();
460
461        if (!isLevelEnabled(levelInt)) {
462            return;
463        }
464
465        NormalizedParameters np = NormalizedParameters.normalize(event);
466
467        innerHandleNormalizedLoggingCall(event.getLevel(), event.getMarkers(), np.getMessage(), np.getArguments(), event.getThrowable());
468    }
469
470    @Override
471    protected String getFullyQualifiedCallerName() {
472        return null;
473    }
474
475}