fix: always apply defaultHttpConfig, drop events on retry limit exceeded

Root cause: when the CDN settings response had no httpConfig field,
analytics.ts guarded the entire merge block with if (resJson.httpConfig),
so this.httpConfig stayed undefined. This prevented RetryManager creation
in SegmentDestination, disabling all retry features (error classification
overrides, canRetry() gating, retry counting, maxRetries enforcement).

Changes:
- Remove httpConfig guard in analytics.ts — always merge defaultHttpConfig
  as baseline, with CDN and config.httpConfig overrides on top
- Add httpConfig?: DeepPartial<HttpConfig> to Config type for client-side
  overrides (e.g. maxRetries from test harness)
- Drop retryable events when retry limits exceeded in SegmentDestination
  instead of leaving them in the queue indefinitely
- Update fetchSettings test to expect defaultHttpConfig when CDN has no
  httpConfig

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

Author: abueide

packages/core/src/__tests__/internal/fetchSettings.test.ts

@@ -1,5 +1,5 @@
 import { SegmentClient } from '../../analytics';
-import { settingsCDN } from '../../constants';
+import { settingsCDN, defaultHttpConfig } from '../../constants';
 import { SEGMENT_DESTINATION_KEY } from '../../plugins/SegmentDestination';
 import { getMockLogger, MockSegmentStore } from '../../test-helpers';
 import { getURL } from '../../util';
@@ -483,7 +483,7 @@ describe('internal #getSettings', () => {
       expect(result?.backoffConfig?.jitterPercent).toBe(20);
     });
 
-    it('returns undefined httpConfig when CDN has no httpConfig', async () => {
+    it('returns defaultHttpConfig when CDN has no httpConfig', async () => {
       (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
         ok: true,
         json: () => Promise.resolve(defaultIntegrationSettings),
@@ -496,7 +496,17 @@ describe('internal #getSettings', () => {
       });
 
       await anotherClient.fetchSettings();
-      expect(anotherClient.getHttpConfig()).toBeUndefined();
+      const result = anotherClient.getHttpConfig();
+      expect(result).toBeDefined();
+      expect(result?.rateLimitConfig?.enabled).toBe(
+        defaultHttpConfig.rateLimitConfig!.enabled
+      );
+      expect(result?.backoffConfig?.enabled).toBe(
+        defaultHttpConfig.backoffConfig!.enabled
+      );
+      expect(result?.backoffConfig?.statusCodeOverrides).toEqual(
+        defaultHttpConfig.backoffConfig!.statusCodeOverrides
+      );
     });
 
     it('returns undefined httpConfig when fetch fails', async () => {

packages/core/src/analytics.ts

@@ -202,8 +202,8 @@ export class SegmentClient {
   }
 
   /**
-   * Retrieves the server-side httpConfig from CDN settings.
-   * Returns undefined if the CDN did not provide httpConfig (retry features disabled).
+   * Retrieves the merged httpConfig (defaultHttpConfig ← CDN ← config overrides).
+   * Returns undefined only if settings have not yet been fetched.
    */
   getHttpConfig(): HttpConfig | undefined {
     return this.httpConfig;
@@ -412,25 +412,27 @@ export class SegmentClient {
         resJson.middlewareSettings?.routingRules ?? []
       );
 
-      // Extract httpConfig from CDN, merge with defaults, validate and clamp
-      if (resJson.httpConfig) {
-        const mergedRateLimit = resJson.httpConfig.rateLimitConfig
-          ? {
-              ...defaultHttpConfig.rateLimitConfig!,
-              ...resJson.httpConfig.rateLimitConfig,
-            }
-          : defaultHttpConfig.rateLimitConfig!;
-
-        const mergedBackoff = resJson.httpConfig.backoffConfig
-          ? {
-              ...defaultHttpConfig.backoffConfig!,
-              ...resJson.httpConfig.backoffConfig,
-              statusCodeOverrides: {
-                ...defaultHttpConfig.backoffConfig!.statusCodeOverrides,
-                ...resJson.httpConfig.backoffConfig.statusCodeOverrides,
-              },
-            }
-          : defaultHttpConfig.backoffConfig!;
+      // Merge httpConfig: defaultHttpConfig ← CDN ← config overrides
+      {
+        const cdnConfig = resJson.httpConfig ?? {};
+        const clientConfig = this.config.httpConfig ?? {};
+
+        const mergedRateLimit = {
+          ...defaultHttpConfig.rateLimitConfig!,
+          ...(cdnConfig.rateLimitConfig ?? {}),
+          ...(clientConfig.rateLimitConfig ?? {}),
+        };
+
+        const mergedBackoff = {
+          ...defaultHttpConfig.backoffConfig!,
+          ...(cdnConfig.backoffConfig ?? {}),
+          ...(clientConfig.backoffConfig ?? {}),
+          statusCodeOverrides: {
+            ...defaultHttpConfig.backoffConfig!.statusCodeOverrides,
+            ...(cdnConfig.backoffConfig?.statusCodeOverrides ?? {}),
+            ...(clientConfig.backoffConfig?.statusCodeOverrides ?? {}),
+          },
+        };
 
         const validatedRateLimit = validateRateLimitConfig(
           mergedRateLimit,
@@ -444,7 +446,9 @@ export class SegmentClient {
             validatedRateLimit
           ),
         };
-        this.logger.info('Loaded httpConfig from CDN settings.');
+        if (resJson.httpConfig) {
+          this.logger.info('Loaded httpConfig from CDN settings.');
+        }
       }
 
       this.logger.info('Received settings from Segment succesfully.');

packages/core/src/plugins/SegmentDestination.ts

@@ -34,6 +34,7 @@ type ErrorAggregation = {
   rateLimitResults: BatchResult[];
   hasTransientError: boolean;
   permanentErrorMessageIds: string[];
+  retryableMessageIds: string[];
 };
 
 export class SegmentDestination extends DestinationPlugin {
@@ -128,6 +129,7 @@ export class SegmentDestination extends DestinationPlugin {
       rateLimitResults: [],
       hasTransientError: false,
       permanentErrorMessageIds: [],
+      retryableMessageIds: [],
     };
 
     for (const result of results) {
@@ -137,10 +139,12 @@ export class SegmentDestination extends DestinationPlugin {
           break;
         case '429':
           aggregation.rateLimitResults.push(result);
+          aggregation.retryableMessageIds.push(...result.messageIds);
           break;
         case 'transient':
         case 'network_error':
           aggregation.hasTransientError = true;
+          aggregation.retryableMessageIds.push(...result.messageIds);
           break;
         case 'permanent':
           aggregation.permanentErrorMessageIds.push(...result.messageIds);
@@ -273,13 +277,12 @@ export class SegmentDestination extends DestinationPlugin {
       );
     }
 
-    // When retry limits are exceeded, the RetryManager resets to READY.
-    // We do NOT drop events here — individual events are only dropped when
-    // they exceed maxTotalBackoffDuration via pruneExpiredEvents (per-event age).
-    // The global retry counter reset just allows the next flush cycle to retry.
-    if (limitExceeded) {
-      this.analytics?.logger.warn(
-        'Retry limits exceeded, counter reset. Stale events will be pruned by age on next flush.'
+    if (limitExceeded && aggregation.retryableMessageIds.length > 0) {
+      await this.queuePlugin.dequeueByMessageIds(
+        aggregation.retryableMessageIds
+      );
+      this.analytics?.logger.error(
+        `Dropped ${aggregation.retryableMessageIds.length} events due to retry limit exceeded`
       );
     }
 

packages/core/src/types.ts

@@ -165,6 +165,12 @@ export type Config = {
    * period expires and transitions back to READY. Disabled by default.
    */
   autoFlushOnRetryReady?: boolean;
+  /**
+   * Client-side httpConfig overrides. Merged on top of defaultHttpConfig and
+   * CDN settings (highest precedence). Useful for setting maxRetryCount from
+   * test harnesses or per-client configuration.
+   */
+  httpConfig?: DeepPartial<HttpConfig>;
 };
 
 export type ClientMethods = {