ENH: improve regex validaiton message

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/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-plugins/common/src/main/java/org/opensearch/dataprepper/plugins/regex/RegexValueValidator.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.plugins.regex;
+
+import java.util.Objects;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+public class RegexValueValidator {
+    public static boolean validateRegex(final String pattern) {
+        if (pattern != null && !Objects.equals(pattern, "")) {
+            try {
+                Pattern.compile(pattern);
+            } catch (PatternSyntaxException e) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

data-prepper-plugins/common/src/test/java/org/opensearch/dataprepper/plugins/regex/RegexValueValidatorTest.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.plugins.regex;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+class RegexValueValidatorTest {
+    @ParameterizedTest
+    @MethodSource("provideRegexAndExpectedResult")
+    void testValidateRegex(final String delimiterRegex, final boolean isValid) {
+        assertThat(RegexValueValidator.validateRegex(delimiterRegex), is(isValid));
+    }
+
+    private static Stream<Arguments> provideRegexAndExpectedResult() {
+        return Stream.of(
+                Arguments.of(null, true),
+                Arguments.of("", true),
+                Arguments.of("abc", true),
+                Arguments.of("(abc", false)
+        );
+    }
+}

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

@@ -267,7 +267,14 @@ 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 regex 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.plugins.regex.RegexValueValidator;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -278,6 +279,26 @@ boolean isValidStringLiteralConfig() {
         return valueGrouping;
     }
 
+    @AssertTrue(message = "The value of key_value_delimiter_regex is not a valid regex string")
+    boolean isKeyValueDelimiterRegexValid() {
+        return RegexValueValidator.validateRegex(keyValueDelimiterRegex);
+    }
+
+    @AssertTrue(message = "The value of delete_key_regex is not a valid regex string")
+    boolean isDeleteKeyRegexValid() {
+        return RegexValueValidator.validateRegex(deleteKeyRegex);
+    }
+
+    @AssertTrue(message = "The value of delete_value_regex is not a valid regex string")
+    boolean isDeleteValueRegexValid() {
+        return RegexValueValidator.validateRegex(deleteValueRegex);
+    }
+
+    @AssertTrue(message = "The value of field_delimiter_regex is not a valid regex string")
+    boolean isFieldDelimiterRegexValid() {
+        return RegexValueValidator.validateRegex(fieldDelimiterRegex);
+    }
+
     public String getSource() {
         return source;
     }

data-prepper-plugins/key-value-processor/src/test/java/org/opensearch/dataprepper/plugins/processor/keyvalue/KeyValueProcessorConfigTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.plugins.processor.keyvalue;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.opensearch.dataprepper.plugins.processor.keyvalue.KeyValueProcessorConfig.FIELD_DELIMITER_REGEX_KEY;
+import static org.opensearch.dataprepper.plugins.processor.keyvalue.KeyValueProcessorConfig.KEY_VALUE_DELIMITER_REGEX_KEY;
+
+class KeyValueProcessorConfigTest {
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    private KeyValueProcessorConfig createObjectUnderTest(final String keyValueDelimiterRegex,
+                                                          final String deleteKeyRegex,
+                                                          final String deleteValueRegex,
+                                                          final String fieldDelimiterRegex) {
+        final Map<String, Object> map = new HashMap<>();
+        map.put(KEY_VALUE_DELIMITER_REGEX_KEY, keyValueDelimiterRegex);
+        map.put("delete_key_regex", deleteKeyRegex);
+        map.put("delete_value_regex", deleteValueRegex);
+        map.put(FIELD_DELIMITER_REGEX_KEY, fieldDelimiterRegex);
+        return OBJECT_MAPPER.convertValue(map, KeyValueProcessorConfig.class);
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideRegexAndIsValid")
+    void testIsKeyValueDelimiterRegexValid(final String keyValueDelimiterRegex, final boolean isValid) {
+        final KeyValueProcessorConfig objectUnderTest = createObjectUnderTest(
+                keyValueDelimiterRegex, null, null, null);
+        assertThat(objectUnderTest.isKeyValueDelimiterRegexValid(), is(isValid));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideRegexAndIsValid")
+    void testIsDeleteKeyRegexValid(final String deleteKeyRegex, final boolean isValid) {
+        final KeyValueProcessorConfig objectUnderTest = createObjectUnderTest(
+                null, deleteKeyRegex, null, null);
+        assertThat(objectUnderTest.isDeleteKeyRegexValid(), is(isValid));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideRegexAndIsValid")
+    void testIsDeleteValueRegexValid(final String deleteValueRegex, final boolean isValid) {
+        final KeyValueProcessorConfig objectUnderTest = createObjectUnderTest(
+                null, null, deleteValueRegex, null);
+        assertThat(objectUnderTest.isDeleteValueRegexValid(), is(isValid));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideRegexAndIsValid")
+    void testIsFieldDelimiterRegexValid(final String fieldDelimiterRegex, final boolean isValid) {
+        final KeyValueProcessorConfig objectUnderTest = createObjectUnderTest(
+                null, null, null, fieldDelimiterRegex);
+        assertThat(objectUnderTest.isFieldDelimiterRegexValid(), is(isValid));
+    }
+
+    private static Stream<Arguments> provideRegexAndIsValid() {
+        return Stream.of(
+                Arguments.of(null, true),
+                Arguments.of("", true),
+                Arguments.of("abc", true),
+                Arguments.of("(abc", false)
+        );
+    }
+}

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

@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.annotation.JsonPropertyDescription;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
 import jakarta.validation.constraints.NotEmpty;
 import jakarta.validation.constraints.NotNull;
 import org.opensearch.dataprepper.model.annotations.AlsoRequired;
@@ -19,6 +20,7 @@
 import org.opensearch.dataprepper.model.event.EventKey;
 import org.opensearch.dataprepper.model.event.EventKeyConfiguration;
 import org.opensearch.dataprepper.model.event.EventKeyFactory;
+import org.opensearch.dataprepper.plugins.regex.RegexValueValidator;
 
 import java.util.List;
 import java.util.regex.Pattern;
@@ -101,6 +103,11 @@ public Pattern getFromKeyCompiledPattern() {
             return fromKeyCompiledPattern;
         }
 
+        @AssertTrue(message = "The value of from_key_regex is not a valid regex string")
+        boolean isFromKeyRegexValid() {
+            return RegexValueValidator.validateRegex(fromKeyRegex);
+        }
+
         public Entry(final EventKey fromKey, final String fromKeyPattern, final EventKey toKey, final boolean overwriteIfKeyExists, final String renameWhen) {
             this.fromKey = fromKey;
             this.fromKeyRegex = fromKeyPattern;

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.dataprepper.plugins.processor.mutateevent;
+
+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 org.opensearch.dataprepper.model.event.EventKey;
+
+import java.util.stream.Stream;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+class RenameKeyProcessorConfigTest {
+    @Mock
+    private EventKey eventKey;
+
+    @ParameterizedTest
+    @MethodSource("provideFromKeyRegexAndIsValid")
+    void testIsFromKeyRegexValid(final String fromKeyRegex, final boolean isValid) {
+        final RenameKeyProcessorConfig.Entry objectUnderTest = new RenameKeyProcessorConfig.Entry(
+                null, fromKeyRegex, eventKey, false, null);
+        assertThat(objectUnderTest.isFromKeyRegexValid(), is(isValid));
+    }
+
+    private static Stream<Arguments> provideFromKeyRegexAndIsValid() {
+        return Stream.of(
+                Arguments.of(null, true),
+                Arguments.of("", true),
+                Arguments.of("abc", true),
+                Arguments.of("(abc", false)
+        );
+    }
+}

data-prepper-plugins/mutate-string-processors/src/main/java/org/opensearch/dataprepper/plugins/processor/mutatestring/SplitStringProcessorConfig.java

@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.annotation.JsonPropertyDescription;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
 import jakarta.validation.constraints.NotEmpty;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
@@ -21,6 +22,7 @@
 import org.opensearch.dataprepper.model.annotations.ExampleValues;
 import org.opensearch.dataprepper.model.annotations.ExampleValues.Example;
 import org.opensearch.dataprepper.model.event.EventKey;
+import org.opensearch.dataprepper.plugins.regex.RegexValueValidator;
 
 import java.util.List;
 
@@ -91,6 +93,11 @@ public String getDelimiter() {
 
         public String getSplitWhen() { return splitWhen; }
 
+        @AssertTrue(message = "The value of delimiter_regex is not a valid regex string")
+        boolean isDelimiterRegexValid() {
+            return RegexValueValidator.validateRegex(delimiterRegex);
+        }
+
         public Entry(final EventKey source, final String delimiterRegex, final String delimiter, final String splitWhen) {
             this.source = source;
             this.delimiterRegex = delimiterRegex;