public Level getLoggerLevel(String loggerName) { return getRootContext().getLogger(loggerName).getLevel(); }
public void changeRoot(LogLevelConfig logLevelConfig, Level newLevel) { ensureSupportedLevel(newLevel); LoggerContext rootContext = getRootContext(); rootContext.getLogger(ROOT_LOGGER_NAME).setLevel(newLevel); logLevelConfig.getConfiguredByProperties().forEach((key, value) -> rootContext.getLogger(key).setLevel(newLevel)); }
/** * Make logback configuration for a process to push all its logs to a log file. * <p> * <ul> * <li>the file's name will use the prefix defined in {@link RootLoggerConfig#getProcessId()#getLogFilenamePrefix()}.</li> * <li>the file will follow the rotation policy defined in property {@link #ROLLING_POLICY_PROPERTY} and * the max number of files defined in property {@link #MAX_FILES_PROPERTY}</li> * <li>the logs will follow the specified log pattern</li> * </ul> * </p> * * @see #buildLogPattern(RootLoggerConfig) */ public FileAppender<ILoggingEvent> configureGlobalFileLog(Props props, RootLoggerConfig config, String logPattern) { LoggerContext ctx = getRootContext(); Logger rootLogger = ctx.getLogger(ROOT_LOGGER_NAME); FileAppender<ILoggingEvent> fileAppender = newFileAppender(ctx, props, config, logPattern); rootLogger.addAppender(fileAppender); return fileAppender; }
/** * Make the logback configuration for a sub process to correctly push all its logs to be read by a stream gobbler * on the sub process's System.out. * * @see #buildLogPattern(RootLoggerConfig) */ public void configureForSubprocessGobbler(Props props, String logPattern) { if (isAllLogsToConsoleEnabled(props)) { LoggerContext ctx = getRootContext(); ctx.getLogger(ROOT_LOGGER_NAME).addAppender(newConsoleAppender(ctx, "root_console", logPattern)); } }
@Test public void getRootContext() { assertThat(underTest.getRootContext()).isNotNull(); }
/** * Applies the specified {@link LogLevelConfig} reading the specified {@link Props}. * * @throws IllegalArgumentException if the any level specified in a property is not one of {@link #ALLOWED_ROOT_LOG_LEVELS} */ public LoggerContext apply(LogLevelConfig logLevelConfig, Props props) { if (!ROOT_LOGGER_NAME.equals(logLevelConfig.getRootLoggerName())) { throw new IllegalArgumentException("Value of LogLevelConfig#rootLoggerName must be \"" + ROOT_LOGGER_NAME + "\""); } LoggerContext rootContext = getRootContext(); logLevelConfig.getConfiguredByProperties().forEach((key, value) -> applyLevelByProperty(props, rootContext.getLogger(key), value)); logLevelConfig.getConfiguredByHardcodedLevel().forEach((key, value) -> applyHardcodedLevel(rootContext, key, value)); Level propertyValueAsLevel = getPropertyValueAsLevel(props, SONAR_LOG_LEVEL_PROPERTY); boolean traceGloballyEnabled = propertyValueAsLevel == Level.TRACE; logLevelConfig.getOffUnlessTrace().forEach(logger -> applyHardUnlessTrace(rootContext, logger, traceGloballyEnabled)); return rootContext; }
public LoggerContext configure(Props props) { LoggerContext ctx = helper.getRootContext(); ctx.reset(); configureRootLogger(props); helper.apply(logLevelConfig, props); configureDirectToConsoleLoggers(ctx, STARTUP_LOGGER_NAME); extendConfigure(); helper.enableJulChangePropagation(ctx); return ctx; }
public static <T> ListAppender attachMemoryAppenderToLoggerOf(Class<T> loggerClass) { ListAppender listAppender = new ListAppender(); new LogbackHelper().getRootContext().getLogger(loggerClass) .addAppender(listAppender); listAppender.start(); return listAppender; }
@Test public void newConsoleAppender() { LoggerContext ctx = underTest.getRootContext(); ConsoleAppender<?> appender = underTest.newConsoleAppender(ctx, "MY_APPENDER", "%msg%n"); assertThat(appender.getName()).isEqualTo("MY_APPENDER"); assertThat(appender.getContext()).isSameAs(ctx); assertThat(appender.isStarted()).isTrue(); assertThat(((PatternLayoutEncoder) appender.getEncoder()).getPattern()).isEqualTo("%msg%n"); assertThat(appender.getCopyOfAttachedFiltersList()).isEmpty(); }
public static <T> void detachMemoryAppenderToLoggerOf(Class<T> loggerClass, ListAppender listAppender) { listAppender.stop(); new LogbackHelper().getRootContext().getLogger(loggerClass) .detachAppender(listAppender); } }
@Test public void enableJulChangePropagation() { LoggerContext ctx = underTest.getRootContext(); int countListeners = ctx.getCopyOfListenerList().size(); LoggerContextListener propagator = underTest.enableJulChangePropagation(ctx); assertThat(ctx.getCopyOfListenerList().size()).isEqualTo(countListeners + 1); ctx.removeListener(propagator); }
@Test public void createRollingPolicy_fail_if_unknown_policy() { props.set("sonar.log.rollingPolicy", "unknown:foo"); try { LoggerContext ctx = underTest.getRootContext(); underTest.createRollingPolicy(ctx, props, "sonar"); fail(); } catch (MessageException e) { assertThat(e).hasMessage("Unsupported value for property sonar.log.rollingPolicy: unknown:foo"); } }
@Test public void createRollingPolicy_defaults() { LoggerContext ctx = underTest.getRootContext(); LogbackHelper.RollingPolicy policy = underTest.createRollingPolicy(ctx, props, "sonar"); FileAppender appender = policy.createAppender("SONAR_FILE"); assertThat(appender).isInstanceOf(RollingFileAppender.class); // max 5 daily files RollingFileAppender fileAppender = (RollingFileAppender) appender; TimeBasedRollingPolicy triggeringPolicy = (TimeBasedRollingPolicy) fileAppender.getTriggeringPolicy(); assertThat(triggeringPolicy.getMaxHistory()).isEqualTo(7); assertThat(triggeringPolicy.getFileNamePattern()).endsWith("sonar.%d{yyyy-MM-dd}.log"); }
@Test public void verify_jul_initialization() { LoggerContext ctx = underTest.getRootContext(); String logbackRootLoggerName = underTest.getRootLoggerName(); LogLevelConfig config = LogLevelConfig.newBuilder(logbackRootLoggerName) underTest.getRootContext().getLogger(logbackRootLoggerName).addAppender(memoryAppender);
@Test public void apply_does_not_set_level_if_sonar_global_level_is_TRACE() { Properties properties = new Properties(); properties.setProperty("sonar.log.level", Level.TRACE.toString()); assertThat(underTest.getRootContext().getLogger("fii").getLevel()).isNull(); LoggerContext context = underTest.apply(newLogLevelConfig().offUnlessTrace("fii").build(), new Props(properties)); assertThat(context.getLogger("fii").getLevel()).isNull(); }
@Test public void createRollingPolicy_time() { props.set("sonar.log.rollingPolicy", "time:yyyy-MM"); props.set("sonar.log.maxFiles", "20"); LoggerContext ctx = underTest.getRootContext(); LogbackHelper.RollingPolicy policy = underTest.createRollingPolicy(ctx, props, "sonar"); RollingFileAppender appender = (RollingFileAppender) policy.createAppender("SONAR_FILE"); // max 5 monthly files TimeBasedRollingPolicy triggeringPolicy = (TimeBasedRollingPolicy) appender.getTriggeringPolicy(); assertThat(triggeringPolicy.getMaxHistory()).isEqualTo(20); assertThat(triggeringPolicy.getFileNamePattern()).endsWith("sonar.%d{yyyy-MM}.log"); }
@Test public void createRollingPolicy_none() { props.set("sonar.log.rollingPolicy", "none"); LoggerContext ctx = underTest.getRootContext(); LogbackHelper.RollingPolicy policy = underTest.createRollingPolicy(ctx, props, "sonar"); Appender appender = policy.createAppender("SONAR_FILE"); assertThat(appender).isNotInstanceOf(RollingFileAppender.class).isInstanceOf(FileAppender.class); }
@Test public void createRollingPolicy_size() throws Exception { props.set("sonar.log.rollingPolicy", "size:1MB"); props.set("sonar.log.maxFiles", "20"); LoggerContext ctx = underTest.getRootContext(); LogbackHelper.RollingPolicy policy = underTest.createRollingPolicy(ctx, props, "sonar"); Appender appender = policy.createAppender("SONAR_FILE"); assertThat(appender).isInstanceOf(RollingFileAppender.class); // max 20 files of 1Mb RollingFileAppender fileAppender = (RollingFileAppender) appender; FixedWindowRollingPolicy rollingPolicy = (FixedWindowRollingPolicy) fileAppender.getRollingPolicy(); assertThat(rollingPolicy.getMaxIndex()).isEqualTo(20); assertThat(rollingPolicy.getFileNamePattern()).endsWith("sonar.%i.log"); SizeBasedTriggeringPolicy triggeringPolicy = (SizeBasedTriggeringPolicy) fileAppender.getTriggeringPolicy(); FileSize maxFileSize = (FileSize) FieldUtils.readField(triggeringPolicy, "maxFileSize", true); assertThat(maxFileSize.getSize()).isEqualTo(1024L * 1024); }
public LoggerContext configure() { LoggerContext ctx = helper.getRootContext(); ctx.reset(); helper.enableJulChangePropagation(ctx); configureConsole(ctx); if (helper.isAllLogsToConsoleEnabled(appSettings.getProps()) || !appSettings.getProps().valueAsBoolean("sonar.wrapped", false)) { configureWithLogbackWritingToFile(ctx); } else { configureWithWrapperWritingToFile(ctx); } helper.apply( LogLevelConfig.newBuilder(helper.getRootLoggerName()) .rootLevelFor(ProcessId.APP) .immutableLevel("com.hazelcast", Level.toLevel("WARN")) .build(), appSettings.getProps()); return ctx; }
public LoggerContext configure(Props props) { LoggerContext ctx = helper.getRootContext(); ctx.reset(); configureRootLogger(props); helper.apply(logLevelConfig, props); configureDirectToConsoleLoggers(ctx, STARTUP_LOGGER_NAME); extendConfigure(); helper.enableJulChangePropagation(ctx); return ctx; }