Java 类ch.qos.logback.core.OutputStreamAppender 实例源码

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 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.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]") );

}