org.apache.logging.log4j.spi.AbstractLogger Java Examples

@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;
}
 

static Log4jTaglibLogger resolveLogger(final Log4jTaglibLoggerContext context, final Object logger,
                                       final MessageFactory factory) throws JspException {
    if (logger instanceof Logger) {
        if (logger instanceof Log4jTaglibLogger) {
            return (Log4jTaglibLogger) logger;
        }
        if (logger instanceof AbstractLogger) {
            if (LOGGER.isInfoEnabled() && !WARNED_FOR.contains(logger)) {
                LOGGER.info("Constructing new Log4jTaglibLogger from AbstractLogger {} name and message factory.",
                        logger.getClass().getName());
                WARNED_FOR.add(logger);
            }
            final AbstractLogger original = (AbstractLogger) logger;
            return getLogger(context, original.getName(), original.getMessageFactory());
        }
        throw new JspException(
                "Log4j Tag Library requires base logging system to extend Log4j AbstractLogger.");
    }
    if (logger instanceof String) {
        return getLogger(context, (String) logger, factory);
    }
    throw new JspException("Logger must be of type String or org.apache.logging.log4j.Logger.");
}
 

@Test
public void testGetLoggerWithTaglibLogger() throws Exception {
    this.setUp(null);

    final AbstractLogger wrapped = (AbstractLogger)LogManager.getLogger("testGetLoggerWithTaglibLogger");
    final Log4jTaglibLogger logger = new Log4jTaglibLogger(wrapped, wrapped.getName(), wrapped.getMessageFactory());

    this.tag.setLogger(logger);
    Log4jTaglibLogger returned = this.tag.getLogger();

    assertNotNull("The first returned logger should not be null.", returned);
    assertSame("The first returned logger should be the same as the set.", logger, returned);
    assertEquals("The name is not correct.", "testGetLoggerWithTaglibLogger", returned.getName());

    returned = this.tag.getLogger();

    assertNotNull("The second returned logger should not be null.", returned);
    assertSame("The second returned logger should be the same as the set.", logger, returned);
}
 

@Test
public void errorDelegatesProperly() {

    // given
    String expectedMessage = UUID.randomUUID().toString();
    AbstractLogger logger = mock(AbstractLogger.class);
    Logger wrapper = new Log4j2StatusLoggerWrapper(logger);
    
    String arg1 = UUID.randomUUID().toString();
    String arg2 = UUID.randomUUID().toString();

    // when
    wrapper.error(expectedMessage, arg1, arg2);

    // then
    ArgumentCaptor<Object[]> captor = ArgumentCaptor.forClass(Object[].class);
    verify(logger).error(eq(expectedMessage), captor.capture());

    assertEquals(arg1, captor.getAllValues().get(0));
    assertEquals(arg2, captor.getAllValues().get(1));

}
 

@Test
public void warnDelegatesProperly() {
    
    // given
    String expectedMessage = UUID.randomUUID().toString();
    AbstractLogger logger = mock(AbstractLogger.class);
    Logger wrapper = new Log4j2StatusLoggerWrapper(logger);

    String arg1 = UUID.randomUUID().toString();
    String arg2 = UUID.randomUUID().toString();

    // when
    wrapper.error(expectedMessage, arg1, arg2);

    // then
    ArgumentCaptor<Object[]> captor = ArgumentCaptor.forClass(Object[].class);
    verify(logger).error(eq(expectedMessage), captor.capture());

    assertEquals(arg1, captor.getAllValues().get(0));
    assertEquals(arg2, captor.getAllValues().get(1));

}
 

@Test
public void infoDelegatesProperly() {
    // given
    String expectedMessage = UUID.randomUUID().toString();
    AbstractLogger logger = mock(AbstractLogger.class);
    Logger wrapper = new Log4j2StatusLoggerWrapper(logger);

    String arg1 = UUID.randomUUID().toString();
    String arg2 = UUID.randomUUID().toString();

    // when
    wrapper.info(expectedMessage, arg1, arg2);

    // then
    ArgumentCaptor<Object[]> captor = ArgumentCaptor.forClass(Object[].class);
    verify(logger).info(eq(expectedMessage), captor.capture());

    assertEquals(arg1, captor.getAllValues().get(0));
    assertEquals(arg2, captor.getAllValues().get(1));

}
 

@Test
public void debugDelegatesProperly() {

    // given
    String expectedMessage = UUID.randomUUID().toString();
    AbstractLogger logger = mock(AbstractLogger.class);
    Logger wrapper = new Log4j2StatusLoggerWrapper(logger);

    String arg1 = UUID.randomUUID().toString();
    String arg2 = UUID.randomUUID().toString();

    // when
    wrapper.debug(expectedMessage, arg1, arg2);

    // then
    ArgumentCaptor<Object[]> captor = ArgumentCaptor.forClass(Object[].class);
    verify(logger).debug(eq(expectedMessage), captor.capture());

    assertEquals(arg1, captor.getAllValues().get(0));
    assertEquals(arg2, captor.getAllValues().get(1));

}
 

@Test
public void traceDelegatesProperly() {

    // given
    String expectedMessage = UUID.randomUUID().toString();
    AbstractLogger logger = mock(AbstractLogger.class);
    Logger wrapper = new Log4j2StatusLoggerWrapper(logger);

    String arg1 = UUID.randomUUID().toString();
    String arg2 = UUID.randomUUID().toString();

    // when
    wrapper.trace(expectedMessage, arg1, arg2);

    // then
    ArgumentCaptor<Object[]> captor = ArgumentCaptor.forClass(Object[].class);
    verify(logger).trace(eq(expectedMessage), captor.capture());

    assertEquals(arg1, captor.getAllValues().get(0));
    assertEquals(arg2, captor.getAllValues().get(1));

}
 

private void handleRingBufferFull(final RingBufferLogEventTranslator translator) {
    if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-1518, LOG4J2-2031
        // If queue is full AND we are in a recursive call, call appender directly to prevent deadlock
        AsyncQueueFullMessageUtil.logWarningToStatusLogger();
        logMessageInCurrentThread(translator.fqcn, translator.level, translator.marker, translator.message,
                translator.thrown);
        translator.clear();
        return;
    }
    final EventRoute eventRoute = loggerDisruptor.getEventRoute(translator.level);
    switch (eventRoute) {
        case ENQUEUE:
            loggerDisruptor.enqueueLogMessageWhenQueueFull(translator);
            break;
        case SYNCHRONOUS:
            logMessageInCurrentThread(translator.fqcn, translator.level, translator.marker, translator.message,
                    translator.thrown);
            translator.clear();
            break;
        case DISCARD:
            translator.clear();
            break;
        default:
            throw new IllegalStateException("Unknown EventRoute " + eventRoute);
    }
}
 

/**
 * Actual writing occurs here.
 *
 * @param logEvent The LogEvent.
 */
@Override
public void append(final LogEvent logEvent) {
    if (!isStarted()) {
        throw new IllegalStateException("AsyncAppender " + getName() + " is not active");
    }
    final Log4jLogEvent memento = Log4jLogEvent.createMemento(logEvent, includeLocation);
    InternalAsyncUtil.makeMessageImmutable(logEvent.getMessage());
    if (!transfer(memento)) {
        if (blocking) {
            if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-1518, LOG4J2-2031
                // If queue is full AND we are in a recursive call, call appender directly to prevent deadlock
                AsyncQueueFullMessageUtil.logWarningToStatusLogger();
                logMessageInCurrentThread(logEvent);
            } else {
                // delegate to the event router (which may discard, enqueue and block, or log in current thread)
                final EventRoute route = asyncQueueFullPolicy.getRoute(thread.getId(), memento.getLevel());
                route.logMessage(this, memento);
            }
        } else {
            error("Appender " + getName() + " is unable to write primary appenders. queue is full");
            logToErrorAppenderIfNecessary(false, memento);
        }
    }
}
 

private void handleRingBufferFull(final StackTraceElement location,
                                  final String fqcn,
                                  final Level level,
                                  final Marker marker,
                                  final Message msg,
                                  final Throwable thrown) {
    if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-1518, LOG4J2-2031
        // If queue is full AND we are in a recursive call, call appender directly to prevent deadlock
        AsyncQueueFullMessageUtil.logWarningToStatusLogger();
        logMessageInCurrentThread(fqcn, level, marker, msg, thrown);
        return;
    }
    final EventRoute eventRoute = loggerDisruptor.getEventRoute(level);
    switch (eventRoute) {
        case ENQUEUE:
            loggerDisruptor.enqueueLogMessageWhenQueueFull(this,
                    this, // asyncLogger: 0
                    location, // location: 1
                    fqcn, // 2
                    level, // 3
                    marker, // 4
                    msg, // 5
                    thrown); // 6
            break;
        case SYNCHRONOUS:
            logMessageInCurrentThread(fqcn, level, marker, msg, thrown);
            break;
        case DISCARD:
            break;
        default:
            throw new IllegalStateException("Unknown EventRoute " + eventRoute);
    }
}
 

private static void checkMessageFactory(final String msg, final MessageFactory messageFactory,
        final Logger testLogger) {
    if (messageFactory == null) {
        assertEquals(msg, AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS,
                testLogger.getMessageFactory().getClass());
    } else {
        MessageFactory actual = testLogger.getMessageFactory();
        assertEquals(msg, messageFactory, actual);
    }
}
 

private static void checkMessageFactory(final MessageFactory messageFactory, final Logger testLogger) {
    if (messageFactory == null) {
        assertEquals(AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS, testLogger.getMessageFactory().getClass());
    } else {
        MessageFactory actual = testLogger.getMessageFactory();
        assertEquals(messageFactory, actual);
    }
}
 

/**
 * Obtains a Logger from the Context.
 *
 * @param name The name of the Logger to return.
 * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change the
 *            logger but will log a warning if mismatched.
 * @return The Logger.
 */
@Override
public Logger getLogger(final String name, final MessageFactory messageFactory) {
    // Note: This is the only method where we add entries to the 'loggerRegistry' ivar.
    Logger logger = loggerRegistry.getLogger(name, messageFactory);
    if (logger != null) {
        AbstractLogger.checkMessageFactory(logger, messageFactory);
        return logger;
    }

    logger = newInstance(this, name, messageFactory);
    loggerRegistry.putIfAbsent(name, messageFactory, logger);
    return loggerRegistry.getLogger(name, messageFactory);
}
 

private void handleQueueFull(final LogEvent event) {
    if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-1518, LOG4J2-2031
        // If queue is full AND we are in a recursive call, call appender directly to prevent deadlock
        AsyncQueueFullMessageUtil.logWarningToStatusLogger();
        logToAsyncLoggerConfigsOnCurrentThread(event);
    } else {
        // otherwise, we leave it to the user preference
        final EventRoute eventRoute = delegate.getEventRoute(event.getLevel());
        eventRoute.logMessage(this, event);
    }
}
 

@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);
}
 

/**
 * Returns a {@code StringBuilder} that this Layout implementation can use to write the formatted log event to.
 *
 * @return a {@code StringBuilder}
 */
protected static StringBuilder getStringBuilder() {
    if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-2368
        // Recursive logging may clobber the cached StringBuilder.
        return new StringBuilder(DEFAULT_STRING_BUILDER_SIZE);
    }
    StringBuilder result = threadLocal.get();
    if (result == null) {
        result = new StringBuilder(DEFAULT_STRING_BUILDER_SIZE);
        threadLocal.set(result);
    }
    trimToMaxSize(result);
    result.setLength(0);
    return result;
}
 

@Test
 public void testNoErrorIfLogAfterShutdown() throws Exception {
     final Logger log = LogManager.getLogger("com.foo.Bar");
     log.info("some message");
     CoreLoggerContexts.stopLoggerContext(); // stop async thread

     // call the #logMessage() method to bypass the isEnabled check: 
     // before the LOG4J2-639 fix this would throw a NPE
     ((AbstractLogger) log).logMessage("com.foo.Bar", Level.INFO, null, new SimpleMessage("msg"), null);
}
 

@Test
public void testNoErrorIfLogAfterShutdown() throws Exception {
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Async logger msg";
    log.info(msg, new InternalError("this is not a real error"));
    CoreLoggerContexts.stopLoggerContext(); // stop async thread

    // call the #logMessage() method to bypass the isEnabled check: 
    // before the LOG4J2-639 fix this would throw a NPE
    ((AbstractLogger) log).logMessage("com.foo.Bar", Level.INFO, null, new SimpleMessage("msg"), null);
}
 

private static void checkMessageFactory(final MessageFactory messageFactory, final Logger testLogger) {
    if (messageFactory == null) {
        assertEquals(AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS, testLogger.getMessageFactory().getClass());
    } else {
        MessageFactory actual = testLogger.getMessageFactory();
        assertEquals(messageFactory, actual);
    }
}
 

/**
 * create a new LogWrapper class for the specified source class
 * 
 * @param component
 *           specified source class
 */
private Log4jLogger_impl(Class<?> component) {
   super(component);

   coreLogger = (org.apache.logging.log4j.core.Logger) LogManager.getLogger( (null == component) 
                                    ?  "org.apache.uima"
                                    : component.getName());
   mf = coreLogger.getMessageFactory();
   
   logger = new ExtendedLoggerWrapper((AbstractLogger) coreLogger, coreLogger.getName(), mf);
}
 

public Log4j2Impl(String clazz) {
  Logger logger = LogManager.getLogger(clazz);

  if (logger instanceof AbstractLogger) {
    log = new Log4j2AbstractLoggerImpl((AbstractLogger) logger);
  } else {
    log = new Log4j2LoggerImpl(logger);
  }
}
 

public Log4j2Impl(String clazz) {
  Logger logger = LogManager.getLogger(clazz);

  if (logger instanceof AbstractLogger) {
    log = new Log4j2AbstractLoggerImpl((AbstractLogger) logger);
  } else {
    log = new Log4j2LoggerImpl(logger);
  }
}
 

public Log4j2Impl(String clazz) {
    Logger logger = LogManager.getLogger(clazz);

    if (logger instanceof AbstractLogger) {
        log = new Log4j2AbstractLoggerImpl((AbstractLogger) logger);
    } else {
        log = new Log4j2LoggerImpl(logger);
    }
}
 

public AbstractLogger enable() {
    enabled = true;
    return this;
}
 

public AbstractLogger disable() {
    enabled = false;
    return this;
}
 

private BHBotLogger(final Logger logger) {
    super((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
    this.logger = this;
}
 

public Log4j2AbstractLoggerImpl(AbstractLogger abstractLogger) {
  log = new ExtendedLoggerWrapper(abstractLogger, abstractLogger.getName(), abstractLogger.getMessageFactory());
}
 

public static MuLogger getLogger(String name)
{
	Logger logger = LogManager.getLogger(name);
	return new MuLogger((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
}
 

public static MuLogger getLogger(Class<?> type)
{
	Logger logger = LogManager.getLogger(type);
	return new MuLogger((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
}