1 /*
   2  * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 
  27 package java.util.logging;
  28 
  29 import java.io.*;
  30 import java.time.ZoneId;
  31 import java.time.ZonedDateTime;
  32 import jdk.internal.logger.SimpleConsoleLogger;
  33 
  34 /**
  35  * Print a brief summary of the {@code LogRecord} in a human readable
  36  * format.  The summary will typically be 1 or 2 lines.
  37  *
  38  * <p>
  39  * <a name="formatting">
  40  * <b>Configuration:</b></a>
  41  * The {@code SimpleFormatter} is initialized with the
  42  * <a href="../Formatter.html#syntax">format string</a>
  43  * specified in the {@code java.util.logging.SimpleFormatter.format}
  44  * property to {@linkplain #format format} the log messages.
  45  * This property can be defined
  46  * in the {@linkplain LogManager#getProperty logging properties}
  47  * configuration file
  48  * or as a system property.  If this property is set in both
  49  * the logging properties and system properties,
  50  * the format string specified in the system property will be used.
  51  * If this property is not defined or the given format string
  52  * is {@linkplain java.util.IllegalFormatException illegal},
  53  * the default format is implementation-specific.
  54  *
  55  * @since 1.4
  56  * @see java.util.Formatter
  57  */
  58 
  59 public class SimpleFormatter extends Formatter {
  60 
  61     // format string for printing the log record
  62     static String getLoggingProperty(String name) {
  63         return LogManager.getLogManager().getProperty(name);
  64     }
  65 
  66     private final String format =
  67         SimpleConsoleLogger.getSimpleFormat(SimpleFormatter::getLoggingProperty);
  68 
  69     /**
  70      * Format the given LogRecord.
  71      * <p>
  72      * The formatting can be customized by specifying the
  73      * <a href="../Formatter.html#syntax">format string</a>
  74      * in the <a href="#formatting">
  75      * {@code java.util.logging.SimpleFormatter.format}</a> property.
  76      * The given {@code LogRecord} will be formatted as if by calling:
  77      * <pre>
  78      *    {@link String#format String.format}(format, date, source, logger, level, message, thrown);
  79      * </pre>
  80      * where the arguments are:<br>
  81      * <ol>
  82      * <li>{@code format} - the {@link java.util.Formatter
  83      *     java.util.Formatter} format string specified in the
  84      *     {@code java.util.logging.SimpleFormatter.format} property
  85      *     or the default format.</li>
  86      * <li>{@code date} - a {@link ZonedDateTime} object representing
  87      *     {@linkplain LogRecord#getInstant() event time} of the log record
  88      *      in the {@link ZoneId#systemDefault()} system time zone.</li>
  89      * <li>{@code source} - a string representing the caller, if available;
  90      *     otherwise, the logger's name.</li>
  91      * <li>{@code logger} - the logger's name.</li>
  92      * <li>{@code level} - the {@linkplain Level#getLocalizedName
  93      *     log level}.</li>
  94      * <li>{@code message} - the formatted log message
  95      *     returned from the {@link Formatter#formatMessage(LogRecord)}
  96      *     method.  It uses {@link java.text.MessageFormat java.text}
  97      *     formatting and does not use the {@code java.util.Formatter
  98      *     format} argument.</li>
  99      * <li>{@code thrown} - a string representing
 100      *     the {@linkplain LogRecord#getThrown throwable}
 101      *     associated with the log record and its backtrace
 102      *     beginning with a newline character, if any;
 103      *     otherwise, an empty string.</li>
 104      * </ol>
 105      *
 106      * <p>Some example formats:<br>
 107      * <ul>
 108      * <li> {@code java.util.logging.SimpleFormatter.format="%4$s: %5$s [%1$tc]%n"}
 109      *     <p>This prints 1 line with the log level ({@code 4$}),
 110      *     the log message ({@code 5$}) and the timestamp ({@code 1$}) in
 111      *     a square bracket.
 112      *     <pre>
 113      *     WARNING: warning message [Tue Mar 22 13:11:31 PDT 2011]
 114      *     </pre></li>
 115      * <li> {@code java.util.logging.SimpleFormatter.format="%1$tc %2$s%n%4$s: %5$s%6$s%n"}
 116      *     <p>This prints 2 lines where the first line includes
 117      *     the timestamp ({@code 1$}) and the source ({@code 2$});
 118      *     the second line includes the log level ({@code 4$}) and
 119      *     the log message ({@code 5$}) followed with the throwable
 120      *     and its backtrace ({@code 6$}), if any:
 121      *     <pre>
 122      *     Tue Mar 22 13:11:31 PDT 2011 MyClass fatal
 123      *     SEVERE: several message with an exception
 124      *     java.lang.IllegalArgumentException: invalid argument
 125      *             at MyClass.mash(MyClass.java:9)
 126      *             at MyClass.crunch(MyClass.java:6)
 127      *             at MyClass.main(MyClass.java:3)
 128      *     </pre></li>
 129      * <li> {@code java.util.logging.SimpleFormatter.format="%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%n"}
 130      *      <p>This prints 2 lines similar to the example above
 131      *         with a different date/time formatting and does not print
 132      *         the throwable and its backtrace:
 133      *     <pre>
 134      *     Mar 22, 2011 1:11:31 PM MyClass fatal
 135      *     SEVERE: several message with an exception
 136      *     </pre></li>
 137      * <li> {@code java.util.logging.SimpleFormatter.format="%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS.%1$tN %1$Tp %2$s%n%4$s: %5$s%6$s%n"}
 138      *      <p>Since JDK 1.9, {@code java.util.logging} uses {@link
 139      *         java.time.Clock#systemUTC() java.time} to create more precise time
 140      *         stamps.
 141      *         The format above can be used to add a {@code .%1$tN} to the
 142      *         date/time formatting so that nanoseconds will also be printed:
 143      *     <pre>
 144      *     Feb 06, 2015 5:33:10.279216000 PM example.Main main
 145      *     INFO: This is a test
 146      *     </pre></li>
 147      * </ul>
 148      * <p>This method can also be overridden in a subclass.
 149      * It is recommended to use the {@link Formatter#formatMessage}
 150      * convenience method to localize and format the message field.
 151      *
 152      * @param record the log record to be formatted.
 153      * @return a formatted log record
 154      */
 155     @Override
 156     public synchronized String format(LogRecord record) {
 157         ZonedDateTime zdt = ZonedDateTime.ofInstant(
 158                 record.getInstant(), ZoneId.systemDefault());
 159         String source;
 160         if (record.getSourceClassName() != null) {
 161             source = record.getSourceClassName();
 162             if (record.getSourceMethodName() != null) {
 163                source += " " + record.getSourceMethodName();
 164             }
 165         } else {
 166             source = record.getLoggerName();
 167         }
 168         String message = formatMessage(record);
 169         String throwable = "";
 170         if (record.getThrown() != null) {
 171             StringWriter sw = new StringWriter();
 172             PrintWriter pw = new PrintWriter(sw);
 173             pw.println();
 174             record.getThrown().printStackTrace(pw);
 175             pw.close();
 176             throwable = sw.toString();
 177         }
 178         return String.format(format,
 179                              zdt,
 180                              source,
 181                              record.getLoggerName(),
 182                              record.getLevel().getLocalizedLevelName(),
 183                              message,
 184                              throwable);
 185     }
 186 }
--- EOF ---