Added 'long' as a target type for 'convert_entry_type' processor

data-prepper-api/src/main/java/org/opensearch/dataprepper/typeconverter/LongConverter.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+ package org.opensearch.dataprepper.typeconverter;
+
+ public class LongConverter implements TypeConverter<Long> {
+     public Long convert(Object source) throws IllegalArgumentException {
+         if (source instanceof String) {
+             return Long.parseLong((String)source);
+         }
+         if (source instanceof Float) {
+             return (long)(float)((Float)source);
+         }
+         if (source instanceof Double) {
+             return (long)(double)((Double)source);
+         }
+         if (source instanceof Boolean) {
+             return ((Boolean)source) ? 1L : 0L;
+         }
+         if (source instanceof Integer) {
+             return ((Integer)source).longValue();
+         }
+         if (source instanceof Long) {
+             return (Long)source;
+         }
+         throw new IllegalArgumentException("Unsupported type conversion. Source class: " + source.getClass());
+     }
+ }
+

data-prepper-api/src/test/java/org/opensearch/dataprepper/typeconverter/LongConverterTests.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+ package org.opensearch.dataprepper.typeconverter;
+
+ import org.junit.jupiter.api.Test;
+
+ import static org.hamcrest.CoreMatchers.equalTo;
+ import static org.hamcrest.MatcherAssert.assertThat;
+ import static org.junit.jupiter.api.Assertions.assertThrows;
+
+ public class LongConverterTests {
+     @Test
+     void testStringToLongConversion() {
+         LongConverter converter = new LongConverter();
+         final String stringConstant = "1234";
+         assertThat(converter.convert(stringConstant), equalTo(Long.parseLong(stringConstant)));
+     }
+     @Test
+     void testfloatToLongConversion() {
+         LongConverter converter = new LongConverter();
+         final Float floatConstant = (float)1234.56789;
+         assertThat(converter.convert(floatConstant), equalTo((long)(float)floatConstant));
+     }
+     @Test
+     void testDoubleToLongConversion() {
+        LongConverter converter = new LongConverter();
+        final Double doubleConstant = (double)12345678.12345678;
+        assertThat(converter.convert(doubleConstant), equalTo((long)(double)doubleConstant));
+     }
+     @Test
+     void testBooleanToLongConversion() {
+         LongConverter converter = new LongConverter();
+         final Boolean boolFalseConstant = false;
+         assertThat(converter.convert(boolFalseConstant), equalTo(0L));
+         final Boolean boolTrueConstant = true;
+         assertThat(converter.convert(boolTrueConstant), equalTo(1L));
+     }
+     @Test
+     void testLongToLongConversion() {
+         LongConverter converter = new LongConverter();
+         final Long longConstant = (long)1234;
+         assertThat(converter.convert(longConstant), equalTo(longConstant));
+     }
+     @Test
+     void testInvalidStringConversion() {
+         IntegerConverter converter = new IntegerConverter();
+         assertThrows(IllegalArgumentException.class, () -> converter.convert(new Object()));
+         IntegerConverter converter = new IntegerConverter();
+         assertThrows(IllegalArgumentException.class, () -> converter.convert(new Object()));
+     }
+ }
+

data-prepper-plugins/mutate-event-processors/README.md

@@ -263,7 +263,7 @@ and the type conversion processor will change it to the following output, where
 ### Configuration
 * `key` - keys whose value needs to be converted to a different type. Required if `keys` option is not defined.
 * `keys` - list of keys whose value needs to be converted to a different type. Required if `key` option is not defined. 
-* `type` - target type for the value of the key. Possible values are `integer`, `double`, `string`, and `boolean`. Default is `integer`.
+* `type` - target type for the value of the key. Possible values are `integer`, `double`, `long`, `string`, and `boolean`. Default is `integer`.
 * `null_values` - treat any value in the null_values list as null.
   * Example: `null_values` is `["-"]` and `key` is `key1`. `{"key1": "-", "key2": "value2"}` will parse into `{"key2": "value2"}`
 * `tags_on_failure`(Optional)-  A `List` of `String`s that specifies the tags to be set in the event the processor fails to convert `key` or `keys` to configured `type`. These tags may be used in conditional expressions in other parts of the configuration

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

@@ -11,6 +11,7 @@
 import org.opensearch.dataprepper.typeconverter.StringConverter;
 import org.opensearch.dataprepper.typeconverter.DoubleConverter;
 import org.opensearch.dataprepper.typeconverter.BooleanConverter;
+import org.opensearch.dataprepper.typeconverter.LongConverter;
 
 import java.util.Map;
 import java.util.Arrays;
@@ -20,7 +21,8 @@ public enum TargetType {
     INTEGER("integer", new IntegerConverter()),
     STRING("string", new StringConverter()),
     DOUBLE("double", new DoubleConverter()),
-    BOOLEAN("boolean", new BooleanConverter());
+    BOOLEAN("boolean", new BooleanConverter()),
+    LONG("long", new LongConverter());
 
     private static final Map<String, TargetType> OPTIONS_MAP = Arrays.stream(TargetType.values())
             .collect(Collectors.toMap(