Refactor property names

Property names are often inconsistent. This commit:

* changes `log4j.configuration.file` to `log4j.configuration.location`,
  since the value is not necessarily a file,
* the names of property classes end in `Properties`, whereas their
  prefix starts with a small letter,
* the `AsyncLogger` and `AsyncLoggerConfig` properties are merged into
  one class, since they should not be used together,
* the `AuthenticationProvider` is removed from `ConfigurationProperties`
  and placed in a standalone class, since multiple components use it.

Author: ppkarwasz

log4j-1.2-api/src/test/java/org/apache/log4j/config/XmlConfigurationFactoryTest.java

@@ -16,6 +16,7 @@
  */
 package org.apache.log4j.config;
 
+import static org.apache.logging.log4j.core.config.ConfigurationFactory.LOG4J1_CONFIGURATION_FILE_PROPERTY;
 import static org.junit.Assert.assertTrue;
 
 import java.io.File;
@@ -31,7 +32,7 @@ public class XmlConfigurationFactoryTest {
 
     @BeforeClass
     public static void beforeClass() {
-        System.setProperty("log4j2.Version1.configuration", "target/test-classes/log4j1-file.xml");
+        System.setProperty(LOG4J1_CONFIGURATION_FILE_PROPERTY, "target/test-classes/log4j1-file.xml");
     }
 
     @Test

log4j-async-logger/src/main/java/org/apache/logging/log4j/async/logger/AsyncLoggerConfigDelegate.java

@@ -21,7 +21,6 @@
 import com.lmax.disruptor.EventFactory;
 import com.lmax.disruptor.EventHandler;
 import com.lmax.disruptor.EventTranslatorTwoArg;
-import com.lmax.disruptor.ExceptionHandler;
 import com.lmax.disruptor.RingBuffer;
 import com.lmax.disruptor.Sequence;
 import com.lmax.disruptor.TimeoutException;
@@ -33,7 +32,7 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.async.logger.internal.DisruptorUtil;
+import org.apache.logging.log4j.async.logger.internal.AsyncLoggerConfigDefaultExceptionHandler;
 import org.apache.logging.log4j.core.AbstractLifeCycle;
 import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.ReusableLogEvent;
@@ -50,6 +49,7 @@
 import org.apache.logging.log4j.core.util.Throwables;
 import org.apache.logging.log4j.message.ReusableMessage;
 import org.apache.logging.log4j.plugins.Inject;
+import org.apache.logging.log4j.util.LoaderUtil;
 
 /**
  * Helper class decoupling the {@code AsyncLoggerConfig} class from the LMAX Disruptor library.
@@ -72,15 +72,16 @@ public class AsyncLoggerConfigDisruptor extends AbstractLifeCycle {
      * RingBuffer events contain all information necessary to perform the work in a separate thread.
      */
     public static class Log4jEventWrapper {
+
         public Log4jEventWrapper() {}
 
         public Log4jEventWrapper(final LogEvent mutableLogEvent) {
             event = mutableLogEvent;
         }
 
         private AsyncLoggerConfig loggerConfig;
-        private LogEvent event;
 
+        private LogEvent event;
         /**
          * Release references held by ring buffer to allow objects to be garbage-collected.
          */
@@ -98,11 +99,11 @@ public String toString() {
             return String.valueOf(event);
         }
     }
-
     /**
      * EventHandler performs the work in a separate thread.
      */
     private static class Log4jEventWrapperHandler implements EventHandler<Log4jEventWrapper> {
+
         private static final int NOTIFY_PROGRESS_THRESHOLD = 50;
         private Sequence sequenceCallback;
         private int counter;
@@ -132,7 +133,6 @@ private void notifyIntermediateProgress(final long sequence) {
             }
         }
     }
-
     /**
      * Factory used to populate the RingBuffer with events. These event objects are then re-used during the life of the
      * RingBuffer.
@@ -169,31 +169,32 @@ private void notifyIntermediateProgress(final long sequence) {
     private AsyncQueueFullPolicy asyncQueueFullPolicy;
 
     private volatile Disruptor<Log4jEventWrapper> disruptor;
+
     private long backgroundThreadId; // LOG4J2-471
     private EventTranslatorTwoArg<Log4jEventWrapper, LogEvent, AsyncLoggerConfig> translator;
     private static volatile boolean alreadyLoggedWarning;
-    private final AsyncLoggerKeys.AsyncLoggerConfig propsConfig;
+    private final AsyncLoggerProperties properties;
     private final WaitStrategy waitStrategy;
     private final boolean mutable;
-
     private final Lock startLock = new ReentrantLock();
+
     private final Lock queueFullEnqueueLock = new ReentrantLock();
 
     @Inject
     public AsyncLoggerConfigDisruptor(
             final WaitStrategy waitStrategy,
             final LogEventFactory logEventFactory,
-            final AsyncLoggerKeys.AsyncLoggerConfig propsConfig) {
+            final AsyncLoggerProperties properties) {
         this.waitStrategy = waitStrategy;
         this.mutable = logEventFactory instanceof ReusableLogEventFactory;
-        this.propsConfig = propsConfig;
+        this.properties = properties;
     }
 
     // package-protected for testing
+
     WaitStrategy getWaitStrategy() {
         return waitStrategy;
     }
-
     /**
      * Increases the reference count and creates and starts a new Disruptor and associated thread if none currently
      * exists.
@@ -210,7 +211,7 @@ public void start() {
                 return;
             }
             LOGGER.trace("AsyncLoggerConfigDisruptor creating new disruptor for this configuration.");
-            final int ringBufferSize = DisruptorUtil.calculateRingBufferSize(propsConfig);
+            final int ringBufferSize = properties.roundedRingBufferSize();
 
             final ThreadFactory threadFactory =
                     new Log4jThreadFactory("AsyncLoggerConfig", true, Thread.NORM_PRIORITY) {
@@ -227,8 +228,7 @@ public Thread newThread(final Runnable r) {
             final EventFactory<Log4jEventWrapper> factory = mutable ? MUTABLE_FACTORY : FACTORY;
             disruptor = new Disruptor<>(factory, ringBufferSize, threadFactory, ProducerType.MULTI, waitStrategy);
 
-            final ExceptionHandler<Log4jEventWrapper> errorHandler =
-                    DisruptorUtil.getAsyncLoggerConfigExceptionHandler(propsConfig);
+            final AsyncLoggerConfigExceptionHandler errorHandler = getExceptionHandler();
             disruptor.setDefaultExceptionHandler(errorHandler);
 
             final Log4jEventWrapperHandler[] handlers = {new Log4jEventWrapperHandler()};
@@ -308,6 +308,18 @@ public EventRoute getEventRoute(final Level logLevel) {
         return asyncQueueFullPolicy.getRoute(backgroundThreadId, logLevel);
     }
 
+    private AsyncLoggerConfigExceptionHandler getExceptionHandler() {
+        try {
+            final Class<? extends AsyncLoggerConfigExceptionHandler> handlerClass = properties.configExceptionHandler();
+            if (handlerClass != null) {
+                return LoaderUtil.newInstanceOf(handlerClass);
+            }
+        } catch (final ReflectiveOperationException e) {
+            LOGGER.debug("Invalid AsyncLogger.ExceptionHandler value: {}", e.getMessage(), e);
+        }
+        return new AsyncLoggerConfigDefaultExceptionHandler();
+    }
+
     private int remainingDisruptorCapacity() {
         final Disruptor<Log4jEventWrapper> temp = disruptor;
         if (hasLog4jBeenShutDown(temp)) {
@@ -400,7 +412,7 @@ private void enqueue(final LogEvent logEvent, final AsyncLoggerConfig asyncLogge
     }
 
     private boolean synchronizeEnqueueWhenQueueFull() {
-        return propsConfig.synchronizeEnqueueWhenQueueFull()
+        return properties.synchronizeEnqueueWhenQueueFull()
                 // Background thread must never block
                 && backgroundThreadId != Thread.currentThread().getId()
                 // Threads owned by log4j are most likely to result in

log4j-async-logger/src/main/java/org/apache/logging/log4j/async/logger/AsyncLoggerConfigDisruptor.java

@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.async.logger;
+
+import com.lmax.disruptor.ExceptionHandler;
+
+/**
+ * Specialization of {@link ExceptionHandler} to be used by the {@link AsyncLoggerConfig} class.
+ */
+public interface AsyncLoggerConfigExceptionHandler
+        extends ExceptionHandler<AsyncLoggerConfigDisruptor.Log4jEventWrapper> {}

log4j-async-logger/src/main/java/org/apache/logging/log4j/async/logger/AsyncLoggerConfigExceptionHandler.java

@@ -18,7 +18,7 @@
 
 import java.net.URI;
 import java.util.concurrent.TimeUnit;
-import org.apache.logging.log4j.async.logger.internal.DefaultBundle;
+import org.apache.logging.log4j.async.logger.internal.AsyncLoggerDefaultBundle;
 import org.apache.logging.log4j.core.Logger;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.Configuration;
@@ -43,7 +43,7 @@ public AsyncLoggerContext(
             final URI configLocation,
             final ConfigurableInstanceFactory instanceFactory) {
         super(name, externalContext, configLocation, instanceFactory);
-        instanceFactory.registerBundle(DefaultBundle.class);
+        instanceFactory.registerBundle(AsyncLoggerDefaultBundle.class);
         instanceFactory.registerBinding(Key.forClass(AsyncLoggerDisruptor.class), loggerDisruptor);
     }
 

log4j-async-logger/src/main/java/org/apache/logging/log4j/async/logger/AsyncLoggerContext.java

@@ -16,7 +16,6 @@
  */
 package org.apache.logging.log4j.async.logger;
 
-import com.lmax.disruptor.ExceptionHandler;
 import com.lmax.disruptor.RingBuffer;
 import com.lmax.disruptor.TimeoutException;
 import com.lmax.disruptor.WaitStrategy;
@@ -27,7 +26,7 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.async.logger.internal.DisruptorUtil;
+import org.apache.logging.log4j.async.logger.internal.AsyncLoggerDefaultExceptionHandler;
 import org.apache.logging.log4j.core.AbstractLifeCycle;
 import org.apache.logging.log4j.core.async.AsyncQueueFullPolicy;
 import org.apache.logging.log4j.core.async.AsyncQueueFullPolicyFactory;
@@ -37,6 +36,8 @@
 import org.apache.logging.log4j.core.util.Log4jThreadFactory;
 import org.apache.logging.log4j.core.util.Throwables;
 import org.apache.logging.log4j.message.Message;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.util.LoaderUtil;
 
 /**
  * Helper class for async loggers: AsyncLoggerDisruptor handles the mechanics of working with the LMAX Disruptor, and
@@ -53,20 +54,21 @@ public class AsyncLoggerDisruptor extends AbstractLifeCycle {
 
     private volatile Disruptor<RingBufferLogEvent> disruptor;
     private String contextName;
-    private final AsyncLoggerKeys.AsyncLogger propsConfig;
+    private final AsyncLoggerProperties properties;
 
     private long backgroundThreadId;
     private AsyncQueueFullPolicy asyncQueueFullPolicy;
     private final WaitStrategy waitStrategy;
 
     public AsyncLoggerDisruptor(
-            final String contextName, final WaitStrategy waitStrategy, final AsyncLoggerKeys.AsyncLogger propsConfig) {
+            final String contextName, final WaitStrategy waitStrategy, final AsyncLoggerProperties properties) {
         this.contextName = contextName;
         this.waitStrategy = waitStrategy;
-        this.propsConfig = propsConfig;
+        this.properties = properties;
     }
 
     // package-protected for testing
+
     WaitStrategy getWaitStrategy() {
         return waitStrategy;
     }
@@ -100,7 +102,7 @@ public void start() {
             }
             setStarting();
             LOGGER.trace("[{}] AsyncLoggerDisruptor creating new disruptor for this context.", contextName);
-            final int ringBufferSize = DisruptorUtil.calculateRingBufferSize(propsConfig);
+            final int ringBufferSize = properties.roundedRingBufferSize();
 
             final ThreadFactory threadFactory =
                     new Log4jThreadFactory("AsyncLogger[" + contextName + "]", true, Thread.NORM_PRIORITY) {
@@ -116,8 +118,7 @@ public Thread newThread(final Runnable r) {
             disruptor = new Disruptor<>(
                     RingBufferLogEvent.FACTORY, ringBufferSize, threadFactory, ProducerType.MULTI, waitStrategy);
 
-            final ExceptionHandler<RingBufferLogEvent> errorHandler =
-                    DisruptorUtil.getAsyncLoggerExceptionHandler(propsConfig);
+            final AsyncLoggerExceptionHandler errorHandler = getExceptionHandler();
             disruptor.setDefaultExceptionHandler(errorHandler);
 
             final RingBufferLogEventHandler[] handlers = {new RingBufferLogEventHandler()};
@@ -200,6 +201,18 @@ EventRoute getEventRoute(final Level logLevel) {
         return asyncQueueFullPolicy.getRoute(backgroundThreadId, logLevel);
     }
 
+    private AsyncLoggerExceptionHandler getExceptionHandler() {
+        try {
+            final Class<? extends AsyncLoggerExceptionHandler> handlerClass = properties.exceptionHandler();
+            if (handlerClass != null) {
+                return LoaderUtil.newInstanceOf(handlerClass);
+            }
+        } catch (final ReflectiveOperationException e) {
+            StatusLogger.getLogger().debug("Invalid AsyncLogger.ExceptionHandler value: {}", e.getMessage(), e);
+        }
+        return new AsyncLoggerDefaultExceptionHandler();
+    }
+
     private int remainingDisruptorCapacity() {
         final Disruptor<RingBufferLogEvent> temp = disruptor;
         if (hasLog4jBeenShutDown(temp)) {
@@ -253,7 +266,7 @@ void enqueueLogMessageWhenQueueFull(final RingBufferLogEventTranslator translato
     }
 
     private boolean synchronizeEnqueueWhenQueueFull() {
-        return propsConfig.synchronizeEnqueueWhenQueueFull()
+        return properties.synchronizeEnqueueWhenQueueFull()
                 // Background thread must never block
                 && backgroundThreadId != Thread.currentThread().getId()
                 // Threads owned by log4j are most likely to result in

log4j-async-logger/src/main/java/org/apache/logging/log4j/async/logger/AsyncLoggerDisruptor.java

@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.async.logger;
+
+import com.lmax.disruptor.ExceptionHandler;
+
+/**
+ * Specialization of {@link ExceptionHandler} to be used by the {@link AsyncLogger} class.
+ */
+public interface AsyncLoggerExceptionHandler extends ExceptionHandler<RingBufferLogEvent> {}