This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch 2.x
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
The following commit(s) were added to refs/heads/2.x by this push:
new f53fca1455 Fix behavior of `CoreLogger#getLevel`
f53fca1455 is described below
commit f53fca145576336f47f8e39eba66e2d6532a17ea
Author: Piotr P. Karwasz <[email protected]>
AuthorDate: Sat Feb 17 08:37:53 2024 +0100
Fix behavior of `CoreLogger#getLevel`
---
.../org/apache/logging/log4j/jul/ApiLogger.java | 15 ++-
.../org/apache/logging/log4j/jul/CoreLogger.java | 11 +-
.../logging/log4j/jul/test/CoreLoggerTest.java | 128 ++++++++++-----------
src/changelog/.2.x.x/2282_fix_jul_set_level.xml | 2 +-
4 files changed, 79 insertions(+), 77 deletions(-)
diff --git
a/log4j-jul/src/main/java/org/apache/logging/log4j/jul/ApiLogger.java
b/log4j-jul/src/main/java/org/apache/logging/log4j/jul/ApiLogger.java
index eee946fc8c..d971819486 100644
--- a/log4j-jul/src/main/java/org/apache/logging/log4j/jul/ApiLogger.java
+++ b/log4j-jul/src/main/java/org/apache/logging/log4j/jul/ApiLogger.java
@@ -16,8 +16,6 @@
*/
package org.apache.logging.log4j.jul;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
@@ -48,12 +46,6 @@ public class ApiLogger extends Logger {
ApiLogger(final ExtendedLogger logger) {
super(logger.getName(), null);
- final Level javaLevel = LevelTranslator.toJavaLevel(logger.getLevel());
- // "java.util.logging.LoggingPermission" "control"
- AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
- ApiLogger.super.setLevel(javaLevel);
- return null;
- });
this.logger = new WrappedLogger(logger);
}
@@ -88,6 +80,13 @@ public class ApiLogger extends Logger {
return logger.getName();
}
+ @Override
+ public Level getLevel() {
+ // Returns the effective level instead of the configured one.
+ // The configured level is not accessible through Log4j API.
+ return LevelTranslator.toJavaLevel(logger.getLevel());
+ }
+
@Override
public void setLevel(final Level newLevel) throws SecurityException {
StatusLogger.getLogger()
diff --git
a/log4j-jul/src/main/java/org/apache/logging/log4j/jul/CoreLogger.java
b/log4j-jul/src/main/java/org/apache/logging/log4j/jul/CoreLogger.java
index 02c2007d35..c634ea1a6d 100644
--- a/log4j-jul/src/main/java/org/apache/logging/log4j/jul/CoreLogger.java
+++ b/log4j-jul/src/main/java/org/apache/logging/log4j/jul/CoreLogger.java
@@ -19,6 +19,7 @@ package org.apache.logging.log4j.jul;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.LoggerConfig;
/**
* Log4j Core implementation of the JUL {@link Logger} class. <strong>Note
that this implementation does
@@ -42,9 +43,17 @@ public class CoreLogger extends ApiLogger {
this.logger = logger;
}
+ @Override
+ public Level getLevel() {
+ final LoggerConfig config = logger.get();
+ return config.getName().equals(logger.getName())
+ ? LevelTranslator.toJavaLevel(config.getExplicitLevel())
+ : null;
+ }
+
@Override
public void setLevel(final Level level) throws SecurityException {
- super.doSetLevel(level); // checks permissions
+ doSetLevel(level); // checks permissions
Configurator.setLevel(logger, LevelTranslator.toLevel(level));
}
diff --git
a/log4j-jul/src/test/java/org/apache/logging/log4j/jul/test/CoreLoggerTest.java
b/log4j-jul/src/test/java/org/apache/logging/log4j/jul/test/CoreLoggerTest.java
index d554758a4f..fe84f4280c 100644
---
a/log4j-jul/src/test/java/org/apache/logging/log4j/jul/test/CoreLoggerTest.java
+++
b/log4j-jul/src/test/java/org/apache/logging/log4j/jul/test/CoreLoggerTest.java
@@ -16,15 +16,11 @@
*/
package org.apache.logging.log4j.jul.test;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.logging.Level;
import java.util.logging.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.apache.logging.log4j.jul.LogManager;
import org.apache.logging.log4j.util.Strings;
@@ -36,6 +32,27 @@ import org.junit.Test;
public class CoreLoggerTest extends AbstractLoggerTest {
+ private static final Level[] LEVELS = new Level[] {
+ Level.ALL,
+ Level.FINEST,
+ Level.FINER,
+ Level.FINE,
+ Level.CONFIG,
+ Level.INFO,
+ Level.WARNING,
+ Level.SEVERE,
+ Level.OFF
+ };
+
+ private static Level getEffectiveLevel(final Logger logger) {
+ for (final Level level : LEVELS) {
+ if (logger.isLoggable(level)) {
+ return level;
+ }
+ }
+ throw new RuntimeException("No level is enabled.");
+ }
+
@BeforeClass
public static void setUpClass() {
System.setProperty("java.util.logging.manager",
LogManager.class.getName());
@@ -47,21 +64,23 @@ public class CoreLoggerTest extends AbstractLoggerTest {
}
@Before
- public void setUp() throws Exception {
- LogManager.getLogManager().reset();
+ public void setUp() {
+ // Reset the logger context
+ LoggerContext.getContext(false).reconfigure();
+
logger = Logger.getLogger(LOGGER_NAME);
logger.setFilter(null);
- assertThat(logger.getLevel(), equalTo(Level.FINE));
+ assertThat(logger.getLevel()).isEqualTo(Level.FINE);
eventAppender = ListAppender.getListAppender("TestAppender");
flowAppender = ListAppender.getListAppender("FlowAppender");
stringAppender = ListAppender.getListAppender("StringAppender");
- assertNotNull(eventAppender);
- assertNotNull(flowAppender);
- assertNotNull(stringAppender);
+ assertThat(eventAppender).isNotNull();
+ assertThat(flowAppender).isNotNull();
+ assertThat(stringAppender).isNotNull();
}
@After
- public void tearDown() throws Exception {
+ public void tearDown() {
if (eventAppender != null) {
eventAppender.clear();
}
@@ -74,82 +93,57 @@ public class CoreLoggerTest extends AbstractLoggerTest {
}
@Test
- public void testRootSetLevelToNull() throws Exception {
+ public void testRootSetLevelToNull() {
final Logger rootLogger = Logger.getLogger(Strings.EMPTY);
- assertThat(rootLogger.getLevel(), equalTo(Level.SEVERE));
- assertThat(rootLogger.isLoggable(Level.SEVERE), is(true));
+ assertThat(rootLogger.getLevel()).isEqualTo(Level.SEVERE);
+ assertThat(getEffectiveLevel(rootLogger)).isEqualTo(Level.SEVERE);
// null test
rootLogger.setLevel(null);
- assertThat(rootLogger.getLevel(), equalTo(null));
- assertThat(rootLogger.isLoggable(Level.SEVERE), is(true));
+ assertThat(rootLogger.getLevel()).isNull();
+ assertThat(getEffectiveLevel(rootLogger)).isEqualTo(Level.SEVERE);
// now go back to a different one
rootLogger.setLevel(Level.INFO);
- assertThat(rootLogger.getLevel(), equalTo(Level.INFO));
- assertThat(rootLogger.isLoggable(Level.FINE), is(false));
+ assertThat(rootLogger.getLevel()).isEqualTo(Level.INFO);
+ assertThat(getEffectiveLevel(rootLogger)).isEqualTo(Level.INFO);
}
@Test
- public void testSetLevel() throws Exception {
- final Logger childLogger = Logger.getLogger(LOGGER_NAME + ".Child");
- assertThat(childLogger.getLevel(), equalTo(Level.FINE));
- logger.setLevel(Level.SEVERE);
- assertThat(childLogger.getLevel(), equalTo(Level.FINE));
- assertThat(logger.getLevel(), equalTo(Level.SEVERE));
- logger.setLevel(Level.FINER);
- assertThat(logger.getLevel(), equalTo(Level.FINER));
- logger.setLevel(Level.FINE);
- assertThat(logger.getLevel(), equalTo(Level.FINE));
- assertThat(childLogger.getLevel(), equalTo(Level.FINE));
- assertThat(childLogger.isLoggable(Level.ALL), is(false));
- }
-
- @Test
- public void testSetLevelIssue2281() {
+ public void testSetLevel() {
final Logger a = Logger.getLogger("a");
final Logger a_b = Logger.getLogger("a.b");
final Logger a_b_c = Logger.getLogger("a.b.c");
// test default for this test
- assertEquals(Level.INFO, a.getLevel());
- assertEquals(Level.INFO, a_b.getLevel());
- assertEquals(Level.INFO, a_b_c.getLevel());
+ assertThat(a.getLevel()).isNull();
+ assertThat(a_b.getLevel()).isNull();
+ assertThat(a_b_c.getLevel()).isNull();
// all levels
- final Level[] levels = new Level[] {
- Level.OFF,
- Level.SEVERE,
- Level.WARNING,
- Level.INFO,
- Level.CONFIG,
- Level.FINE,
- Level.FINER,
- Level.FINEST,
- Level.ALL
- };
- for (int i = 0; i < levels.length - 1; i++) {
- final Level level = levels[i];
- final Level nextLevel = levels[i + 1];
+ for (final Level level : LEVELS) {
a.setLevel(level);
- assertEquals(level, a.getLevel());
- assertTrue(a.isLoggable(level) && !a.isLoggable(nextLevel));
- assertTrue(a_b.isLoggable(level) && !a.isLoggable(nextLevel));
- assertTrue(a_b_c.isLoggable(level) && !a.isLoggable(nextLevel));
+ assertThat(a.getLevel()).isEqualTo(level);
+ assertThat(getEffectiveLevel(a)).isEqualTo(level);
+ assertThat(a_b.getLevel()).isNull();
+ assertThat(getEffectiveLevel(a_b)).isEqualTo(level);
+ assertThat(a_b_c.getLevel()).isNull();
+ assertThat(getEffectiveLevel(a_b_c)).isEqualTo(level);
}
}
@Test
- public void testSetLevelToNull() throws Exception {
+ public void testSetLevelToNull() {
final Logger childLogger = Logger.getLogger(LOGGER_NAME +
".NullChild");
- assertThat(childLogger.getLevel(), equalTo(Level.FINE));
- assertThat(childLogger.isLoggable(Level.FINE), is(true));
+ assertThat(childLogger.getLevel()).isNull();
+ assertThat(getEffectiveLevel(childLogger)).isEqualTo(Level.FINE);
+ // Set explicit level
childLogger.setLevel(Level.SEVERE);
- assertThat(childLogger.getLevel(), equalTo(Level.SEVERE));
- assertThat(childLogger.isLoggable(Level.FINE), is(false));
- // null test
+ assertThat(childLogger.getLevel()).isEqualTo(Level.SEVERE);
+ assertThat(getEffectiveLevel(childLogger)).isEqualTo(Level.SEVERE);
+ // Set null level
childLogger.setLevel(null);
- assertThat(childLogger.getLevel(), equalTo(null));
- assertThat(childLogger.isLoggable(Level.FINE), is(true));
+ assertThat(childLogger.getLevel()).isNull();
+ assertThat(getEffectiveLevel(childLogger)).isEqualTo(Level.FINE);
// now go back
childLogger.setLevel(Level.SEVERE);
- assertThat(childLogger.getLevel(), equalTo(Level.SEVERE));
- assertThat(childLogger.isLoggable(Level.FINE), is(false));
+ assertThat(childLogger.getLevel()).isEqualTo(Level.SEVERE);
+ assertThat(getEffectiveLevel(childLogger)).isEqualTo(Level.SEVERE);
}
}
diff --git a/src/changelog/.2.x.x/2282_fix_jul_set_level.xml
b/src/changelog/.2.x.x/2282_fix_jul_set_level.xml
index 66f6e1e51e..2bfd93867e 100644
--- a/src/changelog/.2.x.x/2282_fix_jul_set_level.xml
+++ b/src/changelog/.2.x.x/2282_fix_jul_set_level.xml
@@ -5,6 +5,6 @@
type="fixed">
<issue id="2282"
link="https://github.com/apache/logging-log4j2/issues/2282"/>
<description format="asciidoc">
- Fix the behavior of `CoreLogger#setLevel` in the log4j-jul module.
+ Fix the behavior of `CoreLogger#getLevel` and `CoreLogger#setLevel` in the
`log4j-jul` module.
</description>
</entry>
