From a4481836812ffe10eba8cceb749ee96bbffc1b48 Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Fri, 21 Oct 2016 18:40:54 -0700 Subject: [PATCH] Polish `/loggers` actuator endpoint See gh-7086 --- .../actuate/endpoint/LoggersEndpoint.java | 66 ++++++++------ .../endpoint/mvc/LoggersMvcEndpoint.java | 12 +-- .../EndpointAutoConfigurationTests.java | 3 +- .../endpoint/LoggersEndpointTests.java | 27 +++--- .../endpoint/mvc/LoggersMvcEndpointTests.java | 46 ++++++---- .../boot/logging/AbstractLoggingSystem.java | 33 +++++++ .../boot/logging/LoggerConfiguration.java | 6 +- .../LoggerConfigurationComparator.java | 2 - .../boot/logging/LoggingSystem.java | 40 ++++----- .../boot/logging/java/JavaLoggingSystem.java | 85 ++++++++----------- .../logging/log4j2/Log4J2LoggingSystem.java | 78 ++++++++--------- .../logging/logback/LogbackLoggingSystem.java | 74 ++++++++-------- .../LoggerConfigurationComparatorTests.java | 4 +- .../LoggingApplicationListenerTests.java | 22 ++--- .../boot/logging/LoggingSystemTests.java | 2 +- .../logging/java/JavaLoggingSystemTests.java | 35 ++++---- .../log4j2/Log4J2LoggingSystemTests.java | 34 ++++---- .../logback/LogbackLoggingSystemTests.java | 37 ++++---- 18 files changed, 319 insertions(+), 287 deletions(-) diff --git a/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/LoggersEndpoint.java b/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/LoggersEndpoint.java index 1cdae7dc5e..334d578295 100644 --- a/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/LoggersEndpoint.java +++ b/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/LoggersEndpoint.java @@ -31,10 +31,12 @@ import org.springframework.util.Assert; * {@link Endpoint} to expose a collection of {@link LoggerConfiguration}s. * * @author Ben Hale + * @author Phillip Webb * @since 1.5.0 */ @ConfigurationProperties(prefix = "endpoints.loggers") -public class LoggersEndpoint extends AbstractEndpoint>> { +public class LoggersEndpoint + extends AbstractEndpoint> { private final LoggingSystem loggingSystem; @@ -49,44 +51,58 @@ public class LoggersEndpoint extends AbstractEndpoint> invoke() { - Collection loggerConfigurations = this.loggingSystem - .listLoggerConfigurations(); - - if (loggerConfigurations == null) { + public Map invoke() { + Collection configurations = this.loggingSystem + .getLoggerConfigurations(); + if (configurations == null) { return Collections.emptyMap(); } - - Map> result = new LinkedHashMap>(loggerConfigurations.size()); - - for (LoggerConfiguration loggerConfiguration : loggerConfigurations) { - result.put(loggerConfiguration.getName(), result(loggerConfiguration)); + Map result = new LinkedHashMap( + configurations.size()); + for (LoggerConfiguration configuration : configurations) { + result.put(configuration.getName(), new LoggerLevels(configuration)); } - return result; } - public Map get(String name) { + public LoggerLevels invoke(String name) { Assert.notNull(name, "Name must not be null"); - return result(this.loggingSystem.getLoggerConfiguration(name)); + LoggerConfiguration configuration = this.loggingSystem + .getLoggerConfiguration(name); + return (configuration == null ? null : new LoggerLevels(configuration)); } - public void set(String name, LogLevel level) { + public void setLogLevel(String name, LogLevel level) { Assert.notNull(name, "Name must not be empty"); this.loggingSystem.setLogLevel(name, level); } - private static Map result(LoggerConfiguration loggerConfiguration) { - if (loggerConfiguration == null) { - return Collections.emptyMap(); + /** + * Levels configured for a given logger exposed in a JSON friendly way. + */ + public static class LoggerLevels { + + private String configuredLevel; + + private String effectiveLevel; + + public LoggerLevels(LoggerConfiguration configuration) { + this.configuredLevel = getName(configuration.getConfiguredLevel()); + this.effectiveLevel = getName(configuration.getEffectiveLevel()); } - Map result = new LinkedHashMap(3); - LogLevel configuredLevel = loggerConfiguration.getConfiguredLevel(); - result.put("configuredLevel", - configuredLevel != null ? configuredLevel.name() : null); - result.put("effectiveLevel", loggerConfiguration.getEffectiveLevel().name()); - return result; + + private String getName(LogLevel level) { + return (level == null ? null : level.name()); + } + + public String getConfiguredLevel() { + return this.configuredLevel; + } + + public String getEffectiveLevel() { + return this.effectiveLevel; + } + } } diff --git a/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpoint.java b/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpoint.java index c0fac73af7..fc635a10ed 100644 --- a/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpoint.java +++ b/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpoint.java @@ -19,8 +19,10 @@ package org.springframework.boot.actuate.endpoint.mvc; import java.util.Map; import org.springframework.boot.actuate.endpoint.LoggersEndpoint; +import org.springframework.boot.actuate.endpoint.LoggersEndpoint.LoggerLevels; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.logging.LogLevel; +import org.springframework.http.HttpEntity; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; @@ -54,11 +56,11 @@ public class LoggersMvcEndpoint extends EndpointMvcAdapter { // disabled return getDisabledResponse(); } - return this.delegate.get(name); + LoggerLevels levels = this.delegate.invoke(name); + return (levels == null ? ResponseEntity.notFound().build() : levels); } - @PostMapping(value = "/{name:.*}", consumes = MediaType.APPLICATION_JSON_VALUE, - produces = MediaType.APPLICATION_JSON_VALUE) + @PostMapping(value = "/{name:.*}", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody @HypermediaDisabled public Object set(@PathVariable String name, @@ -69,8 +71,8 @@ public class LoggersMvcEndpoint extends EndpointMvcAdapter { return getDisabledResponse(); } String level = configuration.get("configuredLevel"); - this.delegate.set(name, level == null ? null : LogLevel.valueOf(level)); - return ResponseEntity.EMPTY; + this.delegate.setLogLevel(name, level == null ? null : LogLevel.valueOf(level)); + return HttpEntity.EMPTY; } } diff --git a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/autoconfigure/EndpointAutoConfigurationTests.java b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/autoconfigure/EndpointAutoConfigurationTests.java index 31044b0b02..e41fc55a8c 100644 --- a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/autoconfigure/EndpointAutoConfigurationTests.java +++ b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/autoconfigure/EndpointAutoConfigurationTests.java @@ -37,6 +37,7 @@ import org.springframework.boot.actuate.endpoint.HealthEndpoint; import org.springframework.boot.actuate.endpoint.InfoEndpoint; import org.springframework.boot.actuate.endpoint.LiquibaseEndpoint; import org.springframework.boot.actuate.endpoint.LoggersEndpoint; +import org.springframework.boot.actuate.endpoint.LoggersEndpoint.LoggerLevels; import org.springframework.boot.actuate.endpoint.MetricsEndpoint; import org.springframework.boot.actuate.endpoint.PublicMetrics; import org.springframework.boot.actuate.endpoint.RequestMappingEndpoint; @@ -129,7 +130,7 @@ public class EndpointAutoConfigurationTests { public void loggersEndpointHasLoggers() throws Exception { load(CustomLoggingConfig.class, EndpointAutoConfiguration.class); LoggersEndpoint endpoint = this.context.getBean(LoggersEndpoint.class); - Map> loggers = endpoint.invoke(); + Map loggers = endpoint.invoke(); assertThat(loggers.size()).isGreaterThan(0); } diff --git a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/LoggersEndpointTests.java b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/LoggersEndpointTests.java index 53572d4a07..21e27f7b8c 100644 --- a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/LoggersEndpointTests.java +++ b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/LoggersEndpointTests.java @@ -17,10 +17,10 @@ package org.springframework.boot.actuate.endpoint; import java.util.Collections; -import java.util.Map; import org.junit.Test; +import org.springframework.boot.actuate.endpoint.LoggersEndpoint.LoggerLevels; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.logging.LogLevel; import org.springframework.boot.logging.LoggerConfiguration; @@ -45,25 +45,24 @@ public class LoggersEndpointTests extends AbstractEndpointTests } @Test - public void invoke() throws Exception { - given(getLoggingSystem().listLoggerConfigurations()).willReturn(Collections - .singleton(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG))); - Map loggingConfiguration = getEndpointBean().invoke() - .get("ROOT"); - assertThat(loggingConfiguration.get("configuredLevel")).isNull(); - assertThat(loggingConfiguration.get("effectiveLevel")).isEqualTo("DEBUG"); + public void invokeShouldReturnConfigurations() throws Exception { + given(getLoggingSystem().getLoggerConfigurations()).willReturn(Collections + .singletonList(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG))); + LoggerLevels levels = getEndpointBean().invoke().get("ROOT"); + assertThat(levels.getConfiguredLevel()).isNull(); + assertThat(levels.getEffectiveLevel()).isEqualTo("DEBUG"); } - public void get() throws Exception { + public void invokeWhenNameSpecifiedShouldReturnLevels() throws Exception { given(getLoggingSystem().getLoggerConfiguration("ROOT")) .willReturn(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG)); - Map loggingConfiguration = getEndpointBean().get("ROOT"); - assertThat(loggingConfiguration.get("configuredLevel")).isNull(); - assertThat(loggingConfiguration.get("effectiveLevel")).isEqualTo("DEBUG"); + LoggerLevels levels = getEndpointBean().invoke("ROOT"); + assertThat(levels.getConfiguredLevel()).isNull(); + assertThat(levels.getEffectiveLevel()).isEqualTo("DEBUG"); } - public void set() throws Exception { - getEndpointBean().set("ROOT", LogLevel.DEBUG); + public void setLogLevelShouldSetLevelOnLoggingSystem() throws Exception { + getEndpointBean().setLogLevel("ROOT", LogLevel.DEBUG); verify(getLoggingSystem()).setLogLevel("ROOT", LogLevel.DEBUG); } diff --git a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpointTests.java b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpointTests.java index 8ada13d112..bcde5aecc6 100644 --- a/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpointTests.java +++ b/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/mvc/LoggersMvcEndpointTests.java @@ -18,9 +18,11 @@ package org.springframework.boot.actuate.endpoint.mvc; import java.util.Collections; +import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mockito; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.actuate.autoconfigure.EndpointWebMvcAutoConfiguration; @@ -37,9 +39,9 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; import org.springframework.http.MediaType; -import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.result.MockMvcResultHandlers; import org.springframework.test.web.servlet.setup.MockMvcBuilders; import org.springframework.web.context.WebApplicationContext; @@ -57,9 +59,9 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers. * Tests for {@link LoggersMvcEndpoint}. * * @author Ben Hale + * @author Phillip Webb */ @RunWith(SpringRunner.class) -@DirtiesContext @SpringBootTest public class LoggersMvcEndpointTests { @@ -74,50 +76,60 @@ public class LoggersMvcEndpointTests { @Before public void setUp() { this.context.getBean(LoggersEndpoint.class).setEnabled(true); - this.mvc = MockMvcBuilders.webAppContextSetup(this.context).build(); + this.mvc = MockMvcBuilders.webAppContextSetup(this.context) + .alwaysDo(MockMvcResultHandlers.print()).build(); } - @Test - public void list() throws Exception { - given(this.loggingSystem.listLoggerConfigurations()).willReturn(Collections - .singleton(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG))); + @After + public void reset() { + Mockito.reset(this.loggingSystem); + } + @Test + public void getLoggerShouldReturnAllLoggerConfigurations() throws Exception { + given(this.loggingSystem.getLoggerConfigurations()).willReturn(Collections + .singletonList(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG))); this.mvc.perform(get("/loggers")).andExpect(status().isOk()) .andExpect(content().string(equalTo("{\"ROOT\":{\"configuredLevel\":" + "null,\"effectiveLevel\":\"DEBUG\"}}"))); } @Test - public void listDisabled() throws Exception { + public void getLoggersWhenDisabledShouldReturnNotFound() throws Exception { this.context.getBean(LoggersEndpoint.class).setEnabled(false); this.mvc.perform(get("/loggers")).andExpect(status().isNotFound()); } @Test - public void getLogger() throws Exception { + public void getLoggerShouldReturnLogLevels() throws Exception { given(this.loggingSystem.getLoggerConfiguration("ROOT")) .willReturn(new LoggerConfiguration("ROOT", null, LogLevel.DEBUG)); - this.mvc.perform(get("/loggers/ROOT")).andExpect(status().isOk()) - .andExpect(content().string(equalTo("{\"configuredLevel\":null," - + "\"effectiveLevel\":\"DEBUG\"}"))); + .andExpect(content().string(equalTo( + "{\"configuredLevel\":null," + "\"effectiveLevel\":\"DEBUG\"}"))); } @Test - public void getLoggerDisabled() throws Exception { + public void getLoggesWhenDisabledShouldReturnNotFound() throws Exception { this.context.getBean(LoggersEndpoint.class).setEnabled(false); this.mvc.perform(get("/loggers/ROOT")).andExpect(status().isNotFound()); } @Test - public void setLogger() throws Exception { + public void getLoggersWhenLoggerNotFoundShouldReturnNotFound() throws Exception { + this.mvc.perform(get("/loggers/com.does.not.exist")) + .andExpect(status().isNotFound()); + } + + @Test + public void setLoggerShouldSetLogLevel() throws Exception { this.mvc.perform(post("/loggers/ROOT").contentType(MediaType.APPLICATION_JSON) - .content("{\"configuredLevel\":\"DEBUG\"}")).andExpect(status().isOk()); + .content("{\"configuredLevel\":\"DEBUG\"}")).andExpect(status().isOk()); verify(this.loggingSystem).setLogLevel("ROOT", LogLevel.DEBUG); } @Test - public void setLoggerDisabled() throws Exception { + public void setLoggerWhenDisabledShouldReturnNotFound() throws Exception { this.context.getBean(LoggersEndpoint.class).setEnabled(false); this.mvc.perform(post("/loggers/ROOT").contentType(MediaType.APPLICATION_JSON) .content("{\"configuredLevel\":\"DEBUG\"}")) @@ -125,11 +137,11 @@ public class LoggersMvcEndpointTests { verifyZeroInteractions(this.loggingSystem); } + @Configuration @Import({ JacksonAutoConfiguration.class, HttpMessageConvertersAutoConfiguration.class, EndpointWebMvcAutoConfiguration.class, WebMvcAutoConfiguration.class, ManagementServerPropertiesAutoConfiguration.class }) - @Configuration public static class TestConfiguration { @Bean diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/AbstractLoggingSystem.java b/spring-boot/src/main/java/org/springframework/boot/logging/AbstractLoggingSystem.java index d89f445062..d3521e2ced 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/AbstractLoggingSystem.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/AbstractLoggingSystem.java @@ -16,6 +16,9 @@ package org.springframework.boot.logging; +import java.util.HashMap; +import java.util.Map; + import org.springframework.core.env.Environment; import org.springframework.core.io.ClassPathResource; import org.springframework.util.ClassUtils; @@ -173,4 +176,34 @@ public abstract class AbstractLoggingSystem extends LoggingSystem { new LoggingSystemProperties(environment).apply(logFile); } + /** + * Maintains a mapping between native levels and {@link LogLevel}. + * @param The native level type + */ + protected static class LogLevels { + + private final Map systemToNative; + + private final Map nativeToSystem; + + public LogLevels() { + this.systemToNative = new HashMap(); + this.nativeToSystem = new HashMap(); + } + + public void map(LogLevel system, T nativeLevel) { + this.systemToNative.put(system, nativeLevel); + this.nativeToSystem.put(nativeLevel, system); + } + + public LogLevel convertNativeToSystem(T level) { + return this.nativeToSystem.get(level); + } + + public T convertSystemToNative(LogLevel level) { + return this.systemToNative.get(level); + } + + } + } diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfiguration.java b/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfiguration.java index 7b695c2520..4172df641e 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfiguration.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfiguration.java @@ -25,14 +25,14 @@ import org.springframework.util.ObjectUtils; * @author Ben Hale * @since 1.5.0 */ -public class LoggerConfiguration { +public final class LoggerConfiguration { + + private final String name; private final LogLevel configuredLevel; private final LogLevel effectiveLevel; - private final String name; - /** * Create a new {@link LoggerConfiguration instance}. * @param name the name of the logger diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfigurationComparator.java b/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfigurationComparator.java index d40b7478ac..ae0cb44095 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfigurationComparator.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/LoggerConfigurationComparator.java @@ -45,11 +45,9 @@ public class LoggerConfigurationComparator implements Comparator listLoggerConfigurations() { - throw new UnsupportedOperationException( - "Listing logger configurations is not supported"); + public List getLoggerConfigurations() { + throw new UnsupportedOperationException("Unable to get logger configurations"); } /** - * Sets the logging level for a given logger. - * @param loggerName the name of the logger to set - * @param level the log level + * Returns the current configuration for a {@link LoggingSystem}'s logger. + * @param loggerName the name of the logger + * @return the current configuration + * @since 1.5.0 */ - public abstract void setLogLevel(String loggerName, LogLevel level); + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + throw new UnsupportedOperationException("Unable to get logger configuration"); + } /** * Detect and return the logging system in use. Supports Logback and Java Logging. @@ -164,18 +166,18 @@ public abstract class LoggingSystem { } @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return null; + public void setLogLevel(String loggerName, LogLevel level) { + } @Override - public Collection listLoggerConfigurations() { + public List getLoggerConfigurations() { return Collections.emptyList(); } @Override - public void setLogLevel(String loggerName, LogLevel level) { - + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + return null; } } diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/java/JavaLoggingSystem.java b/spring-boot/src/main/java/org/springframework/boot/logging/java/JavaLoggingSystem.java index 74a09cb7ea..d23a99d337 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/java/JavaLoggingSystem.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/java/JavaLoggingSystem.java @@ -19,12 +19,9 @@ package org.springframework.boot.logging.java; import java.io.ByteArrayInputStream; import java.io.InputStreamReader; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; import java.util.Enumeration; -import java.util.HashMap; import java.util.List; -import java.util.Map; import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.Logger; @@ -51,29 +48,19 @@ import org.springframework.util.StringUtils; */ public class JavaLoggingSystem extends AbstractLoggingSystem { - private static final LoggerConfigurationComparator COMPARATOR = - new LoggerConfigurationComparator(""); + private static final LoggerConfigurationComparator COMPARATOR = new LoggerConfigurationComparator( + ""); - private static final Map LEVELS; - - private static final Map LOG_LEVELS; + private static final LogLevels LEVELS = new LogLevels(); static { - Map levels = new HashMap(); - levels.put(LogLevel.TRACE, Level.FINEST); - levels.put(LogLevel.DEBUG, Level.FINE); - levels.put(LogLevel.INFO, Level.INFO); - levels.put(LogLevel.WARN, Level.WARNING); - levels.put(LogLevel.ERROR, Level.SEVERE); - levels.put(LogLevel.FATAL, Level.SEVERE); - levels.put(LogLevel.OFF, Level.OFF); - LEVELS = Collections.unmodifiableMap(levels); - - Map logLevels = new HashMap(); - for (Map.Entry entry : LEVELS.entrySet()) { - logLevels.put(entry.getValue(), entry.getKey()); - } - LOG_LEVELS = Collections.unmodifiableMap(logLevels); + LEVELS.map(LogLevel.TRACE, Level.FINEST); + LEVELS.map(LogLevel.DEBUG, Level.FINE); + LEVELS.map(LogLevel.INFO, Level.INFO); + LEVELS.map(LogLevel.WARN, Level.WARNING); + LEVELS.map(LogLevel.ERROR, Level.SEVERE); + LEVELS.map(LogLevel.FATAL, Level.SEVERE); + LEVELS.map(LogLevel.OFF, Level.OFF); } public JavaLoggingSystem(ClassLoader classLoader) { @@ -126,44 +113,39 @@ public class JavaLoggingSystem extends AbstractLoggingSystem { } } - @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return toLoggerConfiguration(Logger.getLogger(loggerName)); - } - - @Override - public Collection listLoggerConfigurations() { - List result = new ArrayList(); - for (Enumeration loggerNames = - LogManager.getLogManager().getLoggerNames(); - loggerNames.hasMoreElements(); ) { - result.add(toLoggerConfiguration(Logger.getLogger( - loggerNames.nextElement()))); - } - Collections.sort(result, COMPARATOR); - return result; - } - @Override public void setLogLevel(String loggerName, LogLevel level) { Assert.notNull(level, "Level must not be null"); String name = (StringUtils.hasText(loggerName) ? loggerName : ""); Logger logger = Logger.getLogger(name); - logger.setLevel(LEVELS.get(level)); + if (logger != null) { + logger.setLevel(LEVELS.convertSystemToNative(level)); + } } @Override - public Runnable getShutdownHandler() { - return new ShutdownHandler(); + public List getLoggerConfigurations() { + List result = new ArrayList(); + Enumeration names = LogManager.getLogManager().getLoggerNames(); + while (names.hasMoreElements()) { + result.add(getLoggerConfiguration(names.nextElement())); + } + Collections.sort(result, COMPARATOR); + return Collections.unmodifiableList(result); } - private static LoggerConfiguration toLoggerConfiguration(Logger logger) { - return new LoggerConfiguration(logger.getName(), - LOG_LEVELS.get(logger.getLevel()), - LOG_LEVELS.get(getEffectiveLevel(logger))); + @Override + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + Logger logger = Logger.getLogger(loggerName); + if (logger == null) { + return null; + } + LogLevel level = LEVELS.convertNativeToSystem(logger.getLevel()); + LogLevel effectiveLevel = LEVELS.convertNativeToSystem(getEffectiveLevel(logger)); + return new LoggerConfiguration(logger.getName(), level, effectiveLevel); } - private static Level getEffectiveLevel(Logger root) { + private Level getEffectiveLevel(Logger root) { Logger logger = root; while (logger.getLevel() == null) { logger = logger.getParent(); @@ -171,6 +153,11 @@ public class JavaLoggingSystem extends AbstractLoggingSystem { return logger.getLevel(); } + @Override + public Runnable getShutdownHandler() { + return new ShutdownHandler(); + } + private final class ShutdownHandler implements Runnable { @Override diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java b/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java index 9e232d6569..999daf16cb 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java @@ -20,11 +20,8 @@ import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; -import java.util.HashMap; import java.util.List; -import java.util.Map; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; @@ -33,6 +30,7 @@ import org.apache.logging.log4j.core.Filter; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.Logger; import org.apache.logging.log4j.core.LoggerContext; +import org.apache.logging.log4j.core.config.Configuration; import org.apache.logging.log4j.core.config.ConfigurationFactory; import org.apache.logging.log4j.core.config.ConfigurationSource; import org.apache.logging.log4j.core.config.LoggerConfig; @@ -62,31 +60,21 @@ import org.springframework.util.StringUtils; */ public class Log4J2LoggingSystem extends Slf4JLoggingSystem { - private static final LoggerConfigurationComparator COMPARATOR = - new LoggerConfigurationComparator(LogManager.ROOT_LOGGER_NAME); + private static final LoggerConfigurationComparator COMPARATOR = new LoggerConfigurationComparator( + LogManager.ROOT_LOGGER_NAME); private static final String FILE_PROTOCOL = "file"; - private static final Map LEVELS; - - private static final Map LOG_LEVELS; + private static final LogLevels LEVELS = new LogLevels(); static { - Map levels = new HashMap(); - levels.put(LogLevel.TRACE, Level.TRACE); - levels.put(LogLevel.DEBUG, Level.DEBUG); - levels.put(LogLevel.INFO, Level.INFO); - levels.put(LogLevel.WARN, Level.WARN); - levels.put(LogLevel.ERROR, Level.ERROR); - levels.put(LogLevel.FATAL, Level.FATAL); - levels.put(LogLevel.OFF, Level.OFF); - LEVELS = Collections.unmodifiableMap(levels); - - Map logLevels = new HashMap(); - for (Map.Entry entry : LEVELS.entrySet()) { - logLevels.put(entry.getValue(), entry.getKey()); - } - LOG_LEVELS = Collections.unmodifiableMap(logLevels); + LEVELS.map(LogLevel.TRACE, Level.TRACE); + LEVELS.map(LogLevel.DEBUG, Level.DEBUG); + LEVELS.map(LogLevel.INFO, Level.INFO); + LEVELS.map(LogLevel.WARN, Level.WARN); + LEVELS.map(LogLevel.ERROR, Level.ERROR); + LEVELS.map(LogLevel.FATAL, Level.FATAL); + LEVELS.map(LogLevel.OFF, Level.OFF); } private static final Filter FILTER = new AbstractFilter() { @@ -210,33 +198,41 @@ public class Log4J2LoggingSystem extends Slf4JLoggingSystem { } @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return toLoggerConfiguration(getLoggerConfig(loggerName)); + public void setLogLevel(String loggerName, LogLevel logLevel) { + Level level = LEVELS.convertSystemToNative(logLevel); + LoggerConfig loggerConfig = getLoggerConfig(loggerName); + if (loggerConfig == null) { + loggerConfig = new LoggerConfig(loggerName, level, true); + getLoggerContext().getConfiguration().addLogger(loggerName, loggerConfig); + } + else { + loggerConfig.setLevel(level); + } + getLoggerContext().updateLoggers(); } @Override - public Collection listLoggerConfigurations() { + public List getLoggerConfigurations() { List result = new ArrayList(); - for (LoggerConfig loggerConfig : - getLoggerContext().getConfiguration().getLoggers().values()) { - result.add(toLoggerConfiguration(loggerConfig)); + Configuration configuration = getLoggerContext().getConfiguration(); + for (LoggerConfig loggerConfig : configuration.getLoggers().values()) { + result.add(convertLoggerConfiguration(loggerConfig)); } Collections.sort(result, COMPARATOR); return result; } @Override - public void setLogLevel(String loggerName, LogLevel logLevel) { - Level level = LEVELS.get(logLevel); - LoggerConfig loggerConfig = getLoggerConfig(loggerName); + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + return convertLoggerConfiguration(getLoggerConfig(loggerName)); + } + + private LoggerConfiguration convertLoggerConfiguration(LoggerConfig loggerConfig) { if (loggerConfig == null) { - loggerConfig = new LoggerConfig(loggerName, level, true); - getLoggerContext().getConfiguration().addLogger(loggerName, loggerConfig); + return null; } - else { - loggerConfig.setLevel(level); - } - getLoggerContext().updateLoggers(); + LogLevel level = LEVELS.convertNativeToSystem(loggerConfig.getLevel()); + return new LoggerConfiguration(loggerConfig.getName(), level, level); } @Override @@ -272,12 +268,6 @@ public class Log4J2LoggingSystem extends Slf4JLoggingSystem { loggerContext.setExternalContext(null); } - private static LoggerConfiguration toLoggerConfiguration(LoggerConfig loggerConfig) { - return new LoggerConfiguration(loggerConfig.getName(), - LOG_LEVELS.get(loggerConfig.getLevel()), - LOG_LEVELS.get(loggerConfig.getLevel())); - } - private final class ShutdownHandler implements Runnable { @Override diff --git a/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java b/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java index f32cf80b9b..f58ba8f57e 100644 --- a/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java +++ b/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java @@ -20,11 +20,8 @@ import java.net.URL; import java.security.CodeSource; import java.security.ProtectionDomain; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; -import java.util.HashMap; import java.util.List; -import java.util.Map; import ch.qos.logback.classic.Level; import ch.qos.logback.classic.LoggerContext; @@ -61,31 +58,21 @@ import org.springframework.util.StringUtils; */ public class LogbackLoggingSystem extends Slf4JLoggingSystem { - private static final LoggerConfigurationComparator COMPARATOR = - new LoggerConfigurationComparator(Logger.ROOT_LOGGER_NAME); + private static final LoggerConfigurationComparator COMPARATOR = new LoggerConfigurationComparator( + Logger.ROOT_LOGGER_NAME); private static final String CONFIGURATION_FILE_PROPERTY = "logback.configurationFile"; - private static final Map LEVELS; - - private static final Map LOG_LEVELS; + private static final LogLevels LEVELS = new LogLevels(); static { - Map levels = new HashMap(); - levels.put(LogLevel.TRACE, Level.TRACE); - levels.put(LogLevel.DEBUG, Level.DEBUG); - levels.put(LogLevel.INFO, Level.INFO); - levels.put(LogLevel.WARN, Level.WARN); - levels.put(LogLevel.ERROR, Level.ERROR); - levels.put(LogLevel.FATAL, Level.ERROR); - levels.put(LogLevel.OFF, Level.OFF); - LEVELS = Collections.unmodifiableMap(levels); - - Map logLevels = new HashMap(); - for (Map.Entry entry : LEVELS.entrySet()) { - logLevels.put(entry.getValue(), entry.getKey()); - } - LOG_LEVELS = Collections.unmodifiableMap(logLevels); + LEVELS.map(LogLevel.TRACE, Level.TRACE); + LEVELS.map(LogLevel.DEBUG, Level.DEBUG); + LEVELS.map(LogLevel.INFO, Level.INFO); + LEVELS.map(LogLevel.WARN, Level.WARN); + LEVELS.map(LogLevel.ERROR, Level.ERROR); + LEVELS.map(LogLevel.FATAL, Level.ERROR); + LEVELS.map(LogLevel.OFF, Level.OFF); } private static final TurboFilter FILTER = new TurboFilter() { @@ -226,23 +213,37 @@ public class LogbackLoggingSystem extends Slf4JLoggingSystem { } @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return toLoggerConfiguration(getLogger(loggerName)); - } - - @Override - public Collection listLoggerConfigurations() { + public List getLoggerConfigurations() { List result = new ArrayList(); for (ch.qos.logback.classic.Logger logger : getLoggerContext().getLoggerList()) { - result.add(toLoggerConfiguration(logger)); + result.add(getLoggerConfiguration(logger)); } Collections.sort(result, COMPARATOR); return result; } + @Override + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + return getLoggerConfiguration(getLogger(loggerName)); + } + + private LoggerConfiguration getLoggerConfiguration( + ch.qos.logback.classic.Logger logger) { + if (logger == null) { + return null; + } + LogLevel level = LEVELS.convertNativeToSystem(logger.getLevel()); + LogLevel effectiveLevel = LEVELS + .convertNativeToSystem(logger.getEffectiveLevel()); + return new LoggerConfiguration(logger.getName(), level, effectiveLevel); + } + @Override public void setLogLevel(String loggerName, LogLevel level) { - getLogger(loggerName).setLevel(LEVELS.get(level)); + ch.qos.logback.classic.Logger logger = getLogger(loggerName); + if (logger != null) { + logger.setLevel(LEVELS.convertSystemToNative(level)); + } } @Override @@ -252,8 +253,8 @@ public class LogbackLoggingSystem extends Slf4JLoggingSystem { private ch.qos.logback.classic.Logger getLogger(String name) { LoggerContext factory = getLoggerContext(); - return factory - .getLogger(StringUtils.isEmpty(name) ? Logger.ROOT_LOGGER_NAME : name); + name = (StringUtils.isEmpty(name) ? Logger.ROOT_LOGGER_NAME : name); + return factory.getLogger(name); } @@ -296,13 +297,6 @@ public class LogbackLoggingSystem extends Slf4JLoggingSystem { loggerContext.removeObject(LoggingSystem.class.getName()); } - private static LoggerConfiguration toLoggerConfiguration( - ch.qos.logback.classic.Logger logger) { - return new LoggerConfiguration(logger.getName(), - LOG_LEVELS.get(logger.getLevel()), - LOG_LEVELS.get(logger.getEffectiveLevel())); - } - private final class ShutdownHandler implements Runnable { @Override diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/LoggerConfigurationComparatorTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/LoggerConfigurationComparatorTests.java index 1a3cb4f765..8c7188f28c 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/LoggerConfigurationComparatorTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/LoggerConfigurationComparatorTests.java @@ -27,8 +27,8 @@ import static org.assertj.core.api.Assertions.assertThat; */ public class LoggerConfigurationComparatorTests { - private final LoggerConfigurationComparator comparator = - new LoggerConfigurationComparator("ROOT"); + private final LoggerConfigurationComparator comparator = new LoggerConfigurationComparator( + "ROOT"); @Test public void rootLoggerFirst() { diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/LoggingApplicationListenerTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/LoggingApplicationListenerTests.java index b6c6ff2465..cbc2647c68 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/LoggingApplicationListenerTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/LoggingApplicationListenerTests.java @@ -18,7 +18,7 @@ package org.springframework.boot.logging; import java.io.File; import java.io.IOException; -import java.util.Collection; +import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.logging.Handler; @@ -519,18 +519,17 @@ public class LoggingApplicationListenerTests { } @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return null; + public void setLogLevel(String loggerName, LogLevel level) { } @Override - public Collection listLoggerConfigurations() { + public List getLoggerConfigurations() { return null; } @Override - public void setLogLevel(String loggerName, LogLevel level) { - + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + return null; } @Override @@ -564,27 +563,24 @@ public class LoggingApplicationListenerTests { private boolean cleanedUp = false; public TestCleanupLoggingSystem(ClassLoader classLoader) { - } @Override public void beforeInitialize() { - } @Override - public LoggerConfiguration getLoggerConfiguration(String loggerName) { - return null; + public void setLogLevel(String loggerName, LogLevel level) { } @Override - public Collection listLoggerConfigurations() { + public List getLoggerConfigurations() { return null; } @Override - public void setLogLevel(String loggerName, LogLevel level) { - + public LoggerConfiguration getLoggerConfiguration(String loggerName) { + return null; } @Override diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/LoggingSystemTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/LoggingSystemTests.java index 735e5814a4..aa3625b92b 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/LoggingSystemTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/LoggingSystemTests.java @@ -49,7 +49,7 @@ public class LoggingSystemTests { @Test(expected = UnsupportedOperationException.class) public void listLoggerConfigurationsIsUnsupported() { - new StubLoggingSystem().listLoggerConfigurations(); + new StubLoggingSystem().getLoggerConfigurations(); } private static final class StubLoggingSystem extends LoggingSystem { diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/java/JavaLoggingSystemTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/java/JavaLoggingSystemTests.java index a624c50b05..12eb04eb9c 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/java/JavaLoggingSystemTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/java/JavaLoggingSystemTests.java @@ -19,7 +19,7 @@ package org.springframework.boot.logging.java; import java.io.File; import java.io.FileFilter; import java.io.IOException; -import java.util.Collection; +import java.util.List; import java.util.Locale; import java.util.logging.Level; @@ -149,35 +149,36 @@ public class JavaLoggingSystemTests extends AbstractLoggingSystemTests { } @Test - public void getLoggingConfiguration() throws Exception { + public void setLevel() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); - this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - assertThat(this.loggingSystem.getLoggerConfiguration(getClass().getName())) - .isEqualTo(new LoggerConfiguration(getClass().getName(), - LogLevel.DEBUG, LogLevel.DEBUG)); + this.logger.debug("Hello"); + this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); + this.logger.debug("Hello"); + assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) + .isEqualTo(1); } @Test - public void listLoggingConfigurations() throws Exception { + public void getLoggingConfigurations() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - Collection loggerConfigurations = this.loggingSystem - .listLoggerConfigurations(); - assertThat(loggerConfigurations.size()).isGreaterThan(0); - assertThat(loggerConfigurations.iterator().next().getName()).isEmpty(); + List configurations = this.loggingSystem + .getLoggerConfigurations(); + assertThat(configurations).isNotEmpty(); + assertThat(configurations.get(0).getName()).isEmpty(); } @Test - public void setLevel() throws Exception { + public void getLoggingConfiguration() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); - this.logger.debug("Hello"); - this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); - this.logger.debug("Hello"); - assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) - .isEqualTo(1); + this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); + LoggerConfiguration configuration = this.loggingSystem + .getLoggerConfiguration(getClass().getName()); + assertThat(configuration).isEqualTo(new LoggerConfiguration(getClass().getName(), + LogLevel.DEBUG, LogLevel.DEBUG)); } } diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystemTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystemTests.java index 25de8b8f31..1e06c7c891 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystemTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystemTests.java @@ -21,7 +21,6 @@ import java.beans.PropertyChangeListener; import java.io.File; import java.io.FileReader; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; import java.util.List; @@ -124,35 +123,36 @@ public class Log4J2LoggingSystemTests extends AbstractLoggingSystemTests { } @Test - public void getLoggingConfiguration() throws Exception { + public void setLevel() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); - this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - assertThat(this.loggingSystem.getLoggerConfiguration(getClass().getName())) - .isEqualTo(new LoggerConfiguration(getClass().getName(), - LogLevel.DEBUG, LogLevel.DEBUG)); + this.logger.debug("Hello"); + this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); + this.logger.debug("Hello"); + assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) + .isEqualTo(1); } @Test - public void listLoggingConfigurations() throws Exception { + public void getLoggingConfigurations() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - Collection loggerConfigurations = this.loggingSystem - .listLoggerConfigurations(); - assertThat(loggerConfigurations.size()).isGreaterThan(0); - assertThat(loggerConfigurations.iterator().next().getName()).isEmpty(); + List configurations = this.loggingSystem + .getLoggerConfigurations(); + assertThat(configurations).isNotEmpty(); + assertThat(configurations.get(0).getName()).isEmpty(); } @Test - public void setLevel() throws Exception { + public void getLoggingConfiguration() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(null, null, null); - this.logger.debug("Hello"); - this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); - this.logger.debug("Hello"); - assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) - .isEqualTo(1); + this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); + LoggerConfiguration configuration = this.loggingSystem + .getLoggerConfiguration(getClass().getName()); + assertThat(configuration).isEqualTo(new LoggerConfiguration(getClass().getName(), + LogLevel.DEBUG, LogLevel.DEBUG)); } @Test diff --git a/spring-boot/src/test/java/org/springframework/boot/logging/logback/LogbackLoggingSystemTests.java b/spring-boot/src/test/java/org/springframework/boot/logging/logback/LogbackLoggingSystemTests.java index 83a8fd60cb..072b9b8210 100644 --- a/spring-boot/src/test/java/org/springframework/boot/logging/logback/LogbackLoggingSystemTests.java +++ b/spring-boot/src/test/java/org/springframework/boot/logging/logback/LogbackLoggingSystemTests.java @@ -18,7 +18,7 @@ package org.springframework.boot.logging.logback; import java.io.File; import java.io.FileReader; -import java.util.Collection; +import java.util.List; import java.util.logging.Handler; import java.util.logging.LogManager; @@ -163,36 +163,37 @@ public class LogbackLoggingSystemTests extends AbstractLoggingSystemTests { } @Test - public void getLoggingConfiguration() throws Exception { + public void setLevel() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(this.initializationContext, null, null); - this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - assertThat(this.loggingSystem.getLoggerConfiguration(getClass().getName())) - .isEqualTo(new LoggerConfiguration(getClass().getName(), - LogLevel.DEBUG, LogLevel.DEBUG)); + this.logger.debug("Hello"); + this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); + this.logger.debug("Hello"); + assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) + .isEqualTo(1); } @Test - public void listLoggingConfigurations() throws Exception { + public void getLoggingConfigurations() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(this.initializationContext, null, null); this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); - Collection loggerConfigurations = this.loggingSystem - .listLoggerConfigurations(); - assertThat(loggerConfigurations.size()).isGreaterThan(0); - assertThat(loggerConfigurations.iterator().next().getName()).isEqualTo( - org.slf4j.Logger.ROOT_LOGGER_NAME); + List configurations = this.loggingSystem + .getLoggerConfigurations(); + assertThat(configurations).isNotEmpty(); + assertThat(configurations.get(0).getName()) + .isEqualTo(org.slf4j.Logger.ROOT_LOGGER_NAME); } @Test - public void setLevel() throws Exception { + public void getLoggingConfiguration() throws Exception { this.loggingSystem.beforeInitialize(); this.loggingSystem.initialize(this.initializationContext, null, null); - this.logger.debug("Hello"); - this.loggingSystem.setLogLevel("org.springframework.boot", LogLevel.DEBUG); - this.logger.debug("Hello"); - assertThat(StringUtils.countOccurrencesOf(this.output.toString(), "Hello")) - .isEqualTo(1); + this.loggingSystem.setLogLevel(getClass().getName(), LogLevel.DEBUG); + LoggerConfiguration configuration = this.loggingSystem + .getLoggerConfiguration(getClass().getName()); + assertThat(configuration).isEqualTo(new LoggerConfiguration(getClass().getName(), + LogLevel.DEBUG, LogLevel.DEBUG)); } @Test