private static void configureInMemoryLogging() { org.slf4j.Logger rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); Logger logbackRootLogger = (Logger) rootLogger; logbackRootLogger.setLevel(Level.INFO); OutputStreamAppender<ILoggingEvent> appender = new OutputStreamAppender<>(); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("[%date] [%level] [%logger{10}] %msg%n"); ple.setContext(lc); ple.start(); try { ple.init(bos); } catch (IOException e) { } appender.setContext(lc); appender.setOutputStream(bos); appender.setName("buffered"); appender.setEncoder(ple); appender.start(); logbackRootLogger.detachAppender("console"); logbackRootLogger.addAppender(appender); logbackRootLogger.setAdditive(true); }
/** * Initializes the logger and the requested log level. * * @param level Logging level threshold */ @SuppressWarnings("unchecked") public static void configure(final Level level) { final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); root.setLevel(level); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(root.getLoggerContext()); encoder.setPattern("%msg%n"); encoder.start(); Iterator<Appender<ILoggingEvent>> iterator = root.iteratorForAppenders(); while (iterator.hasNext()) { Appender<ILoggingEvent> appender = iterator.next(); if (appender instanceof OutputStreamAppender) { ((OutputStreamAppender) appender).setEncoder(encoder); } appender.stop(); appender.start(); } }
private void applyLogConfig() { boolean loggingActivated = isSet(TermSuiteCliOption.LOG_INFO) || isSet(TermSuiteCliOption.LOG_DEBUG) || isSet(TermSuiteCliOption.LOG_TO_FILE); if(loggingActivated) { OutputStreamAppender<ILoggingEvent> appender = isSet(TermSuiteCliOption.LOG_TO_FILE) ? LogbackUtils.createFileAppender(asPath(TermSuiteCliOption.LOG_TO_FILE)) : LogbackUtils.createConsoleAppender(); LogbackUtils.activateLogging(appender); Level level = Level.WARN; if(isSet(TermSuiteCliOption.LOG_INFO)) level = Level.INFO; else if(isSet(TermSuiteCliOption.LOG_DEBUG)) level = Level.DEBUG; else if(isSet(TermSuiteCliOption.LOG_TO_FILE)) level = Level.INFO; LogbackUtils.setGlobalLogLevel(level); } }
/** * Test log statistics store. * * @throws Exception the exception */ @Test public void testLogStatisticsStore() throws Exception { LogStatisticsStore store = new LogStatisticsStore(); store.initialize(LensServerConf.getHiveConf()); // Do some initialization work ByteArrayOutputStream writer = new ByteArrayOutputStream(); Logger l = (Logger) LoggerFactory.getLogger(MyLoggableLens.class); OutputStreamAppender<ILoggingEvent> appender = new OutputStreamAppender<ILoggingEvent>(); appender.setLayout(new StatisticsLogLayout()); appender.setContext(l.getLoggerContext()); appender.setOutputStream(writer); appender.setName(MyLoggableLens.class.getCanonicalName()); appender.start(); l.addAppender(appender); MyLoggableLens sampleEvent = new MyLoggableLens(System.currentTimeMillis()); store.process(sampleEvent); writer.flush(); l.detachAppender(appender); appender.stop(); ObjectMapper mapper = new ObjectMapper(); String expected = mapper.writeValueAsString(sampleEvent); Assert.assertEquals(new String(writer.toByteArray(), "UTF-8").trim(), expected.trim()); writer.close(); }
public LogTester initializeFor(Class<?> klazzFor) { ByteArrayOutputStream out = new ByteArrayOutputStream(); Logger logger = (Logger)LoggerFactory.getLogger(klazzFor); LoggerContext ctx = logger.getLoggerContext(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(ctx); encoder.setPattern("%p:%msg%n"); encoder.start(); OutputStreamAppender<ILoggingEvent> appender = new OutputStreamAppender<ILoggingEvent>(); appender.setContext(ctx); appender.setEncoder(encoder); appender.setOutputStream(out); appender.start(); logger.setLevel(Level.TRACE); logger.addAppender(appender); keeper = new LogKeeper(out); initialized = true; return this; }
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) { RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>(); rollingFileAppender.setFile(logFile.getAbsolutePath()); rollingFileAppender.setName("com.documents4j.logger.client.file"); rollingFileAppender.setContext(loggerContext); FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy(); fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz"); fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX); fixedWindowRollingPolicy.setContext(loggerContext); fixedWindowRollingPolicy.setParent(rollingFileAppender); SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE); sizeBasedTriggeringPolicy.setContext(loggerContext); rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy); rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy); sizeBasedTriggeringPolicy.start(); fixedWindowRollingPolicy.start(); System.out.println("Logging: The log is written to " + logFile); return rollingFileAppender; }
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) { RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>(); rollingFileAppender.setFile(logFile.getAbsolutePath()); rollingFileAppender.setName("com.documents4j.logger.server.file"); rollingFileAppender.setContext(loggerContext); FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy(); fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz"); fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX); fixedWindowRollingPolicy.setContext(loggerContext); fixedWindowRollingPolicy.setParent(rollingFileAppender); SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE); sizeBasedTriggeringPolicy.setContext(loggerContext); rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy); rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy); sizeBasedTriggeringPolicy.start(); fixedWindowRollingPolicy.start(); System.out.println("Logging: The log is written to " + logFile); return rollingFileAppender; }
@Override public void setVerboseMode(boolean on) { PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder(); patternLayoutEncoder.setPattern("[%d{HH:mm:ss.SSS}] [%highlight(%level)] %msg%n"); patternLayoutEncoder.setContext(loggerContext); patternLayoutEncoder.start(); Appender<ILoggingEvent> consoleAppender = new ConsoleAppender(); ((OutputStreamAppender) consoleAppender).setEncoder(patternLayoutEncoder); consoleAppender.setContext(loggerContext); consoleAppender.start(); loggerContext.getLogger("com.paypal.butterfly.cli").detachAppender("CONSOLE"); loggerContext.getLogger("ROOT").addAppender(consoleAppender); }
/** * Turns ImmediateFlush off or on (!buffered) for all encoders descending from * LayoutWrappingEncoder for appenders descending from OutputStreamAppender * except ConsoleAppender. The purpose is to turn on or off buffering/flushing * for all file logging appenders. * * Must be called after {@link #loadFile()}. * * @param buffered whether or not file logging should be buffered or flush immediately */ public static synchronized void setBuffered(boolean buffered) { if (loggerContext == null) { LOGGER.error("Unknown loggerContext, aborting buffered logging. Make sure that loadFile() has been called first."); return; } // Build iterator Iterators<Appender<ILoggingEvent>> iterators = new Iterators<>(); // Add CacheLogger or rootLogger appenders depending on whether CacheLogger is active. if (CacheLogger.isActive()) { iterators.addIterator(CacheLogger.iteratorForAppenders()); } else { iterators.addIterator(rootLogger.iteratorForAppenders()); } // If syslog is active there probably are detached appenders there as well if (!syslogDetachedAppenders.isEmpty()) { iterators.addList(syslogDetachedAppenders); } // Iterate Iterator<Appender<ILoggingEvent>> it = iterators.combinedIterator(); while (it.hasNext()) { Appender<ILoggingEvent> appender = it.next(); if (appender instanceof OutputStreamAppender && !(appender instanceof ConsoleAppender<?>)) { // Appender has ImmediateFlush property ((OutputStreamAppender<ILoggingEvent>) appender).setImmediateFlush(!buffered); } } LOGGER.info("Buffered logging turned {}", buffered ? "ON" : "OFF"); }
private Tab createLogViewTab() { Tab logView = new Tab("log"); TextArea ta = new TextArea(); ta.setWrapText(false); if(console != null) { console.exit(); } console = new Console(ta, lastLogMessage); ta.setStyle("-fx-font-family: Monospaced;"); PrintStream ps = new PrintStream(console, true); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); // ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("ROOT"); // Limit logs to AEMDC otherwise any logs are printed here ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.headwire.aemdc"); // Limit logs to INFO to cut down on number of log statements logger.setLevel(Level.INFO); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%m%n)"); ple.setContext(lc); ple.start(); OutputStreamAppender<ILoggingEvent> appender = new OutputStreamAppender<>(); appender.setContext(lc); appender.setEncoder(ple); appender.setOutputStream(ps); appender.start(); logger.addAppender(appender); logView.setContent(ta); logView.setClosable(false); return logView; }
@Test public void test() { BaleenLogging logging = new BaleenLogging(); InMemoryLoggingBuilder builder = new InMemoryLoggingBuilder(); logging.configure(Arrays.asList(builder, new BaleenConsoleLoggerBuilder(PATTERN, new MinMaxFilter(Level.INFO, Level.ERROR)))); LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); int count = 0; Iterator<Appender<ILoggingEvent>> it = rootLogger.iteratorForAppenders(); while (it.hasNext()) { Appender<ILoggingEvent> appender = it.next(); if (appender instanceof OutputStreamAppender) { Encoder<ILoggingEvent> e = ((OutputStreamAppender<ILoggingEvent>) appender).getEncoder(); assertTrue(e instanceof PatternLayoutEncoder); assertEquals(PATTERN, ((PatternLayoutEncoder) e).getPattern()); } count++; } // 3 = 2 + instrumented appender assertEquals(3, count); }
private Map<String, Object> getJson() throws IOException { OutputStreamAppender<ILoggingEvent> appender = (OutputStreamAppender<ILoggingEvent>) testLogger.getAppender("loggingEventCompositeJsonEncoderAppender"); LoggingEventCompositeJsonEncoder encoder = (LoggingEventCompositeJsonEncoder) appender.getEncoder(); String encodedValue = new String(encoder.encode(listAppender.list.get(0)), "UTF-8"); return jsonFactory.createParser(encodedValue).readValueAs(new TypeReference<Map<String, Object>>() {}); }
@Override public String getEncoding() { if (getTarget() instanceof OutputStreamAppender) { OutputStreamAppender<?> appender = (OutputStreamAppender<?>) getTarget(); Encoder<?> encoder = appender.getEncoder(); if (encoder instanceof LayoutWrappingEncoder) { LayoutWrappingEncoder<?> base = (LayoutWrappingEncoder<?>) encoder; if (base.getCharset() != null) { return base.getCharset().name(); } return null; } } return null; }
private <T extends OutputStreamAppender<ILoggingEvent>> T buildAppender(T appender, AppenderType type, EncoderBase<ILoggingEvent> encoder, boolean start) { this.buildAppender(appender, type, false).setEncoder(encoder); if (start) { appender.start(); } return appender; }
static void activateLogging(OutputStreamAppender<ILoggingEvent> appender) { PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%date %level [%thread] %logger{10} [%file:%line] %msg%n"); ple.setContext(getContext()); ple.start(); appender.setContext(getContext()); appender.setEncoder(ple); appender.start(); // add appender to any Logger (here is root) ch.qos.logback.classic.Logger rootLogger = getRootLogger(); rootLogger.addAppender(appender); }
public static OutputStreamAppender<ILoggingEvent> createFileAppender(Path path) { FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>(); fa.setFile(path.toString()); fa.setAppend(true); fa.setName("FileLogger"); return fa; }
private static void configureLogging(File logFile, Level level) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); OutputStreamAppender<ILoggingEvent> appender; if (logFile == null) { appender = configureConsoleLogging(loggerContext); } else { appender = configureFileLogging(logFile, loggerContext); } System.out.println("Logging: The log level is set to " + level); PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder(); patternLayoutEncoder.setPattern(LogDescription.LOG_PATTERN); patternLayoutEncoder.setContext(loggerContext); patternLayoutEncoder.start(); appender.setEncoder(patternLayoutEncoder); appender.start(); ch.qos.logback.classic.Logger rootLogger = loggerContext.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); loggerContext.stop(); rootLogger.detachAndStopAllAppenders(); rootLogger.addAppender(appender); rootLogger.setLevel(level); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); LevelChangePropagator levelChangePropagator = new LevelChangePropagator(); levelChangePropagator.setResetJUL(true); levelChangePropagator.setContext(loggerContext); levelChangePropagator.start(); loggerContext.addListener(levelChangePropagator); loggerContext.start(); }
private static OutputStreamAppender<ILoggingEvent> configureConsoleLogging(LoggerContext loggerContext) { ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<ILoggingEvent>(); consoleAppender.setName("com.documents4j.logger.client.console"); consoleAppender.setContext(loggerContext); System.out.println("Logging: The log is printed to the console"); return consoleAppender; }
private static OutputStreamAppender<ILoggingEvent> configureConsoleLogging(LoggerContext loggerContext) { ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<ILoggingEvent>(); consoleAppender.setName("com.documents4j.logger.server.console"); consoleAppender.setContext(loggerContext); System.out.println("Logging: The log is printed to the console"); return consoleAppender; }
public Handler configure() { final Logger logger = (Logger) LoggerFactory.getLogger("http.request"); logger.setAdditive(false); final LoggerContext context = logger.getLoggerContext(); final AppenderAttachableImpl<ILoggingEvent> appenders = new AppenderAttachableImpl<ILoggingEvent>(); final RequestLogLayout layout = new RequestLogLayout(); layout.start(); for (OutputStreamAppender<ILoggingEvent> appender : LogbackFactory.buildAppenders(config.getRequestLogConfiguration(), context)) { appender.stop(); appender.setLayout(layout); appender.start(); appenders.addAppender(appender); } final RequestLogHandler handler = new RequestLogHandler(); handler.setRequestLog(new AsyncRequestLog(Clock.defaultClock(), appenders, config.getRequestLogConfiguration().getTimeZone(), config.getRequestLogConfiguration().getCookies())); return handler; }
public static OutputStreamAppender<ILoggingEvent> buildFilteredAppender(final FilteredLoggingConfiguration filtered, LoggerContext context) { AbstractLoggingConfiguration appenderConfig = filtered.getAppender(); OutputStreamAppender<ILoggingEvent> appender = buildAppender(appenderConfig, context); appender.addFilter(new LogEventFilter(filtered)); return appender; }
public static Set<OutputStreamAppender<ILoggingEvent>> buildAppenders(LoggingConfiguration configuration, LoggerContext context) { final Set<OutputStreamAppender<ILoggingEvent>> appenders = new HashSet<OutputStreamAppender<ILoggingEvent>>(); List<AbstractLoggingConfiguration> appenderConfigs = configuration.getAppenderConfigurations(); for (AbstractLoggingConfiguration appenderConfig : appenderConfigs) { appenders.add(buildAppender(appenderConfig, context)); } return appenders; }
private static OutputStreamAppender<ILoggingEvent> buildAppender(AbstractLoggingConfiguration appenderConfig, LoggerContext context) { if (appenderConfig instanceof ConsoleLoggingConfiguration) { return buildConsoleAppender((ConsoleLoggingConfiguration) appenderConfig, context); } else if (appenderConfig instanceof FileLoggingConfiguration) { return buildFileAppender((FileLoggingConfiguration) appenderConfig, context); } else if (appenderConfig instanceof FilteredLoggingConfiguration) { return buildFilteredAppender((FilteredLoggingConfiguration) appenderConfig, context); } else { throw new IllegalArgumentException("Unrecognised appender config type: " + appenderConfig.getClass()); } }
@Test public void config() throws Exception { YamlConfiguration configuration = YamlConfiguration.readFromResource(BaleenLoggingTest.class, "dummyConfig.yaml"); BaleenLogging logging = new BaleenLogging(); logging.configure(configuration); LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); int count = 0; Iterator<Appender<ILoggingEvent>> it = rootLogger.iteratorForAppenders(); while (it.hasNext()) { Appender<ILoggingEvent> appender = it.next(); switch (count) { case 0: assertTrue(appender instanceof ConsoleAppender); break; case 1: assertTrue(appender instanceof RollingFileAppender); break; case 2: assertTrue(appender instanceof FileAppender); assertFalse(appender instanceof RollingFileAppender); break; case 3: if (appender instanceof OutputStreamAppender) { Encoder<ILoggingEvent> e = ((OutputStreamAppender<ILoggingEvent>) appender).getEncoder(); assertTrue(e instanceof PatternLayoutEncoder); assertEquals(PATTERN, ((PatternLayoutEncoder) e).getPattern()); } break; case 4: if (appender instanceof EvictingQueueAppender) { assertEquals(EvictingQueueAppender.DEFAULT_MAX_SIZE, ((EvictingQueueAppender<ILoggingEvent>) appender).getMaxSize()); } else { fail("Unknown additional appender"); } break; case 5: // Allow additional appenders for checking, otherwise throw an error if (!(appender instanceof InstrumentedAppender)) { fail("Unknown additional appender"); } break; default: fail("Too many appenders" + appender.getName()); } count++; } assertEquals(6, count); // TODO: test the instance parameters match the configuration }
/** * Creates an {@link OutputStreamAppender} for the required filter, pattern and logger output. * * @param context Logger context to associate the appender with. * @param filter Event log filter. * @param logOutput Logger output information for the destination to write logger events to. * @param patternProperty Logger context property that defines the pattern for formatting logger event output. * @param name The name of the appender. * @return An {@link OutputStreamAppender} for the required parameters. */ private static OutputStreamAppender<ILoggingEvent> createAppender(LoggerContext context, Filter<ILoggingEvent> filter, LoggerOutput logOutput, String patternProperty, String name) { final PatternLayoutEncoder patternLayoutEncoder = createPatternLayoutEncoder(context, patternProperty); final OutputStreamAppender<ILoggingEvent> appender; if (logOutput.isConsole()) { appender = new OutputStreamAppender<>(); appender.setContext(context); appender.setEncoder(patternLayoutEncoder); appender.setOutputStream(logOutput.getPrintStream()); appender.setName(name); appender.addFilter(filter); appender.start(); } else { RollingFileAppender<ILoggingEvent> rAppender = new RollingFileAppender<>(); rAppender.setContext(context); rAppender.setEncoder(patternLayoutEncoder); rAppender.setFile(logOutput.getOutputName()+"."+logOutput.getOutputType()); rAppender.setName(name); rAppender.addFilter(filter); final FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy(); rollingPolicy.setContext(context); rollingPolicy.setParent(rAppender); rollingPolicy.setFileNamePattern(logOutput.getOutputName()+"%i"+"."+logOutput.getOutputType()); rollingPolicy.setMinIndex(1); rollingPolicy.setMaxIndex(logOutput.getFileCount()); rollingPolicy.start(); final SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<>(); triggeringPolicy.setContext(context); triggeringPolicy.setMaxFileSize(logOutput.getFileLimit()); triggeringPolicy.start(); rAppender.setRollingPolicy(rollingPolicy); rAppender.setTriggeringPolicy(triggeringPolicy); rAppender.start(); appender = rAppender; } return appender; }
public static OutputStreamAppender<ILoggingEvent> createConsoleAppender() { ConsoleAppender<ILoggingEvent> fa = new ConsoleAppender<ILoggingEvent>(); fa.setName("ConsoleLogger"); return fa; }
private void write(String message, Exception throwable) { for (OutputStreamAppender<ILoggingEvent> appender : appenders) { Logger logger = (Logger) LoggerFactory.getLogger(AgentOutputAppender.class); appender.doAppend(new LoggingEvent("", logger, Level.ERROR, message, throwable, null)); } }
void close() { appenders.forEach(OutputStreamAppender::stop); }
@Test public void shouldUseTheFilter() { // given // ...the tested filter DenyDuplicationsFilter filter = new DenyDuplicationsFilter(); filter.setMaxSize(100); filter.setSecondsBetweenEvictions(100); filter.setItemMaxAgeInSeconds(30); // ...logback stopped and ready to work LoggerContext ctx = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = ctx.getLogger(Logger.ROOT_LOGGER_NAME); rootLogger.detachAndStopAllAppenders(); // ...an out stream OutputStream out = new ByteArrayOutputStream(); // ...a pattern layout, pay attention to the format, is important for the test PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setContext(ctx); layout.setPattern("[%level %msg]"); layout.setImmediateFlush(true); layout.start(); // ...a console appender that logs through the filter OutputStreamAppender<ILoggingEvent> appender = new OutputStreamAppender<ILoggingEvent>(); appender.setContext(ctx); appender.setEncoder(layout); appender.addFilter( filter ); appender.setOutputStream(out); appender.start(); // ...a logger we can use for the test Logger testLogger = ctx.getLogger("test"); testLogger.addAppender(appender); testLogger.setLevel(Level.ALL); // when testLogger.trace("Hello World"); // first occurrence, should be logged testLogger.debug("Hello World"); // second occurrence, should be filtered out testLogger.info ("Hello Italy"); // this is new, should be logged testLogger.error("Hello Italy"); // again a repetition testLogger.warn ("Hello World"); // again a repetition testLogger.info ("Hello World"); // again a repetition // then appender.stop(); String string = out.toString(); assertThat( string, equalTo("[TRACE Hello World][INFO Hello Italy]") ); }