/** * Stop the subordinate appender for the operation log so it will not leak a file descriptor. * @param routingAppenderName the name of the RoutingAppender * @param queryId the id of the query that is closing */ public static void stopQueryAppender(String routingAppenderName, String queryId) { LoggerContext context = (LoggerContext) LogManager.getContext(false); org.apache.logging.log4j.core.config.Configuration configuration = context.getConfiguration(); LoggerConfig loggerConfig = configuration.getRootLogger(); Map<String, Appender> appenders = loggerConfig.getAppenders(); RoutingAppender routingAppender = (RoutingAppender) appenders.get(routingAppenderName); // routingAppender can be null if it has not been registered if (routingAppender != null) { // The appender is configured to use ${ctx:queryId} by registerRoutingAppender() try { Class<? extends RoutingAppender> clazz = routingAppender.getClass(); Method method = clazz.getDeclaredMethod("deleteAppender", String.class); method.setAccessible(true); method.invoke(routingAppender, queryId); } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { l4j.warn("Unable to close the operation log appender for query id " + queryId, e); } } }
@Override protected void setUp() throws Exception { super.setUp(); Logger logger = LoggerFactory.getLogger(LogOrRethrowExceptionHandler.class); writer = new StringWriter(); LoggerContext loggerContext = (LoggerContext) LogManager.getContext(); Configuration configuration = loggerContext.getConfiguration(); LoggerConfig rootLoggerConfig = configuration.getLoggerConfig(logger.getName()); rootLoggerConfig.getAppenders().forEach((name, appender) -> { rootLoggerConfig.removeAppender(name); }); Appender appender = WriterAppender.createAppender(PatternLayout.createDefaultLayout(), null, writer,"TESTWriter", false, false); rootLoggerConfig.addAppender(appender, org.apache.logging.log4j.Level.DEBUG, null); }
@Override public void evaluate() throws Throwable { final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration(); Map<String, Appender> appendersMap = config.getLogger("cat1").getAppenders(); assertEquals("Expected 2 Appender references for cat1 but got " + appendersMap.size(), 2, appendersMap.size()); assertTrue(appendersMap.get("STDOUT") instanceof ConsoleAppender); Filter loggerFilter = config.getLogger("cat1").getFilter(); assertTrue(loggerFilter instanceof RegexFilter); assertEquals(loggerFilter.getOnMatch(), Filter.Result.DENY); appendersMap = config.getLogger("cat2").getAppenders(); assertEquals("Expected 1 Appender reference for cat2 but got " + appendersMap.size(), 1, appendersMap.size()); assertTrue(appendersMap.get("File") instanceof FileAppender); appendersMap = config.getLogger("cat3").getAppenders(); assertEquals("Expected 1 Appender reference for cat3 but got " + appendersMap.size(), 1, appendersMap.size()); assertTrue(appendersMap.get("File") instanceof FileAppender); appendersMap = config.getRootLogger().getAppenders(); assertEquals("Expected 2 Appender references for the root logger but got " + appendersMap.size(), 2, appendersMap.size()); assertTrue(appendersMap.get("File") instanceof FileAppender); assertTrue(appendersMap.get("STDOUT") instanceof ConsoleAppender); } };
(org.apache.logging.log4j.core.Logger) logger; LoggerConfig loggerConfig = coreLogger.get(); Map<String, Appender> appenders = loggerConfig.getAppenders();
static long asyncRemainingCapacity(Logger logger) { if (logger instanceof AsyncLogger) { try { Field f = field(AsyncLogger.class, "loggerDisruptor"); return ((AsyncLoggerDisruptor) f.get(logger)).getDisruptor().getRingBuffer().remainingCapacity(); } catch (Exception ex) { throw new RuntimeException(ex); } } else { LoggerConfig loggerConfig = ((org.apache.logging.log4j.core.Logger) logger).get(); if (loggerConfig instanceof AsyncLoggerConfig) { try { Object delegate = field(AsyncLoggerConfig.class, "delegate").get(loggerConfig); return ((Disruptor) field(AsyncLoggerConfigDisruptor.class, "disruptor").get(delegate)).getRingBuffer().remainingCapacity(); } catch (Exception ex) { throw new RuntimeException(ex); } } else { Appender async = loggerConfig.getAppenders().get("async"); if (async instanceof AsyncAppender) { return ((AsyncAppender) async).getQueueCapacity(); } } } throw new IllegalStateException("Neither Async Loggers nor AsyncAppender are configured"); } private static Field field(Class<?> c, String name) throws NoSuchFieldException {
private boolean hasAppender(LoggerContext context, Class<? extends Appender>... appenderTypes) { for (Appender appender : getRootLogger(context).getAppenders().values()) { for (Class<? extends Appender> appenderType : appenderTypes) { if (appenderType.isInstance(appender)) { return true; } } } return false; }
final Map<String, Appender> sampleAppenders = sample.getAppenders(); assertThat("The sample logger should only have one appender", sampleAppenders, hasSize(1)); final AbstractConfiguration baseConfig = (AbstractConfiguration) config; final LoggerConfig root = baseConfig.getRootLogger(); final Map<String, Appender> rootAppenders = root.getAppenders(); assertThat("The root logger should only have one appender", rootAppenders, hasSize(1));
public static Appender findAppender(final Logger logger, final Class<? extends Appender> clazz) { final LoggerContext ctx = (LoggerContext) LogManager.getContext(false); final Configuration config = ctx.getConfiguration(); final LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName()); for (final Map.Entry<String, Appender> entry : loggerConfig.getAppenders().entrySet()) { if (entry.getValue().getClass().equals(clazz)) { return entry.getValue(); } } return null; }
private void removeAppender(LoggerContext context, Function<Appender, Boolean> appenderMatcher) { for (Appender appender : getRootLogger(context).getAppenders().values()) { if (appenderMatcher.apply(appender)) { removeAppender(context, appender); getRootLogger(context).removeAppender(appender.getName()); } } }
@Override public void run() { LoggerConfig rootLogger = ((AbstractConfiguration) context.getConfiguration()).getRootLogger(); Collection<Appender> appenders = new ArrayList<>(); appenders.add(ConsoleAppender.createAppender(mock(Layout.class), null, null, "Console", null, null)); when(rootLogger.getAppenders().values()).thenReturn(appenders); contextConfigurer.configure(context); verify(context.getConfiguration(), never()).addAppender(any(ConsoleAppender.class)); verify(rootLogger, never()).addAppender(any(ConsoleAppender.class), same(Level.INFO), any(Filter.class)); } });
/** * This method is not exposed through the public API and is used primarily for unit testing. * * @return A Map containing the Appender's name as the key and the Appender as the value. */ public Map<String, Appender> getAppenders() { return privateConfig.loggerConfig.getAppenders(); }
private boolean hasAppender(LoggerContext context, Class<? extends Appender>... appenderTypes) { for (Appender appender : getRootLogger(context).getAppenders().values()) { for (Class<? extends Appender> appenderType : appenderTypes) { if (appenderType.isInstance(appender)) { return true; } } } return false; }
private boolean hasAppender(LoggerContext context, Class<? extends Appender>... appenderTypes) { for (Appender appender : getRootLogger(context).getAppenders().values()) { for (Class<? extends Appender> appenderType : appenderTypes) { if (appenderType.isInstance(appender)) { return true; } } } return false; }
@Override public Object[] getHandlers() { List tmp = new LinkedList(); LoggerContext ctx = (LoggerContext) LogManager.getContext(false); Configuration config = ctx.getConfiguration(); LoggerConfig loggerConfig = config.getLoggerConfig(this.logger.getName()); for(String appenderName : loggerConfig.getAppenders().keySet()) tmp.add(loggerConfig.getAppenders().get(appenderName)); return tmp.toArray(); }
@Override public synchronized void propertyChange(final PropertyChangeEvent evt) { if (logger.isDebugEnabled()) { logger.debug("Responding to a property change event. Property name is {}.", evt.getPropertyName()); } if (evt.getPropertyName().equals(LoggerContext.PROPERTY_CONFIG)) { LoggerConfig loggerConfig = this.appenderContext.getLoggerConfig(); if (!loggerConfig.getAppenders().containsKey(APPENDER_NAME)) { loggerConfig.addAppender(this, this.listeners.get(0).getLevel(), null); } } }
public static Appender findAppender(final Logger logger, final Class<? extends Appender> clazz) { final LoggerContext ctx = (LoggerContext) LogManager.getContext(false); final Configuration config = ctx.getConfiguration(); final LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName()); for (final Map.Entry<String, Appender> entry : loggerConfig.getAppenders().entrySet()) { if (entry.getValue().getClass().equals(clazz)) { return entry.getValue(); } } return null; }
public static Appender findAppender(final Logger logger, final Class<? extends Appender> clazz) { final LoggerContext ctx = (LoggerContext) LogManager.getContext(false); final Configuration config = ctx.getConfiguration(); final LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName()); for (final Map.Entry<String, Appender> entry : loggerConfig.getAppenders().entrySet()) { if (entry.getValue().getClass().equals(clazz)) { return entry.getValue(); } } return null; }
private void removeAppender(LoggerContext context, Function<Appender, Boolean> appenderMatcher) { for (Appender appender : getRootLogger(context).getAppenders().values()) { if (appenderMatcher.apply(appender)) { removeAppender(context, appender); getRootLogger(context).removeAppender(appender.getName()); } } }
private void attachAppenderToLoggers(Appender appender) { LoggerContext ctx = (LoggerContext) LogManager.getContext(false); Configuration config = ctx.getConfiguration(); // ensure appender is attached only once per JVM (regardless of #containers) if (config.getRootLogger().getAppenders().get(SimpleDiagnosticsAppender.class.getName()) == null) { LOG.info("Attaching diagnostics appender to root logger"); appender.start(); config.addAppender(appender); for (final LoggerConfig loggerConfig : config.getLoggers().values()) { loggerConfig.addAppender(appender, null, null); } } }
private void removeConsoleAppender(LoggerContext context) { for (Appender appender : getRootLogger(context).getAppenders().values()) { if (appender instanceof ConsoleAppender) { removeAppender(context, appender); getRootLogger(context).removeAppender(appender.getName()); } } }