segmentio
diff --git a/‎.gitignore‎
Lines changed: 3 additions & 0 deletions b/‎.gitignore‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎e2e-cli/e2e-config.json‎
Lines changed: 1 addition & 1 deletion b/‎e2e-cli/e2e-config.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/core/src/__tests__/api.test.ts‎
Lines changed: 63 additions & 10 deletions b/‎packages/core/src/__tests__/api.test.ts‎
Lines changed: 63 additions & 10 deletions
diff --git a/‎packages/core/src/__tests__/internal/fetchSettings.test.ts‎
Lines changed: 87 additions & 3 deletions b/‎packages/core/src/__tests__/internal/fetchSettings.test.ts‎
Lines changed: 87 additions & 3 deletions
diff --git a/‎packages/core/src/analytics.ts‎
Lines changed: 10 additions & 4 deletions b/‎packages/core/src/analytics.ts‎
Lines changed: 10 additions & 4 deletions
diff --git a/‎packages/core/src/api.ts‎
Lines changed: 12 additions & 3 deletions b/‎packages/core/src/api.ts‎
Lines changed: 12 additions & 3 deletions
diff --git a/‎packages/core/src/backoff/RetryManager.ts‎
Lines changed: 0 additions & 8 deletions b/‎packages/core/src/backoff/RetryManager.ts‎
Lines changed: 0 additions & 8 deletions
@@ -97,5 +97,8 @@ packages/core/src/info.ts
 
 AGENTS.md
 
+# Local files (not for commit)
+*.local.sh
+
 # Notes and research (not for commit)
 notes/
@@ -1,6 +1,6 @@
 {
   "sdk": "react-native",
-  "test_suites": "basic,settings",
+  "test_suites": "basic,settings,retry",
   "auto_settings": true,
   "patch": null,
   "env": {
 
@@ -25,7 +25,11 @@ describe('#sendEvents', () => {
       .mockReturnValue('2001-01-01T00:00:00.000Z');
   });
 
-  async function sendAnEventPer(writeKey: string, toUrl: string) {
+  async function sendAnEventPer(
+    writeKey: string,
+    toUrl: string,
+    retryCount?: number
+  ) {
     const mockResponse = Promise.resolve('MANOS');
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
@@ -60,9 +64,19 @@ describe('#sendEvents', () => {
       writeKey: writeKey,
       url: toUrl,
       events: [event],
+      retryCount,
     });
 
-    expect(fetch).toHaveBeenCalledWith(toUrl, {
+    return event;
+  }
+
+  it('sends an event', async () => {
+    const toSegmentBatchApi = 'https://api.segment.io/v1.b';
+    const writeKey = 'SEGMENT_KEY';
+
+    const event = await sendAnEventPer(writeKey, toSegmentBatchApi);
+
+    expect(fetch).toHaveBeenCalledWith(toSegmentBatchApi, {
       method: 'POST',
       keepalive: true,
       body: JSON.stringify({
@@ -74,19 +88,58 @@ describe('#sendEvents', () => {
         'Content-Type': 'application/json; charset=utf-8',
       },
     });
-  }
-
-  it('sends an event', async () => {
-    const toSegmentBatchApi = 'https://api.segment.io/v1.b';
-    const writeKey = 'SEGMENT_KEY';
-
-    await sendAnEventPer(writeKey, toSegmentBatchApi);
   });
 
   it('sends an event to proxy', async () => {
     const toProxyUrl = 'https://myprox.io/b';
     const writeKey = 'SEGMENT_KEY';
 
-    await sendAnEventPer(writeKey, toProxyUrl);
+    const event = await sendAnEventPer(writeKey, toProxyUrl);
+
+    expect(fetch).toHaveBeenCalledWith(toProxyUrl, {
+      method: 'POST',
+      body: JSON.stringify({
+        batch: [event],
+        sentAt: '2001-01-01T00:00:00.000Z',
+        writeKey: 'SEGMENT_KEY',
+      }),
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+      keepalive: true,
+    });
+  });
+
+  it('does not send X-Retry-Count header on first attempt (retryCount=0)', async () => {
+    const url = 'https://api.segment.io/v1.b';
+    await sendAnEventPer('KEY', url);
+
+    const callArgs = (fetch as jest.Mock).mock.calls[0];
+    const headers = callArgs[1].headers;
+    expect(headers['X-Retry-Count']).toBeUndefined();
+  });
+
+  it('sends X-Retry-Count header with provided retry count', async () => {
+    const url = 'https://api.segment.io/v1.b';
+    await sendAnEventPer('KEY', url, 5);
+
+    expect(fetch).toHaveBeenCalledWith(
+      url,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'X-Retry-Count': '5',
+        }),
+      })
+    );
+  });
+
+  it('sends X-Retry-Count as string format', async () => {
+    const url = 'https://api.segment.io/v1.b';
+    await sendAnEventPer('KEY', url, 42);
+
+    const callArgs = (fetch as jest.Mock).mock.calls[0];
+    const headers = callArgs[1].headers;
+    expect(typeof headers['X-Retry-Count']).toBe('string');
+    expect(headers['X-Retry-Count']).toBe('42');
   });
 });
@@ -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';
@@ -436,6 +436,80 @@ describe('internal #getSettings', () => {
     });
   });
 
+  describe('CDN integrations validation', () => {
+    it('treats null integrations as empty (no integrations configured)', async () => {
+      (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ integrations: null }),
+        status: 200,
+      } as Response);
+
+      const client = new SegmentClient(clientArgs);
+      await client.fetchSettings();
+
+      expect(setSettingsSpy).toHaveBeenCalledWith({});
+    });
+
+    it('treats missing integrations as empty (no integrations configured)', async () => {
+      (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+        status: 200,
+      } as Response);
+
+      const client = new SegmentClient(clientArgs);
+      await client.fetchSettings();
+
+      expect(setSettingsSpy).toHaveBeenCalledWith({});
+    });
+
+    it('falls back to defaults when CDN returns integrations as an array', async () => {
+      (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ integrations: ['invalid'] }),
+        status: 200,
+      } as Response);
+
+      const client = new SegmentClient(clientArgs);
+      await client.fetchSettings();
+
+      expect(setSettingsSpy).toHaveBeenCalledWith(
+        defaultIntegrationSettings.integrations
+      );
+    });
+
+    it('falls back to defaults when CDN returns integrations as a string', async () => {
+      (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ integrations: 'invalid' }),
+        status: 200,
+      } as Response);
+
+      const client = new SegmentClient(clientArgs);
+      await client.fetchSettings();
+
+      expect(setSettingsSpy).toHaveBeenCalledWith(
+        defaultIntegrationSettings.integrations
+      );
+    });
+
+    it('stores empty integrations when CDN returns null integrations and no defaults', async () => {
+      (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ integrations: null }),
+        status: 200,
+      } as Response);
+
+      const client = new SegmentClient({
+        ...clientArgs,
+        config: { ...clientArgs.config, defaultSettings: undefined },
+      });
+      await client.fetchSettings();
+
+      expect(setSettingsSpy).toHaveBeenCalledWith({});
+    });
+  });
+
   describe('httpConfig extraction', () => {
     it('extracts httpConfig from CDN response and merges with defaults', async () => {
       const serverHttpConfig = {
@@ -483,7 +557,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 +570,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 () => {
 
@@ -12,6 +12,7 @@ import {
   defaultFlushAt,
   maxPendingEvents,
 } from './constants';
+import { mergeHttpConfig } from './config-validation';
 import { getContext } from './context';
 import {
   createAliasEvent,
@@ -73,7 +74,7 @@ import {
   SegmentError,
   translateHTTPError,
 } from './errors';
-import { validateIntegrations, extractHttpConfig } from './config-validation';
+import { validateIntegrations } from './config-validation';
 import { QueueFlushingPlugin } from './plugins/QueueFlushingPlugin';
 import { WaitingPlugin } from './plugin';
 
@@ -198,8 +199,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;
@@ -418,8 +419,13 @@ export class SegmentClient {
         resJson.middlewareSettings?.routingRules ?? []
       );
 
+      // Merge httpConfig: defaultHttpConfig ← CDN ← config overrides
+      this.httpConfig = mergeHttpConfig(
+        resJson.httpConfig,
+        this.config.httpConfig,
+        this.logger
+      );
       if (resJson.httpConfig) {
-        this.httpConfig = extractHttpConfig(resJson.httpConfig, this.logger);
         this.logger.info('Loaded httpConfig from CDN settings.');
       }
 
 
@@ -4,11 +4,22 @@ export const uploadEvents = async ({
   writeKey,
   url,
   events,
+  retryCount = 0,
 }: {
   writeKey: string;
   url: string;
   events: SegmentEvent[];
+  retryCount?: number;
 }) => {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json; charset=utf-8',
+  };
+
+  // Only send X-Retry-Count on retries (count > 0), omit on first attempt
+  if (retryCount > 0) {
+    headers['X-Retry-Count'] = retryCount.toString();
+  }
+
   return await fetch(url, {
     method: 'POST',
     keepalive: true,
@@ -17,8 +28,6 @@ export const uploadEvents = async ({
       sentAt: new Date().toISOString(),
       writeKey: writeKey,
     }),
-    headers: {
-      'Content-Type': 'application/json; charset=utf-8',
-    },
+    headers,
   });
 };
@@ -126,14 +126,6 @@ export class RetryManager {
       return true;
     }
 
-    if (!this.isPersistedStateValid(state, now)) {
-      this.logger?.warn(
-        'Persisted retry state failed validation, resetting to READY'
-      );
-      await this.reset();
-      return true;
-    }
-
     if (now >= state.waitUntilTime) {
       await this.transitionToReady();
       return true;
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": "react-native",`
`3`		`- "test_suites": "basic,settings",`
	`3`	`+ "test_suites": "basic,settings,retry",`
`4`	`4`	`"auto_settings": true,`
`5`	`5`	`"patch": null,`
`6`	`6`	`"env": {`