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.LocalDateTime; 31 import java.time.ZoneId; 32 import java.time.ZonedDateTime; 33 import sun.util.logging.LoggingSupport; 34 35 /** 36 * Print a brief summary of the {@code LogRecord} in a human readable 37 * format. The summary will typically be 1 or 2 lines. 38 * 39 * <p> 40 * <a name="formatting"> 41 * <b>Configuration:</b></a> 42 * The {@code SimpleFormatter} is initialized with the 43 * <a href="../Formatter.html#syntax">format string</a> 44 * specified in the {@code java.util.logging.SimpleFormatter.format} 45 * property to {@linkplain #format format} the log messages. 46 * This property can be defined 47 * in the {@linkplain LogManager#getProperty logging properties} 48 * configuration file 49 * or as a system property. If this property is set in both 50 * the logging properties and system properties, 51 * the format string specified in the system property will be used. 52 * If this property is not defined or the given format string 53 * is {@linkplain java.util.IllegalFormatException illegal}, 54 * the default format is implementation-specific. 55 * 56 * @since 1.4 57 * @see java.util.Formatter 58 */ 59 60 public class SimpleFormatter extends Formatter { 61 62 // format string for printing the log record 63 private final String format = LoggingSupport.getSimpleFormat(); 64 private final ZoneId zoneId = ZoneId.systemDefault(); 65 66 /** 67 * Format the given LogRecord. 68 * <p> 69 * The formatting can be customized by specifying the 70 * <a href="../Formatter.html#syntax">format string</a> 71 * in the <a href="#formatting"> 72 * {@code java.util.logging.SimpleFormatter.format}</a> property. 73 * The given {@code LogRecord} will be formatted as if by calling: 74 * <pre> 75 * {@link String#format String.format}(format, date, source, logger, level, message, thrown); 76 * </pre> 77 * where the arguments are:<br> 78 * <ol> 79 * <li>{@code format} - the {@link java.util.Formatter 80 * java.util.Formatter} format string specified in the 81 * {@code java.util.logging.SimpleFormatter.format} property 82 * or the default format.</li> 83 * <li>{@code date} - a {@link ZonedDateTime} object representing 84 * {@linkplain LogRecord#getInstant() event time} of the log record 85 * in the {@link ZoneId#systemDefault()} system time zone.</li> 86 * <li>{@code source} - a string representing the caller, if available; 87 * otherwise, the logger's name.</li> 88 * <li>{@code logger} - the logger's name.</li> 89 * <li>{@code level} - the {@linkplain Level#getLocalizedName 90 * log level}.</li> 91 * <li>{@code message} - the formatted log message 92 * returned from the {@link Formatter#formatMessage(LogRecord)} 93 * method. It uses {@link java.text.MessageFormat java.text} 94 * formatting and does not use the {@code java.util.Formatter 95 * format} argument.</li> 96 * <li>{@code thrown} - a string representing 97 * the {@linkplain LogRecord#getThrown throwable} 98 * associated with the log record and its backtrace 99 * beginning with a newline character, if any; 100 * otherwise, an empty string.</li> 101 * </ol> 102 * 103 * <p>Some example formats:<br> 104 * <ul> 105 * <li> {@code java.util.logging.SimpleFormatter.format="%4$s: %5$s [%1$tc]%n"} 106 * <p>This prints 1 line with the log level ({@code 4$}), 107 * the log message ({@code 5$}) and the timestamp ({@code 1$}) in 108 * a square bracket. 109 * <pre> 110 * WARNING: warning message [Tue Mar 22 13:11:31 PDT 2011] 111 * </pre></li> 112 * <li> {@code java.util.logging.SimpleFormatter.format="%1$tc %2$s%n%4$s: %5$s%6$s%n"} 113 * <p>This prints 2 lines where the first line includes 114 * the timestamp ({@code 1$}) and the source ({@code 2$}); 115 * the second line includes the log level ({@code 4$}) and 116 * the log message ({@code 5$}) followed with the throwable 117 * and its backtrace ({@code 6$}), if any: 118 * <pre> 119 * Tue Mar 22 13:11:31 PDT 2011 MyClass fatal 120 * SEVERE: several message with an exception 121 * java.lang.IllegalArgumentException: invalid argument 122 * at MyClass.mash(MyClass.java:9) 123 * at MyClass.crunch(MyClass.java:6) 124 * at MyClass.main(MyClass.java:3) 125 * </pre></li> 126 * <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"} 127 * <p>This prints 2 lines similar to the example above 128 * with a different date/time formatting and does not print 129 * the throwable and its backtrace: 130 * <pre> 131 * Mar 22, 2011 1:11:31 PM MyClass fatal 132 * SEVERE: several message with an exception 133 * </pre></li> 134 * <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"} 135 * <p>Since JDK 1.9, {@code java.util.logging} uses {@link 136 * java.time.Clock#systemUTC() java.time} to create more precise time 137 * stamps. 138 * The format above can be used to add a {@code .%1$tN} to the 139 * date/time formatting so that nanoseconds will also be printed: 140 * <pre> 141 * Feb 06, 2015 5:33:10.279216000 PM example.Main main 142 * INFO: This is a test 143 * </pre></li> 144 * </ul> 145 * <p>This method can also be overridden in a subclass. 146 * It is recommended to use the {@link Formatter#formatMessage} 147 * convenience method to localize and format the message field. 148 * 149 * @param record the log record to be formatted. 150 * @return a formatted log record 151 */ 152 @Override 153 public synchronized String format(LogRecord record) { 154 ZonedDateTime zdt = ZonedDateTime.ofInstant( 155 record.getInstant(), zoneId); 156 String source; 157 if (record.getSourceClassName() != null) { 158 source = record.getSourceClassName(); 159 if (record.getSourceMethodName() != null) { 160 source += " " + record.getSourceMethodName(); 161 } 162 } else { 163 source = record.getLoggerName(); 164 } 165 String message = formatMessage(record); 166 String throwable = ""; 167 if (record.getThrown() != null) { 168 StringWriter sw = new StringWriter(); 169 PrintWriter pw = new PrintWriter(sw); 170 pw.println(); 171 record.getThrown().printStackTrace(pw); 172 pw.close(); 173 throwable = sw.toString(); 174 } 175 return String.format(format, 176 zdt, 177 source, 178 record.getLoggerName(), 179 record.getLevel().getLocalizedLevelName(), 180 message, 181 throwable); 182 } 183 }