You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by pk...@apache.org on 2022/04/24 18:00:21 UTC
[logging-log4j2] branch master updated (c813616555 -> a9982b8cdc)
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
from c813616555 LOG4J2-3476 ignore JUL ApiLogger.setLevel without error
new 22f1955fd9 [LOG4J-3413] Fixes resolution of non-Log4j properties
new 2d3246467b [LOG4J2-3439] Corrects default SSL configuration
new facf2f2074 Changelog entry for LOG4J2-3429
new 8bfd936a34 Adds missing reporter credit
new ca08ed8e46 [LOG4J2-2872] Normalizes level names
new 271e489fb4 LOG4J2-3462 Duplicate dependency in pom.xml (#812)
new e0d25b863a [LOG4J2-3440] Synchronize Log4j 1.x and Log4j 2.x appenders
new 3464578e58 Changelog entries for LOG4J2-2872 and LOG4J-3340
new 2db7968d56 [LOG4J2-3475] Add missing message parameterization in RegexFilter
new af60ec3b29 Add changelog entry for LOG4J2-3475
new a9982b8cdc Add developer info in POM
The 11 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../src/main/java/org/apache/log4j/Category.java | 49 +++++++---
.../org/apache/log4j/bridge/AppenderAdapter.java | 7 +-
.../org/apache/log4j/legacy/core/CategoryUtil.java | 45 +++++++++-
.../test/java/org/apache/log4j/CategoryTest.java | 100 +++++++++++++++++++--
.../test/java/org/apache/log4j/ListAppender.java | 4 +
.../config/PropertiesReconfigurationTest.java | 16 +---
.../apache/log4j/helpers/UtilLoggingLevelTest.java | 7 +-
.../java/org/apache/logging/log4j/LevelTest.java | 19 +++-
.../logging/log4j/util/PropertiesUtilTest.java | 28 ++++++
.../log4j/util/PropertySourceTokenizerTest.java | 4 +
.../src/test/resources/Jira3413Test.properties | 29 +++---
.../main/java/org/apache/logging/log4j/Level.java | 18 ++--
.../apache/logging/log4j/util/PropertySource.java | 27 ++++--
.../logging/log4j/core/filter/RegexFilterTest.java | 20 +++++
.../core/net/ssl/SslConfigurationFactoryTest.java | 73 +++++++++++++++
.../logging/log4j/core/filter/RegexFilter.java | 6 +-
.../net/ssl/AbstractKeyStoreConfiguration.java | 4 +-
.../log4j/core/net/ssl/KeyStoreConfiguration.java | 2 +-
.../core/net/ssl/SslConfigurationDefaults.java | 7 +-
.../core/net/ssl/SslConfigurationFactory.java | 8 +-
pom.xml | 16 ++--
src/changes/changes.xml | 12 +++
src/site/asciidoc/manual/appenders.adoc | 7 +-
23 files changed, 426 insertions(+), 82 deletions(-)
copy log4j-spring-cloud-config/log4j-spring-cloud-config-samples/log4j-spring-cloud-config-sample-application/Dockerfile => log4j-api-test/src/test/resources/Jira3413Test.properties (64%)
create mode 100644 log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactoryTest.java
[logging-log4j2] 06/11: LOG4J2-3462 Duplicate dependency in pom.xml (#812)
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 271e489fb4343336e1a3b7f56624d8c9942dd587
Author: Clara Fang <68...@users.noreply.github.com>
AuthorDate: Mon Apr 4 15:01:12 2022 -0400
LOG4J2-3462 Duplicate dependency in pom.xml (#812)
---
pom.xml | 5 -----
1 file changed, 5 deletions(-)
diff --git a/pom.xml b/pom.xml
index 22fe39d3d0..5f95e1f5a3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1396,11 +1396,6 @@
<artifactId>wagon-ssh</artifactId>
<version>3.1.0</version>
</dependency>
- <dependency>
- <groupId>org.asciidoctor</groupId>
- <artifactId>asciidoctor-maven-plugin</artifactId>
- <version>${asciidoc.plugin.version}</version>
- </dependency>
</dependencies>
<configuration>
<!-- only build English site even on other language OS -->
[logging-log4j2] 01/11: [LOG4J-3413] Fixes resolution of non-Log4j properties
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 22f1955fd9359c737f37fb3bf1aeed51bde071dd
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Fri Feb 25 21:58:18 2022 +0100
[LOG4J-3413] Fixes resolution of non-Log4j properties
For properties that does not start with `log4j` or
`org.apache.logging.log4j` the loosed token-based lookup should not be
applied. There are a couple of exceptions to this rule: the properties
that start with `AsyncLogger` and those related to
`disableThreadContext`.
This PR prevents properties such as `level` to be used as a substitute
for `log4j2.level`
Conflicts:
log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
---
.../logging/log4j/util/PropertiesUtilTest.java | 28 ++++++++++++++++++
.../log4j/util/PropertySourceTokenizerTest.java | 4 +++
.../src/test/resources/Jira3413Test.properties | 34 ++++++++++++++++++++++
.../apache/logging/log4j/util/PropertySource.java | 27 +++++++++++++----
4 files changed, 88 insertions(+), 5 deletions(-)
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
index f7671b609f..d417777095 100644
--- a/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
+++ b/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
@@ -120,4 +120,32 @@ public class PropertiesUtilTest {
assertNotNull(value, "System property was not published");
assertEquals("Log4j", value);
}
+
+ private static final String[][] data = {
+ { null, "org.apache.logging.log4j.level" },
+ { null, "Log4jAnotherProperty" },
+ { null, "log4j2.catalinaBase" },
+ { "ok", "log4j2.configurationFile" },
+ { "ok", "log4j2.defaultStatusLevel" },
+ { "ok", "log4j2.newLevel" },
+ { "ok", "log4j2.asyncLoggerTimeout" },
+ { "ok", "log4j2.asyncLoggerConfigRingBufferSize" },
+ { "ok", "log4j2.disableThreadContext" },
+ { "ok", "log4j2.disableThreadContextStack" },
+ { "ok", "log4j2.disableThreadContextMap" },
+ { "ok", "log4j2.isThreadContextMapInheritable" }
+ };
+
+ /**
+ * LOG4J2-3413: Log4j should only resolve properties that start with a 'log4j'
+ * prefix or similar.
+ */
+ @Test
+ @ResourceLock(value = Resources.SYSTEM_PROPERTIES, mode = ResourceAccessMode.READ)
+ public void testResolvesOnlyLog4jProperties() {
+ final PropertiesUtil util = new PropertiesUtil("Jira3413Test.properties");
+ for (final String[] pair : data) {
+ assertEquals(pair[0], util.getStringProperty(pair[1]));
+ }
+ }
}
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
index f73c4021a5..6dbf4d0f40 100644
--- a/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
+++ b/log4j-api-test/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
@@ -44,6 +44,10 @@ public class PropertySourceTokenizerTest {
{"log4j2-dashed-propertyName", Arrays.asList("dashed", "property", "name")},
{"Log4jProperty_with.all-the/separators", Arrays.asList("property", "with", "all", "the", "separators")},
{"org.apache.logging.log4j.config.property", Arrays.asList("config", "property")},
+ // LOG4J2-3413
+ {"level", Collections.emptyList()},
+ {"user.home", Collections.emptyList()},
+ {"CATALINA_BASE", Collections.emptyList()}
};
}
diff --git a/log4j-api-test/src/test/resources/Jira3413Test.properties b/log4j-api-test/src/test/resources/Jira3413Test.properties
new file mode 100644
index 0000000000..1d3bdff366
--- /dev/null
+++ b/log4j-api-test/src/test/resources/Jira3413Test.properties
@@ -0,0 +1,34 @@
+#
+# 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.
+#
+
+# These should not be resolved
+level=fail
+another.property=fail
+catalina.base=fail
+
+# Some legacy properties with a characteristic prefix
+log4j.configurationFile=ok
+Log4jDefaultStatusLevel=ok
+org.apache.logging.log4j.newLevel=ok
+
+# No characteristic prefix
+AsyncLogger.Timeout=ok
+AsyncLoggerConfig.RingBufferSize=ok
+disableThreadContext=ok
+disableThreadContextStack=ok
+disableThreadContextMap=ok
+isThreadContextMapInheritable=ok
\ No newline at end of file
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/util/PropertySource.java b/log4j-api/src/main/java/org/apache/logging/log4j/util/PropertySource.java
index 8b30878a00..2b12f431af 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/util/PropertySource.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/util/PropertySource.java
@@ -18,6 +18,7 @@ package org.apache.logging.log4j.util;
import java.io.Serializable;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -100,9 +101,19 @@ public interface PropertySource {
* @since 2.10.0
*/
final class Util {
- private static final String PREFIXES = "(?i:^log4j2?[-._/]?|^org\\.apache\\.logging\\.log4j\\.)?";
- private static final Pattern PROPERTY_TOKENIZER = Pattern.compile(PREFIXES + "([A-Z]*[a-z0-9]+|[A-Z0-9]+)[-._/]?");
+ private static final Pattern PREFIX_PATTERN = Pattern.compile(
+ // just lookahead for AsyncLogger
+ "(^log4j2?[-._/]?|^org\\.apache\\.logging\\.log4j\\.)|(?=AsyncLogger(Config)?\\.)",
+ Pattern.CASE_INSENSITIVE);
+ private static final Pattern PROPERTY_TOKENIZER = Pattern.compile("([A-Z]*[a-z0-9]+|[A-Z0-9]+)[-._/]?");
private static final Map<CharSequence, List<CharSequence>> CACHE = new ConcurrentHashMap<>();
+ static {
+ // Add legacy properties without Log4j prefix
+ CACHE.put("disableThreadContext", Arrays.asList("disable", "thread", "context"));
+ CACHE.put("disableThreadContextStack", Arrays.asList("disable", "thread", "context", "stack"));
+ CACHE.put("disableThreadContextMap", Arrays.asList("disable", "thread", "context", "map"));
+ CACHE.put("isThreadContextMapInheritable", Arrays.asList("is", "thread", "context", "map", "inheritable"));
+ }
/**
* Converts a property name string into a list of tokens. This will strip a prefix of {@code log4j},
@@ -118,9 +129,15 @@ public interface PropertySource {
return CACHE.get(value);
}
final List<CharSequence> tokens = new ArrayList<>();
- final Matcher matcher = PROPERTY_TOKENIZER.matcher(value);
- while (matcher.find()) {
- tokens.add(matcher.group(1).toLowerCase());
+ int start = 0;
+ final Matcher prefixMatcher = PREFIX_PATTERN.matcher(value);
+ if (prefixMatcher.find(start)) {
+ start = prefixMatcher.end();
+ final Matcher matcher = PROPERTY_TOKENIZER.matcher(value);
+ while (matcher.find(start)) {
+ tokens.add(matcher.group(1).toLowerCase());
+ start = matcher.end();
+ }
}
CACHE.put(value, tokens);
return tokens;
[logging-log4j2] 08/11: Changelog entries for LOG4J2-2872 and LOG4J-3340
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 3464578e58319c2bd0d11dab77a5cd0dcfa4009b
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Sun Apr 10 07:49:20 2022 +0200
Changelog entries for LOG4J2-2872 and LOG4J-3340
Conflicts:
src/changes/changes.xml
---
src/changes/changes.xml | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index d949a2bf2e..0ea31a9d34 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -208,6 +208,12 @@
<action issue="LOG4J2-3359" dev="ggregory" type="fix" due-to="Rajesh, Gary Gregory">
log4j-1.2-api 2.17.2 throws NullPointerException while removing appender with name as null.
</action>
+ <action issue="LOG4J2-2872" dev="pkarwasz" type="fix" due-to="Alla Gofman, Piotr P. Karwasz">
+ Fix problem with non-uppercase custom levels.
+ </action>
+ <action issue="LOG4J2-3440" dev="pkarwasz" type="add">
+ Add support for adding and retrieving appenders in Log4j 1.x bridge.
+ </action>
</release>
<release version="2.17.2" date="2022-02-23" description="GA Release 2.17.2">
<!-- FIXES -->
[logging-log4j2] 10/11: Add changelog entry for LOG4J2-3475
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit af60ec3b2981e7b875e8aee1f9833c1ce5bf44fd
Author: Jeremy Lin <je...@gmail.com>
AuthorDate: Wed Apr 13 02:06:23 2022 -0700
Add changelog entry for LOG4J2-3475
Conflicts:
src/changes/changes.xml
---
src/changes/changes.xml | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 0ea31a9d34..c8017e5093 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -214,6 +214,9 @@
<action issue="LOG4J2-3440" dev="pkarwasz" type="add">
Add support for adding and retrieving appenders in Log4j 1.x bridge.
</action>
+ <action issue="LOG4J2-3475" dev="jjlin" type="fix" due-to="Jeremy Lin">
+ Add missing message parameterization in RegexFilter.
+ </action>
</release>
<release version="2.17.2" date="2022-02-23" description="GA Release 2.17.2">
<!-- FIXES -->
[logging-log4j2] 02/11: [LOG4J2-3439] Corrects default SSL configuration
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 2d3246467b70879adfe44ce619fec350394a7ad9
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Sun Mar 20 21:09:31 2022 +0100
[LOG4J2-3439] Corrects default SSL configuration
Replaces an invalid `SSLContext` algorithm name with Log4j's default and
adds unity tests.
Conflicts:
log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactory.java
src/site/xdoc/manual/appenders.xml
---
.../core/net/ssl/SslConfigurationFactoryTest.java | 73 ++++++++++++++++++++++
.../net/ssl/AbstractKeyStoreConfiguration.java | 4 +-
.../log4j/core/net/ssl/KeyStoreConfiguration.java | 2 +-
.../core/net/ssl/SslConfigurationDefaults.java | 7 ++-
.../core/net/ssl/SslConfigurationFactory.java | 8 ++-
src/site/asciidoc/manual/appenders.adoc | 7 ++-
6 files changed, 92 insertions(+), 9 deletions(-)
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactoryTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactoryTest.java
new file mode 100644
index 0000000000..e6de0db6a2
--- /dev/null
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactoryTest.java
@@ -0,0 +1,73 @@
+/*
+ * 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.net.ssl;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.util.Properties;
+
+import org.apache.logging.log4j.core.test.net.ssl.TestConstants;
+import org.apache.logging.log4j.util.PropertiesUtil;
+import org.junit.jupiter.api.Test;
+
+public class SslConfigurationFactoryTest {
+
+ private static void addKeystoreConfiguration(Properties props) {
+ props.setProperty("log4j2.keyStoreLocation", TestConstants.KEYSTORE_FILE_RESOURCE);
+ props.setProperty("log4j2.keyStoreKeyStoreType", TestConstants.KEYSTORE_TYPE);
+ }
+
+ private static void addTruststoreConfiguration(Properties props) {
+ props.setProperty("log4j2.trustStoreLocation", TestConstants.TRUSTSTORE_FILE_RESOURCE);
+ props.setProperty("log4j2.trustStoreKeyStoreType", TestConstants.TRUSTSTORE_TYPE);
+ }
+
+ @Test
+ public void testStaticConfiguration() {
+ final Properties props = new Properties();
+ final PropertiesUtil util = new PropertiesUtil(props);
+ // No keystore and truststore -> no SslConfiguration
+ SslConfiguration sslConfiguration = SslConfigurationFactory.createSslConfiguration(util);
+ assertNull(sslConfiguration);
+ // Only keystore
+ props.clear();
+ addKeystoreConfiguration(props);
+ util.reload();
+ sslConfiguration = SslConfigurationFactory.createSslConfiguration(util);
+ assertNotNull(sslConfiguration);
+ assertNotNull(sslConfiguration.getKeyStoreConfig());
+ assertNull(sslConfiguration.getTrustStoreConfig());
+ // Only truststore
+ props.clear();
+ addTruststoreConfiguration(props);
+ util.reload();
+ sslConfiguration = SslConfigurationFactory.createSslConfiguration(util);
+ assertNotNull(sslConfiguration);
+ assertNull(sslConfiguration.getKeyStoreConfig());
+ assertNotNull(sslConfiguration.getTrustStoreConfig());
+ // Both
+ props.clear();
+ addKeystoreConfiguration(props);
+ addTruststoreConfiguration(props);
+ util.reload();
+ sslConfiguration = SslConfigurationFactory.createSslConfiguration(util);
+ assertNotNull(sslConfiguration);
+ assertNotNull(sslConfiguration.getKeyStoreConfig());
+ assertNotNull(sslConfiguration.getTrustStoreConfig());
+ }
+}
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/AbstractKeyStoreConfiguration.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/AbstractKeyStoreConfiguration.java
index 74e5eaa577..4df86e7f8c 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/AbstractKeyStoreConfiguration.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/AbstractKeyStoreConfiguration.java
@@ -32,6 +32,8 @@ import org.apache.logging.log4j.core.util.NetUtils;
* Configuration of the KeyStore
*/
public class AbstractKeyStoreConfiguration extends StoreConfiguration<KeyStore> {
+ static final char[] DEFAULT_PASSWORD = "changeit".toCharArray();
+
private final KeyStore keyStore;
private final String keyStoreType;
@@ -54,7 +56,7 @@ public class AbstractKeyStoreConfiguration extends StoreConfiguration<KeyStore>
final KeyStore ks = KeyStore.getInstance(this.keyStoreType);
final char[] password = this.getPassword();
try {
- ks.load(fin, password);
+ ks.load(fin, password != null ? password : DEFAULT_PASSWORD);
} finally {
if (password != null) {
Arrays.fill(password, '\0');
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/KeyStoreConfiguration.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/KeyStoreConfiguration.java
index 6459ac013a..4547f0a395 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/KeyStoreConfiguration.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/KeyStoreConfiguration.java
@@ -128,7 +128,7 @@ public class KeyStoreConfiguration extends AbstractKeyStoreConfiguration {
final KeyManagerFactory kmFactory = KeyManagerFactory.getInstance(this.keyManagerFactoryAlgorithm);
final char[] password = this.getPassword();
try {
- kmFactory.init(this.getKeyStore(), password);
+ kmFactory.init(this.getKeyStore(), password != null ? password : DEFAULT_PASSWORD);
} finally {
if (password != null) {
Arrays.fill(password, '\0');
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationDefaults.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationDefaults.java
index 3c95eeb1e4..daa052e05a 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationDefaults.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationDefaults.java
@@ -16,12 +16,15 @@
*/
package org.apache.logging.log4j.core.net.ssl;
+import java.security.KeyStore;
+
/**
*
*/
public class SslConfigurationDefaults {
- public static final String KEYSTORE_TYPE = "JKS";
- public static final String PROTOCOL = "SSL";
+ public static final String KEYSTORE_TYPE = KeyStore.getDefaultType();
+ // "TLS" uses all protocols available except those excluded in "jdk.tls.disabledAlgorithms"
+ public static final String PROTOCOL = "TLS";
}
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactory.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactory.java
index ad393d6dbd..7c1bf3b583 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactory.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/net/ssl/SslConfigurationFactory.java
@@ -46,6 +46,10 @@ public class SslConfigurationFactory {
private static final Supplier<SslConfiguration> SSL_CONFIGURATION = LazyValue.from(() -> {
final PropertiesUtil props = PropertiesUtil.getProperties();
+ return createSslConfiguration(props);
+ });
+
+ static final SslConfiguration createSslConfiguration(final PropertiesUtil props) {
KeyStoreConfiguration keyStoreConfiguration = null;
TrustStoreConfiguration trustStoreConfiguration = null;
String location = props.getStringProperty(trustStorelocation);
@@ -82,11 +86,11 @@ public class SslConfigurationFactory {
}
if (trustStoreConfiguration != null || keyStoreConfiguration != null) {
final boolean isVerifyHostName = props.getBooleanProperty(verifyHostName, false);
- return SslConfiguration.createSSLConfiguration("https", keyStoreConfiguration,
+ return SslConfiguration.createSSLConfiguration(null, keyStoreConfiguration,
trustStoreConfiguration, isVerifyHostName);
}
return null;
- });
+ }
public static SslConfiguration getSslConfiguration() {
return SSL_CONFIGURATION.get();
diff --git a/src/site/asciidoc/manual/appenders.adoc b/src/site/asciidoc/manual/appenders.adoc
index 00087c29d8..b6dd769458 100644
--- a/src/site/asciidoc/manual/appenders.adoc
+++ b/src/site/asciidoc/manual/appenders.adoc
@@ -4266,9 +4266,10 @@ documents the parameters available for SSL configuration.
[cols=",,",options="header",]
|=======================================================================
|Parameter Name |Type |Description
-|protocol |String |`SSL` if omitted. See also
-http://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#SSLContext[Standard
-names].
+|protocol |String |The SSL protocol to use, `TLS` if omitted. A single value
+may enable multiple protocoles, see the
+https://docs.oracle.com/en/java/javase/11/docs/specs/security/standard-names.html#sslcontext-algorithms[JVM
+documentation] for details.
|KeyStore |KeyStore |Contains your private keys and certificates, and
determines which authentication credentials to send to the remote host.
[logging-log4j2] 05/11: [LOG4J2-2872] Normalizes level names
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit ca08ed8e466ece9a86d32d671e2bf088d2f477af
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Thu Apr 7 22:49:32 2022 +0200
[LOG4J2-2872] Normalizes level names
Calling `Level.forName` with a non upper case argument, can create a
custom level that can not be retrieved using `Level.toLevel`.
This PR fixes to upper case the keys in the `Level.LEVELS` map.
Conflicts:
log4j-api/src/test/java/org/apache/logging/log4j/LevelTest.java
---
.../apache/log4j/helpers/UtilLoggingLevelTest.java | 7 +++++--
.../test/java/org/apache/logging/log4j/LevelTest.java | 19 +++++++++++++++++--
.../src/main/java/org/apache/logging/log4j/Level.java | 18 +++++++++++++-----
pom.xml | 2 +-
4 files changed, 36 insertions(+), 10 deletions(-)
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/helpers/UtilLoggingLevelTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/helpers/UtilLoggingLevelTest.java
index 2d49b43b1c..3b53aa668d 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/helpers/UtilLoggingLevelTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/helpers/UtilLoggingLevelTest.java
@@ -18,6 +18,7 @@
package org.apache.log4j.helpers;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.stream.Stream;
@@ -49,9 +50,11 @@ public class UtilLoggingLevelTest {
@ParameterizedTest
@MethodSource("namesAndLevels")
public void testOptionConverterToLevel(final String name, final UtilLoggingLevel level) {
- assertEquals(level, OptionConverter.toLevel(name, Level.ALL));
+ assertTrue(level == OptionConverter.toLevel(name, Level.ALL), "get v1 level by name");
// Comparison of Log4j 2.x levels
- assertEquals(level.getVersion2Level(), org.apache.logging.log4j.Level.getLevel(name));
+ assertTrue(level.getVersion2Level() == org.apache.logging.log4j.Level.getLevel(name), "get v2 level by name");
+ // Test convertLevel
+ assertTrue(level == OptionConverter.convertLevel(level.getVersion2Level()), "convert level v2 -> v1");
}
}
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/LevelTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/LevelTest.java
index cabcc8496b..4ecf62c2b8 100644
--- a/log4j-api-test/src/test/java/org/apache/logging/log4j/LevelTest.java
+++ b/log4j-api-test/src/test/java/org/apache/logging/log4j/LevelTest.java
@@ -16,9 +16,14 @@
*/
package org.apache.logging.log4j;
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
+import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
public class LevelTest {
@@ -37,9 +42,19 @@ public class LevelTest {
assertNotNull(level);
assertEquals(level, Level.forName(name, intValue));
assertEquals(level, Level.getLevel(name));
+ assertEquals(level, Level.toLevel(name));
assertEquals(intValue, Level.getLevel(name).intLevel());
}
+ @Test
+ public void testThrowsOnNull() {
+ assertThrowsExactly(IllegalArgumentException.class, () -> Level.forName(null, 100));
+ assertThrowsExactly(IllegalArgumentException.class, () -> Level.getLevel(null));
+ // the intLevel should be checked only if we create a new level
+ assertNull(Level.getLevel("Bar"));
+ assertThrowsExactly(IllegalArgumentException.class, () -> Level.forName("Bar", -1));
+ }
+
@Test
public void testGoodLevels() {
final Level level = Level.toLevel("INFO");
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/Level.java b/log4j-api/src/main/java/org/apache/logging/log4j/Level.java
index 48d36d1292..9f9af36b08 100644
--- a/log4j-api/src/main/java/org/apache/logging/log4j/Level.java
+++ b/log4j-api/src/main/java/org/apache/logging/log4j/Level.java
@@ -17,7 +17,6 @@
package org.apache.logging.log4j;
import java.io.Serializable;
-import java.util.Collection;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
@@ -139,7 +138,7 @@ public final class Level implements Comparable<Level>, Serializable {
this.name = name;
this.intLevel = intLevel;
this.standardLevel = StandardLevel.getStandardLevel(intLevel);
- if (LEVELS.putIfAbsent(name, this) != null) {
+ if (LEVELS.putIfAbsent(toUpperCase(name.trim()), this) != null) {
throw new IllegalStateException("Level " + name + " has already been defined.");
}
}
@@ -259,15 +258,20 @@ public final class Level implements Comparable<Level>, Serializable {
* @throws java.lang.IllegalArgumentException if the name is null or intValue is less than zero.
*/
public static Level forName(final String name, final int intValue) {
- final Level level = LEVELS.get(name);
+ if (Strings.isEmpty(name)) {
+ throw new IllegalArgumentException("Illegal null or empty Level name.");
+ }
+ final String normalizedName = toUpperCase(name.trim());
+ final Level level = LEVELS.get(normalizedName);
if (level != null) {
return level;
}
try {
+ // use original capitalization
return new Level(name, intValue);
} catch (final IllegalStateException ex) {
// The level was added by something else so just return that one.
- return LEVELS.get(name);
+ return LEVELS.get(normalizedName);
}
}
@@ -276,9 +280,13 @@ public final class Level implements Comparable<Level>, Serializable {
*
* @param name The name of the Level.
* @return The Level or null.
+ * @throws java.lang.IllegalArgumentException if the name is null.
*/
public static Level getLevel(final String name) {
- return LEVELS.get(name);
+ if (Strings.isEmpty(name)) {
+ throw new IllegalArgumentException("Illegal null or empty Level name.");
+ }
+ return LEVELS.get(toUpperCase(name.trim()));
}
/**
diff --git a/pom.xml b/pom.xml
index 98daee4e97..22fe39d3d0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -274,7 +274,7 @@
<minSeverity>info</minSeverity>
<jctoolsVersion>3.3.0</jctoolsVersion>
<junitVersion>4.13.2</junitVersion>
- <junitJupiterVersion>5.7.2</junitJupiterVersion>
+ <junitJupiterVersion>5.8.2</junitJupiterVersion>
<junitPioneerVersion>1.5.0</junitPioneerVersion>
<mockitoVersion>4.2.0</mockitoVersion>
<byteBuddyVersion>1.11.0</byteBuddyVersion>
[logging-log4j2] 11/11: Add developer info in POM
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit a9982b8cdcb780a4a78f4610d45716536369041f
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Sat Apr 16 15:27:31 2022 +0200
Add developer info in POM
---
pom.xml | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/pom.xml b/pom.xml
index 5f95e1f5a3..5042849678 100644
--- a/pom.xml
+++ b/pom.xml
@@ -141,6 +141,15 @@
</roles>
<timezone>Europe/Amsterdam</timezone>
</developer>
+ <developer>
+ <id>pkarwasz</id>
+ <name>Piotr P. Karwasz</name>
+ <email>pkarwasz@apache.org</email>
+ <roles>
+ <role>Committer</role>
+ </roles>
+ <timezone>Europe/Warsaw</timezone>
+ </developer>
</developers>
<!-- Contributors -->
<contributors>
[logging-log4j2] 07/11: [LOG4J2-3440] Synchronize Log4j 1.x and Log4j 2.x appenders
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit e0d25b863a1732ce4a56775b66438abce6838ecd
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Sun Apr 3 14:35:24 2022 +0200
[LOG4J2-3440] Synchronize Log4j 1.x and Log4j 2.x appenders
Forwards the `addAppender`, `callAppenders`, `getAllAppenders` and
`getAppender` calls the the corresponding Log4j 2.x objects if Log4j 2.x
Core is present.
The `getAllAppenders` method only returns those appenders, which are
attached to homonymous logger config and are native Log4j 1.x appenders.
Conflicts:
log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java
---
.../src/main/java/org/apache/log4j/Category.java | 49 +++++++---
.../org/apache/log4j/bridge/AppenderAdapter.java | 7 +-
.../org/apache/log4j/legacy/core/CategoryUtil.java | 45 +++++++++-
.../test/java/org/apache/log4j/CategoryTest.java | 100 +++++++++++++++++++--
.../test/java/org/apache/log4j/ListAppender.java | 4 +
.../config/PropertiesReconfigurationTest.java | 16 +---
6 files changed, 183 insertions(+), 38 deletions(-)
diff --git a/log4j-1.2-api/src/main/java/org/apache/log4j/Category.java b/log4j-1.2-api/src/main/java/org/apache/log4j/Category.java
index cfafe8d1ea..0ebffc9c77 100644
--- a/log4j-1.2-api/src/main/java/org/apache/log4j/Category.java
+++ b/log4j-1.2-api/src/main/java/org/apache/log4j/Category.java
@@ -16,13 +16,18 @@
*/
package org.apache.log4j;
+import java.util.Collection;
+import java.util.Collections;
import java.util.Enumeration;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Vector;
import java.util.concurrent.ConcurrentMap;
+import java.util.stream.Collectors;
+import org.apache.log4j.bridge.AppenderAdapter;
import org.apache.log4j.bridge.AppenderWrapper;
+import org.apache.log4j.bridge.LogEventWrapper;
import org.apache.log4j.helpers.AppenderAttachableImpl;
import org.apache.log4j.helpers.NullEnumeration;
import org.apache.log4j.legacy.core.CategoryUtil;
@@ -32,6 +37,7 @@ import org.apache.log4j.spi.AppenderAttachable;
import org.apache.log4j.spi.HierarchyEventListener;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.message.LocalizedMessage;
import org.apache.logging.log4j.message.MapMessage;
import org.apache.logging.log4j.message.Message;
@@ -194,11 +200,17 @@ public class Category implements AppenderAttachable {
*/
@Override
public void addAppender(final Appender appender) {
- if (aai == null) {
- aai = new AppenderAttachableImpl();
- }
- aai.addAppender(appender);
if (appender != null) {
+ if (LogManager.isLog4jCorePresent()) {
+ CategoryUtil.addAppender(logger, AppenderAdapter.adapt(appender));
+ } else {
+ synchronized (this) {
+ if (aai == null) {
+ aai = new AppenderAttachableImpl();
+ }
+ aai.addAppender(appender);
+ }
+ }
repository.fireAddAppenderEvent(this, appender);
}
}
@@ -233,6 +245,10 @@ public class Category implements AppenderAttachable {
* @param event the event to log.
*/
public void callAppenders(final LoggingEvent event) {
+ if (LogManager.isLog4jCorePresent()) {
+ CategoryUtil.log(logger, new LogEventWrapper(event));
+ return;
+ }
int writes = 0;
for (Category c = this; c != null; c = c.parent) {
// Protected against simultaneous call to addAppender, removeAppender,...
@@ -353,14 +369,23 @@ public class Category implements AppenderAttachable {
}
/**
- * Get the appenders contained in this category as an {@link Enumeration}. If no appenders can be found, then a
- * {@link NullEnumeration} is returned.
+ * Get all the Log4j 1.x appenders contained in this category as an
+ * {@link Enumeration}. Log4j 2.x appenders are omitted.
*
* @return Enumeration An enumeration of the appenders in this category.
*/
@Override
- @SuppressWarnings("rawtypes")
+ @SuppressWarnings("unchecked")
public Enumeration getAllAppenders() {
+ if (LogManager.isLog4jCorePresent()) {
+ final Collection<org.apache.logging.log4j.core.Appender> appenders = CategoryUtil.getAppenders(logger)
+ .values();
+ return Collections.enumeration(appenders.stream()
+ // omit native Log4j 2.x appenders
+ .filter(AppenderAdapter.Adapter.class::isInstance)
+ .map(AppenderWrapper::adapt)
+ .collect(Collectors.toSet()));
+ }
return aai == null ? NullEnumeration.getInstance() : aai.getAllAppenders();
}
@@ -372,14 +397,10 @@ public class Category implements AppenderAttachable {
*/
@Override
public Appender getAppender(final String name) {
- Appender appender = aai != null ? aai.getAppender(name) : null;
- if (appender == null && LogManager.isLog4jCorePresent()) {
- final org.apache.logging.log4j.core.Appender coreAppender = CategoryUtil.getAppenders(logger).get(name);
- if (coreAppender != null) {
- addAppender(appender = AppenderWrapper.adapt(coreAppender));
- }
+ if (LogManager.isLog4jCorePresent()) {
+ return AppenderWrapper.adapt(CategoryUtil.getAppenders(logger).get(name));
}
- return appender;
+ return aai != null ? aai.getAppender(name) : null;
}
public Priority getChainedPriority() {
diff --git a/log4j-1.2-api/src/main/java/org/apache/log4j/bridge/AppenderAdapter.java b/log4j-1.2-api/src/main/java/org/apache/log4j/bridge/AppenderAdapter.java
index f57e29deab..23931b2ee6 100644
--- a/log4j-1.2-api/src/main/java/org/apache/log4j/bridge/AppenderAdapter.java
+++ b/log4j-1.2-api/src/main/java/org/apache/log4j/bridge/AppenderAdapter.java
@@ -24,6 +24,7 @@ import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.util.Strings;
/**
* Binds a Log4j 1.x Appender to Log4j 2.
@@ -62,7 +63,11 @@ public class AppenderAdapter {
private AppenderAdapter(Appender appender) {
this.appender = appender;
final org.apache.logging.log4j.core.Filter appenderFilter = FilterAdapter.adapt(appender.getFilter());
- this.adapter = new Adapter(appender.getName(), appenderFilter, null, true, null);
+ String name = appender.getName();
+ if (Strings.isEmpty(name)) {
+ name = String.format("0x%08x", appender.hashCode());
+ }
+ this.adapter = new Adapter(name, appenderFilter, null, true, null);
}
public Adapter getAdapter() {
diff --git a/log4j-1.2-api/src/main/java/org/apache/log4j/legacy/core/CategoryUtil.java b/log4j-1.2-api/src/main/java/org/apache/log4j/legacy/core/CategoryUtil.java
index ea6b43cd0e..3e5dc2c515 100644
--- a/log4j-1.2-api/src/main/java/org/apache/log4j/legacy/core/CategoryUtil.java
+++ b/log4j-1.2-api/src/main/java/org/apache/log4j/legacy/core/CategoryUtil.java
@@ -16,14 +16,19 @@
*/
package org.apache.log4j.legacy.core;
+import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
+import java.util.Optional;
import java.util.function.Supplier;
+import org.apache.log4j.bridge.AppenderAdapter;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.spi.LoggerContext;
/**
@@ -40,13 +45,23 @@ public final class CategoryUtil {
}
/**
- * Delegates to {@link org.apache.logging.log4j.core.Logger#getAppenders()} if appropriate.
+ * Gets the appenders attached directly to this logger.
*
* @param logger The target logger.
* @return A Map containing the Appender's name as the key and the Appender as the value.
*/
public static Map<String, Appender> getAppenders(final Logger logger) {
- return get(logger, asCore(logger)::getAppenders, null);
+ return get(logger, () -> getDirectAppenders(logger), Collections.emptyMap());
+ }
+
+ private static Map<String, Appender> getDirectAppenders(final Logger logger) {
+ return CategoryUtil.getExactLoggerConfig(logger)
+ .map(LoggerConfig::getAppenders)
+ .orElse(Collections.emptyMap());
+ }
+
+ private static Optional<LoggerConfig> getExactLoggerConfig(final Logger logger) {
+ return Optional.of(asCore(logger).get()).filter(lc -> logger.getName().equals(lc.getName()));
}
/**
@@ -117,6 +132,32 @@ public final class CategoryUtil {
}
}
+ /**
+ * Adds an appender to the logger. This method requires a check for the presence
+ * of Log4j Core or it will cause a {@code ClassNotFoundException}.
+ *
+ * @param logger The target logger.
+ * @param appender A Log4j2 appender.
+ */
+ public static void addAppender(final Logger logger, final Appender appender) {
+ if (appender instanceof AppenderAdapter.Adapter) {
+ appender.start();
+ }
+ asCore(logger).addAppender(appender);
+ }
+
+ /**
+ * Sends the event to all appenders directly connected with the logger. This
+ * method requires a check for the presence of Log4j Core or it will cause a
+ * {@code ClassNotFoundException}.
+ *
+ * @param logger The target logger.
+ * @param event The event to send.
+ */
+ public static void log(final Logger logger, final LogEvent event) {
+ getExactLoggerConfig(logger).ifPresent(lc -> lc.log(event));
+ }
+
private CategoryUtil() {
}
}
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java
index e490df3c45..e474681eb4 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java
@@ -17,6 +17,23 @@
package org.apache.log4j;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import org.apache.log4j.bridge.AppenderAdapter;
+import org.apache.log4j.bridge.AppenderWrapper;
+import org.apache.log4j.spi.LoggingEvent;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
@@ -34,24 +51,20 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Consumer;
-
-import static org.junit.jupiter.api.Assertions.*;
-
/**
* Tests of Category.
*/
public class CategoryTest {
- private static ListAppender appender = new ListAppender("List");
+ private static final String VERSION1_APPENDER_NAME = "Version1List";
+ private static final String VERSION2_APPENDER_NAME = "List";
+ private static ListAppender appender = new ListAppender(VERSION2_APPENDER_NAME);
+ private static org.apache.log4j.ListAppender version1Appender = new org.apache.log4j.ListAppender();
@BeforeAll
public static void setupClass() {
appender.start();
+ version1Appender.setName(VERSION1_APPENDER_NAME);
System.setProperty(ConfigurationFactory.CONFIGURATION_FACTORY_PROPERTY, BasicConfigurationFactory.class.getName());
}
@@ -328,6 +341,75 @@ public class CategoryTest {
}
+ @Test
+ public void testAddAppender() {
+ try {
+ final Logger rootLogger = LogManager.getRootLogger();
+ int count = version1Appender.getEvents().size();
+ rootLogger.addAppender(version1Appender);
+ final Logger logger = LogManager.getLogger(CategoryTest.class);
+ final org.apache.log4j.ListAppender appender = new org.apache.log4j.ListAppender();
+ appender.setName("appender2");
+ logger.addAppender(appender);
+ // Root logger
+ rootLogger.info("testAddLogger");
+ assertEquals(++count, version1Appender.getEvents().size(), "adding at root works");
+ assertEquals(0, appender.getEvents().size(), "adding at child works");
+ // Another logger
+ logger.info("testAddLogger2");
+ assertEquals(++count, version1Appender.getEvents().size(), "adding at root works");
+ assertEquals(1, appender.getEvents().size(), "adding at child works");
+ // Call appenders
+ final LoggingEvent event = new LoggingEvent();
+ logger.callAppenders(event);
+ assertEquals(++count, version1Appender.getEvents().size(), "callAppenders");
+ assertEquals(2, appender.getEvents().size(), "callAppenders");
+ } finally {
+ LogManager.resetConfiguration();
+ }
+ }
+
+ @Test
+ public void testGetAppender() {
+ try {
+ final Logger rootLogger = LogManager.getRootLogger();
+ final org.apache.logging.log4j.core.Logger v2RootLogger = (org.apache.logging.log4j.core.Logger) rootLogger
+ .getLogger();
+ v2RootLogger.addAppender(AppenderAdapter.adapt(version1Appender));
+ v2RootLogger.addAppender(appender);
+ final List<Appender> rootAppenders = Collections.list(rootLogger.getAllAppenders());
+ assertEquals(1, rootAppenders.size(), "only v1 appenders");
+ assertTrue(rootAppenders.get(0) instanceof org.apache.log4j.ListAppender, "appender is a v1 ListAppender");
+ assertEquals(VERSION1_APPENDER_NAME, rootLogger.getAppender(VERSION1_APPENDER_NAME).getName(),
+ "explicitly named appender");
+ Appender v2ListAppender = rootLogger.getAppender(VERSION2_APPENDER_NAME);
+ assertTrue(v2ListAppender instanceof AppenderWrapper, "explicitly named appender");
+ assertTrue(((AppenderWrapper) v2ListAppender).getAppender() instanceof ListAppender,
+ "appender is a v2 ListAppender");
+
+ final Logger logger = LogManager.getLogger(CategoryTest.class);
+ final org.apache.logging.log4j.core.Logger v2Logger = (org.apache.logging.log4j.core.Logger) logger
+ .getLogger();
+ final org.apache.log4j.ListAppender loggerAppender = new org.apache.log4j.ListAppender();
+ loggerAppender.setName("appender2");
+ v2Logger.addAppender(AppenderAdapter.adapt(loggerAppender));
+ final List<Appender> appenders = Collections.list(logger.getAllAppenders());
+ assertEquals(1, appenders.size(), "no parent appenders");
+ assertEquals(loggerAppender, appenders.get(0));
+ assertNull(logger.getAppender(VERSION1_APPENDER_NAME), "no parent appenders");
+ assertNull(logger.getAppender(VERSION2_APPENDER_NAME), "no parent appenders");
+
+ final Logger childLogger = LogManager.getLogger(CategoryTest.class.getName() + ".child");
+ final Enumeration<Appender> childAppenders = childLogger.getAllAppenders();
+ assertFalse(childAppenders.hasMoreElements(), "no parent appenders");
+ assertNull(childLogger.getAppender("appender2"), "no parent appenders");
+ assertNull(childLogger.getAppender(VERSION1_APPENDER_NAME), "no parent appenders");
+ assertNull(childLogger.getAppender(VERSION2_APPENDER_NAME), "no parent appenders");
+ } finally {
+ LogManager.resetConfiguration();
+ }
+ }
+
/**
* Derived category to check method signature of forcedLog.
*/
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/ListAppender.java b/log4j-1.2-api/src/test/java/org/apache/log4j/ListAppender.java
index 573d98673c..c1d5a799aa 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/ListAppender.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/ListAppender.java
@@ -80,4 +80,8 @@ public class ListAppender extends AppenderSkeleton {
}
return getMessages();
}
+
+ public String toString() {
+ return String.format("ListAppender[%s]", getName());
+ }
}
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
index ae2910e41f..c7774d4daf 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
@@ -128,24 +128,15 @@ public class PropertiesReconfigurationTest {
}
private void checkCustomAppender(final String appenderName, final boolean expectBoolean, final int expectInt, final String expectString) {
- final Logger logger = LogManager.getLogger("test");
+ final Logger logger = LogManager.getRootLogger();
final org.apache.log4j.Appender appender = logger.getAppender(appenderName);
assertNotNull(appender);
assertCustomNoopAppender(appender, expectBoolean, expectInt, expectString);
assertCustomNoopAppender(getAppenderFromContext(appenderName), expectBoolean, expectInt, expectString);
}
- private void checkCustomFileAppender(final boolean expectAppend, final Appender appender) {
- assertNotNull(appender);
- final FileAppender fileAppender = (FileAppender) appender;
- @SuppressWarnings("resource")
- final FileManager manager = fileAppender.getManager();
- assertNotNull(manager);
- assertEquals(expectAppend, manager.isAppend());
- }
-
private void checkCustomFileAppender(final String appenderName, final boolean expectBoolean, final int expectInt, final String expectString) {
- final Logger logger = LogManager.getLogger("test");
+ final Logger logger = LogManager.getRootLogger();
final org.apache.log4j.Appender appender = logger.getAppender(appenderName);
assertNotNull(appender);
assertCustomFileAppender(appender, expectBoolean, expectInt, expectString);
@@ -153,13 +144,14 @@ public class PropertiesReconfigurationTest {
}
private void checkFileAppender(final boolean expectAppend, final String appenderName) {
- final Logger logger = LogManager.getLogger("test");
+ final Logger logger = LogManager.getRootLogger();
final org.apache.log4j.Appender appender = logger.getAppender(appenderName);
assertNotNull(appender);
final AppenderWrapper appenderWrapper = (AppenderWrapper) appender;
checkCoreFileAppender(expectAppend, appenderWrapper.getAppender());
}
+ @SuppressWarnings("unchecked")
private <T extends org.apache.log4j.Appender> T getAppenderFromContext(final String appenderName) {
final LoggerContext context = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
final LoggerConfig loggerConfig = context.getConfiguration().getRootLogger();
[logging-log4j2] 09/11: [LOG4J2-3475] Add missing message parameterization in RegexFilter
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 2db7968d56b75ec6bdba2176a8d63ffb683ef3d7
Author: Jeremy Lin <je...@gmail.com>
AuthorDate: Tue Apr 12 22:18:57 2022 -0700
[LOG4J2-3475] Add missing message parameterization in RegexFilter
Conflicts:
log4j-core/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java
---
.../logging/log4j/core/filter/RegexFilterTest.java | 20 ++++++++++++++++++++
.../logging/log4j/core/filter/RegexFilter.java | 6 +++++-
2 files changed, 25 insertions(+), 1 deletion(-)
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java
index 19dbed9c84..9b68263237 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java
@@ -81,4 +81,24 @@ public class RegexFilterTest {
assertSame(Filter.Result.DENY, filter.filter(null, Level.DEBUG, null, (Message) null, (Throwable) null));
assertSame(Filter.Result.DENY, filter.filter(null, Level.DEBUG, null, null, (Object[]) null));
}
+
+ @Test
+ public void testParameterizedMsg() throws Exception {
+ final String msg = "params {} {}";
+ final Object[] params = { "foo", "bar" };
+
+ // match against raw message
+ final RegexFilter rawFilter = RegexFilter.createFilter("params \\{\\} \\{\\}", null,
+ true, // useRawMsg
+ Result.ACCEPT, Result.DENY);
+ final Result rawResult = rawFilter.filter(null, null, null, msg, params);
+ assertThat(rawResult, equalTo(Result.ACCEPT));
+
+ // match against formatted message
+ final RegexFilter fmtFilter = RegexFilter.createFilter("params foo bar", null,
+ false, // useRawMsg
+ Result.ACCEPT, Result.DENY);
+ final Result fmtResult = fmtFilter.filter(null, null, null, msg, params);
+ assertThat(fmtResult, equalTo(Result.ACCEPT));
+ }
}
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/RegexFilter.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/RegexFilter.java
index 35ee5c79dc..9a3608923d 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/RegexFilter.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/RegexFilter.java
@@ -33,6 +33,7 @@ import org.apache.logging.log4j.plugins.PluginAttribute;
import org.apache.logging.log4j.plugins.PluginElement;
import org.apache.logging.log4j.plugins.PluginFactory;
import org.apache.logging.log4j.message.Message;
+import org.apache.logging.log4j.message.ParameterizedMessage;
/**
* This filter returns the onMatch result if the message matches the regular expression.
@@ -57,7 +58,10 @@ public final class RegexFilter extends AbstractFilter {
@Override
public Result filter(final Logger logger, final Level level, final Marker marker, final String msg,
final Object... params) {
- return filter(msg);
+ if (useRawMessage || params == null || params.length == 0) {
+ return filter(msg);
+ }
+ return filter(ParameterizedMessage.format(msg, params));
}
@Override
[logging-log4j2] 03/11: Changelog entry for LOG4J2-3429
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit facf2f20740ea20b9b320e7d0fa3c256cbcf7966
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Tue Mar 22 09:58:26 2022 +0100
Changelog entry for LOG4J2-3429
Conflicts:
src/changes/changes.xml
---
src/changes/changes.xml | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 7aca637841..e26e644530 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -202,6 +202,9 @@
<action issue="LOG4J2-3423" type="fix" due-to="Radim Tlusty, Gary Gregory">
JAR file containing Log4j configuration isn't closed.
</action>
+ <action issue="LOG4J2-3439" dev="pkarwasz" type="fix">
+ Fixes default SslConfiguration, when a custom keystore is used.
+ </action>
<action issue="LOG4J2-3359" dev="ggregory" type="fix" due-to="Rajesh, Gary Gregory">
log4j-1.2-api 2.17.2 throws NullPointerException while removing appender with name as null.
</action>
[logging-log4j2] 04/11: Adds missing reporter credit
Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pkarwasz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 8bfd936a34f4f11fb5346c728b215f48e20c06fc
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Tue Mar 22 10:04:16 2022 +0100
Adds missing reporter credit
Conflicts:
src/changes/changes.xml
---
src/changes/changes.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index e26e644530..d949a2bf2e 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -202,7 +202,7 @@
<action issue="LOG4J2-3423" type="fix" due-to="Radim Tlusty, Gary Gregory">
JAR file containing Log4j configuration isn't closed.
</action>
- <action issue="LOG4J2-3439" dev="pkarwasz" type="fix">
+ <action issue="LOG4J2-3439" dev="pkarwasz" type="fix" due-to="Jayesh Netravali, Piotr P. Karwasz">
Fixes default SslConfiguration, when a custom keystore is used.
</action>
<action issue="LOG4J2-3359" dev="ggregory" type="fix" due-to="Rajesh, Gary Gregory">