Fix 1799 and Spring 33450

log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java

@@ -140,6 +140,23 @@ public void testPublish() {
         assertEquals("Log4j", value);
     }
 
+    @Test
+    @ResourceLock(Resources.SYSTEM_PROPERTIES)
+    public void testBadPropertysource() {
+        final String key1 = "testKey";
+        System.getProperties().put(key1, "test");
+        final PropertiesUtil util = new PropertiesUtil(new Properties());
+        ErrorPropertySource source = new ErrorPropertySource();
+        util.addPropertySource(source);
+        try {
+            assertEquals("test", util.getStringProperty(key1));
+            assertTrue(source.exceptionThrown);
+        } finally {
+            util.removePropertySource(source);
+            System.getProperties().remove(key1);
+        }
+    }
+
     private static final String[][] data = {
         {null, "org.apache.logging.log4j.level"},
         {null, "Log4jAnotherProperty"},
@@ -184,4 +201,25 @@ public void testLog4jProperty() {
         final PropertiesUtil util = new PropertiesUtil(props);
         assertNull(util.getStringProperty(correct));
     }
+
+    private class ErrorPropertySource implements PropertySource {
+        public boolean exceptionThrown = false;
+
+        @Override
+        public int getPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public String getProperty(String key) {
+            exceptionThrown = true;
+            throw new InstantiationError("Test");
+        }
+
+        @Override
+        public boolean containsProperty(String key) {
+            exceptionThrown = true;
+            throw new InstantiationError("Test");
+        }
+    }
 }

log4j-api/src/main/java/org/apache/logging/log4j/util/PropertiesUtil.java

@@ -199,6 +199,13 @@ public void addPropertySource(final PropertySource propertySource) {
         }
     }
 
+    @Override
+    public void removePropertySource(final PropertySource propertySource) {
+        if (environment != null) {
+            environment.removePropertySource(propertySource);
+        }
+    }
+
     /**
      * Returns {@code true} if the specified property is defined, regardless of its value (it may not have a value).
      *
@@ -683,6 +690,11 @@ public void addPropertySource(final PropertySource propertySource) {
             sources.add(propertySource);
         }
 
+        @Override
+        public void removePropertySource(final PropertySource propertySource) {
+            sources.remove(propertySource);
+        }
+
         private void reload() {
             literal.clear();
             sources.forEach((s) -> {
@@ -700,14 +712,14 @@ private void reload() {
                     sources.forEach(source -> {
                         if (source instanceof ContextAwarePropertySource) {
                             final ContextAwarePropertySource src = Cast.cast(source);
-                            if (src.containsProperty(contextName, contextKey)) {
+                            if (sourceContainsProperty(src, contextName, contextKey)) {
                                 literal.putIfAbsent(key, src.getProperty(contextName, contextKey));
                             }
                         }
                     });
                 }
                 sources.forEach(source -> {
-                    if (source.containsProperty(contextKey)) {
+                    if (sourceContainsProperty(source, contextKey)) {
                         literal.putIfAbsent(key, source.getProperty(contextKey));
                     }
                 });
@@ -727,7 +739,7 @@ public String getStringProperty(final String key) {
                 while (source != null) {
                     if (source instanceof ContextAwarePropertySource) {
                         final ContextAwarePropertySource src = Cast.cast(source);
-                        result = src.getProperty(contextName, contextKey);
+                        result = sourceGetProperty(src, contextName, contextKey);
                     }
                     if (result != null) {
                         return result;
@@ -737,7 +749,7 @@ public String getStringProperty(final String key) {
             }
             PropertySource source = sources.first();
             while (source != null) {
-                result = source.getProperty(contextKey);
+                result = sourceGetProperty(source, contextKey);
                 if (result != null) {
                     return result;
                 }
@@ -746,6 +758,22 @@ public String getStringProperty(final String key) {
             return result;
         }
 
+        private String sourceGetProperty(ContextAwarePropertySource source, String contextName, String key) {
+            try {
+                return source.getProperty(contextName, key);
+            } catch (Throwable ex) {
+                return null;
+            }
+        }
+
+        private String sourceGetProperty(PropertySource source, String key) {
+            try {
+                return source.getProperty(key);
+            } catch (Throwable ex) {
+                return null;
+            }
+        }
+
         @Override
         public boolean hasProperty(final String key) {
             if (literal.containsKey(key)) {
@@ -758,7 +786,7 @@ public boolean hasProperty(final String key) {
                 while (source != null) {
                     if (source instanceof ContextAwarePropertySource) {
                         final ContextAwarePropertySource src = Cast.cast(source);
-                        if (src.containsProperty(contextName, contextKey)) {
+                        if (sourceContainsProperty(src, contextName, contextKey)) {
                             return true;
                         }
                     }
@@ -769,9 +797,9 @@ public boolean hasProperty(final String key) {
             while (source != null) {
                 if (source instanceof ContextAwarePropertySource) {
                     final ContextAwarePropertySource src = Cast.cast(source);
-                    if (src.containsProperty(contextName, contextKey)
+                    if (sourceContainsProperty(src, contextName, contextKey)
                             || (!contextName.equals(PropertySource.SYSTEM_CONTEXT)
-                                    && src.containsProperty(PropertySource.SYSTEM_CONTEXT, contextKey))) {
+                                    && sourceContainsProperty(src, PropertySource.SYSTEM_CONTEXT, contextKey))) {
                         return true;
                     }
                 } else {
@@ -784,6 +812,22 @@ public boolean hasProperty(final String key) {
             return false;
         }
 
+        private boolean sourceContainsProperty(ContextAwarePropertySource source, String contextName, String key) {
+            try {
+                return source.containsProperty(contextName, key);
+            } catch (Throwable ex) {
+                return false;
+            }
+        }
+
+        private boolean sourceContainsProperty(PropertySource source, String key) {
+            try {
+                return source.containsProperty(key);
+            } catch (Throwable ex) {
+                return false;
+            }
+        }
+
         private String getContextKey(final String key) {
             String keyToCheck = key;
             if (keyToCheck.startsWith(PropertySource.PREFIX)) {

log4j-api/src/main/java/org/apache/logging/log4j/util/PropertyEnvironment.java

@@ -28,6 +28,12 @@ public interface PropertyEnvironment {
      */
     void addPropertySource(PropertySource propertySource);
 
+    /**
+     * Allows a PropertySource that was added to be removed.
+     * @param propertySource the PropertySource to remove.
+     */
+    void removePropertySource(PropertySource propertySource);
+
     /**
      * Returns {@code true} if the specified property is defined, regardless of its value (it may not have a value).
      *

log4j-core-test/src/test/java/org/apache/logging/log4j/core/LoggerContextTest.java

@@ -0,0 +1,46 @@
+/*
+ * 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.core;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.impl.Log4jContextFactory;
+import org.apache.logging.log4j.core.impl.internal.InternalLoggerContext;
+import org.apache.logging.log4j.core.util.DefaultShutdownCallbackRegistry;
+import org.apache.logging.log4j.core.util.ShutdownCallbackRegistry;
+import org.apache.logging.log4j.spi.LoggerContextFactory;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Validate Logging after Shutdown.
+ */
+public class LoggerContextTest {
+
+    @Test
+    public void shutdownTest() {
+        LoggerContextFactory contextFactory = LogManager.getFactory();
+        assertTrue(contextFactory instanceof Log4jContextFactory);
+        Log4jContextFactory factory = (Log4jContextFactory) contextFactory;
+        ShutdownCallbackRegistry registry = factory.getShutdownCallbackRegistry();
+        assertTrue(registry instanceof DefaultShutdownCallbackRegistry);
+        ((DefaultShutdownCallbackRegistry) registry).start();
+        ((DefaultShutdownCallbackRegistry) registry).stop();
+        LoggerContext loggerContext = factory.getContext(LoggerContextTest.class.getName(), null, null, false);
+        assertTrue(loggerContext instanceof InternalLoggerContext);
+    }
+}

log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/MissingRootLoggerTest.java

@@ -21,6 +21,7 @@
 import static org.hamcrest.Matchers.hasKey;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.startsWith;
 import static org.junit.jupiter.api.Assertions.*;
 
 import java.util.Map;
@@ -48,7 +49,7 @@ public void testMissingRootLogger(final LoggerContext ctx) throws Exception {
         assertNotNull(map, "Appenders not null");
         assertThat("There should only be two appenders", map, hasSize(2));
         assertThat(map, hasKey("List"));
-        assertThat(map, hasKey("DefaultConsole-2"));
+        assertThat(map, hasKey(startsWith("DefaultConsole-")));
 
         final Map<String, LoggerConfig> loggerMap = config.getLoggers();
         assertNotNull(loggerMap, "loggerMap not null");
@@ -67,7 +68,8 @@ public void testMissingRootLogger(final LoggerContext ctx) throws Exception {
         final Map<String, Appender> rootAppenders = root.getAppenders();
         assertThat("The root logger should only have one appender", rootAppenders, hasSize(1));
         // root only has Console appender!
-        assertThat("The root appender should be a ConsoleAppender", rootAppenders, hasKey("DefaultConsole-2"));
+        assertThat(
+                "The root appender should be a ConsoleAppender", rootAppenders, hasKey(startsWith("DefaultConsole-")));
         assertEquals(Level.ERROR, root.getLevel());
     }
 }

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

@@ -66,6 +66,17 @@ protected Logger(final LoggerContext context, final String name, final MessageFa
         privateConfig = new PrivateConfig(context.getConfiguration(), this);
     }
 
+    /**
+     * This is used to construct an InternalLoggerContext, which makes SimpleLoggerContext conmpatible with core.
+     * @param context the InternalLoggerContext.
+     * @param name the Logger name.
+     */
+    protected Logger(final LoggerContext context, final String name) {
+        super(name);
+        this.context = context;
+        privateConfig = null;
+    }
+
     /**
      * This method is only used for 1.x compatibility. Returns the parent of this Logger. If it doesn't already exist
      * return a temporary Logger.

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

@@ -99,6 +99,15 @@ public class LoggerContext extends AbstractLifeCycle
 
     private final Lock configLock = new ReentrantLock();
 
+    /**
+     * Constructor used to create an InternalLoggerContext.
+     */
+    protected LoggerContext() {
+        setStarted();
+        instanceFactory = null;
+        this.nullConfiguration = null;
+    }
+
     /**
      * Constructor taking only a name.
      *
@@ -428,6 +437,7 @@ public boolean stop(final long timeout, final TimeUnit timeUnit) {
             }
 
             this.setStopping();
+            String name = getName();
             try {
                 Server.unregisterLoggerContext(getName()); // LOG4J2-406, LOG4J2-500
             } catch (final LinkageError | Exception e) {

log4j-core/src/main/java/org/apache/logging/log4j/core/config/ConfigurationFactory.java

@@ -21,12 +21,15 @@
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
 import org.apache.logging.log4j.core.impl.Log4jPropertyKey;
+import org.apache.logging.log4j.core.util.AuthorizationProvider;
 import org.apache.logging.log4j.plugins.Namespace;
 import org.apache.logging.log4j.plugins.di.ConfigurableInstanceFactory;
 import org.apache.logging.log4j.plugins.di.Key;
 import org.apache.logging.log4j.plugins.model.PluginNamespace;
 import org.apache.logging.log4j.status.StatusLogger;
 import org.apache.logging.log4j.util.LoaderUtil;
+import org.apache.logging.log4j.util.PropertiesUtil;
+import org.apache.logging.log4j.util.PropertyEnvironment;
 import org.apache.logging.log4j.util.PropertyKey;
 
 /**
@@ -118,6 +121,15 @@ protected boolean isActive() {
         return true;
     }
 
+    /**
+     * Required for Spring Boot.
+     * @param props PropertiesUtil.
+     * @return the AuthorizationProvider, if any.
+     */
+    public static AuthorizationProvider authorizationProvider(final PropertiesUtil props) {
+        return AuthorizationProvider.getAuthorizationProvider((PropertyEnvironment) props);
+    }
+
     public abstract Configuration getConfiguration(final LoggerContext loggerContext, ConfigurationSource source);
 
     /**