ENH: improve regex validaiton message (opensearch-project#5447)

* ENH: improve regex validaiton message

Signed-off-by: George Chen <qchea@amazon.com>

Author: chenqi0805

data-prepper-api/build.gradle

@@ -14,6 +14,7 @@ dependencies {
     implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8'
     implementation libs.parquet.common
     implementation libs.commons.lang3
+    implementation 'jakarta.validation:jakarta.validation-api:3.0.2'
     testImplementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml'
     testImplementation project(':data-prepper-test-common')
     testImplementation 'org.skyscreamer:jsonassert:1.5.3'

data-prepper-api/src/main/java/org/opensearch/dataprepper/model/annotations/ValidRegex.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.model.annotations;
+
+import jakarta.validation.Constraint;
+import jakarta.validation.Payload;
+import org.opensearch.dataprepper.model.validation.RegexValueValidator;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Constraint(validatedBy = RegexValueValidator.class)
+@Target({ElementType.FIELD, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ValidRegex {
+    String message() default "Invalid regular expression pattern";
+
+    Class<?>[] groups() default {};
+
+    Class<? extends Payload>[] payload() default {};
+}

data-prepper-api/src/main/java/org/opensearch/dataprepper/model/plugin/InvalidPluginConfigurationException.java

@@ -15,4 +15,8 @@ public class InvalidPluginConfigurationException extends RuntimeException {
     public InvalidPluginConfigurationException(final String message) {
         super(message);
     }
+
+    public InvalidPluginConfigurationException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
 }

data-prepper-api/src/main/java/org/opensearch/dataprepper/model/validation/RegexValueValidator.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.model.validation;
+
+import jakarta.validation.ConstraintValidator;
+import jakarta.validation.ConstraintValidatorContext;
+import org.opensearch.dataprepper.model.annotations.ValidRegex;
+
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+public class RegexValueValidator implements ConstraintValidator<ValidRegex, String> {
+    @Override
+    public boolean isValid(final String pattern, final ConstraintValidatorContext constraintValidatorContext) {
+        if (pattern != null && !pattern.isEmpty()) {
+            try {
+                Pattern.compile(pattern);
+            } catch (PatternSyntaxException e) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

data-prepper-api/src/test/java/org/opensearch/dataprepper/model/plugin/InvalidPluginConfigurationExceptionTest.java

@@ -7,13 +7,20 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.util.UUID;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+@ExtendWith(MockitoExtension.class)
 class InvalidPluginConfigurationExceptionTest {
+    @Mock
+    private Throwable cause;
+
     private String message;
 
     @BeforeEach
@@ -30,4 +37,11 @@ void getMessage_returns_message() {
         assertThat(createObjectUnderTest().getMessage(),
                 equalTo(message));
     }
+
+    @Test
+    void getCause_returns_cause() {
+        final InvalidPluginConfigurationException objectUnderTest = new InvalidPluginConfigurationException(
+                message, cause);
+        assertThat(objectUnderTest.getCause(), equalTo(cause));
+    }
 }

data-prepper-api/src/test/java/org/opensearch/dataprepper/model/validation/RegexValueValidatorTest.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.model.validation;
+
+import jakarta.validation.ConstraintValidatorContext;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.stream.Stream;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+@ExtendWith(MockitoExtension.class)
+class RegexValueValidatorTest {
+    @Mock
+    private ConstraintValidatorContext constraintValidatorContext;
+
+    @ParameterizedTest
+    @MethodSource("provideRegexAndExpectedResult")
+    void testValidateRegex(final String delimiterRegex, final boolean isValid) {
+        final RegexValueValidator objectUnderTest = new RegexValueValidator();
+        assertThat(objectUnderTest.isValid(delimiterRegex, constraintValidatorContext), is(isValid));
+    }
+
+    private static Stream<Arguments> provideRegexAndExpectedResult() {
+        return Stream.of(
+                arguments(null, true),
+                arguments("", true),
+                arguments("abc", true),
+                arguments("(abc", false)
+        );
+    }
+}

data-prepper-plugins/grok-processor/src/main/java/org/opensearch/dataprepper/plugins/processor/grok/GrokProcessor.java

@@ -267,7 +267,15 @@ private void compileMatchPatterns() {
         for (final Map.Entry<String, List<String>> entry : grokProcessorConfig.getMatch().entrySet()) {
             fieldToGrok.put(entry.getKey(), entry.getValue()
                             .stream()
-                            .map(item -> grokCompiler.compile(item, grokProcessorConfig.isNamedCapturesOnly()))
+                            .map(item -> {
+                                try {
+                                    return grokCompiler.compile(item, grokProcessorConfig.isNamedCapturesOnly());
+                                } catch (IllegalArgumentException e) {
+                                    throw new InvalidPluginConfigurationException(
+                                            String.format("Invalid regular expression pattern in match: %s",
+                                                    entry.getKey()), e);
+                                }
+                            })
                             .collect(Collectors.toList()));
         }
     }

data-prepper-plugins/grok-processor/src/test/java/org/opensearch/dataprepper/plugins/processor/grok/GrokProcessorIT.java

@@ -19,6 +19,7 @@
 import org.opensearch.dataprepper.metrics.PluginMetrics;
 import org.opensearch.dataprepper.model.configuration.PluginSetting;
 import org.opensearch.dataprepper.model.event.Event;
+import org.opensearch.dataprepper.model.plugin.InvalidPluginConfigurationException;
 import org.opensearch.dataprepper.model.record.Record;
 
 import java.util.ArrayList;
@@ -30,6 +31,7 @@
 import java.util.stream.Stream;
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -453,9 +455,11 @@ public void testPatternsDirWithCustomPatternsFilesGlob() throws JsonProcessingEx
         pluginSetting.getSettings().put(GrokProcessorConfig.MATCH, matchConfigWithPatterns2Pattern);
         grokProcessorConfig = OBJECT_MAPPER.convertValue(pluginSetting.getSettings(), GrokProcessorConfig.class);
 
-        Throwable throwable = assertThrows(IllegalArgumentException.class, () -> new GrokProcessor(
+        Throwable throwable = assertThrows(InvalidPluginConfigurationException.class, () -> new GrokProcessor(
                 pluginMetrics, grokProcessorConfig, expressionEvaluator));
-        assertThat("No definition for key 'CUSTOMBIRTHDAYPATTERN' found, aborting", equalTo(throwable.getMessage()));
+        assertThat(throwable.getCause(), instanceOf(IllegalArgumentException.class));
+        assertThat("No definition for key 'CUSTOMBIRTHDAYPATTERN' found, aborting", equalTo(throwable
+                .getCause().getMessage()));
     }
 
     @Test
@@ -522,7 +526,7 @@ public void testCompileNonRegisteredPatternThrowsIllegalArgumentException() {
         pluginSetting.getSettings().put(GrokProcessorConfig.MATCH, matchConfig);
         grokProcessorConfig = OBJECT_MAPPER.convertValue(pluginSetting.getSettings(), GrokProcessorConfig.class);
 
-        assertThrows(IllegalArgumentException.class, () -> new GrokProcessor(
+        assertThrows(InvalidPluginConfigurationException.class, () -> new GrokProcessor(
                 pluginMetrics, grokProcessorConfig, expressionEvaluator));
     }
 

data-prepper-plugins/key-value-processor/src/main/java/org/opensearch/dataprepper/plugins/processor/keyvalue/KeyValueProcessorConfig.java

@@ -16,6 +16,7 @@
 import org.opensearch.dataprepper.model.annotations.AlsoRequired;
 import org.opensearch.dataprepper.model.annotations.ExampleValues;
 import org.opensearch.dataprepper.model.annotations.ExampleValues.Example;
+import org.opensearch.dataprepper.model.annotations.ValidRegex;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -65,6 +66,7 @@ public class KeyValueProcessorConfig {
     })
     private String fieldSplitCharacters = DEFAULT_FIELD_SPLIT_CHARACTERS;
 
+    @ValidRegex(message = "The value of field_delimiter_regex is not a valid regex string")
     @JsonProperty(FIELD_DELIMITER_REGEX_KEY)
     @JsonPropertyDescription("A regular expression specifying the delimiter that separates key-value pairs. " +
             "For example, to split on multiple <code>&amp;</code> characters use <code>&amp;+</code>. " +
@@ -93,6 +95,7 @@ public class KeyValueProcessorConfig {
     })
     private String valueSplitCharacters = DEFAULT_VALUE_SPLIT_CHARACTERS;
 
+    @ValidRegex(message = "The value of key_value_delimiter_regex is not a valid regex string")
     @JsonProperty(KEY_VALUE_DELIMITER_REGEX_KEY)
     @JsonPropertyDescription("A regular expression specifying the delimiter that separates keys from their values within a key-value pair. " +
             "For example, to split on multiple <code>=</code> characters use <code>=+</code>. " +
@@ -142,6 +145,7 @@ public class KeyValueProcessorConfig {
     })
     private String prefix = null;
 
+    @ValidRegex(message = "The value of delete_key_regex is not a valid regex string")
     @JsonProperty("delete_key_regex")
     @JsonPropertyDescription("A regular expression specifying characters to delete from the key. " +
             "Special regular expression characters such as <code>[</code> and <code>]</code> must be escaped with <code>\\\\</code>. " +
@@ -152,6 +156,7 @@ public class KeyValueProcessorConfig {
     })
     private String deleteKeyRegex;
 
+    @ValidRegex(message = "The value of delete_value_regex is not a valid regex string")
     @JsonProperty("delete_value_regex")
     @JsonPropertyDescription("A regular expression specifying characters to delete from the value. " +
             "Special regular expression characters such as <code>[</code> and <code>]</code> must be escaped with <code>\\\\</code>. " +

data-prepper-plugins/mutate-event-processors/src/main/java/org/opensearch/dataprepper/plugins/processor/mutateevent/RenameKeyProcessorConfig.java

@@ -16,6 +16,7 @@
 import org.opensearch.dataprepper.model.annotations.AlsoRequired;
 import org.opensearch.dataprepper.model.annotations.ExampleValues;
 import org.opensearch.dataprepper.model.annotations.ExampleValues.Example;
+import org.opensearch.dataprepper.model.annotations.ValidRegex;
 import org.opensearch.dataprepper.model.event.EventKey;
 import org.opensearch.dataprepper.model.event.EventKeyConfiguration;
 import org.opensearch.dataprepper.model.event.EventKeyFactory;
@@ -40,6 +41,7 @@ public static class Entry {
         private EventKey fromKey;
 
 
+        @ValidRegex(message = "The value of from_key_regex is not a valid regex string")
         @JsonProperty(defaultValue = FROM_KEY_REGEX)
         @JsonPropertyDescription("The regex pattern of the key of the entry to be renamed. " +
                 "This field cannot be defined along with <code>from_key</code>.")