private static String logWithSpanAndLog4jConfiguration(
    String log4jPattern, SpanContext spanContext, Function<Logger, Void> loggingFunction) {
  StringWriter output = new StringWriter();
  StringLayout layout = PatternLayout.newBuilder().withPattern(log4jPattern).build();
  Appender appender =
      WriterAppender.newBuilder()
          .setTarget(output)
          .setLayout(layout)
          .setName("TestAppender")
          .build();
  ((LoggerContext) LogManager.getContext(false)).updateLoggers();
  appender.start();
  logger.addAppender(appender);
  logger.setLevel(Level.ALL);
  try {
    logWithSpan(spanContext, loggingFunction, logger);
    return output.toString();
  } finally {
    logger.removeAppender(appender);
  }
}
 

/**
 * Gets an instance of the class.
 *
 * @param config
 *            The current Configuration.
 * @param options
 *            pattern options, may be null. If first element is "short", only the first line of the throwable will
 *            be formatted.
 * @return instance of class.
 */
public static StyleConverter newInstance(final Configuration config, final String[] options) {
    if (options == null) {
        return null;
    }
    if (options.length < 2) {
        LOGGER.error("Incorrect number of options on style. Expected at least 1, received " + options.length);
        return null;
    }
    if (options[0] == null) {
        LOGGER.error("No pattern supplied for style converter");
        return null;
    }
    if (options[1] == null) {
        LOGGER.error("No style attributes supplied for style converter");
        return null;
    }
    final PatternParser parser = PatternLayout.createPatternParser(config);
    final List<PatternFormatter> formatters = parser.parse(options[0]);
    final String style = AnsiEscape.createSequence(options[1].split(Patterns.COMMA_SEPARATOR));
    final boolean disableAnsi = Arrays.toString(options).contains(PatternParser.DISABLE_ANSI + "=true");
    final boolean noConsoleNoAnsi = Arrays.toString(options).contains(PatternParser.NO_CONSOLE_NO_ANSI + "=true");
    final boolean hideAnsi = disableAnsi || (noConsoleNoAnsi && System.console() == null);
    return new StyleConverter(formatters, style, hideAnsi);
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
private static void createAppenderAndStart(String loggerName, String fileName, String filePattern) {

    Layout layout = PatternLayout.newBuilder().withConfiguration(config)
        .withPattern("[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n").build();
    TimeBasedTriggeringPolicy tbtp = TimeBasedTriggeringPolicy.createPolicy(null, null);
    TriggeringPolicy tp = SizeBasedTriggeringPolicy.createPolicy("10M");
    CompositeTriggeringPolicy policyComposite = CompositeTriggeringPolicy.createPolicy(tbtp, tp);

    String loggerDir = datalogDir + File.separator;

    String loggerPathPrefix = loggerDir + File.separator;
    RollingFileAppender.Builder builder = RollingFileAppender.newBuilder().withFilePattern(filePattern)
        .withStrategy(null).withPolicy(policyComposite).withConfiguration(config);
    RollingFileAppender appender = builder.build();
    appender.start();
    config.addAppender(appender);

    AppenderRef ref = AppenderRef.createAppenderRef(loggerName, Level.INFO, null);
    AppenderRef[] refs = new AppenderRef[] {ref};
    LoggerConfig loggerConfig =
        LoggerConfig.createLogger(false, Level.ALL, loggerName, "true", refs, null, config, null);
    loggerConfig.addAppender(appender, null, null);
    config.addLogger(loggerName, loggerConfig);
    ctx.updateLoggers();
}
 

@Test
public void testRefresh() {
	Logger log = LogManager.getLogger(this.getClass());
	final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
	final Configuration config = ctx.getConfiguration();
	PatternLayout layout = PatternLayout.newBuilder()
	// @formatter:off
			.setPattern(PatternLayout.SIMPLE_CONVERSION_PATTERN)
			.setConfiguration(config)
			.build();
	// @formatter:on
	Appender appender = FileAppender.newBuilder().setFileName("target/test.log").setLayout(layout)
			.setConfiguration(config).setBufferSize(4000).setName("File").build();
	// appender.start();
	config.addAppender(appender);
	AppenderRef ref = AppenderRef.createAppenderRef("File", null, null);
	AppenderRef[] refs = new AppenderRef[] { ref };
	LoggerConfig loggerConfig = LoggerConfig.createLogger(false, Level.INFO, "testlog4j2refresh", "true", refs,
			null, config, null);
	loggerConfig.addAppender(appender, null, null);
	config.addLogger("testlog4j2refresh", loggerConfig);
	ctx.stop();
	ctx.start(config);

	log.error("Info message");
}
 

@Test
public void testClassName() {
    final Category category = Category.getInstance("TestCategory");
    final Layout<String> layout = PatternLayout.newBuilder().withPattern("%d %p %C{1.} [%t] %m%n").build();
    final ListAppender appender = new ListAppender("List2", null, layout, false, false);
    appender.start();
    category.setAdditivity(false);
    ((org.apache.logging.log4j.core.Logger) category.getLogger()).addAppender(appender);
    category.error("Test Message");
    final List<String> msgs = appender.getMessages();
    assertTrue("Incorrect number of messages. Expected 1 got " + msgs.size(), msgs.size() == 1);
    final String msg = msgs.get(0);
    appender.clear();
    final String threadName = Thread.currentThread().getName();
    final String expected = "ERROR o.a.l.CategoryTest [" + threadName + "] Test Message" + Strings.LINE_SEPARATOR;
    assertTrue("Incorrect message " + Strings.dquote(msg) + " expected " + Strings.dquote(expected), msg.endsWith(expected));
}
 

/**
 * @throws Exception if the test fails
 */
void loggedCalls() throws Exception {
    final URL url = getClass().getResource("debugFrameImplTest.html");
    final String expectedLog = IOUtils.toString(getClass().getResourceAsStream("debugFrameImplTest.txt"),
            ISO_8859_1);

    final StringWriter stringWriter = new StringWriter();
    final PatternLayout layout = PatternLayout.newBuilder().withPattern("%msg%n").build();

    final WriterAppender writerAppender = WriterAppender.newBuilder().setName("writeLogger").setTarget(stringWriter)
            .setLayout(layout).build();
    writerAppender.start();

    loggerDebugFrameImpl_.addAppender(writerAppender);
    try {
        client_.getPage(url);
    }
    finally {
        loggerDebugFrameImpl_.removeAppender(writerAppender);
    }

    assertEquals(expectedLog, stringWriter.toString());
}
 

protected void setToDefault() {
    // LOG4J2-1176 facilitate memory leak investigation
    setName(DefaultConfiguration.DEFAULT_NAME + "@" + Integer.toHexString(hashCode()));
    final Layout<? extends Serializable> layout = PatternLayout.newBuilder()
            .setPattern(DefaultConfiguration.DEFAULT_PATTERN)
            .setConfiguration(this)
            .build();
    final Appender appender = ConsoleAppender.createDefaultAppenderForLayout(layout);
    appender.start();
    addAppender(appender);
    final LoggerConfig rootLoggerConfig = getRootLogger();
    rootLoggerConfig.addAppender(appender, null, null);

    final Level defaultLevel = Level.ERROR;
    final String levelName = PropertiesUtil.getProperties().getStringProperty(DefaultConfiguration.DEFAULT_LEVEL,
            defaultLevel.name());
    final Level level = Level.valueOf(levelName);
    rootLoggerConfig.setLevel(level != null ? level : defaultLevel);
}
 

/**
 * Gets an instance of the class.
 *
 * @param config The current Configuration.
 * @param options pattern options, may be null.  If first element is "short",
 *                only the first line of the throwable will be formatted.
 * @return instance of class.
 */
public static RegexReplacementConverter newInstance(final Configuration config, final String[] options) {
    if (options.length != 3) {
        LOGGER.error("Incorrect number of options on replace. Expected 3 received " + options.length);
        return null;
    }
    if (options[0] == null) {
        LOGGER.error("No pattern supplied on replace");
        return null;
    }
    if (options[1] == null) {
        LOGGER.error("No regular expression supplied on replace");
        return null;
    }
    if (options[2] == null) {
        LOGGER.error("No substitution supplied on replace");
        return null;
    }
    final Pattern p = Pattern.compile(options[1]);
    final PatternParser parser = PatternLayout.createPatternParser(config);
    final List<PatternFormatter> formatters = parser.parse(options[0]);
    return new RegexReplacementConverter(formatters, p, options[2]);
}
 

@Override
public ColumnMapping build() {
    if (pattern != null) {
        layout = PatternLayout.newBuilder()
            .setPattern(pattern)
            .setConfiguration(configuration)
            .setAlwaysWriteExceptions(false)
            .build();
    }
    if (!(layout == null
        || literal == null
        || Date.class.isAssignableFrom(type)
        || ReadOnlyStringMap.class.isAssignableFrom(type)
        || ThreadContextMap.class.isAssignableFrom(type)
        || ThreadContextStack.class.isAssignableFrom(type))) {
        LOGGER.error("No 'layout' or 'literal' value specified and type ({}) is not compatible with ThreadContextMap, ThreadContextStack, or java.util.Date for the mapping", type, this);
        return null;
    }
    if (literal != null && parameter != null) {
        LOGGER.error("Only one of 'literal' or 'parameter' can be set on the column mapping {}", this);
        return null;
    }
    return new ColumnMapping(name, source, layout, literal, parameter, type);
}
 

/**
 * Gets an instance of the class.
 *
 * @param config  The current Configuration.
 * @param options pattern options, an array of three elements: pattern, testString, and substitution.
 * @return instance of class.
 */
public static EqualsReplacementConverter newInstance(final Configuration config, final String[] options) {
    if (options.length != 3) {
        LOGGER.error("Incorrect number of options on equals. Expected 3 received " + options.length);
        return null;
    }
    if (options[0] == null) {
        LOGGER.error("No pattern supplied on equals");
        return null;
    }
    if (options[1] == null) {
        LOGGER.error("No test string supplied on equals");
        return null;
    }
    if (options[2] == null) {
        LOGGER.error("No substitution supplied on equals");
        return null;
    }
    final String p = options[1];
    final PatternParser parser = PatternLayout.createPatternParser(config);
    final List<PatternFormatter> formatters = parser.parse(options[0]);
    return new EqualsReplacementConverter(formatters, p, options[2], parser);
}
 

private static Logger configureLog4j() {
    LoggerContext context = (LoggerContext) LogManager.getContext();
    Configuration config = context.getConfiguration();

    PatternLayout layout = PatternLayout.createLayout("%m%n", null, null, Charset.defaultCharset(), false, false, null, null);
    Appender appender = ConsoleAppender.createAppender(layout, null, null, "CONSOLE_APPENDER", null, null);
    appender.start();
    AppenderRef ref = AppenderRef.createAppenderRef("CONSOLE_APPENDER", null, null);
    AppenderRef[] refs = new AppenderRef[]{ref};
    LoggerConfig loggerConfig = LoggerConfig.createLogger("false", Level.INFO, "CONSOLE_LOGGER", "com", refs, null, null, null);
    loggerConfig.addAppender(appender, null, null);

    config.addAppender(appender);
    config.addLogger("Main.class", loggerConfig);
    context.updateLoggers(config);
    return LogManager.getContext().getLogger("Main.class");
}
 

private static Logger configureLog4j() {
    LoggerContext context = (LoggerContext) LogManager.getContext();
    Configuration config = context.getConfiguration();

    PatternLayout layout = PatternLayout.createLayout("%m%n", null, null, Charset.defaultCharset(), false, false, null, null);
    Appender appender = ConsoleAppender.createAppender(layout, null, null, "CONSOLE_APPENDER", null, null);
    appender.start();
    AppenderRef ref = AppenderRef.createAppenderRef("CONSOLE_APPENDER", null, null);
    AppenderRef[] refs = new AppenderRef[]{ref};
    LoggerConfig loggerConfig = LoggerConfig.createLogger("false", Level.INFO, "CONSOLE_LOGGER", "com", refs, null, null, null);
    loggerConfig.addAppender(appender, null, null);

    config.addAppender(appender);
    config.addLogger("Main.class", loggerConfig);
    context.updateLoggers(config);
    return LogManager.getContext().getLogger("Main.class");
}
 

PatternResolver(
        final EventResolverContext context,
        final TemplateResolverConfig config) {
    final String pattern = config.getString("pattern");
    if (Strings.isBlank(pattern)) {
        throw new IllegalArgumentException("blank pattern: " + config);
    }
    final PatternLayout patternLayout = PatternLayout
            .newBuilder()
            .setConfiguration(context.getConfiguration())
            .setCharset(context.getCharset())
            .setPattern(pattern)
            .build();
    this.emitter = (final StringBuilder stringBuilder, final LogEvent logEvent) ->
            patternLayout.serialize(logEvent, stringBuilder);
}
 

@Test
public void testSystemProducerAppenderInAM() throws InterruptedException {
  System.setProperty("samza.container.name", "samza-job-coordinator");

  PatternLayout layout = PatternLayout.newBuilder().withPattern("%m").build();
  MockSystemProducerAppender systemProducerAppender = MockSystemProducerAppender.createAppender("testName", null, layout, false, null, null);
  systemProducerAppender.start();
  log.addAppender(systemProducerAppender);
  log.setLevel(Level.INFO);

  log.info("no-received"); // System isn't initialized yet, so this message should be dropped

  systemProducerAppender.setupSystem();
  MockSystemProducerAppender.systemInitialized = true;

  List<String> messages = Lists.newArrayList("testing3", "testing4");
  logAndVerifyMessages(messages);
  systemProducerAppender.stop();
}
 

/**
 * Gets an instance of the class.
 *
 * @param config  The current Configuration.
 * @param options pattern options, an array of two elements: pattern, max length (defaults to 100 on invalid value).
 * @return instance of class.
 */
public static MaxLengthConverter newInstance(final Configuration config, final String[] options) {
    if (options.length != 2) {
        LOGGER.error("Incorrect number of options on maxLength: expected 2 received {}: {}", options.length,
            options);
        return null;
    }
    if (options[0] == null) {
        LOGGER.error("No pattern supplied on maxLength");
        return null;
    }
    if (options[1] == null) {
        LOGGER.error("No length supplied on maxLength");
        return null;
    }
    final PatternParser parser = PatternLayout.createPatternParser(config);
    final List<PatternFormatter> formatters = parser.parse(options[0]);
    return new MaxLengthConverter(formatters, AbstractAppender.parseInt(options[1], 100));
}
 

@Override
protected void initTargetAppender() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    // get log file path from existing file appender
    RollingRandomAccessFileAppender mainFile =
            (RollingRandomAccessFileAppender) ctx.getConfiguration().getAppender("mainFile");

    String pathPrefix = mainFile == null
            ? System.getProperty("user.dir") + StringUtils.replace("/target/log", "/", File.separator)
            + File.separator
            : StringUtils.replace(mainFile.getFileName(), "core.log", StringUtils.EMPTY);

    targetAppender = FileAppender.newBuilder().
            setName(getTargetAppenderName()).
            withAppend(true).
            withFileName(pathPrefix + getTargetAppenderName() + ".log").
            setLayout(PatternLayout.newBuilder().
                    withPattern("%d{HH:mm:ss.SSS} %-5level %logger - %msg%n").
                    build()).
            build();
}
 

/**
 * Gets an instance of the class.
 *
 * @param config The current Configuration.
 * @param options pattern options, may be null. If first element is "short", only the first line of the
 *                throwable will be formatted.
 * @return instance of class.
 */
public static HighlightConverter newInstance(final Configuration config, final String[] options) {
    if (options.length < 1) {
        LOGGER.error("Incorrect number of options on style. Expected at least 1, received " + options.length);
        return null;
    }
    if (options[0] == null) {
        LOGGER.error("No pattern supplied on style");
        return null;
    }
    final PatternParser parser = PatternLayout.createPatternParser(config);
    final List<PatternFormatter> formatters = parser.parse(options[0]);
    final boolean disableAnsi = Arrays.toString(options).contains(PatternParser.DISABLE_ANSI + "=true");
    final boolean noConsoleNoAnsi = Arrays.toString(options).contains(PatternParser.NO_CONSOLE_NO_ANSI + "=true");
    final boolean hideAnsi = disableAnsi || (noConsoleNoAnsi && System.console() == null);
    return new HighlightConverter(formatters, createLevelStyleMap(options), hideAnsi);
}
 

private Layout createLayout(String pattern, final Log4j1Configuration config) {
    if (pattern == null) {
        LOGGER.info("No pattern provided for pattern layout, using default pattern");
        pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
    }
    return new LayoutWrapper(PatternLayout.newBuilder()
            .setPattern(pattern
                    // Log4j 2's %x (NDC) is not compatible with Log4j 1's
                    // %x
                    // Log4j 1: "foo bar baz"
                    // Log4j 2: "[foo, bar, baz]"
                    // Use %ndc to get the Log4j 1 format
                    .replace("%x", "%ndc")

                    // Log4j 2's %X (MDC) is not compatible with Log4j 1's
                    // %X
                    // Log4j 1: "{{foo,bar}{hoo,boo}}"
                    // Log4j 2: "{foo=bar,hoo=boo}"
                    // Use %properties to get the Log4j 1 format
                    .replace("%X", "%properties"))
            .setConfiguration(config)
            .build());
}
 

@Test
public void testEnvironment() throws Exception {
    ctx = Configurator.initialize("-config", null);
    LogManager.getLogger("org.apache.test.TestConfigurator");
    final Configuration config = ctx.getConfiguration();
    assertNotNull("No configuration", config);
    assertEquals("Incorrect Configuration.", CONFIG_NAME, config.getName());
    final Map<String, Appender> map = config.getAppenders();
    assertNotNull("Appenders map should not be null.", map);
    assertThat(map, hasSize(greaterThan(0)));
    assertThat("No ListAppender named List2", map, hasKey("List2"));
    final Appender app = map.get("List2");
    final Layout<? extends Serializable> layout = app.getLayout();
    assertNotNull("Appender List2 does not have a Layout", layout);
    assertThat("Appender List2 is not configured with a PatternLayout", layout, instanceOf(PatternLayout.class));
    final String pattern = ((PatternLayout) layout).getConversionPattern();
    assertNotNull("No conversion pattern for List2 PatternLayout", pattern);
    assertFalse("Environment variable was not substituted", pattern.startsWith("${env:PATH}"));
}
 

@Test
@SuppressWarnings("deprecation")
public void testLog() {
    final PatternLayout layout = PatternLayout.newBuilder().withPattern("%d %C %L %m").build();
    final ListAppender appender = new ListAppender("List", null, layout, false, false);
    appender.start();
    final Logger root = Logger.getRootLogger();
    try {
        ((org.apache.logging.log4j.core.Logger) root.getLogger()).addAppender(appender);
        root.setLevel(Level.INFO);
        final MyLogger log = new MyLogger(root);
        log.logInfo("This is a test", null);
        root.log(Priority.INFO, "Test msg2", null);
        root.log(Priority.INFO, "Test msg3");
        final List<String> msgs = appender.getMessages();
        assertTrue("Incorrect number of messages", msgs.size() == 3);
        final String msg = msgs.get(0);
        assertTrue("Message contains incorrect class name: " + msg, msg.contains(LoggerTest.class.getName()));
        appender.stop();
    } finally {
        ((org.apache.logging.log4j.core.Logger) root.getLogger()).removeAppender(appender);
    }
}
 

private void validate(final Configuration config) {
    assertNotNull(config);
    assertNotNull(config.getName());
    assertFalse(config.getName().isEmpty());
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 1);
    final ConsoleAppender consoleAppender = (ConsoleAppender)appenders.get("Stdout");
    final PatternLayout gelfLayout = (PatternLayout)consoleAppender.getLayout();
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final LoggerConfig rootLoggerConfig = loggers.get("");
    assertEquals(Level.ERROR, rootLoggerConfig.getLevel());
    assertFalse(rootLoggerConfig.isIncludeLocation());
    final LoggerConfig loggerConfig = loggers.get("org.apache.logging.log4j");
    assertEquals(Level.DEBUG, loggerConfig.getLevel());
    assertTrue(loggerConfig.isIncludeLocation());
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final List<CustomLevelConfig> customLevels = config.getCustomLevels();
    assertNotNull("No CustomLevels", filter);
    assertEquals(1, customLevels.size());
    final CustomLevelConfig customLevel = customLevels.get(0);
    assertEquals("Panic", customLevel.getLevelName());
    assertEquals(17, customLevel.getIntLevel());
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}
 

private void testFactoryMethod() {
    final CronTriggeringPolicy triggerPolicy = createPolicy();
    final DefaultRolloverStrategy rolloverStrategy = createStrategy();

    try (RollingFileManager fileManager = RollingFileManager.getFileManager("target/testcmd3.log",
            "target/testcmd3.log.%d{yyyy-MM-dd}", true, true, triggerPolicy, rolloverStrategy, null,
            PatternLayout.createDefaultLayout(), 0, true, false, null, null, null, configuration)) {
        // trigger rollover
        fileManager.initialize();
        fileManager.rollover();
    }
}
 

public CustomJsonLayout(final Configuration config, final boolean locationInfo, final boolean properties,
    final boolean encodeThreadContextAsList, final boolean complete, final boolean compact, final boolean eventEol,
    final String headerPattern, final String footerPattern, final Charset charset, final boolean includeStacktrace,
    boolean stacktraceAsString, boolean objectMessageAsJsonObject) {
    super(config,
        new JacksonFactory.JSON(encodeThreadContextAsList, includeStacktrace, stacktraceAsString,
            objectMessageAsJsonObject).newWriter(locationInfo, properties, compact),
        charset, compact, complete, eventEol,
        PatternLayout.createSerializer(config, null, headerPattern, DEFAULT_HEADER, null, false, false),
        PatternLayout.createSerializer(config, null, footerPattern, DEFAULT_FOOTER, null, false, false));
}
 

@Test
void testLogFilePlainText(@TempDir Path tempDir) {
    String logFile = tempDir.resolve("agent.log").toString();
    Configuration configuration = getLogConfig(Map.of("log_file", logFile));

    assertThat(configuration.getAppenders().values()).hasSize(1);
    Appender appender = configuration.getAppenders().values().iterator().next();

    assertThat(appender).isInstanceOf(RollingFileAppender.class);
    assertThat(((RollingFileAppender) appender).getFileName()).isEqualTo(logFile);
    assertThat(appender.getLayout()).isInstanceOf(PatternLayout.class);
}
 

public ConsolePatternSelector(
    final AbstractConfiguration configuration, final boolean omitStackTraces) {
  this.omitStackTraces = omitStackTraces;

  final PatternParser patternParser = PatternLayout.createPatternParser(configuration);
  omitStackTraceFormat =
      patternParser.parse(CONSOLE_EXCEPTION_FORMAT, false, true).toArray(PatternFormatter[]::new);
  defaultFormat =
      patternParser.parse(CONSOLE_FORMAT, true, true).toArray(PatternFormatter[]::new);
}
 

/**
 * @throws Exception if an error occurs
 */
@Test
@Alerts(DEFAULT = "Host",
        IE = {})
public void hostHeaderFirst() throws Exception {
    final Logger logger = (Logger) LogManager.getLogger("org.apache.http.headers");
    final Level oldLevel = logger.getLevel();
    Configurator.setLevel(logger.getName(), Level.DEBUG);

    final StringWriter stringWriter = new StringWriter();
    final PatternLayout layout = PatternLayout.newBuilder().withPattern("%msg%n").build();

    final WriterAppender writerAppender = WriterAppender.newBuilder().setName("writeLogger").setTarget(stringWriter)
            .setLayout(layout).build();
    writerAppender.start();

    logger.addAppender(writerAppender);
    try {
        startWebServer("./");

        final WebClient webClient = getWebClient();
        webClient.getPage(URL_FIRST + "LICENSE.txt");
        final String[] messages = StringUtils.split(stringWriter.toString(), "\n");
        for (int i = 0; i < getExpectedAlerts().length; i++) {
            assertTrue(messages[i + 1].contains(getExpectedAlerts()[i]));
        }
    }
    finally {
        logger.removeAppender(writerAppender);
        Configurator.setLevel(logger.getName(), oldLevel);
    }
}
 

@PluginFactory
public static GelfLogField createField(@PluginConfiguration final Configuration config,
        @PluginAttribute("name") String name, @PluginAttribute("literal") String literalValue,
        @PluginAttribute("mdc") String mdc, @PluginAttribute("pattern") String pattern) {

    final boolean isPattern = Strings.isNotEmpty(pattern);
    final boolean isLiteralValue = Strings.isNotEmpty(literalValue);
    final boolean isMDC = Strings.isNotEmpty(mdc);

    if (Strings.isEmpty(name)) {
        LOGGER.error("The name is empty");
        return null;
    }

    if ((isPattern && isLiteralValue) || (isPattern && isMDC) || (isLiteralValue && isMDC)) {
        LOGGER.error("The pattern, literal, and mdc attributes are mutually exclusive.");
        return null;
    }

    if (isPattern) {

        PatternLayout patternLayout = newBuilder().withPattern(pattern).withConfiguration(config)
                .withNoConsoleNoAnsi(false).withAlwaysWriteExceptions(false).build();

        return new GelfLogField(name, null, null, patternLayout);
    }

    return new GelfLogField(name, literalValue, mdc, null);
}
 

@Override
public ColumnConfig build() {
    if (Strings.isEmpty(name)) {
        LOGGER.error("The column config is not valid because it does not contain a column name.");
        return null;
    }

    final boolean isPattern = Strings.isNotEmpty(pattern);
    final boolean isLiteralValue = Strings.isNotEmpty(literal);

    if ((isPattern && isLiteralValue) || (isPattern && isEventTimestamp) || (isLiteralValue && isEventTimestamp)) {
        LOGGER.error("The pattern, literal, and isEventTimestamp attributes are mutually exclusive.");
        return null;
    }

    if (isEventTimestamp) {
        return new ColumnConfig(name, null, null, true, false, false);
    }

    if (isLiteralValue) {
        return new ColumnConfig(name, null, literal, false, false, false);
    }

    if (isPattern) {
        final PatternLayout layout =
            PatternLayout.newBuilder()
                .setPattern(pattern)
                .setConfiguration(configuration)
                .setAlwaysWriteExceptions(false)
                .build();
        return new ColumnConfig(name, layout, null, false, isUnicode, isClob);
    }

    LOGGER.error("To configure a column you must specify a pattern or literal or set isEventDate to true.");
    return null;
}
 

/**
 * Creates a new {@link TerminalConsoleAppender}.
 *
 * @param name The name of the appender
 * @param filter The filter, can be {@code null}
 * @param layout The layout, can be {@code null}
 * @param ignoreExceptions If {@code true} exceptions encountered when
 *     appending events are logged, otherwise they are propagated to the
 *     caller
 * @return The new appender
 */
@PluginFactory
public static TerminalConsoleAppender createAppender(
        @Required(message = "No name provided for TerminalConsoleAppender") @PluginAttribute("name") String name,
        @PluginElement("Filter") Filter filter,
        @PluginElement("Layout") @Nullable Layout<? extends Serializable> layout,
        @PluginAttribute(value = "ignoreExceptions", defaultBoolean = true) boolean ignoreExceptions) {

    if (layout == null) {
        layout = PatternLayout.createDefaultLayout();
    }

    return new TerminalConsoleAppender(name, filter, layout, ignoreExceptions);
}
 

@BeforeMethod
public void initMethod() {

    out = new ByteArrayOutputStream();
    writer = new PrintWriter(out);
    PatternLayout layout = PatternLayout.createDefaultLayout();
    appender = WriterAppender.newBuilder().setName("writeLogger").setTarget(writer).setLayout(layout).build();
    appender.start();
    logger.addAppender(appender);
    userMgtFailureAuditLogger = spy(UserMgtFailureAuditLogger.class);
    when(userMgtFailureAuditLogger.isEnable()).thenReturn(true);
}