Restore code to 2.24.1

Author: ppkarwasz

log4j-api/src/main/java/org/apache/logging/log4j/message/package-info.java

@@ -19,7 +19,7 @@
  * Public Message Types used for Log4j 2. Users may implement their own Messages.
  */
 @Export
-@Version("2.24.2")
+@Version("2.24.1")
 package org.apache.logging.log4j.message;
 
 import org.osgi.annotation.bundle.Export;

log4j-api/src/main/java/org/apache/logging/log4j/simple/SimpleLoggerContext.java

@@ -102,7 +102,13 @@ public ExtendedLogger getLogger(final String name) {
     public ExtendedLogger getLogger(final String name, @Nullable final MessageFactory messageFactory) {
         final MessageFactory effectiveMessageFactory =
                 messageFactory != null ? messageFactory : DEFAULT_MESSAGE_FACTORY;
-        return loggerRegistry.computeIfAbsent(name, effectiveMessageFactory, this::createLogger);
+        final ExtendedLogger oldLogger = loggerRegistry.getLogger(name, effectiveMessageFactory);
+        if (oldLogger != null) {
+            return oldLogger;
+        }
+        final ExtendedLogger newLogger = createLogger(name, effectiveMessageFactory);
+        loggerRegistry.putIfAbsent(name, effectiveMessageFactory, newLogger);
+        return loggerRegistry.getLogger(name, effectiveMessageFactory);
     }
 
     private ExtendedLogger createLogger(final String name, @Nullable final MessageFactory messageFactory) {

log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java

@@ -166,11 +166,7 @@ private static MessageFactory2 adaptMessageFactory(final MessageFactory result)
      *
      * @param logger The logger to check
      * @param messageFactory The message factory to check.
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
-     * Instead, in {@link LoggerContext#getLogger(String, MessageFactory)} implementations, namespace loggers with message factories.
-     * If your implementation uses {@link LoggerRegistry}, you are already covered.
      */
-    @Deprecated
     public static void checkMessageFactory(final ExtendedLogger logger, final MessageFactory messageFactory) {
         final String name = logger.getName();
         final MessageFactory loggerMessageFactory = logger.getMessageFactory();

log4j-api/src/main/java/org/apache/logging/log4j/spi/LoggerContext.java

@@ -18,7 +18,6 @@
 
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.MessageFactory;
-import org.jspecify.annotations.Nullable;
 
 /**
  * Anchor point for logging implementations.
@@ -55,7 +54,7 @@ default ExtendedLogger getLogger(Class<?> cls) {
      * @return The logger.
      * @since 2.14.0
      */
-    default ExtendedLogger getLogger(Class<?> cls, @Nullable MessageFactory messageFactory) {
+    default ExtendedLogger getLogger(Class<?> cls, MessageFactory messageFactory) {
         final String canonicalName = cls.getCanonicalName();
         return getLogger(canonicalName != null ? canonicalName : cls.getName(), messageFactory);
     }
@@ -74,7 +73,7 @@ default ExtendedLogger getLogger(Class<?> cls, @Nullable MessageFactory messageF
      *                       the logger but will log a warning if mismatched.
      * @return The logger with the specified name.
      */
-    ExtendedLogger getLogger(String name, @Nullable MessageFactory messageFactory);
+    ExtendedLogger getLogger(String name, MessageFactory messageFactory);
 
     /**
      * Gets the LoggerRegistry.
@@ -119,7 +118,7 @@ default Object getObject(String key) {
      * @return true if the Logger exists, false otherwise.
      * @since 2.5
      */
-    boolean hasLogger(String name, @Nullable MessageFactory messageFactory);
+    boolean hasLogger(String name, MessageFactory messageFactory);
 
     /**
      * Associates an object into the LoggerContext by name for later use.

log4j-api/src/main/java/org/apache/logging/log4j/spi/LoggerRegistry.java

@@ -30,17 +30,12 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.function.BiFunction;
 import org.apache.logging.log4j.message.MessageFactory;
 import org.apache.logging.log4j.message.ParameterizedMessageFactory;
-import org.apache.logging.log4j.status.StatusLogger;
-import org.jspecify.annotations.NullMarked;
-import org.jspecify.annotations.Nullable;
 
 /**
  * Convenience class to be used as an {@link ExtendedLogger} registry by {@code LoggerContext} implementations.
  */
-@NullMarked
 public class LoggerRegistry<T extends ExtendedLogger> {
 
     private final Map<String, Map<MessageFactory, WeakReference<T>>> loggerRefByMessageFactoryByName = new HashMap<>();
@@ -55,9 +50,7 @@ public class LoggerRegistry<T extends ExtendedLogger> {
      * Data structure contract for the internal storage of admitted loggers.
      *
      * @param <T> subtype of {@code ExtendedLogger}
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
      */
-    @Deprecated
     public interface MapFactory<T extends ExtendedLogger> {
 
         Map<String, T> createInnerMap();
@@ -71,9 +64,7 @@ public interface MapFactory<T extends ExtendedLogger> {
      * {@link MapFactory} implementation using {@link ConcurrentHashMap}.
      *
      * @param <T> subtype of {@code ExtendedLogger}
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
      */
-    @Deprecated
     public static class ConcurrentMapFactory<T extends ExtendedLogger> implements MapFactory<T> {
 
         @Override
@@ -96,9 +87,7 @@ public void putIfAbsent(final Map<String, T> innerMap, final String name, final
      * {@link MapFactory} implementation using {@link WeakHashMap}.
      *
      * @param <T> subtype of {@code ExtendedLogger}
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
      */
-    @Deprecated
     public static class WeakMapFactory<T extends ExtendedLogger> implements MapFactory<T> {
 
         @Override
@@ -123,10 +112,8 @@ public LoggerRegistry() {}
      * Constructs an instance <b>ignoring</b> the given the map factory.
      *
      * @param mapFactory a map factory
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
      */
-    @Deprecated
-    public LoggerRegistry(@Nullable final MapFactory<T> mapFactory) {
+    public LoggerRegistry(final MapFactory<T> mapFactory) {
         this();
     }
 
@@ -139,10 +126,7 @@ public LoggerRegistry(@Nullable final MapFactory<T> mapFactory) {
      *
      * @param name a logger name
      * @return the logger associated with the name
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
-     * Use {@link #getLogger(String, MessageFactory)} instead.
      */
-    @Deprecated
     public T getLogger(final String name) {
         requireNonNull(name, "name");
         return getLogger(name, null);
@@ -160,7 +144,7 @@ public T getLogger(final String name) {
      * @param messageFactory a message factory
      * @return the logger associated with the given name and message factory
      */
-    public T getLogger(final String name, @Nullable final MessageFactory messageFactory) {
+    public T getLogger(final String name, final MessageFactory messageFactory) {
         requireNonNull(name, "name");
         readLock.lock();
         try {
@@ -209,10 +193,7 @@ public Collection<T> getLoggers(final Collection<T> destination) {
      *
      * @param name a logger name
      * @return {@code true}, if the logger exists; {@code false} otherwise.
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
-     * Use {@link #hasLogger(String, MessageFactory)} instead.
      */
-    @Deprecated
     public boolean hasLogger(final String name) {
         requireNonNull(name, "name");
         final T logger = getLogger(name);
@@ -232,7 +213,7 @@ public boolean hasLogger(final String name) {
      * @return {@code true}, if the logger exists; {@code false} otherwise.
      * @since 2.5
      */
-    public boolean hasLogger(final String name, @Nullable final MessageFactory messageFactory) {
+    public boolean hasLogger(final String name, final MessageFactory messageFactory) {
         requireNonNull(name, "name");
         final T logger = getLogger(name, messageFactory);
         return logger != null;
@@ -265,23 +246,18 @@ public boolean hasLogger(final String name, final Class<? extends MessageFactory
      * @param name ignored – kept for backward compatibility
      * @param messageFactory ignored – kept for backward compatibility
      * @param logger a logger instance
-     * @deprecated As of version {@code 2.25.0}, planned to be removed!
-     * Use {@link #computeIfAbsent(String, MessageFactory, BiFunction)} instead.
      */
-    @Deprecated
-    public void putIfAbsent(
-            @Nullable final String name, @Nullable final MessageFactory messageFactory, final T logger) {
+    public void putIfAbsent(final String name, final MessageFactory messageFactory, final T logger) {
 
         // Check arguments
         requireNonNull(logger, "logger");
 
         // Insert the logger
         writeLock.lock();
         try {
-            final String loggerName = logger.getName();
             final Map<MessageFactory, WeakReference<T>> loggerRefByMessageFactory =
                     loggerRefByMessageFactoryByName.computeIfAbsent(
-                            loggerName, this::createLoggerRefByMessageFactoryMap);
+                            logger.getName(), this::createLoggerRefByMessageFactoryMap);
             final MessageFactory loggerMessageFactory = logger.getMessageFactory();
             final WeakReference<T> loggerRef = loggerRefByMessageFactory.get(loggerMessageFactory);
             if (loggerRef == null || loggerRef.get() == null) {
@@ -292,60 +268,6 @@ public void putIfAbsent(
         }
     }
 
-    public T computeIfAbsent(
-            final String name,
-            final MessageFactory messageFactory,
-            final BiFunction<String, MessageFactory, T> loggerSupplier) {
-
-        // Check arguments
-        requireNonNull(name, "name");
-        requireNonNull(messageFactory, "messageFactory");
-        requireNonNull(loggerSupplier, "loggerSupplier");
-
-        // Read lock fast path: See if logger already exists
-        T logger = getLogger(name, messageFactory);
-        if (logger != null) {
-            return logger;
-        }
-
-        // Write lock slow path: Insert the logger
-        writeLock.lock();
-        try {
-
-            // See if the logger is created by another thread in the meantime
-            final Map<MessageFactory, WeakReference<T>> loggerRefByMessageFactory =
-                    loggerRefByMessageFactoryByName.computeIfAbsent(name, this::createLoggerRefByMessageFactoryMap);
-            final WeakReference<T> loggerRef;
-            if ((loggerRef = loggerRefByMessageFactory.get(messageFactory)) != null
-                    && (logger = loggerRef.get()) != null) {
-                return logger;
-            }
-
-            // Create the logger
-            logger = loggerSupplier.apply(name, messageFactory);
-
-            // Report message factory mismatches, if there is any
-            final MessageFactory loggerMessageFactory = logger.getMessageFactory();
-            if (!loggerMessageFactory.equals(messageFactory)) {
-                StatusLogger.getLogger()
-                        .error(
-                                "Newly registered logger with name `{}` and message factory `{}`, is requested to be associated with a different message factory: `{}`.\n"
-                                        + "Effectively the message factory of the logger will be used and the other one will be ignored.\n"
-                                        + "This generally hints a problem at the logger context implementation.\n"
-                                        + "Please report this using the Log4j project issue tracker.",
-                                name,
-                                loggerMessageFactory,
-                                messageFactory);
-            }
-
-            // Insert the logger
-            loggerRefByMessageFactory.put(loggerMessageFactory, new WeakReference<>(logger));
-            return logger;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
     private Map<MessageFactory, WeakReference<T>> createLoggerRefByMessageFactoryMap(final String ignored) {
         return new WeakHashMap<>();
     }

log4j-api/src/main/java/org/apache/logging/log4j/spi/package-info.java

@@ -19,7 +19,7 @@
  * API classes.
  */
 @Export
-@Version("2.25.0")
+@Version("2.24.1")
 package org.apache.logging.log4j.spi;
 
 import org.osgi.annotation.bundle.Export;

log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java

@@ -55,7 +55,6 @@
 import org.apache.logging.log4j.spi.Terminable;
 import org.apache.logging.log4j.spi.ThreadContextMapFactory;
 import org.apache.logging.log4j.util.PropertiesUtil;
-import org.jspecify.annotations.Nullable;
 
 /**
  * The LoggerContext is the anchor for the logging system. It maintains a list of all the loggers requested by
@@ -524,10 +523,16 @@ public Collection<Logger> getLoggers() {
      * @return a logger matching the given name and message factory
      */
     @Override
-    public Logger getLogger(final String name, @Nullable final MessageFactory messageFactory) {
+    public Logger getLogger(final String name, final MessageFactory messageFactory) {
         final MessageFactory effectiveMessageFactory =
                 messageFactory != null ? messageFactory : DEFAULT_MESSAGE_FACTORY;
-        return loggerRegistry.computeIfAbsent(name, effectiveMessageFactory, this::newInstance);
+        final Logger oldLogger = loggerRegistry.getLogger(name, effectiveMessageFactory);
+        if (oldLogger != null) {
+            return oldLogger;
+        }
+        final Logger newLogger = newInstance(name, effectiveMessageFactory);
+        loggerRegistry.putIfAbsent(name, effectiveMessageFactory, newLogger);
+        return loggerRegistry.getLogger(name, effectiveMessageFactory);
     }
 
     /**
@@ -558,7 +563,7 @@ public boolean hasLogger(final String name) {
      * @return True if the Logger exists, false otherwise.
      */
     @Override
-    public boolean hasLogger(final String name, @Nullable final MessageFactory messageFactory) {
+    public boolean hasLogger(final String name, final MessageFactory messageFactory) {
         final MessageFactory effectiveMessageFactory =
                 messageFactory != null ? messageFactory : DEFAULT_MESSAGE_FACTORY;
         return loggerRegistry.hasLogger(name, effectiveMessageFactory);

log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java

@@ -172,7 +172,7 @@ public static int parseInt(final String s, final int defaultValue) {
     private final boolean ignoreExceptions;
     private final Layout<? extends Serializable> layout;
 
-    private volatile ErrorHandler handler = new DefaultErrorHandler(this);
+    private ErrorHandler handler = new DefaultErrorHandler(this);
 
     @Override
     public boolean requiresLocation() {
@@ -316,6 +316,10 @@ public void setHandler(final ErrorHandler handler) {
             LOGGER.error("The handler cannot be set to null");
             return;
         }
+        if (isStarted()) {
+            LOGGER.error("The handler cannot be changed once the appender is started");
+            return;
+        }
         this.handler = handler;
     }
 

log4j-core/src/main/java/org/apache/logging/log4j/core/appender/HttpURLConnectionManager.java

@@ -100,8 +100,7 @@ public void send(final Layout<?> layout, final LogEvent event) throws IOExceptio
                     header.getName(), header.evaluate(getConfiguration().getStrSubstitutor()));
         }
         if (sslConfiguration != null) {
-            ((HttpsURLConnection) urlConnection)
-                    .setSSLSocketFactory(sslConfiguration.getSslContext().getSocketFactory());
+            ((HttpsURLConnection) urlConnection).setSSLSocketFactory(sslConfiguration.getSslSocketFactory());
         }
         if (isHttps && !verifyHostname) {
             ((HttpsURLConnection) urlConnection).setHostnameVerifier(LaxHostnameVerifier.INSTANCE);

log4j-core/src/main/java/org/apache/logging/log4j/core/async/package-info.java

@@ -18,7 +18,7 @@
  * Provides Asynchronous Logger classes and interfaces for low-latency logging.
  */
 @Export
-@Version("2.24.1")
+@Version("2.24.0")
 package org.apache.logging.log4j.core.async;
 
 import org.osgi.annotation.bundle.Export;