Optimize assignment getting (#30)

* Eppo Client with shared UFC tests passing (#23)

* tests passing for rule evaluator, flag evaluator, and eppo value

* work in progress

* shared UFC tests passing

* don't check in test data

* changes from self-review of PR

* apply spotless linter

* working on tests

* better test logging

* use make test for tests

* Add bandit support (#25)

* bandit test harness ready

* add bandit result

* set up for dropping in bandit evaluation

* bandit deserialization wired up

* loading bandit parameters

* bandit stuff happening

* shared bandit tests passing

* bandit logger classes

* bandit log test passing

* more tests for logger

* bandit tests for graceful mode

* apply spotless formatting autofix

* changes from self-review of PR so far

* more changes from self-review of PR

* more changes from self-review

* make test less fragile

* bump version; don't sign local maven

* bandit logging errors should be non-fatal

* use normalized probability floor

* update result before even attempting to log bandit

* spotless 🙄

* do the rename (#26)

* work in progress

* remove singleton for base client

* linter

* expose bandit test harnesses

* expose test uilities

* changes from self-review of PR

* make base client constructor protected

* add simple logger for tests

* basic profiling test

* improvement not using bigint

* faster getShard()

* linter

* more helpful failure message

* increase CPU time allowance to account for slower machines

* bump version

Author: aarsilv

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = 'cloud.eppo'
-version = '3.0.0-SNAPSHOT'
+version = '3.0.1-SNAPSHOT'
 ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
 
 dependencies {
@@ -17,6 +17,7 @@ dependencies {
   // For UFC DTOs
   implementation 'commons-codec:commons-codec:1.17.0'
   implementation 'org.slf4j:slf4j-api:2.0.13'
+  testImplementation 'org.slf4j:slf4j-simple:2.0.16'
   testImplementation platform('org.junit:junit-bom:5.10.3')
   testImplementation 'org.junit.jupiter:junit-jupiter'
   testImplementation 'org.skyscreamer:jsonassert:1.5.3'

src/main/java/cloud/eppo/BanditEvaluator.java

@@ -1,5 +1,7 @@
 package cloud.eppo;
 
+import static cloud.eppo.Utils.getShard;
+
 import cloud.eppo.ufc.dto.*;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -144,15 +146,14 @@ private static String selectAction(
             .sorted(
                 Comparator.comparingInt(
                         (String actionKey) ->
-                            ShardUtils.getShard(
+                            getShard(
                                 flagKey + "-" + subjectKey + "-" + actionKey,
                                 BANDIT_ASSIGNMENT_SHARDS))
                     .thenComparing(actionKey -> actionKey))
             .collect(Collectors.toList());
 
     // Select action from the shuffled actions, based on weight
-    double assignedShard =
-        ShardUtils.getShard(flagKey + "-" + subjectKey, BANDIT_ASSIGNMENT_SHARDS);
+    double assignedShard = getShard(flagKey + "-" + subjectKey, BANDIT_ASSIGNMENT_SHARDS);
     double assignmentWeightThreshold = assignedShard / (double) BANDIT_ASSIGNMENT_SHARDS;
     double cumulativeWeight = 0;
     String assignedAction = null;

src/main/java/cloud/eppo/FlagEvaluator.java

@@ -1,7 +1,7 @@
 package cloud.eppo;
 
-import static cloud.eppo.ShardUtils.getShard;
 import static cloud.eppo.Utils.base64Decode;
+import static cloud.eppo.Utils.getShard;
 
 import cloud.eppo.model.ShardRange;
 import cloud.eppo.ufc.dto.Allocation;

src/main/java/cloud/eppo/ShardUtils.java

@@ -1,7 +1,6 @@
 package cloud.eppo;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -16,28 +15,60 @@
 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);
+    }
+  }
 
   public static void throwIfEmptyOrNull(String input, String errorMessage) {
     if (input == null || input.isEmpty()) {
       throw new IllegalArgumentException(errorMessage);
     }
   }
 
+  /**
+   * Return the String representation of the zero-padded hexadecimal hash of a string input This is
+   * useful for comparing against other string hashes, such as obfuscated flag names.
+   */
   public static String getMD5Hex(String input) {
-    MessageDigest md;
-    try {
-      md = MessageDigest.getInstance("MD5");
-    } catch (NoSuchAlgorithmException e) {
-      throw new RuntimeException("Error computing md5 hash", e);
+    // md5 the input
+    md.reset();
+    byte[] md5Bytes = md.digest(input.getBytes());
+    // Pre-allocate a StringBuilder with a capacity of 32 characters
+    StringBuilder hexString = new StringBuilder(32);
+
+    for (byte b : md5Bytes) {
+      // Append the two hex digits corresponding to the byte
+      hexString.append(Character.forDigit((b >> 4) & 0xF, 16));
+      hexString.append(Character.forDigit(b & 0xF, 16));
     }
-    byte[] messageDigest = md.digest(input.getBytes());
-    BigInteger no = new BigInteger(1, messageDigest);
-    StringBuilder hashText = new StringBuilder(no.toString(16));
-    while (hashText.length() < 32) {
-      hashText.insert(0, "0");
+
+    return hexString.toString();
+  }
+
+  /**
+   * Return a deterministic pseudo-random integer based on the input that falls between 0
+   * (inclusive) and a max value (exclusive) This is useful for randomly bucketing subjects or
+   * shuffling bandit actions
+   */
+  public static int getShard(String input, int maxShardValue) {
+    // md5 the input
+    md.reset();
+    byte[] md5Bytes = md.digest(input.getBytes());
+
+    // Extract the first 4 bytes (8 digits) and convert to a long
+    long value = 0;
+    for (int i = 0; i < 4; i++) {
+      value = (value << 8) | (md5Bytes[i] & 0xFF);
     }
 
-    return hashText.toString();
+    // Modulo into the shard space
+    return (int) (value % maxShardValue);
   }
 
   public static Date parseUtcISODateNode(JsonNode isoDateStringElement) {

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

@@ -0,0 +1,98 @@
+package cloud.eppo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import cloud.eppo.logging.Assignment;
+import cloud.eppo.logging.AssignmentLogger;
+import cloud.eppo.ufc.dto.Attributes;
+import java.lang.management.ManagementFactory;
+import java.lang.management.ThreadMXBean;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ProfileBaseEppoClientTest {
+  private static final Logger log = LoggerFactory.getLogger(ProfileBaseEppoClientTest.class);
+
+  private static final String DUMMY_FLAG_API_KEY = "dummy-flags-api-key"; // Will load flags-v1
+  private static final String TEST_HOST =
+      "https://us-central1-eppo-qa.cloudfunctions.net/serveGitHubRacTestFile";
+
+  private static BaseEppoClient eppoClient;
+  private static final AssignmentLogger noOpAssignmentLogger =
+      new AssignmentLogger() {
+        @Override
+        public void logAssignment(Assignment assignment) {
+          /* no-op */
+        }
+      };
+
+  @BeforeAll
+  public static void initClient() {
+    eppoClient =
+        new BaseEppoClient(
+            DUMMY_FLAG_API_KEY,
+            "java",
+            "3.0.0",
+            TEST_HOST,
+            noOpAssignmentLogger,
+            null,
+            false,
+            false);
+
+    eppoClient.loadConfiguration();
+
+    log.info("Test client initialized");
+  }
+
+  @Test
+  public void testGetStringAssignmentPerformance() {
+    Map<String, AtomicInteger> variationCounts = new HashMap<>();
+    Attributes subjectAttributes = new Attributes();
+    subjectAttributes.put("country", "FR");
+
+    ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
+    long startTime = threadBean.getCurrentThreadCpuTime();
+
+    int numIterations = 10000;
+
+    for (int i = 0; i < numIterations; i++) {
+      String subjectKey = "subject" + i;
+      String assignedVariation =
+          eppoClient.getStringAssignment(
+              "new-user-onboarding", subjectKey, subjectAttributes, "default");
+      AtomicInteger existingCount =
+          variationCounts.computeIfAbsent(assignedVariation, k -> new AtomicInteger(0));
+      existingCount.incrementAndGet();
+    }
+    long endTime = threadBean.getCurrentThreadCpuTime();
+    long elapsedTime = endTime - startTime;
+
+    log.info("Assignment counts: {}", variationCounts);
+    log.info("CPU Time: {}", elapsedTime);
+
+    // Assert assignments shook out as expected based the shard ranges
+    assertEquals(4, variationCounts.keySet().size());
+    // Expect ~40% default
+    assertEquals(0.40, variationCounts.get("default").doubleValue() / numIterations, 0.02);
+    // Expect ~30% control (50% of 60%)
+    assertEquals(0.30, variationCounts.get("control").doubleValue() / numIterations, 0.02);
+    // Expect ~18% red (30% of 60%)
+    assertEquals(0.18, variationCounts.get("red").doubleValue() / numIterations, 0.02);
+    // Expect ~12% yellow (20% of 60%)
+    assertEquals(0.12, variationCounts.get("yellow").doubleValue() / numIterations, 0.02);
+
+    // Seeing ~48,000,000 - ~54,000,000 for 10k iterations on a M2 Macbook Pro; let's fail if more
+    // than 150,000,000; giving a generous allowance for slower systems (like GitHub) but will still
+    // catch if things slow down considerably
+    long maxAllowedTime = 15000 * numIterations;
+    assertTrue(
+        elapsedTime < maxAllowedTime,
+        "Cpu time of " + elapsedTime + " is more than the " + maxAllowedTime + " allowed");
+  }
+}

src/test/java/cloud/eppo/ProfileBaseEppoClientTest.java

@@ -1,6 +1,6 @@
 package cloud.eppo;
 
-import static cloud.eppo.Utils.parseUtcISODateNode;
+import static cloud.eppo.Utils.*;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
@@ -11,6 +11,34 @@
 import org.junit.jupiter.api.Test;
 
 public class UtilsTest {
+  @Test
+  public void testGetMd5Hash() {
+    // empty string
+    assertEquals("d41d8cd98f00b204e9800998ecf8427e", getMD5Hex(""));
+    // leading zero
+    assertEquals("0212de0d90804f17d2b7bab512cd2f0f", getMD5Hex("input-59"));
+    // zero first byte
+    assertEquals("00dd33988da4202fc1990a4dfa7ee18b", getMD5Hex("input-411"));
+    // zero middle byte
+    assertEquals("448614887a99f16179b400cfccceb72d", getMD5Hex("input-62"));
+    // zero last byte
+    assertEquals("429fb7196ccb2978443a0de8da180e00", getMD5Hex("input-34"));
+  }
+
+  @Test
+  public void testGetShard() {
+    // Shard is the first 8 digits read as a number and modulo into the space
+    int computedShard = (int) (Long.parseLong(getMD5Hex("shard me").substring(0, 8), 16) % 10000);
+    int shardFromGetShard = getShard("shard me", 10000);
+    assertEquals(computedShard, shardFromGetShard);
+
+    // Total shards is respected
+    assertEquals(538, getShard("shard me", 10000));
+    assertEquals(538, getShard("shard me", 1000));
+    assertEquals(38, getShard("shard me", 100));
+    assertEquals(8, getShard("shard me", 10));
+  }
+
   @Test
   public void testParseUtcISODateNode() throws JsonProcessingException {
     ObjectMapper mapper = new ObjectMapper();