Remove log4j2.enable.threadlocals property

Author: vy

log4j-1.2-api/src/main/java/org/apache/log4j/layout/Log4j1SyslogLayout.java

@@ -146,7 +146,7 @@ public static <B extends Builder<B>> B newBuilder() {
      */
     private static final String[] dateFormatOptions = {"MMM dd HH:mm:ss", null, "en"};
 
-    private final LogEventPatternConverter dateConverter = DatePatternConverter.newInstance(dateFormatOptions);
+    private final LogEventPatternConverter dateConverter;
 
     private Log4j1SyslogLayout(
             final Configuration config,
@@ -160,6 +160,7 @@ private Log4j1SyslogLayout(
         this.facilityPrinting = facilityPrinting;
         this.header = header;
         this.messageLayout = messageLayout;
+        this.dateConverter = DatePatternConverter.newInstance(config, dateFormatOptions);
     }
 
     /**

log4j-api-test/src/test/java/org/apache/logging/log4j/AbstractLoggerTest.java

@@ -28,7 +28,7 @@
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.message.ObjectMessage;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.logging.log4j.message.ParameterizedMessageFactory;
+import org.apache.logging.log4j.message.ReusableMessageFactory;
 import org.apache.logging.log4j.message.SimpleMessage;
 import org.apache.logging.log4j.spi.AbstractLogger;
 import org.apache.logging.log4j.status.StatusData;
@@ -964,7 +964,7 @@ private static class CountingLogger extends AbstractLogger {
         private int objectCount;
 
         CountingLogger() {
-            super("CountingLogger", ParameterizedMessageFactory.INSTANCE);
+            super("CountingLogger", new ReusableMessageFactory());
         }
 
         void setCurrentLevel(final Level currentLevel) {
@@ -1261,7 +1261,7 @@ private static class ThrowableExpectingLogger extends AbstractLogger {
         private final boolean expectingThrowables;
 
         ThrowableExpectingLogger(final boolean expectingThrowables) {
-            super("ThrowableExpectingLogger", ParameterizedMessageFactory.INSTANCE);
+            super("ThrowableExpectingLogger", new ReusableMessageFactory());
             this.expectingThrowables = expectingThrowables;
         }
 

log4j-api-test/src/test/java/org/apache/logging/log4j/LogManagerTest.java

@@ -21,7 +21,7 @@
 
 import java.io.Closeable;
 import java.io.IOException;
-import org.apache.logging.log4j.message.ParameterizedMessageFactory;
+import org.apache.logging.log4j.message.ReusableMessageFactory;
 import org.apache.logging.log4j.spi.LoggerContext;
 import org.junit.jupiter.api.Test;
 import org.junitpioneer.jupiter.ReadsSystemProperty;
@@ -52,25 +52,26 @@ public void testGetLogger() {
         Logger logger = LogManager.getLogger();
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
-        logger = LogManager.getLogger(ParameterizedMessageFactory.INSTANCE);
+        final ReusableMessageFactory messageFactory = new ReusableMessageFactory();
+        logger = LogManager.getLogger(messageFactory);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
         logger = LogManager.getLogger((Class<?>) null);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
-        logger = LogManager.getLogger((Class<?>) null, ParameterizedMessageFactory.INSTANCE);
+        logger = LogManager.getLogger((Class<?>) null, messageFactory);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
         logger = LogManager.getLogger((String) null);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
-        logger = LogManager.getLogger((String) null, ParameterizedMessageFactory.INSTANCE);
+        logger = LogManager.getLogger((String) null, messageFactory);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
         logger = LogManager.getLogger((Object) null);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
-        logger = LogManager.getLogger((Object) null, ParameterizedMessageFactory.INSTANCE);
+        logger = LogManager.getLogger((Object) null, messageFactory);
         assertNotNull(logger, "No Logger returned");
         assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
     }

log4j-api-test/src/test/java/org/apache/logging/log4j/LoggerTest.java

@@ -34,7 +34,7 @@
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.message.MessageFactory;
 import org.apache.logging.log4j.message.ObjectMessage;
-import org.apache.logging.log4j.message.ParameterizedMessageFactory;
+import org.apache.logging.log4j.message.ReusableMessageFactory;
 import org.apache.logging.log4j.message.SimpleMessage;
 import org.apache.logging.log4j.message.SimpleMessageFactory;
 import org.apache.logging.log4j.message.StringFormatterMessageFactory;
@@ -347,7 +347,7 @@ public void getFormatterLogger_String() {
     public void getLogger_Class_ParameterizedMessageFactory() {
         // The TestLogger logger was already created in an instance variable for this class.
         // The message factory is only used when the logger is created.
-        final ParameterizedMessageFactory messageFactory = ParameterizedMessageFactory.INSTANCE;
+        final MessageFactory messageFactory = new ReusableMessageFactory();
         final TestLogger testLogger =
                 (TestLogger) LogManager.getLogger(TestParameterizedMessageFactory.class, messageFactory);
         assertNotNull(testLogger);
@@ -378,7 +378,7 @@ public void getLogger_Class_StringFormatterMessageFactory() {
     public void getLogger_Object_ParameterizedMessageFactory() {
         // The TestLogger logger was already created in an instance variable for this class.
         // The message factory is only used when the logger is created.
-        final ParameterizedMessageFactory messageFactory = ParameterizedMessageFactory.INSTANCE;
+        final MessageFactory messageFactory = new ReusableMessageFactory();
         final TestLogger testLogger =
                 (TestLogger) LogManager.getLogger(new TestParameterizedMessageFactory(), messageFactory);
         assertNotNull(testLogger);
@@ -419,7 +419,7 @@ public void getLogger_String_MessageFactoryMismatch() {
         assertNotNull(testLogger);
         assertEqualMessageFactory(messageFactory, testLogger);
         final TestLogger testLogger2 = (TestLogger)
-                LogManager.getLogger("getLogger_String_MessageFactoryMismatch", ParameterizedMessageFactory.INSTANCE);
+                LogManager.getLogger("getLogger_String_MessageFactoryMismatch", new ReusableMessageFactory());
         assertNotNull(testLogger2);
         // TODO: How to test?
         // This test context always creates new loggers, other test context impls I tried fail other tests.
@@ -434,7 +434,7 @@ public void getLogger_String_MessageFactoryMismatch() {
     @Test
     @ResourceLock("log4j2.TestLogger")
     public void getLogger_String_ParameterizedMessageFactory() {
-        final ParameterizedMessageFactory messageFactory = ParameterizedMessageFactory.INSTANCE;
+        final MessageFactory messageFactory = new ReusableMessageFactory();
         final TestLogger testLogger =
                 (TestLogger) LogManager.getLogger("getLogger_String_ParameterizedMessageFactory", messageFactory);
         assertNotNull(testLogger);

log4j-api-test/src/test/java/org/apache/logging/log4j/internal/recycler/ArrayQueueTest.java

@@ -16,48 +16,32 @@
  */
 package org.apache.logging.log4j.internal.recycler;
 
-import static org.apache.logging.log4j.internal.recycler.RecyclerFactoryTestUtil.createForEnvironment;
 import static org.apache.logging.log4j.spi.recycler.Recycler.DEFAULT_CAPACITY;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import edu.umd.cs.findbugs.annotations.Nullable;
+import java.util.Properties;
 import org.apache.logging.log4j.internal.recycler.DummyRecyclerFactoryProvider.DummyRecyclerFactory;
 import org.apache.logging.log4j.internal.recycler.QueueingRecyclerFactoryProvider.QueueingRecyclerFactory;
-import org.apache.logging.log4j.internal.recycler.ThreadLocalRecyclerFactoryProvider.ThreadLocalRecyclerFactory;
 import org.apache.logging.log4j.spi.recycler.RecyclerFactory;
 import org.apache.logging.log4j.spi.recycler.RecyclerFactoryProvider;
+import org.apache.logging.log4j.spi.recycler.RecyclerFactoryRegistry;
+import org.apache.logging.log4j.util.PropertiesUtil;
+import org.apache.logging.log4j.util.PropertyEnvironment;
 import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.jupiter.api.Test;
 
 public class RecyclerFactoryRegistryTest {
 
     @Test
     void DummyRecyclerFactory_should_work() {
-        final RecyclerFactory factory = createForEnvironment(null, "dummy", null);
+        final RecyclerFactory factory = createForEnvironment("dummy", null);
         assertThat(factory).isInstanceOf(DummyRecyclerFactory.class);
     }
 
-    @Test
-    void ThreadLocalRecyclerFactory_should_work() {
-        final RecyclerFactory factory = createForEnvironment(null, "threadLocal", null);
-        assertThat(factory)
-                .asInstanceOf(InstanceOfAssertFactories.type(ThreadLocalRecyclerFactory.class))
-                .extracting(factory_ -> factory_.capacity)
-                .isEqualTo(DEFAULT_CAPACITY);
-    }
-
-    @Test
-    void ThreadLocalRecyclerFactory_should_work_with_capacity() {
-        final int capacity = 13;
-        final RecyclerFactory factory = createForEnvironment(null, "threadLocal", capacity);
-        assertThat(factory)
-                .asInstanceOf(InstanceOfAssertFactories.type(ThreadLocalRecyclerFactory.class))
-                .extracting(factory_ -> factory_.capacity)
-                .isEqualTo(capacity);
-    }
-
     @Test
     void QueueingRecyclerFactory_should_work() {
-        final RecyclerFactory factory = createForEnvironment(null, "queue", null);
+        final RecyclerFactory factory = createForEnvironment("queue", null);
         assertThat(factory)
                 .asInstanceOf(InstanceOfAssertFactories.type(QueueingRecyclerFactory.class))
                 .extracting(factory_ -> factory_.capacity)
@@ -67,19 +51,31 @@ void QueueingRecyclerFactory_should_work() {
     @Test
     void QueueingRecyclerFactory_should_work_with_capacity() {
         final int capacity = 100;
-        final RecyclerFactory factory = createForEnvironment(null, "queue", capacity);
+        final RecyclerFactory factory = createForEnvironment("queue", capacity);
         assertThat(factory)
                 .asInstanceOf(InstanceOfAssertFactories.type(QueueingRecyclerFactory.class))
                 .extracting(factory_ -> factory_.capacity)
                 .isEqualTo(capacity);
     }
 
+    @Nullable
+    private static RecyclerFactory createForEnvironment(
+            @Nullable final String factory, @Nullable final Integer capacity) {
+        final Properties properties = new Properties();
+        if (factory != null) {
+            properties.setProperty("log4j2.*.Recycler.factory", factory);
+        }
+        if (capacity != null) {
+            properties.setProperty("log4j2.*.Recycler.capacity", "" + capacity);
+        }
+        final PropertyEnvironment env = new PropertiesUtil(properties);
+        return RecyclerFactoryRegistry.findRecyclerFactory(env);
+    }
+
     @Test
     void verify_order() {
         final RecyclerFactoryProvider dummyProvider = new DummyRecyclerFactoryProvider();
-        final RecyclerFactoryProvider threadLocalProvider = new ThreadLocalRecyclerFactoryProvider();
         final RecyclerFactoryProvider queueProvider = new QueueingRecyclerFactoryProvider();
         assertThat(dummyProvider.getOrder()).isGreaterThan(queueProvider.getOrder());
-        assertThat(queueProvider.getOrder()).isGreaterThan(threadLocalProvider.getOrder());
     }
 }