Improve HTTP response handling and retry behavior

packages/browser/jest.config.js

@@ -4,6 +4,9 @@ module.exports = createJestTSConfig(__dirname, {
   modulePathIgnorePatterns: ['<rootDir>/e2e-tests', '<rootDir>/qa'],
   setupFilesAfterEnv: ['./jest.setup.js'],
   testEnvironment: 'jsdom',
+  moduleNameMapper: {
+    '^@segment/analytics-page-tools$': '<rootDir>/../page-tools/src',
+  },
   coverageThreshold: {
     global: {
       branches: 0,

packages/browser/src/browser/__tests__/integration.test.ts

@@ -1603,9 +1603,11 @@ describe('setting headers', () => {
     const [call] = fetchCalls.filter((el) =>
       el.url.toString().includes('api.segment.io')
     )
-    expect(call.headers).toEqual({
-      'Content-Type': 'text/plain',
-      'X-Test': 'foo',
-    })
+    expect(call.headers).toEqual(
+      expect.objectContaining({
+        'Content-Type': 'text/plain',
+        'X-Test': 'foo',
+      })
+    )
   })
 })

packages/browser/src/core/__mocks__/analytics-page-tools.ts

@@ -0,0 +1,28 @@
+export type PageContext = Record<string, unknown>
+export type BufferedPageContext = PageContext
+
+export const BufferedPageContextDiscriminant = 'buffered' as const
+
+export function getDefaultPageContext(): PageContext {
+  return {}
+}
+
+export function getDefaultBufferedPageContext(): BufferedPageContext {
+  return {}
+}
+
+export function createPageContext(ctx: Partial<PageContext> = {}): PageContext {
+  return { ...ctx }
+}
+
+export function createBufferedPageContext(
+  ctx: Partial<BufferedPageContext> = {}
+): BufferedPageContext {
+  return { ...ctx }
+}
+
+export function isBufferedPageContext(
+  _ctx: unknown
+): _ctx is BufferedPageContext {
+  return false
+}

packages/browser/src/lib/priority-queue/__tests__/backoff.test.ts

@@ -2,14 +2,14 @@ import { backoff } from '../backoff'
 
 describe('backoff', () => {
   it('increases with the number of attempts', () => {
-    expect(backoff({ attempt: 1 })).toBeGreaterThan(1000)
-    expect(backoff({ attempt: 2 })).toBeGreaterThan(2000)
-    expect(backoff({ attempt: 3 })).toBeGreaterThan(3000)
-    expect(backoff({ attempt: 4 })).toBeGreaterThan(4000)
+    expect(backoff({ attempt: 1 })).toBeGreaterThan(200)
+    expect(backoff({ attempt: 2 })).toBeGreaterThan(400)
+    expect(backoff({ attempt: 3 })).toBeGreaterThan(800)
+    expect(backoff({ attempt: 4 })).toBeGreaterThan(1600)
   })
 
   it('accepts a max timeout', () => {
-    expect(backoff({ attempt: 1, maxTimeout: 3000 })).toBeGreaterThan(1000)
+    expect(backoff({ attempt: 1, maxTimeout: 3000 })).toBeGreaterThan(200)
     expect(backoff({ attempt: 3, maxTimeout: 3000 })).toBeLessThanOrEqual(3000)
     expect(backoff({ attempt: 4, maxTimeout: 3000 })).toBeLessThanOrEqual(3000)
   })

packages/browser/src/lib/priority-queue/__tests__/index.test.ts

@@ -121,7 +121,7 @@ describe('backoffs', () => {
     expect(spy).toHaveBeenCalled()
 
     const delay = spy.mock.calls[0][1]
-    expect(delay).toBeGreaterThan(1000)
+    expect(delay).toBeGreaterThan(200)
   })
 
   it('increases the delay as work gets requeued', () => {
@@ -147,12 +147,12 @@ describe('backoffs', () => {
     queue.pop()
 
     const firstDelay = spy.mock.calls[0][1]
-    expect(firstDelay).toBeGreaterThan(1000)
+    expect(firstDelay).toBeGreaterThan(200)
 
     const secondDelay = spy.mock.calls[1][1]
-    expect(secondDelay).toBeGreaterThan(2000)
+    expect(secondDelay).toBeGreaterThan(400)
 
     const thirdDelay = spy.mock.calls[2][1]
-    expect(thirdDelay).toBeGreaterThan(3000)
+    expect(thirdDelay).toBeGreaterThan(800)
   })
 })

packages/browser/src/lib/priority-queue/backoff.ts

@@ -1,8 +1,8 @@
 type BackoffParams = {
-  /** The number of milliseconds before starting the first retry. Default is 500 */
+  /** The number of milliseconds before starting the first retry. Default is 100 */
   minTimeout?: number
 
-  /** The maximum number of milliseconds between two retries. Default is Infinity */
+  /** The maximum number of milliseconds between two retries. Default is 60000 (1 minute) */
   maxTimeout?: number
 
   /** The exponential factor to use. Default is 2. */
@@ -14,11 +14,6 @@ type BackoffParams = {
 
 export function backoff(params: BackoffParams): number {
   const random = Math.random() + 1
-  const {
-    minTimeout = 500,
-    factor = 2,
-    attempt,
-    maxTimeout = Infinity,
-  } = params
+  const { minTimeout = 100, factor = 2, attempt, maxTimeout = 60000 } = params
   return Math.min(random * minTimeout * Math.pow(factor, attempt), maxTimeout)
 }