Java Code Examples for org.apache.logging.log4j.Logger#fatal()

public void test(final String[] args) {
    System.setProperty("log4j.skipJansi", "false"); // LOG4J2-2087: explicitly enable
    // System.out.println(System.getProperty("java.class.path"));
    final String config = args == null || args.length == 0 ? "target/test-classes/log4j2-console-style-ansi.xml"
            : args[0];
    try (final LoggerContext ctx = Configurator.initialize(ConsoleAppenderAnsiMessagesMain.class.getName(), config)) {
        final Logger logger = LogManager.getLogger(ConsoleAppenderAnsiStyleLayoutMain.class);
        logger.fatal("Fatal message.");
        logger.error("Error message.");
        logger.warn("Warning message.");
        logger.info("Information message.");
        logger.debug("Debug message.");
        logger.trace("Trace message.");
        logger.error("Error message.", new IOException("test"));
    }
}
 

/**
 * @reason Warn the player (configurable to crash or log too) instead of only logging a
 * message a scheduled task throws an exception. The default vanilla behaviour is dangerous
 * as things will fail silently, making future bugs much harder to solve. In fact, it may
 * actually be a vanilla bug that the client doesn't crash, since they are using the "fatal"
 * log level, which is otherwise used only for problems which crash the game.
 */
@Overwrite
@Nullable
// TODO: Utils shouldn't depend on minecraft, redirect individual calls to runTask instead
public static <V> V runTask(FutureTask<V> task, Logger logger) {
    task.run();
    try {
        return task.get();
    } catch (InterruptedException | ExecutionException e) {
        ModConfig.ProblemAction action = ModConfig.crashes.scheduledTaskAction;

        if (action == ModConfig.ProblemAction.CRASH) {
            CrashUtils.crash(new CrashReport("Error executing task", e));
        } else if (action == ModConfig.ProblemAction.WARNING_SCREEN) {
            CrashUtils.warn(new CrashReport("Error executing task", e));
        } else if (action == ModConfig.ProblemAction.NOTIFICATION) {
            CrashUtils.notify(new CrashReport("Error executing task", e));
        } else if (action == ModConfig.ProblemAction.LOG) {
            logger.fatal("Error executing task", e);
        }
        return null;
    }
}
 

@Test
void log4j2LevelMetrics() {
    new Log4j2Metrics().bindTo(registry);

    assertThat(registry.get("log4j2.events").counter().count()).isEqualTo(0.0);

    Logger logger = LogManager.getLogger(Log4j2MetricsTest.class);
    Configurator.setLevel(Log4j2MetricsTest.class.getName(), Level.INFO);
    logger.info("info");
    logger.warn("warn");
    logger.fatal("fatal");
    logger.error("error");
    logger.debug("debug"); // shouldn't record a metric as per log level config
    logger.trace("trace"); // shouldn't record a metric as per log level config

    assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1.0);
    assertThat(registry.get("log4j2.events").tags("level", "warn").counter().count()).isEqualTo(1.0);
    assertThat(registry.get("log4j2.events").tags("level", "fatal").counter().count()).isEqualTo(1.0);
    assertThat(registry.get("log4j2.events").tags("level", "error").counter().count()).isEqualTo(1.0);
    assertThat(registry.get("log4j2.events").tags("level", "debug").counter().count()).isEqualTo(0.0);
    assertThat(registry.get("log4j2.events").tags("level", "trace").counter().count()).isEqualTo(0.0);
}
 

@Test
public void testAppender() throws Exception {
  final Logger logger = loggerContextRule.getLogger();
  for (int i = 0; i < 10; ++i) {
    // 30 chars per message: each message triggers a rollover
    logger.fatal("This is a test message number " + i); // 30 chars:
  }
  Thread.sleep(100); // Allow time for rollover to complete

  final File dir = new File(DIR);
  assertTrue("Dir " + DIR + " should exist", dir.exists());
  assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length == 6);

  final File[] files = dir.listFiles();
  final List<String> expected = Arrays.asList("rollingtest.log", "test-001.log", "test-002.log", "test-003.log", "test-004.log", "test-005.log");
  assertEquals("Unexpected number of files", expected.size(), files.length);
  for (final File file : files) {
    if (!expected.contains(file.getName())) {
      fail("unexpected file" + file);
    }
  }
}
 

public static void main(String[] args) {
	final Logger logger = LogManager.getLogger(StartSECC.class.getSimpleName());
	MiscUtils.loadProperties(GlobalValues.SECC_CONFIG_PROPERTIES_PATH.toString());
	
	UDPServer udpServer = UDPServer.getInstance();
	TCPServer tcpServer = TCPServer.getInstance();
	TLSServer tlsServer = TLSServer.getInstance();
	
	if (!udpServer.initialize() || !tlsServer.initialize() || !tcpServer.initialize()) {
		logger.fatal("Unable to start SECC because UDP, TCP or TLS server could not be initialized");
	} else {
		Thread udpServerThread = new Thread(udpServer);
		udpServerThread.setName("UDPServerThread");
		
		Thread tcpServerThread = new Thread(tcpServer);
		tcpServerThread.setName("TCPServerThread");
		
		Thread tlsServerThread = new Thread(tlsServer);
		tlsServerThread.setName("TLSServerThread");
		
		// All transport layer threads need to be initialized before initializing the SECC session handler.
		new V2GCommunicationSessionHandlerSECC();
		
		/*
		 * To avoid possible race conditions, the transport layer threads need to be started AFTER the SECC
		 * session handler has been initialized. Otherwise the situation might occur that the UDPServer is 
		 * receiving a UDP client packet and tries to access the MessageHandler object before this object has
		 * been created by the SECC session handler.
		 */
		udpServerThread.start();
		tcpServerThread.start();
		tlsServerThread.start();
	} 
}
 

@Test
public void givenLoggerWithConsoleConfig_whenLogToConsoleInColors_thanOK() throws Exception {
    Logger logger = LogManager.getLogger("CONSOLE_PATTERN_APPENDER_MARKER");
    Exception e = new RuntimeException("This is only a test!");

    logger.trace("This is a colored message at TRACE level.");
    logger.debug("This is a colored message at DEBUG level. " + "This is the minimum visible level.");
    logger.info("This is a colored message at INFO level.");
    logger.warn("This is a colored message at WARN level.");
    logger.error("This is a colored message at ERROR level.", e);
    logger.fatal("This is a colored message at FATAL level.");
}
 

@Test
public void givenLoggerWithFailoverConfig_whenLog_thanOK() throws Exception {
    Logger logger = LogManager.getLogger("FAIL_OVER_SYSLOG_APPENDER");
    Exception e = new RuntimeException("This is only a test!");

    logger.trace("This is a syslog message at TRACE level.");
    logger.debug("This is a syslog message at DEBUG level.");
    logger.info("This is a syslog message at INFO level. This is the minimum visible level.");
    logger.warn("This is a syslog message at WARN level.");
    logger.error("This is a syslog message at ERROR level.", e);
    logger.fatal("This is a syslog message at FATAL level.");
}
 

@Test
public void testMethodLogger() throws Exception {
    final ListAppender app = context.getListAppender("Method").clear();
    final Logger logger = context.getLogger("MethodLogger");
    logger.info("More messages.");
    logger.warn("CATASTROPHE INCOMING!");
    logger.error("ZOMBIES!!!");
    logger.fatal("brains~~~");
    logger.info("Itchy. Tasty.");
    final List<String> messages = app.getMessages();
    assertEquals("Incorrect number of messages.", 5, messages.size());
    for (final String message : messages) {
        assertEquals("Incorrect caller method name.", "testMethodLogger", message);
    }
}
 

@Test
public void testRouter() throws Exception {
    final Logger logger = LogManager.getLogger(AsyncAppenderQueueFullPolicyTest.class);

    assertEquals(4, asyncAppender.getQueueCapacity());
    logger.error("event 1 - gets taken off the queue");
    logger.warn("event 2");
    logger.info("event 3");
    logger.info("event 4");
    while (asyncAppender.getQueueRemainingCapacity() == 0) {
        Thread.yield(); // wait until background thread takes one element off the queue
    }
    logger.info("event 5 - now the queue is full");
    assertEquals("queue remaining capacity", 0, asyncAppender.getQueueRemainingCapacity());
    assertEquals("EventRouter invocations", 0, policy.queueFull.get());

    final Thread release = new Thread("AsyncAppenderReleaser") {
        @Override
        public void run() {
            while (policy.queueFull.get() == 0) {
                try {
                    Thread.sleep(10L);
                } catch (final InterruptedException ignored) {
                    //ignored
                }
            }
            blockingAppender.running = false;
        }
    };
    release.setDaemon(true);
    release.start();
    logger.fatal("this blocks until queue space available");
    assertEquals(1, policy.queueFull.get());
}
 

@Test
public void test() throws Exception {
    try (Connection connection = jdbcRule.getConnection()) {
        final Error exception = new Error("This is a test.");
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try (final PrintWriter writer = new PrintWriter(outputStream)) {
            exception.printStackTrace(writer);
        }
        final String stackTrace = outputStream.toString();

        final Logger logger = LogManager.getLogger(this.getClass().getName() + ".testDataSourceConfig");
        logger.trace("Data source logged message 01.");
        logger.fatal("Error from data source 02.", exception);
        Thread.sleep(1000);
        try (final Statement statement = connection.createStatement();
                final ResultSet resultSet = statement.executeQuery("SELECT * FROM dsMappingLogEntry ORDER BY id")) {

            assertTrue("There should be at least one row.", resultSet.next());

            assertEquals("The level column is not correct (1).", "FATAL", resultSet.getNString("level"));
            assertEquals("The logger column is not correct (1).", logger.getName(), resultSet.getNString("logger"));
            assertEquals("The message column is not correct (1).", "Hello World!", resultSet.getString("message"));
            assertEquals("The exception column is not correct (1).", stackTrace,
                    IOUtils.readStringAndClose(resultSet.getNClob("exception").getCharacterStream(), -1));

            assertFalse("There should not be two rows.", resultSet.next());
        }
    }

}
 

@Test
public void testDataSourceConfig() throws Exception {
    try (final Connection connection = jdbcRule.getConnectionSource().getConnection()) {
        final Error exception = new Error("Final error massage is fatal!");
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try (final PrintWriter writer = new PrintWriter(outputStream)) {
            exception.printStackTrace(writer);
        }
        final String stackTrace = outputStream.toString();

        final long millis = System.currentTimeMillis();

        final Logger logger = LogManager.getLogger(this.getClass().getName() + ".testDataSourceConfig");
        logger.trace("Data source logged message 01.");
        logger.fatal("Error from data source 02.", exception);

        try (final Statement statement = connection.createStatement();
                final ResultSet resultSet = statement.executeQuery("SELECT * FROM dsLogEntry ORDER BY id")) {

            assertTrue("There should be at least one row.", resultSet.next());

            final long date = resultSet.getTimestamp("eventDate").getTime();
            assertTrue("The date should be later than pre-logging (1).", date >= millis);
            assertTrue("The date should be earlier than now (1).", date <= System.currentTimeMillis());
            assertEquals("The literal column is not correct (1).", "Literal Value of Data Source",
                    resultSet.getString("literalColumn"));
            assertEquals("The level column is not correct (1).", "FATAL", resultSet.getNString("level"));
            assertEquals("The logger column is not correct (1).", logger.getName(), resultSet.getNString("logger"));
            assertEquals("The message column is not correct (1).", "Error from data source 02.",
                    resultSet.getString("message"));
            assertEquals("The exception column is not correct (1).", stackTrace,
                    IOUtils.readStringAndClose(resultSet.getNClob("exception").getCharacterStream(), -1));

            assertFalse("There should not be two rows.", resultSet.next());
        }
    }
}
 

@Test
public void test() throws Exception {
	try (Connection connection = jdbcRule.getConnection()) {
		final Error exception = new Error("This is a test.");
		final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
		try (final PrintWriter writer = new PrintWriter(outputStream)) {
			exception.printStackTrace(writer);
		}
		final String stackTrace = outputStream.toString();

		final Logger logger = LogManager.getLogger(this.getClass().getName() + ".testDataSourceConfig");
		logger.trace("Data source logged message 01.");
		logger.fatal("Error from data source 02.", exception);
		Thread.sleep(1000);
		try (final Statement statement = connection.createStatement();
				final ResultSet resultSet = statement.executeQuery("SELECT * FROM dsMappingLogEntry ORDER BY id")) {

			assertTrue("There should be at least one row.", resultSet.next());

			assertEquals("The level column is not correct (1).", "FATAL", resultSet.getNString("level"));
			assertEquals("The logger column is not correct (1).", logger.getName(), resultSet.getNString("logger"));
			assertEquals("The message column is not correct (1).", "Error from data source 02.",
					resultSet.getString("message"));
			assertEquals("The exception column is not correct (1).", stackTrace,
					IOUtils.readStringAndClose(resultSet.getNClob("exception").getCharacterStream(), -1));

			assertFalse("There should not be two rows.", resultSet.next());
		}
	}

}
 

@Test
public void testBasicJpaEntityAppender() throws SQLException {
    try {
        this.setUp("log4j2-" + this.databaseType + "-jpa-basic.xml");

        final Error exception = new Error("Goodbye, cruel world!");
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        final PrintWriter writer = new PrintWriter(outputStream);
        exception.printStackTrace(writer);
        writer.close();
        final String stackTrace = outputStream.toString().replace("\r\n", "\n");

        final long millis = System.currentTimeMillis();

        final Logger logger1 = LogManager.getLogger(this.getClass().getName() + ".testBasicJpaEntityAppender");
        final Logger logger2 = LogManager.getLogger(this.getClass().getName() + ".testBasicJpaEntityAppenderAgain");
        logger1.debug("Test my debug 01.");
        logger1.warn("This is another warning 02.", exception);
        logger2.fatal("A fatal warning has been issued.");

        final Statement statement = this.connection.createStatement();
        final ResultSet resultSet = statement.executeQuery("SELECT * FROM jpaBasicLogEntry ORDER BY id");

        assertTrue("There should be at least one row.", resultSet.next());

        long date = resultSet.getLong("timemillis");
        assertTrue("The date should be later than pre-logging (1).", date >= millis);
        assertTrue("The date should be earlier than now (1).", date <= System.currentTimeMillis());
        assertEquals("The level column is not correct (1).", "DEBUG", resultSet.getString("level"));
        assertEquals("The logger column is not correct (1).", logger1.getName(), resultSet.getString("loggerName"));
        assertEquals("The message column is not correct (1).", "Test my debug 01.",
                resultSet.getString("message"));
        assertNull("The exception column is not correct (1).", resultSet.getString("thrown"));

        assertTrue("There should be at least two rows.", resultSet.next());

        date = resultSet.getLong("timemillis");
        assertTrue("The date should be later than pre-logging (2).", date >= millis);
        assertTrue("The date should be earlier than now (2).", date <= System.currentTimeMillis());
        assertEquals("The level column is not correct (2).", "WARN", resultSet.getString("level"));
        assertEquals("The logger column is not correct (2).", logger1.getName(), resultSet.getString("loggerName"));
        assertEquals("The message column is not correct (2).", "This is another warning 02.",
                resultSet.getString("message"));
        assertEquals("The exception column is not correct (2).", stackTrace, resultSet.getString("thrown"));

        assertTrue("There should be three rows.", resultSet.next());

        date = resultSet.getLong("timemillis");
        assertTrue("The date should be later than pre-logging (3).", date >= millis);
        assertTrue("The date should be earlier than now (3).", date <= System.currentTimeMillis());
        assertEquals("The level column is not correct (3).", "FATAL", resultSet.getString("level"));
        assertEquals("The logger column is not correct (3).", logger2.getName(), resultSet.getString("loggerName"));
        assertEquals("The message column is not correct (3).", "A fatal warning has been issued.",
                resultSet.getString("message"));
        assertNull("The exception column is not correct (3).", resultSet.getString("thrown"));

        assertFalse("There should not be four rows.", resultSet.next());
    } finally {
        this.tearDown();
    }
}