下面列出了怎么用org.apache.logging.log4j.spi.ExtendedLogger的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Construct a prefix logger with the specified name and prefix.
*
* @param logger the extended logger to wrap
* @param name the name of this prefix logger
* @param prefix the prefix for this prefix logger
*/
PrefixLogger(final ExtendedLogger logger, final String name, final String prefix) {
super(logger, name, null);
final String actualPrefix = (prefix == null ? "" : prefix);
final Marker actualMarker;
// markers is not thread-safe, so we synchronize access
synchronized (MARKERS) {
final Marker maybeMarker = MARKERS.get(actualPrefix);
if (maybeMarker == null) {
actualMarker = new MarkerManager.Log4jMarker(actualPrefix);
/*
* We must create a new instance here as otherwise the marker will hold a reference to the key in the weak hash map; as
* those references are held strongly, this would give a strong reference back to the key preventing them from ever being
* collected. This also guarantees that no other strong reference can be held to the prefix anywhere.
*/
// noinspection RedundantStringConstructorCall
MARKERS.put(new String(actualPrefix), actualMarker);
} else {
actualMarker = maybeMarker;
}
}
this.marker = actualMarker;
}
@Override
public Log4jTaglibLogger getLogger(final String name, final MessageFactory messageFactory) {
// Note: This is the only method where we add entries to the 'loggerRegistry' ivar.
Log4jTaglibLogger logger = this.loggerRegistry.getLogger(name, messageFactory);
if (logger != null) {
AbstractLogger.checkMessageFactory(logger, messageFactory);
return logger;
}
synchronized (this.loggerRegistry) {
logger = this.loggerRegistry.getLogger(name, messageFactory);
if (logger == null) {
final LoggerContext context = LogManager.getContext(false);
final ExtendedLogger original = messageFactory == null ?
context.getLogger(name) : context.getLogger(name, messageFactory);
// wrap a logger from an underlying implementation
logger = new Log4jTaglibLogger(original, name, original.getMessageFactory());
this.loggerRegistry.putIfAbsent(name, messageFactory, logger);
}
}
return logger;
}
@Test
public void testLog4j2Only() throws InterruptedException {
final org.apache.logging.log4j.Logger log4JLogger = LogManager.getLogger(this.getClass());
final int limit = 11; // more than unrolled varargs
final Object[] args = createArray(limit);
final Object[] originalArgs = Arrays.copyOf(args, args.length);
listAppender.countDownLatch = new CountDownLatch(1);
((ExtendedLogger)log4JLogger).logIfEnabled("test", Level.ERROR, null, "test {}", args);
listAppender.countDownLatch.await(1, TimeUnit.SECONDS);
Assert.assertArrayEquals(Arrays.toString(args), originalArgs, args);
((ExtendedLogger)log4JLogger).logIfEnabled("test", Level.ERROR, null, "test {}", args);
Assert.assertArrayEquals(Arrays.toString(args), originalArgs, args);
}
@Test
public void testLog4j2Only() throws InterruptedException {
final org.apache.logging.log4j.Logger log4JLogger = LogManager.getLogger(this.getClass());
final int limit = 11; // more than unrolled varargs
final Object[] args = createArray(limit);
final Object[] originalArgs = Arrays.copyOf(args, args.length);
listAppender.countDownLatch = new CountDownLatch(1);
((ExtendedLogger)log4JLogger).logIfEnabled("test", Level.ERROR, null, "test {}", args);
listAppender.countDownLatch.await(1, TimeUnit.SECONDS);
Assert.assertArrayEquals(Arrays.toString(args), originalArgs, args);
((ExtendedLogger)log4JLogger).logIfEnabled("test", Level.ERROR, null, "test {}", args);
Assert.assertArrayEquals(Arrays.toString(args), originalArgs, args);
}
PrefixPluginLogger(ExtendedLogger logger, String name, String prefix) {
super(logger, name, null);
String actualPrefix = prefix == null ? "" : prefix;
MarkerManager.Log4jMarker actualMarker;
synchronized (MARKERS) {
MarkerManager.Log4jMarker maybeMarker = (MarkerManager.Log4jMarker)MARKERS.get(actualPrefix);
if (maybeMarker == null) {
actualMarker = new MarkerManager.Log4jMarker(actualPrefix);
MARKERS.put(actualPrefix, actualMarker);
} else {
actualMarker = maybeMarker;
}
}
this.marker = actualMarker;
}
static Logger getLogger(String prefix, Logger logger) {
/*
* In a followup we'll throw an exception if prefix is null or empty
* redirecting folks to LogManager.getLogger.
*
* This and more is tracked in https://github.com/elastic/elasticsearch/issues/32174
*/
if (prefix == null || prefix.length() == 0) {
return logger;
}
return new PrefixLogger((ExtendedLogger)logger, logger.getName(), prefix);
}
@Override
public ExtendedLogger getLogger(final String name, final MessageFactory messageFactory) {
// Note: This is the only method where we add entries to the 'loggerRegistry' ivar.
final ExtendedLogger extendedLogger = loggerRegistry.getLogger(name, messageFactory);
if (extendedLogger != null) {
AbstractLogger.checkMessageFactory(extendedLogger, messageFactory);
return extendedLogger;
}
final SimpleLogger simpleLogger = new SimpleLogger(name, defaultLevel, showLogName, showShortName, showDateTime,
showContextMap, dateTimeFormat, messageFactory, props, stream);
loggerRegistry.putIfAbsent(name, messageFactory, simpleLogger);
return loggerRegistry.getLogger(name, messageFactory);
}
@Override
public ExtendedLogger getLogger(final String name) {
final ExtendedLogger extendedLogger = map.get(name);
if (extendedLogger != null) {
return extendedLogger;
}
final ExtendedLogger logger = new TestLogger(name);
map.put(name, logger);
return logger;
}
private void maybeLog(final String fqcn, final org.apache.logging.log4j.Level level,
final Object message, final Throwable throwable) {
if (logger.isEnabled(level)) {
@SuppressWarnings("unchecked")
Message msg = message instanceof Map ? new MapMessage((Map) message) : new ObjectMessage(message);
if (logger instanceof ExtendedLogger) {
((ExtendedLogger) logger).logMessage(fqcn, level, null, msg, throwable);
} else {
logger.log(level, msg, throwable);
}
}
}
public void forcedLog(final String fqcn, final Priority level, final Object message, final Throwable t) {
final org.apache.logging.log4j.Level lvl = org.apache.logging.log4j.Level.toLevel(level.toString());
ObjectRenderer renderer = get(message.getClass());
final Message msg = message instanceof Message ? (Message) message : renderer != null ?
new RenderedMessage(renderer, message) : new ObjectMessage(message);
if (logger instanceof ExtendedLogger) {
((ExtendedLogger) logger).logMessage(fqcn, lvl, null, new ObjectMessage(message), t);
} else {
logger.log(lvl, msg, t);
}
}
private void maybeLog(final String fqcn, final org.apache.logging.log4j.Level level,
final Object message, final Throwable throwable) {
if (logger.isEnabled(level)) {
if (logger instanceof ExtendedLogger) {
((ExtendedLogger) logger).logMessage(fqcn, level, null, new ObjectMessage(message), throwable);
} else {
logger.log(level, message, throwable);
}
}
}
/**
* Constructs a new IoBuilder for the given Logger. This method is provided for extensibility of this builder
* class. The static factory methods should be used normally.
*
* @param logger the {@link ExtendedLogger} to wrap
*/
protected IoBuilder(final Logger logger) {
if (!(logger instanceof ExtendedLogger)) {
throw new UnsupportedOperationException("The provided Logger [" + String.valueOf(logger) +
"] does not implement " + ExtendedLogger.class.getName());
}
this.logger = (ExtendedLogger) logger;
}
public ByteStreamLogger(final ExtendedLogger logger, final Level level, final Marker marker, final Charset charset) {
this.logger = logger;
this.level = level == null ? logger.getLevel() : level;
this.marker = marker;
this.reader = new InputStreamReader(new ByteBufferInputStream(),
charset == null ? Charset.defaultCharset() : charset);
}
ApiLogger(final ExtendedLogger logger) {
super(logger.getName(), null);
final Level javaLevel = LevelTranslator.toJavaLevel(logger.getLevel());
// "java.util.logging.LoggingPermission" "control"
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
ApiLogger.super.setLevel(javaLevel);
return null;
}
});
this.logger = new WrappedLogger(logger);
}
@Override
public void publish(LogRecord record) {
if (record == null) { // silently ignore null records
return;
}
org.apache.logging.log4j.Logger log4jLogger = getLog4jLogger(record);
String msg = julFormatter.formatMessage(record); // use JUL's implementation to get real msg
/* log4j allows nulls:
if (msg == null) {
// JUL allows nulls, but other log system may not
msg = "<null log msg>";
} */
org.apache.logging.log4j.Level log4jLevel = LevelTranslator.toLevel(record.getLevel());
Throwable thrown = record.getThrown();
if (log4jLogger instanceof ExtendedLogger) {
// relevant for location information
try {
((ExtendedLogger) log4jLogger).logIfEnabled(FQCN, log4jLevel, null, msg, thrown);
} catch (NoClassDefFoundError e) {
// sometimes there are problems with log4j.ExtendedStackTraceElement, so try a workaround
log4jLogger.warn("Log4jBridgeHandler: ignored exception when calling 'ExtendedLogger': {}", e.toString());
log4jLogger.log(log4jLevel, msg, thrown);
}
} else {
log4jLogger.log(log4jLevel, msg, thrown);
}
}
@Override
public ExtendedLogger getLogger(final String name) {
if (!loggerRegistry.hasLogger(name)) {
loggerRegistry.putIfAbsent(name, null, new SLF4JLogger(name, LoggerFactory.getLogger(name)));
}
return loggerRegistry.getLogger(name);
}
@Override
public ExtendedLogger getLogger(final String name, final MessageFactory messageFactory) {
// FIXME according to LOG4J2-1180, the below line should be:
// FIXME if (!loggerRegistry.hasLogger(name, messageFactory)) {
if (!loggerRegistry.hasLogger(name)) {
// FIXME: should be loggerRegistry.putIfAbsent(name, messageFactory,
loggerRegistry.putIfAbsent(name, null,
new SLF4JLogger(name, messageFactory, LoggerFactory.getLogger(name)));
}
// FIXME should be return loggerRegistry.getLogger(name, messageFactory);
return loggerRegistry.getLogger(name);
// TODO applying the above fixes causes (log4j-to-slf4j) LoggerTest to fail
}
@VisibleForTesting
public ExtendedLogger getLogger() {
return logger;
}
Log4J2Logger(Logger logger) {
super((ExtendedLogger) logger, logger.getName(), logger.getMessageFactory());
}
Log4J2Logger(Logger logger) {
super((ExtendedLogger) logger, logger.getName(), logger.getMessageFactory());
if (VARARGS_ONLY) {
throw new UnsupportedOperationException("Log4J2 version mismatch");
}
}
static public Logger getLogger(String prefix, Logger logger) {
return (Logger)(prefix != null && prefix.length() != 0 ? new PrefixPluginLogger((ExtendedLogger)logger, logger.getName(), prefix) : logger);
}
Log4J2Logger(Logger logger) {
super((ExtendedLogger) logger, logger.getName(), logger.getMessageFactory());
}
@Override
public ExtendedLogger getLogger(String name) {
return getLogger(name, null);
}
@Override
public ExtendedLogger getLogger(String name, MessageFactory messageFactory) {
return loggers.computeIfAbsent(name, key -> new ESLogger(key, messageFactory, (LoggerImpl) LoggerFactory.getLogger(key)));
}
public Log4j2Impl(final Logger logger) {
Assert.notNull(logger);
this.logger = (ExtendedLogger) logger;
setLoggerName(logger.getName());
}
public Log4j2Impl(final String loggerName) {
Assert.hasText(loggerName);
logger = (ExtendedLogger) LogManager.getLogger(loggerName);
setLoggerName(loggerName);
}
ApimanLog4j2LogDelegate(final String name) {
logger = (ExtendedLogger) org.apache.logging.log4j.LogManager.getLogger(name, new FormattedMessageFactory());
}
@Override
public ExtendedLogger getLogger(final String name) {
return getLogger(name, null);
}
@Override
public ExtendedLogger getLogger(final String name, final MessageFactory messageFactory) {
return new TestLogger(name, messageFactory);
}
public Log4jSystemLogger(final ExtendedLogger logger) {
this.logger = logger;
}