下面列出了怎么用org.springframework.boot.logging.LoggingSystem的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* 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());
}
}
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);
}
}
}
@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);
}
}
@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 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 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 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
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 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 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 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 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 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"));
}
@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 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 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 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());
}
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);
}
}
@Override
public void onApplicationEvent(EnvironmentChangeEvent event) {
if (this.environment == null) {
return;
}
LoggingSystem system = LoggingSystem.get(LoggingSystem.class.getClassLoader());
setLogLevels(system, this.environment);
}
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());
}
}
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 + "'");
}
}
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());
}
@Bean
@Primary
public EclairLogger simpleLogger() {
return new SimpleLogger(loggerFacadeFactory, LoggingSystem.get(SimpleLogger.class.getClassLoader()));
}
public SimpleLogger() {
this(new Slf4JLoggerFacadeFactory(), LoggingSystem.get(SimpleLogger.class.getClassLoader()));
}
public SimpleLogger(LoggerFacadeFactory loggerFacadeFactory, LoggingSystem loggingSystem) {
this.loggerFacadeFactory = loggerFacadeFactory;
this.loggingSystem = loggingSystem;
}
@BeforeClass
public static void setErrorLogging() {
LoggingSystem.get(ClassLoader.getSystemClassLoader()).setLogLevel(Logger.ROOT_LOGGER_NAME, LogLevel.DEBUG);
}