use an assignment cache to deduplicate bandit action assignments

Author: aarsilv

src/cache/abstract-assignment-cache.ts

@@ -2,11 +2,18 @@ import { getMD5Hash } from '../obfuscation';
 
 import { LRUCache } from './lru-cache';
 
-export type AssignmentCacheValue = {
+export type FlagAssignmentCacheValue = {
   allocationKey: string;
   variationKey: string;
 };
 
+export type BanditAssignmentCacheValue = {
+  banditKey: string;
+  actionKey: string;
+};
+
+type AssignmentCacheValue = FlagAssignmentCacheValue | BanditAssignmentCacheValue;
+
 export type AssignmentCacheKey = {
   subjectKey: string;
   flagKey: string;
@@ -19,11 +26,18 @@ export function assignmentCacheKeyToString({ subjectKey, flagKey }: AssignmentCa
   return getMD5Hash([subjectKey, flagKey].join(';'));
 }
 
-export function assignmentCacheValueToString({
-  allocationKey,
-  variationKey,
-}: AssignmentCacheValue): string {
-  return getMD5Hash([allocationKey, variationKey].join(';'));
+export function assignmentCacheValueToString(cacheValue: AssignmentCacheValue): string {
+  const fieldsToHash: string[] = [];
+
+  if ('allocationKey' in cacheValue && 'variationKey' in cacheValue) {
+    fieldsToHash.push(cacheValue.allocationKey, cacheValue.variationKey);
+  }
+
+  if ('banditKey' in cacheValue && 'actionKey' in cacheValue) {
+    fieldsToHash.push(cacheValue.banditKey, cacheValue.actionKey);
+  }
+
+  return getMD5Hash(fieldsToHash.join(';'));
 }
 
 export interface AsyncMap<K, V> {

src/client/eppo-client-with-bandits.spec.ts

@@ -480,6 +480,7 @@ describe('EppoClient Bandits E2E test', () => {
 
       beforeEach(() => {
         client.useNonExpiringInMemoryAssignmentCache();
+        client.useNonExpiringInMemoryBanditAssignmentCache();
       });
 
       afterEach(() => {
@@ -538,7 +539,7 @@ describe('EppoClient Bandits E2E test', () => {
         const fourthBanditAssignment = requestClientBanditAction();
 
         expect(fourthBanditAssignment.variation).toBe('banner_bandit');
-        expect(thirdBanditAssignment.action).toBe('toyota');
+        expect(fourthBanditAssignment.action).toBe('toyota');
         expect(mockLogAssignment).toHaveBeenCalledTimes(2);
         expect(mockLogBanditAction).toHaveBeenCalledTimes(3);
 

src/client/eppo-client.ts

@@ -75,6 +75,7 @@ export default class EppoClient {
   private banditLogger?: IBanditLogger;
   private isGracefulFailureMode = true;
   private assignmentCache?: AssignmentCache;
+  private banditAssignmentCache?: AssignmentCache;
   private requestPoller?: IPoller;
   private readonly evaluator = new Evaluator();
   private readonly banditEvaluator = new BanditEvaluator();
@@ -651,6 +652,25 @@ export default class EppoClient {
   }
 
   private logBanditAction(banditEvent: IBanditEvent): void {
+    const subjectKey = banditEvent.subject;
+    const flagKey = banditEvent.featureFlag;
+    const banditKey = banditEvent.bandit;
+    const actionKey = banditEvent.action ?? '__eppo_no_action';
+
+    // What our bandit assignment cache cares about for avoiding logging duplicate bandit assignments,
+    // if one is active. Like the flag assignment cache, entries are only stored for a given flag
+    // and subject.
+    const banditAssignmentCacheProperties = {
+      flagKey,
+      subjectKey,
+      banditKey,
+      actionKey,
+    };
+
+    if (this.banditAssignmentCache?.has(banditAssignmentCacheProperties)) {
+      return;
+    }
+
     if (!this.banditLogger) {
       // No bandit logger set; enqueue the event in case a logger is later set
       if (this.queuedBanditEvents.length < MAX_EVENT_QUEUE_SIZE) {
@@ -661,6 +681,7 @@ export default class EppoClient {
     // If here, we have a logger
     try {
       this.banditLogger.logBanditAction(banditEvent);
+      this.banditAssignmentCache?.set(banditAssignmentCacheProperties);
     } catch (err) {
       logger.warn('Error encountered logging bandit action', err);
     }
@@ -904,6 +925,22 @@ export default class EppoClient {
     this.assignmentCache = cache;
   }
 
+  public disableBanditAssignmentCache() {
+    this.banditAssignmentCache = undefined;
+  }
+
+  public useNonExpiringInMemoryBanditAssignmentCache() {
+    this.banditAssignmentCache = new NonExpiringInMemoryAssignmentCache();
+  }
+
+  public useLRUInMemoryBanditAssignmentCache(maxSize: number) {
+    this.banditAssignmentCache = new LRUInMemoryAssignmentCache(maxSize);
+  }
+
+  public useCustomBanditAssignmentCache(cache: AssignmentCache) {
+    this.banditAssignmentCache = cache;
+  }
+
   public setIsGracefulFailureMode(gracefulFailureMode: boolean) {
     this.isGracefulFailureMode = gracefulFailureMode;
   }