Thread-safe md5 (#128)

* use ThreadLocal for MD5 digest

* unit test for thread-safe md5

* don't hash at runtime evaluation of operator

* update method name

* spotless fixes

* not autoclosable until Java 9

* use numThreads variable for loop

Author: aarsilv

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = 'cloud.eppo'
-version = '3.11.2-SNAPSHOT'
+version = '3.11.2'
 ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
 
 java {

src/main/java/cloud/eppo/Utils.java

@@ -15,14 +15,20 @@
 public final class Utils {
   private static final SimpleDateFormat UTC_ISO_DATE_FORMAT = buildUtcIsoDateFormat();
   private static final Logger log = LoggerFactory.getLogger(Utils.class);
-  private static final MessageDigest md = buildMd5MessageDigest();
-
-  private static MessageDigest buildMd5MessageDigest() {
-    try {
-      return MessageDigest.getInstance("MD5");
-    } catch (NoSuchAlgorithmException e) {
-      throw new RuntimeException("Error computing md5 hash", e);
-    }
+  private static final ThreadLocal<MessageDigest> md = buildMd5MessageDigest();
+
+  @SuppressWarnings("AnonymousHasLambdaAlternative")
+  private static ThreadLocal<MessageDigest> buildMd5MessageDigest() {
+    return new ThreadLocal<MessageDigest>() {
+      @Override
+      protected MessageDigest initialValue() {
+        try {
+          return MessageDigest.getInstance("MD5");
+        } catch (NoSuchAlgorithmException e) {
+          throw new RuntimeException("Error initializing MD5 hash", e);
+        }
+      }
+    };
   }
 
   public static void throwIfEmptyOrNull(String input, String errorMessage) {
@@ -37,8 +43,8 @@ public static void throwIfEmptyOrNull(String input, String errorMessage) {
    */
   public static String getMD5Hex(String input) {
     // md5 the input
-    md.reset();
-    byte[] md5Bytes = md.digest(input.getBytes());
+    md.get().reset();
+    byte[] md5Bytes = md.get().digest(input.getBytes());
     // Pre-allocate a StringBuilder with a capacity of 32 characters
     StringBuilder hexString = new StringBuilder(32);
 
@@ -58,8 +64,8 @@ public static String getMD5Hex(String input) {
    */
   public static int getShard(String input, int maxShardValue) {
     // md5 the input
-    md.reset();
-    byte[] md5Bytes = md.digest(input.getBytes());
+    md.get().reset();
+    byte[] md5Bytes = md.get().digest(input.getBytes());
 
     // Extract the first 4 bytes (8 digits) and convert to a long
     long value = 0;

src/main/java/cloud/eppo/ufc/dto/OperatorType.java

@@ -2,6 +2,9 @@
 
 import static cloud.eppo.Utils.getMD5Hex;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public enum OperatorType {
   NOT_MATCHES("NOT_MATCHES"),
   MATCHES("MATCHES"),
@@ -14,20 +17,40 @@ public enum OperatorType {
   IS_NULL("IS_NULL");
 
   public final String value;
+  private static final Map<String, OperatorType> valuesToOperatorType =
+      buildValueToOperatorTypeMap();
+  private static final Map<String, OperatorType> hashesToOperatorType =
+      buildHashToOperatorTypeMap();
+
+  private static Map<String, OperatorType> buildValueToOperatorTypeMap() {
+    Map<String, OperatorType> result = new HashMap<>();
+    for (OperatorType type : OperatorType.values()) {
+      result.put(type.value, type);
+    }
+    return result;
+  }
+
+  private static Map<String, OperatorType> buildHashToOperatorTypeMap() {
+    Map<String, OperatorType> result = new HashMap<>();
+    for (OperatorType type : OperatorType.values()) {
+      result.put(getMD5Hex(type.value), type);
+    }
+    return result;
+  }
 
   OperatorType(String value) {
     this.value = value;
   }
 
   public static OperatorType fromString(String value) {
-    for (OperatorType type : OperatorType.values()) {
-      if (type.value.equals(value)
-          || getMD5Hex(type.value).equals(value)
-          || getMD5Hex(type.value).equals(value)) {
-        return type;
-      }
+    // First we try obfuscated lookup as in client situations we'll care more about ingestion
+    // performance
+    OperatorType type = hashesToOperatorType.get(value);
+    // Then we'll try non-obfuscated lookup
+    if (type == null) {
+      type = valuesToOperatorType.get(value);
     }
-    return null;
+    return type;
   }
 
   public boolean isInequalityComparison() {

src/test/java/cloud/eppo/UtilsTest.java

@@ -1,13 +1,16 @@
 package cloud.eppo;
 
 import static cloud.eppo.Utils.*;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.util.Date;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.jupiter.api.Test;
 
 public class UtilsTest {
@@ -25,6 +28,42 @@ public void testGetMd5Hash() {
     assertEquals("429fb7196ccb2978443a0de8da180e00", getMD5Hex("input-34"));
   }
 
+  @Test
+  public void testGetMd5HashThreadSafe() {
+    final AtomicBoolean interferenceEncountered = new AtomicBoolean(false);
+    int numThreads = 2;
+    ExecutorService pool = Executors.newFixedThreadPool(numThreads);
+    try {
+      for (int i = 0; i < numThreads; i += 1) {
+        pool.execute(
+            () -> {
+              if (testForMd5Interference()) {
+                interferenceEncountered.set(true);
+              }
+            });
+      }
+      pool.shutdown();
+    } finally {
+      try {
+        assertTrue(pool.awaitTermination(5, TimeUnit.SECONDS));
+      } catch (InterruptedException ex) {
+        fail();
+      }
+      assertFalse(interferenceEncountered.get());
+    }
+  }
+
+  private boolean testForMd5Interference() {
+    boolean interferenceEncountered = false;
+    for (int i = 0; i < 100; i += 1) {
+      if (!getMD5Hex("input-62").equals("448614887a99f16179b400cfccceb72d")) {
+        interferenceEncountered = true;
+        break;
+      }
+    }
+    return interferenceEncountered;
+  }
+
   @Test
   public void testGetShard() {
     // Shard is the first 8 digits read as a number and modulo into the space