org.springframework.boot.logging.LoggingSystem Java Examples

@Test
public void loggingSystemNotInitialized() {
	System.setProperty(LoggingSystem.SYSTEM_PROPERTY,
			TestLoggingSystem.class.getName());
	TestLoggingSystem system = (TestLoggingSystem) LoggingSystem
			.get(getClass().getClassLoader());
	then(system.getCount()).isEqualTo(0);
	try (ConfigurableApplicationContext context = SpringApplication.run(Empty.class,
			"--spring.main.web-application-type=none", "--debug=false",
			"--spring.main.bannerMode=OFF",
			"--spring.cloud.bootstrap.name=refresh")) {
		then(system.getCount()).isEqualTo(4);
		ContextRefresher refresher = new ContextRefresher(context, this.scope);
		refresher.refresh();
		then(system.getCount()).isEqualTo(4);
	}
}
 

private void reinitializeLoggingSystem(ConfigurableEnvironment environment,
		String oldLogConfig, LogFile oldLogFile) {
	Map<String, Object> props = Binder.get(environment)
			.bind("logging", Bindable.mapOf(String.class, Object.class))
			.orElseGet(Collections::emptyMap);
	if (!props.isEmpty()) {
		String logConfig = environment.resolvePlaceholders("${logging.config:}");
		LogFile logFile = LogFile.get(environment);
		LoggingSystem system = LoggingSystem
				.get(LoggingSystem.class.getClassLoader());
		try {
			ResourceUtils.getURL(logConfig).openStream().close();
			// Three step initialization that accounts for the clean up of the logging
			// context before initialization. Spring Boot doesn't initialize a logging
			// system that hasn't had this sequence applied (since 1.4.1).
			system.cleanUp();
			system.beforeInitialize();
			system.initialize(new LoggingInitializationContext(environment),
					logConfig, logFile);
		}
		catch (Exception ex) {
			PropertySourceBootstrapConfiguration.logger
					.warn("Error opening logging config file " + logConfig, ex);
		}
	}
}
 

/**
 * deducing groupId, artifactId
 *
 * @param event
 */
private void onApplicationStartingEvent(ApplicationStartingEvent event) {
    if (ClassUtils.isPresent("ch.qos.logback.core.Appender",
            event.getSpringApplication().getClassLoader())) {
        // base package
        Class<?> mainClass = event.getSpringApplication().getMainApplicationClass();
        if (mainClass != null) {
            String basePackage = mainClass.getPackage().getName();
            System.setProperty("BASE_PACKAGE", basePackage);
        } else {
            System.setProperty("BASE_PACKAGE", "");
            logger.warn("can not set BASE_PACKAGE correctly");
        }

        // set logging system impl
        System.setProperty(LoggingSystem.SYSTEM_PROPERTY, FormulaLogbackSystem.class.getName());
    }
}
 

@Test
public void logError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.ERROR);
    logger.log(LogLevel.ERROR, "logger name", "error message");
    assertThat(capture.toString(), containsString("ERROR logger name - error message"));
}
 

private void setLogLevel(LoggingSystem system, Environment environment, String name,
		String level) {
	try {
		if (name.equalsIgnoreCase("root")) {
			name = null;
		}
		level = environment.resolvePlaceholders(level);
		system.setLogLevel(name, resolveLogLevel(level));
	}
	catch (RuntimeException ex) {
		this.logger.error("Cannot set level: " + level + " for '" + name + "'");
	}
}
 

protected void setLogLevels(LoggingSystem system, Environment environment) {
	Map<String, String> levels = Binder.get(environment)
			.bind("logging.level", STRING_STRING_MAP)
			.orElseGet(Collections::emptyMap);
	for (Entry<String, String> entry : levels.entrySet()) {
		setLogLevel(system, environment, entry.getKey(), entry.getValue().toString());
	}
}
 

@Override
public void onApplicationEvent(EnvironmentChangeEvent event) {
	if (this.environment == null) {
		return;
	}
	LoggingSystem system = LoggingSystem.get(LoggingSystem.class.getClassLoader());
	setLogLevels(system, this.environment);
}
 

static void setEnabled(boolean enabled) {
	if (enabled) {
		LoggingSystem system = LoggingSystem.get(Thread.currentThread().getContextClassLoader());
		system.setLogLevel("org.springframework", LogLevel.DEBUG);
		system.setLogLevel("io.spring.concourse.artifactoryresource", LogLevel.DEBUG);
	}
}
 

@Test
public void logTraceErrorOff() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.OFF);
    logger.log(LogLevel.TRACE, "logger name", "trace message", new Exception("error message"));
    Pattern pattern = Pattern.compile("TRACE logger name - trace message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertFalse(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logFatalError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.FATAL);
    logger.log(LogLevel.FATAL, "logger name", "fatal message", new Exception("error message"));
    Pattern pattern = Pattern.compile("ERROR logger name - fatal message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logFatal() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.FATAL);
    logger.log(LogLevel.FATAL, "logger name", "fatal message");
    assertThat(capture.toString(), containsString("ERROR logger name - fatal message"));
}
 

@Test
public void logErrorError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.ERROR);
    logger.log(LogLevel.ERROR, "logger name", "error message", new Exception("error message"));
    Pattern pattern = Pattern.compile("ERROR logger name - error message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logWarningError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.WARN);
    logger.log(LogLevel.WARN, "logger name", "warn message", new Exception("error message"));
    Pattern pattern = Pattern.compile("WARN logger name - warn message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logWarning() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.WARN);
    logger.log(LogLevel.WARN, "logger name", "warn message");
    assertThat(capture.toString(), containsString("WARN logger name - warn message"));
}
 

@Test
public void logInfoError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.INFO);
    logger.log(LogLevel.INFO, "logger name", "info message", new Exception("error message"));
    Pattern pattern = Pattern.compile("INFO logger name - info message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logInfo() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.INFO);
    logger.log(LogLevel.INFO, "logger name", "info message");
    assertThat(capture.toString(), containsString("INFO logger name - info message"));
}
 

@Test
public void logDebug() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.DEBUG);
    logger.log(LogLevel.DEBUG, "logger name", "debug message");
    assertThat(capture.toString(), containsString("DEBUG logger name - debug message"));
}
 

@Test
void changeDefaultROOTLogLevel() {
	var app = application(it -> it.logging(log -> log.level(LogLevel.DEBUG)));
	app.run();
	var loggingSystem = LoggingSystem.get(LoggingDslTests.class.getClassLoader());
	assertEquals(LogLevel.DEBUG, loggingSystem.getLoggerConfiguration("ROOT").getEffectiveLevel());
}
 

@Test
void changePackageLogLevel() {
	var packageName = "org.springframework";
	var app = application(it -> it.logging(log -> log.level(packageName, LogLevel.DEBUG)));
	app.run();
	var loggingSystem = LoggingSystem.get(LoggingDslTests.class.getClassLoader());
	assertEquals(LogLevel.DEBUG, loggingSystem.getLoggerConfiguration(packageName).getEffectiveLevel());
}
 

@Test
void changeClassLogLevel() {
	var loggingSystem = LoggingSystem.get(LoggingDslTests.class.getClassLoader());
	loggingSystem.setLogLevel("ROOT", LogLevel.INFO);
	var app = application(it -> it.logging(log -> log.level(DefaultListableBeanFactory.class, LogLevel.DEBUG)));
	app.run();
	assertEquals(LogLevel.DEBUG, loggingSystem.getLoggerConfiguration("org.springframework.beans.factory.support.DefaultListableBeanFactory").getEffectiveLevel());
}
 

@Test
public void logDebugError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.DEBUG);
    logger.log(LogLevel.DEBUG, "logger name", "debug message", new Exception("error message"));
    Pattern pattern = Pattern.compile("DEBUG logger name - debug message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logTraceError() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.TRACE);
    logger.log(LogLevel.TRACE, "logger name", "trace message", new Exception("error message"));
    Pattern pattern = Pattern.compile("TRACE logger name - trace message.*java.lang.Exception: error message",
            Pattern.DOTALL | Pattern.MULTILINE);
    assertTrue(pattern.matcher(capture.toString()).find());
}
 

@Test
public void logTrace() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.TRACE);
    logger.log(LogLevel.TRACE, "logger name", "trace message");
    assertThat(capture.toString(), containsString("TRACE logger name - trace message"));
}
 

@Test
public void isLogTraceDisabled() {
    LoggingSystem.get(ClassLoader.getSystemClassLoader())
            .setLogLevel(org.slf4j.Logger.ROOT_LOGGER_NAME, LogLevel.OFF);
    assertFalse(logger.isEnabled(LogLevel.TRACE, "logger name"));
}
 

@After
public void close() {
	System.clearProperty(LoggingSystem.SYSTEM_PROPERTY);
	TestLoggingSystem.count = 0;
}
 

@After
public void reset() {
	LoggingSystem.get(getClass().getClassLoader())
			.setLogLevel("org.springframework.web", LogLevel.INFO);
}
 

private void shutdownLogging() {
	LoggingSystem loggingSystem = LoggingSystem
			.get(ClassUtils.getDefaultClassLoader());
	loggingSystem.cleanUp();
	loggingSystem.beforeInitialize();
}
 

private boolean isAlreadyInitialized(LoggerContext loggerContext) {
	return loggerContext.getObject(LoggingSystem.class.getName()) != null;
}
 

private void markAsInitialized(LoggerContext loggerContext) {
	loggerContext.putObject(LoggingSystem.class.getName(), new Object());
}
 

private void markAsUninitialized(LoggerContext loggerContext) {
	loggerContext.removeObject(LoggingSystem.class.getName());
}