Add option to provide URIs to monitor in addition to the config file

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

@@ -0,0 +1,61 @@
+/*
+ * 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.awaitility.Awaitility.waitAtMost;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.ConfigurationSource;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
+import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
+import org.apache.logging.log4j.core.config.properties.PropertiesConfiguration;
+import org.apache.logging.log4j.core.util.Source;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.CleanupMode;
+import org.junit.jupiter.api.io.TempDir;
+
+public class MonitorUriTest {
+
+    private static final int MONITOR_INTERVAL = 3;
+
+    @Test
+    void testReconfigureOnChangeInMonitorUri(@TempDir(cleanup = CleanupMode.ON_SUCCESS) final Path tempDir)
+            throws IOException {
+        ConfigurationBuilder<PropertiesConfiguration> configBuilder =
+                ConfigurationBuilderFactory.newConfigurationBuilder(PropertiesConfiguration.class);
+        Path config = tempDir.resolve("config.xml");
+        Path monitorUri = tempDir.resolve("monitorUri.xml");
+        ConfigurationSource configSource = new ConfigurationSource(new Source(config), new byte[] {}, 0);
+        Configuration configuration = configBuilder
+                .setConfigurationSource(configSource)
+                .setMonitorInterval(String.valueOf(MONITOR_INTERVAL))
+                .add(configBuilder.newMonitorUri(monitorUri.toUri().toString()))
+                .build();
+
+        try (LoggerContext loggerContext = Configurator.initialize(configuration)) {
+            Files.write(monitorUri, Collections.singletonList("a change"));
+            waitAtMost(MONITOR_INTERVAL + 2, TimeUnit.SECONDS)
+                    .until(() -> loggerContext.getConfiguration() != configuration);
+        }
+    }
+}

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

@@ -22,6 +22,7 @@
 import java.io.InputStream;
 import java.lang.ref.WeakReference;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -132,6 +133,7 @@ public abstract class AbstractConfiguration extends AbstractFilterable implement
     private ConcurrentMap<String, Appender> appenders = new ConcurrentHashMap<>();
     private ConcurrentMap<String, LoggerConfig> loggerConfigs = new ConcurrentHashMap<>();
     private List<CustomLevelConfig> customLevels = Collections.emptyList();
+    private List<URI> uris = Collections.emptyList();
     private final ConcurrentMap<String, String> propertyMap = new ConcurrentHashMap<>();
     private final Interpolator tempLookup = new Interpolator(propertyMap);
     private final StrSubstitutor runtimeStrSubstitutor = new RuntimeStrSubstitutor(tempLookup);
@@ -323,10 +325,19 @@ public void start() {
         LOGGER.info("Starting configuration {}...", this);
         this.setStarting();
         if (watchManager.getIntervalSeconds() >= 0) {
-            LOGGER.info(
-                    "Start watching for changes to {} every {} seconds",
-                    getConfigurationSource(),
-                    watchManager.getIntervalSeconds());
+            if (uris != null && uris.size() > 0) {
+                LOGGER.info(
+                        "Start watching for changes to {} and {} every {} seconds",
+                        getConfigurationSource(),
+                        uris,
+                        watchManager.getIntervalSeconds());
+                watchMonitorUris();
+            } else {
+                LOGGER.info(
+                        "Start watching for changes to {} every {} seconds",
+                        getConfigurationSource(),
+                        watchManager.getIntervalSeconds());
+            }
             watchManager.start();
         }
         if (hasAsyncLoggers()) {
@@ -347,6 +358,17 @@ public void start() {
         LOGGER.info("Configuration {} started.", this);
     }
 
+    private void watchMonitorUris() {
+        if (this instanceof Reconfigurable) {
+            uris.stream().forEach(uri -> {
+                Source source = new Source(uri);
+                final ConfigurationFileWatcher watcher = new ConfigurationFileWatcher(
+                        this, (Reconfigurable) this, listeners, source.getFile().lastModified());
+                watchManager.watch(source, watcher);
+            });
+        }
+    }
+
     private boolean hasAsyncLoggers() {
         if (root instanceof AsyncLoggerConfig) {
             return true;
@@ -729,9 +751,16 @@ protected void doConfigure() {
             } else if (child.isInstanceOf(AsyncWaitStrategyFactoryConfig.class)) {
                 final AsyncWaitStrategyFactoryConfig awsfc = child.getObject(AsyncWaitStrategyFactoryConfig.class);
                 asyncWaitStrategyFactory = awsfc.createWaitStrategyFactory();
+            } else if (child.isInstanceOf(MonitorUris.class)) {
+                uris = convertToJavaNetUris(child.getObject(MonitorUris.class).getUris());
             } else {
                 final List<String> expected = Arrays.asList(
-                        "\"Appenders\"", "\"Loggers\"", "\"Properties\"", "\"Scripts\"", "\"CustomLevels\"");
+                        "\"Appenders\"",
+                        "\"Loggers\"",
+                        "\"Properties\"",
+                        "\"Scripts\"",
+                        "\"CustomLevels\"",
+                        "\"MonitorUris\"");
                 LOGGER.error(
                         "Unknown object \"{}\" of type {} is ignored: try nesting it inside one of: {}.",
                         child.getName(),
@@ -767,6 +796,18 @@ protected void doConfigure() {
         setParents();
     }
 
+    private List<URI> convertToJavaNetUris(final List<Uri> uris) {
+        final List<URI> javaNetUris = new ArrayList<>();
+        for (Uri uri : uris) {
+            try {
+                javaNetUris.add(new URI(uri.getUri()));
+            } catch (URISyntaxException e) {
+                LOGGER.error("Error parsing monitor URI: " + uri, e);
+            }
+        }
+        return javaNetUris;
+    }
+
     public static Level getDefaultLevel() {
         final String levelName = PropertiesUtil.getProperties()
                 .getStringProperty(DefaultConfiguration.DEFAULT_LEVEL, Level.ERROR.name());

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

@@ -0,0 +1,58 @@
+/*
+ * 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.config;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.apache.logging.log4j.core.Core;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.config.plugins.PluginElement;
+import org.apache.logging.log4j.core.config.plugins.PluginFactory;
+
+/**
+ * Container for MonitorUri objects.
+ */
+@Plugin(name = "MonitorUris", category = Core.CATEGORY_NAME, printObject = true)
+public final class MonitorUris {
+
+    private final List<Uri> uris;
+
+    private MonitorUris(final Uri[] uris) {
+        this.uris = new ArrayList<>(Arrays.asList(uris));
+    }
+
+    /**
+     * Create a MonitorUris object to contain all the URIs to be monitored.
+     *
+     * @param uris An array of URIs.
+     * @return A MonitorUris object.
+     */
+    @PluginFactory
+    public static MonitorUris createMonitorUris( //
+            @PluginElement("Uris") final Uri[] uris) {
+        return new MonitorUris(uris == null ? Uri.EMPTY_ARRAY : uris);
+    }
+
+    /**
+     * Returns a list of the {@code Uri} objects created during configuration.
+     * @return the URIs to be monitored
+     */
+    public List<Uri> getUris() {
+        return uris;
+    }
+}

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

@@ -0,0 +1,88 @@
+/*
+ * 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.config;
+
+import java.util.Objects;
+import org.apache.logging.log4j.core.Core;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.config.plugins.PluginFactory;
+import org.apache.logging.log4j.core.config.plugins.PluginValue;
+import org.apache.logging.log4j.status.StatusLogger;
+
+/**
+ * Descriptor of a URI object that is created via configuration.
+ */
+@Plugin(name = "Uri", category = Core.CATEGORY_NAME, printObject = true)
+public final class Uri {
+
+    /**
+     * The empty array.
+     */
+    static final Uri[] EMPTY_ARRAY = {};
+
+    private final String uri;
+
+    private Uri(final String uri) {
+        this.uri = Objects.requireNonNull(uri, "uri is null");
+    }
+
+    /**
+     * Creates a Uri object.
+     *
+     * @param uri the URI.
+     * @return A Uri object.
+     */
+    @PluginFactory
+    public static Uri createUri( // @formatter:off
+            @PluginValue("uri") final String uri) {
+        // @formatter:on
+
+        StatusLogger.getLogger().debug("Creating Uri('{}')", uri);
+        return new Uri(uri);
+    }
+
+    /**
+     * Returns the URI.
+     *
+     * @return the URI
+     */
+    public String getUri() {
+        return uri;
+    }
+
+    @Override
+    public int hashCode() {
+        return uri.hashCode();
+    }
+
+    @Override
+    public boolean equals(final Object object) {
+        if (this == object) {
+            return true;
+        }
+        if (!(object instanceof Uri)) {
+            return false;
+        }
+        final Uri other = (Uri) object;
+        return this.uri == other.uri;
+    }
+
+    @Override
+    public String toString() {
+        return "Uri[" + uri + "]";
+    }
+}

log4j-core/src/main/java/org/apache/logging/log4j/core/config/builder/api/ConfigurationBuilder.java

@@ -61,6 +61,15 @@ public interface ConfigurationBuilder<T extends Configuration> extends Builder<T
      */
     ConfigurationBuilder<T> add(CustomLevelComponentBuilder builder);
 
+    /**
+     * Adds a MonitorUri component.
+     * @param builder The MonitorUriComponentBuilder with all of its attributes set.
+     * @return this builder instance.
+     */
+    default ConfigurationBuilder<T> add(MonitorUriComponentBuilder builder) {
+        return this;
+    }
+
     /**
      * Adds a Filter component.
      * @param builder the FilterComponentBuilder with all of its attributes and sub components set.
@@ -272,6 +281,15 @@ public interface ConfigurationBuilder<T extends Configuration> extends Builder<T
      */
     CustomLevelComponentBuilder newCustomLevel(String name, int level);
 
+    /**
+     * Returns a builder for creating MonitorUris
+     * @param uri The URI.
+     * @return A new MonitorUriComponentBuilder.
+     */
+    default MonitorUriComponentBuilder newMonitorUri(String uri) {
+        return null;
+    }
+
     /**
      * Returns a builder for creating Filters.
      * @param pluginName The Plugin type of the Filter.

log4j-core/src/main/java/org/apache/logging/log4j/core/config/builder/api/MonitorUriComponentBuilder.java

@@ -0,0 +1,22 @@
+/*
+ * 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.config.builder.api;
+
+/**
+ * Assembler for constructing MonitorUri Components.
+ */
+public interface MonitorUriComponentBuilder extends ComponentBuilder<MonitorUriComponentBuilder> {}

log4j-core/src/main/java/org/apache/logging/log4j/core/config/builder/api/package-info.java

@@ -20,7 +20,7 @@
  * @since 2.4
  */
 @Export
-@Version("2.20.1")
+@Version("2.25.0")
 package org.apache.logging.log4j.core.config.builder.api;
 
 import org.osgi.annotation.bundle.Export;

log4j-core/src/main/java/org/apache/logging/log4j/core/config/builder/impl/BuiltConfiguration.java

@@ -46,6 +46,7 @@ public class BuiltConfiguration extends AbstractConfiguration {
     private Component propertiesComponent;
     private Component customLevelsComponent;
     private Component scriptsComponent;
+    private Component monitorUriComponent;
     private String contentType = "text";
 
     public BuiltConfiguration(
@@ -78,6 +79,10 @@ public BuiltConfiguration(
                     customLevelsComponent = component;
                     break;
                 }
+                case "MonitorUris": {
+                    monitorUriComponent = component;
+                    break;
+                }
             }
         }
         this.rootComponent = rootComponent;
@@ -95,6 +100,9 @@ public void setup() {
         if (customLevelsComponent.getComponents().size() > 0) {
             children.add(convertToNode(rootNode, customLevelsComponent));
         }
+        if (monitorUriComponent.getComponents().size() > 0) {
+            children.add(convertToNode(rootNode, monitorUriComponent));
+        }
         children.add(convertToNode(rootNode, loggersComponent));
         children.add(convertToNode(rootNode, appendersComponent));
         if (filtersComponent.getComponents().size() > 0) {