LOG4J2-2731 - Add a LevelPatternSelector
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/LevelPatternSelector.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/LevelPatternSelector.java
new file mode 100644
index 0000000..0a08efb
--- /dev/null
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/LevelPatternSelector.java
@@ -0,0 +1,239 @@
+/*
+ * 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.layout;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
+import org.apache.logging.log4j.core.config.plugins.PluginConfiguration;
+import org.apache.logging.log4j.core.config.plugins.PluginElement;
+import org.apache.logging.log4j.core.pattern.PatternFormatter;
+import org.apache.logging.log4j.core.pattern.PatternParser;
+import org.apache.logging.log4j.plugins.Node;
+import org.apache.logging.log4j.plugins.Plugin;
+import org.apache.logging.log4j.status.StatusLogger;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Selects the pattern to use based on the Level in the LogEvent.
+ */
+@Plugin(name = "LevelPatternSelector", category = Node.CATEGORY, elementType = PatternSelector.ELEMENT_TYPE, printObject = true)
+public class LevelPatternSelector implements PatternSelector{
+
+ /**
+ * Custom MarkerPatternSelector builder. Use the {@link LevelPatternSelector#newBuilder() builder factory method} to create this.
+ */
+ public static class Builder implements org.apache.logging.log4j.core.util.Builder<LevelPatternSelector> {
+
+ @PluginElement("PatternMatch")
+ private PatternMatch[] properties;
+
+ @PluginBuilderAttribute("defaultPattern")
+ private String defaultPattern;
+
+ @PluginBuilderAttribute(value = "alwaysWriteExceptions")
+ private boolean alwaysWriteExceptions = true;
+
+ @PluginBuilderAttribute(value = "disableAnsi")
+ private boolean disableAnsi;
+
+ @PluginBuilderAttribute(value = "noConsoleNoAnsi")
+ private boolean noConsoleNoAnsi;
+
+ @PluginConfiguration
+ private Configuration configuration;
+
+ @Override
+ public LevelPatternSelector build() {
+ if (defaultPattern == null) {
+ defaultPattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
+ }
+ if (properties == null || properties.length == 0) {
+ LOGGER.warn("No marker patterns were provided with PatternMatch");
+ return null;
+ }
+ return new LevelPatternSelector(properties, defaultPattern, alwaysWriteExceptions, disableAnsi,
+ noConsoleNoAnsi, configuration);
+ }
+
+ public Builder setProperties(final PatternMatch[] properties) {
+ this.properties = properties;
+ return this;
+ }
+
+ public Builder setDefaultPattern(final String defaultPattern) {
+ this.defaultPattern = defaultPattern;
+ return this;
+ }
+
+ public Builder setAlwaysWriteExceptions(final boolean alwaysWriteExceptions) {
+ this.alwaysWriteExceptions = alwaysWriteExceptions;
+ return this;
+ }
+
+ public Builder setDisableAnsi(final boolean disableAnsi) {
+ this.disableAnsi = disableAnsi;
+ return this;
+ }
+
+ public Builder setNoConsoleNoAnsi(final boolean noConsoleNoAnsi) {
+ this.noConsoleNoAnsi = noConsoleNoAnsi;
+ return this;
+ }
+
+ public Builder setConfiguration(final Configuration configuration) {
+ this.configuration = configuration;
+ return this;
+ }
+
+ }
+
+ private final Map<String, PatternFormatter[]> formatterMap = new HashMap<>();
+
+ private final Map<String, String> patternMap = new HashMap<>();
+
+ private final PatternFormatter[] defaultFormatters;
+
+ private final String defaultPattern;
+
+ private static Logger LOGGER = StatusLogger.getLogger();
+
+ private final boolean requiresLocation;
+
+ /**
+ * @deprecated Use {@link #newBuilder()} instead. This will be private in a future version.
+ */
+ @Deprecated
+ public LevelPatternSelector(final PatternMatch[] properties, final String defaultPattern,
+ final boolean alwaysWriteExceptions, final boolean noConsoleNoAnsi,
+ final Configuration config) {
+ this(properties, defaultPattern, alwaysWriteExceptions, false, noConsoleNoAnsi, config);
+ }
+
+ private LevelPatternSelector(final PatternMatch[] properties, final String defaultPattern,
+ final boolean alwaysWriteExceptions, final boolean disableAnsi,
+ final boolean noConsoleNoAnsi, final Configuration config) {
+ boolean needsLocation = false;
+ final PatternParser parser = PatternLayout.createPatternParser(config);
+ for (final PatternMatch property : properties) {
+ try {
+ final List<PatternFormatter> list = parser.parse(property.getPattern(), alwaysWriteExceptions,
+ disableAnsi, noConsoleNoAnsi);
+ PatternFormatter[] formatters = list.toArray(new PatternFormatter[0]);
+ formatterMap.put(property.getKey(), formatters);
+ for (int i = 0; !needsLocation && i < formatters.length; ++i) {
+ needsLocation = formatters[i].requiresLocation();
+ }
+
+ patternMap.put(property.getKey(), property.getPattern());
+ } catch (final RuntimeException ex) {
+ throw new IllegalArgumentException("Cannot parse pattern '" + property.getPattern() + "'", ex);
+ }
+ }
+ try {
+ final List<PatternFormatter> list = parser.parse(defaultPattern, alwaysWriteExceptions, disableAnsi,
+ noConsoleNoAnsi);
+ defaultFormatters = list.toArray(new PatternFormatter[0]);
+ this.defaultPattern = defaultPattern;
+ for (int i = 0; !needsLocation && i < defaultFormatters.length; ++i) {
+ needsLocation = defaultFormatters[i].requiresLocation();
+ }
+ } catch (final RuntimeException ex) {
+ throw new IllegalArgumentException("Cannot parse pattern '" + defaultPattern + "'", ex);
+ }
+ requiresLocation = needsLocation;
+ }
+
+ @Override
+ public boolean requiresLocation() {
+ return requiresLocation;
+ }
+
+ @Override
+ public PatternFormatter[] getFormatters(final LogEvent event) {
+ final Level level = event.getLevel();
+ if (level == null) {
+ return defaultFormatters;
+ }
+ for (final String key : formatterMap.keySet()) {
+ if (level.name().equalsIgnoreCase(key)) {
+ return formatterMap.get(key);
+ }
+ }
+ return defaultFormatters;
+ }
+
+ /**
+ * Creates a builder for a custom ScriptPatternSelector.
+ *
+ * @return a ScriptPatternSelector builder.
+ */
+ @PluginBuilderFactory
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ /**
+ * Deprecated, use {@link #newBuilder()} instead.
+ * @param properties
+ * @param defaultPattern
+ * @param alwaysWriteExceptions
+ * @param noConsoleNoAnsi
+ * @param configuration
+ * @return a new MarkerPatternSelector.
+ * @deprecated Use {@link #newBuilder()} instead.
+ */
+ @Deprecated
+ public static LevelPatternSelector createSelector(
+ final PatternMatch[] properties,
+ final String defaultPattern,
+ final boolean alwaysWriteExceptions,
+ final boolean noConsoleNoAnsi,
+ final Configuration configuration) {
+ final Builder builder = newBuilder();
+ builder.setProperties(properties);
+ builder.setDefaultPattern(defaultPattern);
+ builder.setAlwaysWriteExceptions(alwaysWriteExceptions);
+ builder.setNoConsoleNoAnsi(noConsoleNoAnsi);
+ builder.setConfiguration(configuration);
+ return builder.build();
+ }
+
+ @Override
+ public String toString() {
+ final StringBuilder sb = new StringBuilder();
+ boolean first = true;
+ for (final Map.Entry<String, String> entry : patternMap.entrySet()) {
+ if (!first) {
+ sb.append(", ");
+ }
+ sb.append("key=\"").append(entry.getKey()).append("\", pattern=\"").append(entry.getValue()).append("\"");
+ first = false;
+ }
+ if (!first) {
+ sb.append(", ");
+ }
+ sb.append("default=\"").append(defaultPattern).append("\"");
+ return sb.toString();
+ }
+}
diff --git a/log4j-core/src/test/java/org/apache/logging/log4j/core/layout/PatternSelectorTest.java b/log4j-core/src/test/java/org/apache/logging/log4j/core/layout/PatternSelectorTest.java
index 45b33b7..a332f1e 100644
--- a/log4j-core/src/test/java/org/apache/logging/log4j/core/layout/PatternSelectorTest.java
+++ b/log4j-core/src/test/java/org/apache/logging/log4j/core/layout/PatternSelectorTest.java
@@ -38,7 +38,7 @@
LoggerContext ctx = LoggerContext.getContext();
@Test
- public void testPatternSelector() throws Exception {
+ public void testMarkerPatternSelector() throws Exception {
final PatternMatch[] patterns = new PatternMatch[1];
patterns[0] = new PatternMatch("FLOW", "%d %-5p [%t]: ====== %C{1}.%M:%L %m ======%n");
// @formatter:off
@@ -59,7 +59,7 @@
.setIncludeLocation(true)
.setMessage(new SimpleMessage("entry")).build();
final String result1 = new FauxLogger().formatEvent(event1, layout);
- final String expectSuffix1 = String.format("====== PatternSelectorTest.testPatternSelector:61 entry ======%n");
+ final String expectSuffix1 = String.format("====== PatternSelectorTest.testMarkerPatternSelector:61 entry ======%n");
assertTrue("Unexpected result: " + result1, result1.endsWith(expectSuffix1));
final LogEvent event2 = Log4jLogEvent.newBuilder() //
.setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
@@ -70,4 +70,27 @@
assertTrue("Unexpected result: " + result2, result2.endsWith(expectSuffix2));
}
+ @Test
+ public void testLevelPatternSelector() throws Exception {
+ final PatternMatch[] patterns = new PatternMatch[1];
+ patterns[0] = new PatternMatch("TRACE", "%d %-5p [%t]: ====== %C{1}.%M:%L %m ======%n");
+ final PatternSelector selector = LevelPatternSelector.createSelector(patterns, "%d %-5p [%t]: %m%n", true, true, ctx.getConfiguration());
+ final PatternLayout layout = PatternLayout.newBuilder().setPatternSelector(selector)
+ .setConfiguration(ctx.getConfiguration()).build();
+ final LogEvent event1 = Log4jLogEvent.newBuilder() //
+ .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.layout.PatternSelectorTest$FauxLogger")
+ .setLevel(Level.TRACE) //
+ .setIncludeLocation(true)
+ .setMessage(new SimpleMessage("entry")).build();
+ final String result1 = new FauxLogger().formatEvent(event1, layout);
+ final String expectSuffix1 = String.format("====== PatternSelectorTest.testLevelPatternSelector:85 entry ======%n");
+ assertTrue("Unexpected result: " + result1, result1.endsWith(expectSuffix1));
+ final LogEvent event2 = Log4jLogEvent.newBuilder() //
+ .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
+ .setLevel(Level.INFO) //
+ .setMessage(new SimpleMessage("Hello, world 1!")).build();
+ final String result2 = new String(layout.toByteArray(event2));
+ final String expectSuffix2 = String.format("Hello, world 1!%n");
+ assertTrue("Unexpected result: " + result2, result2.endsWith(expectSuffix2));
+ }
}
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index e830296..24a45ba 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -160,6 +160,9 @@
</action>
</release>
<release version="2.13.0" date="2019-MM-DD" description="GA Release 2.13.0">
+ <action issue="LOG4J2-2731" dev="rgoers" type="add">
+ Add a Level Patttern Selector.
+ </action>
<action issue="LOG4J2-2727" dev="rogers" type="fix" due-to="Clément Mathieu">
Add setKey method to Kafka Appender Builder.
</action>
diff --git a/src/site/asciidoc/manual/layouts.adoc b/src/site/asciidoc/manual/layouts.adoc
index 888b5b5..04386c0 100644
--- a/src/site/asciidoc/manual/layouts.adoc
+++ b/src/site/asciidoc/manual/layouts.adoc
@@ -1665,6 +1665,23 @@
and a set of PatternMatch elements that identify the various patterns
that can be selected.
+[#LevelPatternSelector]
+==== LevelPatternSelector
+
+The LevelPatternSelector selects patterns based on the log level of
+the log event. If the Level in the log event is equal to (ignoring case)
+ the name specified on the PatternMatch key attribute, then
+the pattern specified on that PatternMatch element will be used.
+
+[source,xml]
+----
+<PatternLayout>
+ <MarkerPatternSelector defaultPattern="[%-5level] %c{1.} %msg%n">
+ <PatternMatch key="FLOW" pattern="[%-5level] %c{1.} ====== %C{1.}.%M:%L %msg ======%n"/>
+ </MarkerPatternSelector>
+</PatternLayout>
+----
+
[#MarkerPatternSelector]
==== MarkerPatternSelector
