001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache license, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the license for the specific language governing permissions and 015 * limitations under the license. 016 */ 017 package org.apache.logging.log4j.core.layout; 018 019 import java.nio.charset.Charset; 020 import java.util.HashMap; 021 import java.util.List; 022 import java.util.Map; 023 024 import org.apache.logging.log4j.core.LogEvent; 025 import org.apache.logging.log4j.core.config.Configuration; 026 import org.apache.logging.log4j.core.config.DefaultConfiguration; 027 import org.apache.logging.log4j.core.config.plugins.Plugin; 028 import org.apache.logging.log4j.core.config.plugins.PluginAttribute; 029 import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute; 030 import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory; 031 import org.apache.logging.log4j.core.config.plugins.PluginConfiguration; 032 import org.apache.logging.log4j.core.config.plugins.PluginElement; 033 import org.apache.logging.log4j.core.config.plugins.PluginFactory; 034 import org.apache.logging.log4j.core.pattern.LogEventPatternConverter; 035 import org.apache.logging.log4j.core.pattern.PatternFormatter; 036 import org.apache.logging.log4j.core.pattern.PatternParser; 037 import org.apache.logging.log4j.core.pattern.RegexReplacement; 038 import org.apache.logging.log4j.core.util.Charsets; 039 040 /** 041 * <p>A flexible layout configurable with pattern string. The goal of this class 042 * is to {@link org.apache.logging.log4j.core.Layout#toByteArray format} a {@link LogEvent} and return the results. 043 * The format of the result depends on the <em>conversion pattern</em>. 044 * <p> 045 * <p/> 046 * <p>The conversion pattern is closely related to the conversion 047 * pattern of the printf function in C. A conversion pattern is 048 * composed of literal text and format control expressions called 049 * <em>conversion specifiers</em>. 050 * 051 * See the Log4j Manual for details on the supported pattern converters. 052 */ 053 @Plugin(name = "PatternLayout", category = "Core", elementType = "layout", printObject = true) 054 public final class PatternLayout extends AbstractStringLayout { 055 /** 056 * Default pattern string for log output. Currently set to the 057 * string <b>"%m%n"</b> which just prints the application supplied 058 * message. 059 */ 060 public static final String DEFAULT_CONVERSION_PATTERN = "%m%n"; 061 062 /** 063 * A conversion pattern equivalent to the TTCCCLayout. 064 * Current value is <b>%r [%t] %p %c %x - %m%n</b>. 065 */ 066 public static final String TTCC_CONVERSION_PATTERN = 067 "%r [%t] %p %c %x - %m%n"; 068 069 /** 070 * A simple pattern. 071 * Current value is <b>%d [%t] %p %c - %m%n</b>. 072 */ 073 public static final String SIMPLE_CONVERSION_PATTERN = 074 "%d [%t] %p %c - %m%n"; 075 076 /** Key to identify pattern converters. */ 077 public static final String KEY = "Converter"; 078 079 /** 080 * Initial converter for pattern. 081 */ 082 private final List<PatternFormatter> formatters; 083 084 /** 085 * Conversion pattern. 086 */ 087 private final String conversionPattern; 088 089 090 /** 091 * The current Configuration. 092 */ 093 private final Configuration config; 094 095 private final RegexReplacement replace; 096 097 private final boolean alwaysWriteExceptions; 098 099 private final boolean noConsoleNoAnsi; 100 101 /** 102 * Constructs a EnhancedPatternLayout using the supplied conversion pattern. 103 * 104 * @param config The Configuration. 105 * @param replace The regular expression to match. 106 * @param pattern conversion pattern. 107 * @param charset The character set. 108 * @param alwaysWriteExceptions Whether or not exceptions should always be handled in this pattern (if {@code true}, 109 * exceptions will be written even if the pattern does not specify so). 110 * @param noConsoleNoAnsi 111 * If {@code "true"} (default) and {@link System#console()} is null, do not output ANSI escape codes 112 * @param header 113 */ 114 private PatternLayout(final Configuration config, final RegexReplacement replace, final String pattern, 115 final Charset charset, final boolean alwaysWriteExceptions, final boolean noConsoleNoAnsi, 116 final String header, final String footer) { 117 super(charset, toBytes(header, charset), toBytes(footer, charset)); 118 this.replace = replace; 119 this.conversionPattern = pattern; 120 this.config = config; 121 this.alwaysWriteExceptions = alwaysWriteExceptions; 122 this.noConsoleNoAnsi = noConsoleNoAnsi; 123 final PatternParser parser = createPatternParser(config); 124 this.formatters = parser.parse(pattern == null ? DEFAULT_CONVERSION_PATTERN : pattern, this.alwaysWriteExceptions, this.noConsoleNoAnsi); 125 } 126 127 private static byte[] toBytes(String str, Charset charset) { 128 if (str != null) { 129 return str.getBytes(charset != null ? charset : Charset.defaultCharset()); 130 } 131 return null; 132 } 133 134 private byte[] strSubstitutorReplace(final byte... b) { 135 if (b != null && config != null) { 136 final Charset cs = getCharset(); 137 return config.getStrSubstitutor().replace(new String(b, cs)).getBytes(cs); 138 } 139 return b; 140 } 141 142 @Override 143 public byte[] getHeader() { 144 return strSubstitutorReplace(super.getHeader()); 145 } 146 147 @Override 148 public byte[] getFooter() { 149 return strSubstitutorReplace(super.getFooter()); 150 } 151 152 /** 153 * Gets the conversion pattern. 154 * 155 * @return the conversion pattern. 156 */ 157 public String getConversionPattern() { 158 return conversionPattern; 159 } 160 161 /** 162 * PatternLayout's content format is specified by:<p/> 163 * Key: "structured" Value: "false"<p/> 164 * Key: "formatType" Value: "conversion" (format uses the keywords supported by OptionConverter)<p/> 165 * Key: "format" Value: provided "conversionPattern" param 166 * @return Map of content format keys supporting PatternLayout 167 */ 168 @Override 169 public Map<String, String> getContentFormat() 170 { 171 final Map<String, String> result = new HashMap<String, String>(); 172 result.put("structured", "false"); 173 result.put("formatType", "conversion"); 174 result.put("format", conversionPattern); 175 return result; 176 } 177 178 /** 179 * Formats a logging event to a writer. 180 * 181 * 182 * @param event logging event to be formatted. 183 * @return The event formatted as a String. 184 */ 185 @Override 186 public String toSerializable(final LogEvent event) { 187 final StringBuilder buf = new StringBuilder(); 188 for (final PatternFormatter formatter : formatters) { 189 formatter.format(event, buf); 190 } 191 String str = buf.toString(); 192 if (replace != null) { 193 str = replace.format(str); 194 } 195 return str; 196 } 197 198 /** 199 * Create a PatternParser. 200 * @param config The Configuration. 201 * @return The PatternParser. 202 */ 203 public static PatternParser createPatternParser(final Configuration config) { 204 if (config == null) { 205 return new PatternParser(config, KEY, LogEventPatternConverter.class); 206 } 207 PatternParser parser = config.getComponent(KEY); 208 if (parser == null) { 209 parser = new PatternParser(config, KEY, LogEventPatternConverter.class); 210 config.addComponent(KEY, parser); 211 parser = (PatternParser) config.getComponent(KEY); 212 } 213 return parser; 214 } 215 216 @Override 217 public String toString() { 218 return conversionPattern; 219 } 220 221 /** 222 * Create a pattern layout. 223 * 224 * @param pattern 225 * The pattern. If not specified, defaults to DEFAULT_CONVERSION_PATTERN. 226 * @param config 227 * The Configuration. Some Converters require access to the Interpolator. 228 * @param replace 229 * A Regex replacement String. 230 * @param charset 231 * The character set. 232 * @param alwaysWriteExceptions 233 * If {@code "true"} (default) exceptions are always written even if the pattern contains no exception tokens. 234 * @param noConsoleNoAnsi 235 * If {@code "true"} (default is false) and {@link System#console()} is null, do not output ANSI escape codes 236 * @param header 237 * The footer to place at the top of the document, once. 238 * @param footer 239 * The footer to place at the bottom of the document, once. 240 * @return The PatternLayout. 241 */ 242 @PluginFactory 243 public static PatternLayout createLayout( 244 @PluginAttribute(value = "pattern", defaultString = DEFAULT_CONVERSION_PATTERN) final String pattern, 245 @PluginConfiguration final Configuration config, 246 @PluginElement("Replace") final RegexReplacement replace, 247 @PluginAttribute(value = "charset", defaultString = "UTF-8") final Charset charset, 248 @PluginAttribute(value = "alwaysWriteExceptions", defaultBoolean = true) final boolean alwaysWriteExceptions, 249 @PluginAttribute(value = "noConsoleNoAnsi", defaultBoolean = false) final boolean noConsoleNoAnsi, 250 @PluginAttribute("header") final String header, 251 @PluginAttribute("footer") final String footer) { 252 return newBuilder() 253 .withPattern(pattern) 254 .withConfiguration(config) 255 .withRegexReplacement(replace) 256 .withCharset(charset) 257 .withAlwaysWriteExceptions(alwaysWriteExceptions) 258 .withNoConsoleNoAnsi(noConsoleNoAnsi) 259 .withHeader(header) 260 .withFooter(footer) 261 .build(); 262 } 263 264 /** 265 * Creates a PatternLayout using the default options. These options include using UTF-8, the default conversion 266 * pattern, exceptions being written, and with ANSI escape codes. 267 * 268 * @return the PatternLayout. 269 * @see #DEFAULT_CONVERSION_PATTERN Default conversion pattern 270 */ 271 public static PatternLayout createDefaultLayout() { 272 return newBuilder().build(); 273 } 274 275 /** 276 * Creates a builder for a custom PatternLayout. 277 * @return a PatternLayout builder. 278 */ 279 @PluginBuilderFactory 280 public static Builder newBuilder() { 281 return new Builder(); 282 } 283 284 /** 285 * Custom PatternLayout builder. Use the {@link PatternLayout#newBuilder() builder factory method} to create this. 286 */ 287 public static class Builder implements org.apache.logging.log4j.core.util.Builder<PatternLayout> { 288 289 // FIXME: it seems rather redundant to repeat default values (same goes for field names) 290 // perhaps introduce a @PluginBuilderAttribute that has no values of its own and uses reflection? 291 292 @PluginBuilderAttribute 293 private String pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN; 294 295 @PluginConfiguration 296 private Configuration configuration = null; 297 298 @PluginElement("Replace") 299 private RegexReplacement regexReplacement = null; 300 301 @PluginBuilderAttribute 302 private Charset charset = Charsets.UTF_8; 303 304 @PluginBuilderAttribute 305 private boolean alwaysWriteExceptions = true; 306 307 @PluginBuilderAttribute 308 private boolean noConsoleNoAnsi = false; 309 310 @PluginBuilderAttribute 311 private String header = null; 312 313 @PluginBuilderAttribute 314 private String footer = null; 315 316 private Builder() { 317 } 318 319 // TODO: move javadocs from PluginFactory to here 320 321 public Builder withPattern(final String pattern) { 322 this.pattern = pattern; 323 return this; 324 } 325 326 327 public Builder withConfiguration(final Configuration configuration) { 328 this.configuration = configuration; 329 return this; 330 } 331 332 public Builder withRegexReplacement(final RegexReplacement regexReplacement) { 333 this.regexReplacement = regexReplacement; 334 return this; 335 } 336 337 public Builder withCharset(final Charset charset) { 338 this.charset = charset; 339 return this; 340 } 341 342 public Builder withAlwaysWriteExceptions(final boolean alwaysWriteExceptions) { 343 this.alwaysWriteExceptions = alwaysWriteExceptions; 344 return this; 345 } 346 347 public Builder withNoConsoleNoAnsi(final boolean noConsoleNoAnsi) { 348 this.noConsoleNoAnsi = noConsoleNoAnsi; 349 return this; 350 } 351 352 public Builder withHeader(final String header) { 353 this.header = header; 354 return this; 355 } 356 357 public Builder withFooter(final String footer) { 358 this.footer = footer; 359 return this; 360 } 361 362 @Override 363 public PatternLayout build() { 364 // fall back to DefaultConfiguration 365 if (configuration == null) { 366 configuration = new DefaultConfiguration(); 367 } 368 return new PatternLayout(configuration, regexReplacement, pattern, charset, alwaysWriteExceptions, 369 noConsoleNoAnsi, header, footer); 370 } 371 } 372 }