Updates per PR Code Review (apache#3086)

+ made AbstractFiltter.AbstractFilterBuilder onMatch/onMismatch fields protected
+ added AbstractFilter(AbstractFilterBuilder) constructor
+ added RegexFilter.Builder implementation
+ added RegexFilter(Builder) constructor
+ moved RegexFilter Pattern compile into constructor
+ added fields to persist configuration propertties + getters (regexExpression, patternFlags)
+ changed private constructor to accept builder as argument
+ renamed private method 'targetMessageTest' to more approprriate 'getMessageTextByType'
+ added Javadoc
+ grouped deprecations

Author: JWT007

log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/RegexFilterTest.java

@@ -18,6 +18,8 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+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;
@@ -40,8 +42,19 @@ public static void before() {
     }
 
     @Test
-    public void testThresholds() throws Exception {
-        RegexFilter filter = RegexFilter.createFilter(".* test .*", null, false, null, null);
+    void testRegexFilterDoesNotThrowWithAllTheParametersExceptRegexEqualNull() {
+        assertDoesNotThrow(() -> {
+            RegexFilter.newBuilder().setRegex(".* test .*").build();
+        });
+    }
+
+    @Test
+    void testThresholds() throws Exception {
+        RegexFilter filter = RegexFilter.newBuilder()
+                .setRegex(".* test .*")
+                .setUseRawMsg(false)
+                .build();
+        assertNotNull(filter);
         filter.start();
         assertTrue(filter.isStarted());
         assertSame(
@@ -59,7 +72,7 @@ public void testThresholds() throws Exception {
                 .setMessage(new SimpleMessage("test")) //
                 .build();
         assertSame(Filter.Result.DENY, filter.filter(event));
-        filter = RegexFilter.createFilter(null, null, false, null, null);
+        filter = RegexFilter.newBuilder().build();
         assertNull(filter);
     }
 

log4j-core/src/main/java/org/apache/logging/log4j/core/filter/AbstractFilter.java

@@ -16,6 +16,8 @@
  */
 package org.apache.logging.log4j.core.filter;
 
+import java.util.Objects;
+import java.util.Optional;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.Marker;
 import org.apache.logging.log4j.core.AbstractLifeCycle;
@@ -43,16 +45,30 @@ public abstract static class AbstractFilterBuilder<B extends AbstractFilterBuild
         public static final String ATTR_ON_MISMATCH = "onMismatch";
         public static final String ATTR_ON_MATCH = "onMatch";
 
+        /**
+         * The action to perform when a match occurs.
+         */
         @PluginBuilderAttribute(ATTR_ON_MATCH)
-        private Result onMatch = Result.NEUTRAL;
+        protected Result onMatch = Result.NEUTRAL;
 
+        /**
+         * The action to perform when a mismatch occurs.
+         */
         @PluginBuilderAttribute(ATTR_ON_MISMATCH)
-        private Result onMismatch = Result.DENY;
+        protected Result onMismatch = Result.DENY;
 
+        /**
+         * Returns the action to apply when a match occurs
+         * @return the match result
+         */
         public Result getOnMatch() {
             return onMatch;
         }
 
+        /**
+         * Returns the action to apply when a mismatch occurs
+         * @return the mismatch result
+         */
         public Result getOnMismatch() {
             return onMismatch;
         }
@@ -110,6 +126,19 @@ protected AbstractFilter(final Result onMatch, final Result onMismatch) {
         this.onMismatch = onMismatch == null ? Result.DENY : onMismatch;
     }
 
+    /**
+     * Constructs a new instance configured by the given builder
+     * @param builder the builder
+     * @throws NullPointerException if the builder argument is {@code null}
+     */
+    protected AbstractFilter(final AbstractFilterBuilder<?> builder) {
+
+        Objects.requireNonNull(builder, "The 'builder' argument cannot be null.");
+
+        this.onMatch = Optional.ofNullable(builder.onMatch).orElse(Result.NEUTRAL);
+        this.onMismatch = Optional.ofNullable(builder.onMismatch).orElse(Result.DENY);
+    }
+
     @Override
     protected boolean equalsImpl(final Object obj) {
         if (this == obj) {