org.apache.logging.log4j.core.pattern.DatePatternConverter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of log4j-core Show documentation
Show all versions of log4j-core Show documentation
The Apache Log4j Implementation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.logging.log4j.core.pattern;
import java.util.Arrays;
import java.util.Date;
import java.util.Objects;
import java.util.TimeZone;
import java.util.concurrent.atomic.AtomicReference;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.util.Constants;
import org.apache.logging.log4j.core.util.datetime.FastDateFormat;
import org.apache.logging.log4j.core.util.datetime.FixedDateFormat;
import org.apache.logging.log4j.core.util.datetime.FixedDateFormat.FixedFormat;
/**
* Converts and formats the event's date in a StringBuilder.
*/
@Plugin(name = "DatePatternConverter", category = PatternConverter.CATEGORY)
@ConverterKeys({"d", "date"})
public final class DatePatternConverter extends LogEventPatternConverter implements ArrayPatternConverter {
private abstract static class Formatter {
long previousTime; // for ThreadLocal caching mode
abstract String format(long timeMillis);
abstract void formatToBuffer(long timeMillis, StringBuilder destination);
public String toPattern() {
return null;
}
}
private static final class PatternFormatter extends Formatter {
private final FastDateFormat fastDateFormat;
// this field is only used in ThreadLocal caching mode
private final StringBuilder cachedBuffer = new StringBuilder(64);
PatternFormatter(final FastDateFormat fastDateFormat) {
this.fastDateFormat = fastDateFormat;
}
@Override
String format(final long timeMillis) {
return fastDateFormat.format(timeMillis);
}
@Override
void formatToBuffer(final long timeMillis, final StringBuilder destination) {
if (previousTime != timeMillis) {
cachedBuffer.setLength(0);
fastDateFormat.format(timeMillis, cachedBuffer);
}
destination.append(cachedBuffer);
}
@Override
public String toPattern() {
return fastDateFormat.toPattern();
}
}
private static final class FixedFormatter extends Formatter {
private final FixedDateFormat fixedDateFormat;
// below fields are only used in ThreadLocal caching mode
private final char[] cachedBuffer = new char[64]; // max length of formatted date-time in any format < 64
private int length = 0;
FixedFormatter(final FixedDateFormat fixedDateFormat) {
this.fixedDateFormat = fixedDateFormat;
}
@Override
String format(final long timeMillis) {
return fixedDateFormat.format(timeMillis);
}
@Override
void formatToBuffer(final long timeMillis, final StringBuilder destination) {
if (previousTime != timeMillis) {
length = fixedDateFormat.format(timeMillis, cachedBuffer, 0);
}
destination.append(cachedBuffer, 0, length);
}
@Override
public String toPattern() {
return fixedDateFormat.getFormat();
}
}
private static final class UnixFormatter extends Formatter {
@Override
String format(final long timeMillis) {
return Long.toString(timeMillis / 1000);
}
@Override
void formatToBuffer(final long timeMillis, final StringBuilder destination) {
destination.append(timeMillis / 1000); // no need for caching
}
}
private static final class UnixMillisFormatter extends Formatter {
@Override
String format(final long timeMillis) {
return Long.toString(timeMillis);
}
@Override
void formatToBuffer(final long timeMillis, final StringBuilder destination) {
destination.append(timeMillis); // no need for caching
}
}
private final class CachedTime {
public long timestampMillis;
public String formatted;
public CachedTime(final long timestampMillis) {
this.timestampMillis = timestampMillis;
this.formatted = formatter.format(this.timestampMillis);
}
}
/**
* UNIX formatter in seconds (standard).
*/
private static final String UNIX_FORMAT = "UNIX";
/**
* UNIX formatter in milliseconds
*/
private static final String UNIX_MILLIS_FORMAT = "UNIX_MILLIS";
private final String[] options;
private final ThreadLocal threadLocalFormatter = new ThreadLocal<>();
private final AtomicReference cachedTime;
private final Formatter formatter;
/**
* Private constructor.
*
* @param options options, may be null.
*/
private DatePatternConverter(final String[] options) {
super("Date", "date");
this.options = options == null ? null : Arrays.copyOf(options, options.length);
this.formatter = createFormatter(options);
cachedTime = new AtomicReference<>(new CachedTime(System.currentTimeMillis()));
}
private Formatter createFormatter(final String[] options) {
final FixedDateFormat fixedDateFormat = FixedDateFormat.createIfSupported(options);
if (fixedDateFormat != null) {
return createFixedFormatter(fixedDateFormat);
}
return createNonFixedFormatter(options);
}
/**
* Obtains an instance of pattern converter.
*
* @param options options, may be null.
* @return instance of pattern converter.
*/
public static DatePatternConverter newInstance(final String[] options) {
return new DatePatternConverter(options);
}
private static Formatter createFixedFormatter(final FixedDateFormat fixedDateFormat) {
return new FixedFormatter(fixedDateFormat);
}
private static Formatter createNonFixedFormatter(final String[] options) {
// if we get here, options is a non-null array with at least one element (first of which non-null)
Objects.requireNonNull(options);
if (options.length == 0) {
throw new IllegalArgumentException("options array must have at least one element");
}
Objects.requireNonNull(options[0]);
final String patternOption = options[0];
if (UNIX_FORMAT.equals(patternOption)) {
return new UnixFormatter();
}
if (UNIX_MILLIS_FORMAT.equals(patternOption)) {
return new UnixMillisFormatter();
}
// LOG4J2-1149: patternOption may be a name (if a time zone was specified)
final FixedDateFormat.FixedFormat fixedFormat = FixedDateFormat.FixedFormat.lookup(patternOption);
final String pattern = fixedFormat == null ? patternOption : fixedFormat.getPattern();
// if the option list contains a TZ option, then set it.
TimeZone tz = null;
if (options.length > 1 && options[1] != null) {
tz = TimeZone.getTimeZone(options[1]);
}
try {
final FastDateFormat tempFormat = FastDateFormat.getInstance(pattern, tz);
return new PatternFormatter(tempFormat);
} catch (final IllegalArgumentException e) {
LOGGER.warn("Could not instantiate FastDateFormat with pattern " + pattern, e);
// default to the DEFAULT format
return createFixedFormatter(FixedDateFormat.create(FixedFormat.DEFAULT));
}
}
/**
* Appends formatted date to string buffer.
*
* @param date date
* @param toAppendTo buffer to which formatted date is appended.
*/
public void format(final Date date, final StringBuilder toAppendTo) {
format(date.getTime(), toAppendTo);
}
/**
* {@inheritDoc}
*/
@Override
public void format(final LogEvent event, final StringBuilder output) {
format(event.getTimeMillis(), output);
}
public void format(final long timestampMillis, final StringBuilder output) {
if (Constants.ENABLE_THREADLOCALS) {
formatWithoutAllocation(timestampMillis, output);
} else {
formatWithoutThreadLocals(timestampMillis, output);
}
}
private void formatWithoutAllocation(final long timestampMillis, final StringBuilder output) {
final Formatter formatter = getThreadLocalFormatter();
formatter.formatToBuffer(timestampMillis, output);
}
private Formatter getThreadLocalFormatter() {
Formatter result = threadLocalFormatter.get();
if (result == null) {
result = createFormatter(options);
threadLocalFormatter.set(result);
}
return result;
}
private void formatWithoutThreadLocals(final long timestampMillis, final StringBuilder output) {
CachedTime cached = cachedTime.get();
if (timestampMillis != cached.timestampMillis) {
final CachedTime newTime = new CachedTime(timestampMillis);
if (cachedTime.compareAndSet(cached, newTime)) {
cached = newTime;
} else {
cached = cachedTime.get();
}
}
output.append(cached.formatted);
}
/**
* {@inheritDoc}
*/
@Override
public void format(final Object obj, final StringBuilder output) {
if (obj instanceof Date) {
format((Date) obj, output);
}
super.format(obj, output);
}
@Override
public void format(final StringBuilder toAppendTo, final Object... objects) {
for (final Object obj : objects) {
if (obj instanceof Date) {
format(obj, toAppendTo);
break;
}
}
}
/**
* Gets the pattern string describing this date format.
*
* @return the pattern string describing this date format.
*/
public String getPattern() {
return formatter.toPattern();
}
}