fix: remove retryStrategy config, hardcode eager; count pruned events as drops

- Remove retryStrategy from Config type, defaultConfig, and RetryManager
  constructor — always use eager (shortest wait) for concurrent batch errors
- Count events pruned by maxTotalBackoffDuration toward droppedEventCount
- Add SDD-default config tests verifying all spec status codes against
  defaultHttpConfig overrides (408/410/460=retry, 501/505=drop)
- Update RetryManager tests for eager-only behavior

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: abueide

packages/core/src/__tests__/errors-classification.test.ts

@@ -1,19 +1,17 @@
 import { classifyError, parseRetryAfter } from '../errors';
+import { defaultHttpConfig } from '../constants';
 
 describe('classifyError', () => {
-  describe('SDD-default config (statusCodeOverrides per spec)', () => {
+  describe('SDD-default config (defaultHttpConfig overrides)', () => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const backoff = defaultHttpConfig.backoffConfig!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const rateLimit = defaultHttpConfig.rateLimitConfig!;
     const sddConfig = {
-      default4xxBehavior: 'drop' as const,
-      default5xxBehavior: 'retry' as const,
-      statusCodeOverrides: {
-        '408': 'retry' as const,
-        '410': 'retry' as const,
-        '429': 'retry' as const,
-        '460': 'retry' as const,
-        '501': 'drop' as const,
-        '505': 'drop' as const,
-      },
-      rateLimitEnabled: true,
+      default4xxBehavior: backoff.default4xxBehavior,
+      default5xxBehavior: backoff.default5xxBehavior,
+      statusCodeOverrides: backoff.statusCodeOverrides,
+      rateLimitEnabled: rateLimit.enabled,
     };
 
     it('retries 408 (Request Timeout)', () => {

packages/core/src/backoff/RetryManager.ts

@@ -29,8 +29,9 @@ export type RetryResult = 'rate_limited' | 'backed_off' | 'limit_exceeded';
  * - BACKING_OFF: transient error; exponential backoff until wait expires
  *
  * Designed for concurrent batch uploads (Promise.all). Multiple batches can
- * fail simultaneously with different errors or partially succeed. The retry
- * strategy (eager/lazy) controls how concurrent wait times are consolidated.
+ * fail simultaneously with different errors or partially succeed. When
+ * concurrent wait times conflict, the shorter wait is used (eager strategy)
+ * to retry sooner.
  *
  * Uses a global retry counter since batches are re-chunked from the event
  * queue on each flush and have no stable identities.
@@ -40,20 +41,17 @@ export class RetryManager {
   private rateLimitConfig?: RateLimitConfig;
   private backoffConfig?: BackoffConfig;
   private logger?: LoggerType;
-  private retryStrategy: 'eager' | 'lazy';
 
   constructor(
     storeId: string,
     persistor: Persistor | undefined,
     rateLimitConfig?: RateLimitConfig,
     backoffConfig?: BackoffConfig,
-    logger?: LoggerType,
-    retryStrategy: 'eager' | 'lazy' = 'lazy'
+    logger?: LoggerType
   ) {
     this.rateLimitConfig = rateLimitConfig;
     this.backoffConfig = backoffConfig;
     this.logger = logger;
-    this.retryStrategy = retryStrategy;
 
     try {
       this.store = createStore<RetryStateData>(
@@ -293,14 +291,11 @@ export class RetryManager {
   }
 
   /**
-   * Consolidate two wait-until times based on retry strategy.
-   * - 'lazy': take the longer wait (most conservative, default)
-   * - 'eager': take the shorter wait (retry sooner)
+   * Consolidate two wait-until times using the eager strategy:
+   * take the shorter wait to retry sooner.
    */
   private applyRetryStrategy(existing: number, incoming: number): number {
-    return this.retryStrategy === 'eager'
-      ? Math.min(existing, incoming)
-      : Math.max(existing, incoming);
+    return Math.min(existing, incoming);
   }
 
   private async transitionToReady(): Promise<void> {

packages/core/src/backoff/__tests__/RetryManager.test.ts

@@ -166,7 +166,7 @@ describe('RetryManager', () => {
       expect(await rm.getRetryCount()).toBe(2);
     });
 
-    it('uses longest retry-after when multiple 429s occur', async () => {
+    it('uses shortest retry-after when multiple 429s occur (eager)', async () => {
       const now = 1000000;
       jest.spyOn(Date, 'now').mockReturnValue(now);
 
@@ -181,11 +181,8 @@ describe('RetryManager', () => {
       await rm.handle429(60);
       await rm.handle429(120);
 
-      // Should wait 120s, not 60s
+      // Eager: should use 60s (shortest)
       jest.spyOn(Date, 'now').mockReturnValue(now + 61000);
-      expect(await rm.canRetry()).toBe(false);
-
-      jest.spyOn(Date, 'now').mockReturnValue(now + 121000);
       expect(await rm.canRetry()).toBe(true);
     });
 
@@ -391,20 +388,22 @@ describe('RetryManager', () => {
       jest.spyOn(Date, 'now').mockReturnValue(now + 400);
       expect(await rm.canRetry()).toBe(false);
 
-      // Second error before first expires: 0.5 * 2^1 = 1s
-      jest.spyOn(Date, 'now').mockReturnValue(now + 400);
+      // Advance past first wait → transitions to READY (retryCount preserved)
+      jest.spyOn(Date, 'now').mockReturnValue(now + 600);
+      expect(await rm.canRetry()).toBe(true);
+
+      // Second error: 0.5 * 2^1 = 1s (retryCount is still 1)
       await rm.handleTransientError();
 
-      // Should now wait for the 1s from second error
-      jest.spyOn(Date, 'now').mockReturnValue(now + 1300);
-      expect(await rm.canRetry()).toBe(false);
       jest.spyOn(Date, 'now').mockReturnValue(now + 1500);
+      expect(await rm.canRetry()).toBe(false);
+      jest.spyOn(Date, 'now').mockReturnValue(now + 1700);
       expect(await rm.canRetry()).toBe(true);
     });
 
     it('clamps backoff to maxBackoffInterval', async () => {
-      const now = 1000000;
-      jest.spyOn(Date, 'now').mockReturnValue(now);
+      let t = 1000000;
+      jest.spyOn(Date, 'now').mockReturnValue(t);
 
       const config: BackoffConfig = {
         ...defaultBackoffConfig,
@@ -418,16 +417,21 @@ describe('RetryManager', () => {
         mockLogger
       );
 
-      // Retry many times to exceed maxBackoffInterval
-      // Without moving time forward so they accumulate
-      for (let i = 0; i < 10; i++) {
+      // Advance retryCount high enough that unclamped backoff would exceed 5s
+      // (0.5 * 2^4 = 8s > 5s). Advance time between errors to avoid eager min.
+      for (let i = 0; i < 5; i++) {
         await rm.handleTransientError();
+        t += 10000;
+        jest.spyOn(Date, 'now').mockReturnValue(t);
+        await rm.canRetry(); // transition to READY
       }
 
-      // Should be clamped to 5s
-      jest.spyOn(Date, 'now').mockReturnValue(now + 4000);
+      // Next error: 0.5 * 2^5 = 16s, clamped to 5s
+      await rm.handleTransientError();
+
+      jest.spyOn(Date, 'now').mockReturnValue(t + 4000);
       expect(await rm.canRetry()).toBe(false);
-      jest.spyOn(Date, 'now').mockReturnValue(now + 6000);
+      jest.spyOn(Date, 'now').mockReturnValue(t + 6000);
       expect(await rm.canRetry()).toBe(true);
     });
 
@@ -506,12 +510,11 @@ describe('RetryManager', () => {
     });
   });
 
-  describe('retryStrategy', () => {
-    it('defaults to lazy (uses longest wait time)', async () => {
+  describe('concurrent wait time consolidation', () => {
+    it('uses shortest wait time when multiple 429s occur (eager)', async () => {
       const now = 1000000;
       jest.spyOn(Date, 'now').mockReturnValue(now);
 
-      // No retryStrategy passed → defaults to 'lazy'
       const rm = new RetryManager(
         'test-key',
         mockPersistor,
@@ -523,36 +526,12 @@ describe('RetryManager', () => {
       await rm.handle429(60);
       await rm.handle429(120);
 
-      // Lazy: should use 120s (longest)
-      jest.spyOn(Date, 'now').mockReturnValue(now + 61000);
-      expect(await rm.canRetry()).toBe(false);
-
-      jest.spyOn(Date, 'now').mockReturnValue(now + 121000);
-      expect(await rm.canRetry()).toBe(true);
-    });
-
-    it('eager strategy uses shortest wait time', async () => {
-      const now = 1000000;
-      jest.spyOn(Date, 'now').mockReturnValue(now);
-
-      const rm = new RetryManager(
-        'test-key',
-        mockPersistor,
-        defaultRateLimitConfig,
-        defaultBackoffConfig,
-        mockLogger,
-        'eager'
-      );
-
-      await rm.handle429(60);
-      await rm.handle429(120);
-
       // Eager: should use 60s (shortest)
       jest.spyOn(Date, 'now').mockReturnValue(now + 61000);
       expect(await rm.canRetry()).toBe(true);
     });
 
-    it('lazy strategy uses longest wait time', async () => {
+    it('uses shortest wait time for transient errors too', async () => {
       const now = 1000000;
       jest.spyOn(Date, 'now').mockReturnValue(now);
 
@@ -561,32 +540,7 @@ describe('RetryManager', () => {
         mockPersistor,
         defaultRateLimitConfig,
         defaultBackoffConfig,
-        mockLogger,
-        'lazy'
-      );
-
-      await rm.handle429(60);
-      await rm.handle429(120);
-
-      // Lazy: should use 120s (longest)
-      jest.spyOn(Date, 'now').mockReturnValue(now + 61000);
-      expect(await rm.canRetry()).toBe(false);
-
-      jest.spyOn(Date, 'now').mockReturnValue(now + 121000);
-      expect(await rm.canRetry()).toBe(true);
-    });
-
-    it('eager strategy applies to transient errors too', async () => {
-      const now = 1000000;
-      jest.spyOn(Date, 'now').mockReturnValue(now);
-
-      const rm = new RetryManager(
-        'test-key',
-        mockPersistor,
-        defaultRateLimitConfig,
-        defaultBackoffConfig,
-        mockLogger,
-        'eager'
+        mockLogger
       );
 
       // First transient: 0.5 * 2^0 = 0.5s → wait until now + 500ms
@@ -763,7 +717,7 @@ describe('RetryManager', () => {
   });
 
   describe('mixed 429 and transient errors', () => {
-    it('429 wait time takes precedence over shorter transient backoff', async () => {
+    it('state stays RATE_LIMITED but wait uses shorter time (eager)', async () => {
       const now = 1000000;
       jest.spyOn(Date, 'now').mockReturnValue(now);
 
@@ -775,20 +729,18 @@ describe('RetryManager', () => {
         mockLogger
       );
 
-      // Get a 429 first
+      // Get a 429 first → RATE_LIMITED, waitUntilTime = now + 60s
       await rm.handle429(60);
       expect(await rm.getRetryCount()).toBe(1);
 
-      // Then a transient error before 429 expires
+      // Transient error at t=10s → backoff = 0.5*2^1 = 1s → waitUntil = now+11s
+      // Eager: min(now+60s, now+11s) = now+11s, state stays RATE_LIMITED
       jest.spyOn(Date, 'now').mockReturnValue(now + 10000);
       await rm.handleTransientError();
       expect(await rm.getRetryCount()).toBe(2);
 
-      // Should use the longest wait time (429's 60s)
-      jest.spyOn(Date, 'now').mockReturnValue(now + 50000);
-      expect(await rm.canRetry()).toBe(false);
-
-      jest.spyOn(Date, 'now').mockReturnValue(now + 61000);
+      // Eager picks shorter wait, so retryable after ~11s from original now
+      jest.spyOn(Date, 'now').mockReturnValue(now + 12000);
       expect(await rm.canRetry()).toBe(true);
     });
   });

packages/core/src/constants.ts

@@ -10,7 +10,6 @@ export const defaultConfig: Config = {
   trackAppLifecycleEvents: false,
   autoAddSegmentDestination: true,
   useSegmentEndpoints: false,
-  retryStrategy: 'lazy',
 };
 
 export const defaultHttpConfig: HttpConfig = {

packages/core/src/plugins/SegmentDestination.ts

@@ -184,6 +184,7 @@ export class SegmentDestination extends DestinationPlugin {
 
     if (expiredMessageIds.length > 0) {
       await this.queuePlugin.dequeueByMessageIds(expiredMessageIds);
+      this.droppedEventCount += expiredMessageIds.length;
       this.analytics?.logger.warn(
         `Pruned ${expiredMessageIds.length} events older than ${maxAge}s`
       );
@@ -368,8 +369,7 @@ export class SegmentDestination extends DestinationPlugin {
           config?.storePersistor,
           httpConfig.rateLimitConfig,
           httpConfig.backoffConfig,
-          this.analytics?.logger,
-          config?.retryStrategy ?? 'lazy'
+          this.analytics?.logger
         );
       }
     }