✨ Deduplicate concurrent remote config fetches across SDK bundles

Author: mormubis

packages/browser-core/src/domain/remoteConfiguration/remoteConfigurationFetch.spec.ts

@@ -50,4 +50,28 @@ describe('fetchRemoteConfiguration', () => {
     expect(result.ok).toBeFalse()
     expect((result as { ok: false; error: Error }).error).toBeInstanceOf(Error)
   })
+
+  it('removes the window registry entry after all fetches settle', async () => {
+    const config = { rum: { applicationId: 'abc', sessionSampleRate: 50 } }
+    interceptor.withFetch(() => Promise.resolve({ ok: true, json: () => Promise.resolve(config) }))
+
+    await fetchRemoteConfiguration(options)
+
+    expect((window as unknown as Record<string, unknown>).__ddRcInflight).toBeUndefined()
+  })
+
+  it('deduplicates concurrent calls for the same endpoint', async () => {
+    let fetchCount = 0
+    const config = { rum: { applicationId: 'abc', sessionSampleRate: 50 } }
+    interceptor.withFetch(() => {
+      fetchCount++
+      return Promise.resolve({ ok: true, json: () => Promise.resolve(config) })
+    })
+
+    const [result1, result2] = await Promise.all([fetchRemoteConfiguration(options), fetchRemoteConfiguration(options)])
+
+    expect(fetchCount).toBe(1)
+    expect(result1).toEqual({ ok: true, value: config })
+    expect(result2).toEqual({ ok: true, value: config })
+  })
 })

packages/browser-core/src/domain/remoteConfiguration/remoteConfigurationFetch.ts

@@ -31,12 +31,42 @@ export function buildEndpoint(options: RemoteConfigurationEndpointOptions): stri
   })
 }
 
-export async function fetchRemoteConfiguration(
+// Use a window-level registry so deduplication works across separate SDK bundles
+// (e.g. RUM and Logs loaded as separate CDN scripts on the same page).
+const INFLIGHT_FETCHES_KEY = '__ddRcInflight'
+
+function getInflightFetches(): Map<string, Promise<FetchRemoteConfigurationResult>> {
+  const win = window as unknown as Record<string, unknown>
+  if (!win[INFLIGHT_FETCHES_KEY]) {
+    win[INFLIGHT_FETCHES_KEY] = new Map<string, Promise<FetchRemoteConfigurationResult>>()
+  }
+  return win[INFLIGHT_FETCHES_KEY] as Map<string, Promise<FetchRemoteConfigurationResult>>
+}
+
+export function fetchRemoteConfiguration(
   options: RemoteConfigurationEndpointOptions
 ): Promise<FetchRemoteConfigurationResult> {
+  const endpoint = buildEndpoint(options)
+  const inflightFetches = getInflightFetches()
+
+  if (!inflightFetches.has(endpoint)) {
+    const win = window as unknown as Record<string, unknown>
+    const promise = doFetchRemoteConfiguration(endpoint).finally(() => {
+      inflightFetches.delete(endpoint)
+      if (inflightFetches.size === 0) {
+        delete win[INFLIGHT_FETCHES_KEY]
+      }
+    })
+    inflightFetches.set(endpoint, promise)
+  }
+
+  return inflightFetches.get(endpoint)!
+}
+
+async function doFetchRemoteConfiguration(endpoint: string): Promise<FetchRemoteConfigurationResult> {
   let response: Response | undefined
   try {
-    response = await fetch(buildEndpoint(options))
+    response = await fetch(endpoint)
   } catch {
     response = undefined
   }

packages/browser-logs/src/domain/remoteConfiguration.spec.ts

@@ -1,5 +1,5 @@
-import { CACHE_VERSION, buildCacheKey } from '@datadog/browser-core'
-import { interceptRequests, registerCleanupTask } from '@datadog/browser-core/test'
+import { CACHE_VERSION, buildCacheKey, display } from '@datadog/browser-core'
+import { interceptRequests } from '@datadog/browser-core/test'
 import type { LogsInitConfiguration } from './configuration'
 import {
   applyLogsRemoteConfiguration,
@@ -114,10 +114,12 @@ describe('fetchAndApplyLogsRemoteConfiguration', () => {
     expect(result!.forwardErrorsToLogs).toBeFalse()
   })
 
-  it('returns undefined when the fetch fails', async () => {
+  it('returns undefined and displays an error when the fetch fails', async () => {
+    spyOn(display, 'error')
     interceptor.withFetch(() => Promise.resolve({ ok: false, status: 500 }))
 
     const result = await fetchAndApplyLogsRemoteConfiguration(DEFAULT_LOGS_INIT)
     expect(result).toBeUndefined()
+    expect(display.error).toHaveBeenCalled()
   })
 })

packages/browser-logs/src/domain/remoteConfiguration.ts

@@ -1,5 +1,5 @@
+import type { RemoteConfiguration } from '@datadog/browser-core'
 import {
-  type RemoteConfiguration,
   createConfigurationCache,
   display,
   fetchRemoteConfiguration,

test/e2e/scenario/remoteConfiguration.scenario.ts

@@ -0,0 +1,30 @@
+import type { Page } from '@playwright/test'
+import { test, expect } from '@playwright/test'
+import { createTest } from '../lib/framework'
+
+const RC_ID = 'e2e'
+
+test.describe('remote configuration', () => {
+  createTest('should issue a single fetch when both RUM and Logs share the same remote config ID')
+    .withRum({ remoteConfigurationId: RC_ID, sessionSampleRate: 100 })
+    .withLogs({ remoteConfigurationId: RC_ID })
+    .withRemoteConfiguration({
+      rum: { applicationId: RC_ID, sessionSampleRate: 100 },
+      logs: { forwardErrorsToLogs: true },
+    })
+    .run(async ({ page }) => {
+      await waitForRumRemoteConfigurationApplied(page)
+
+      const configRequestCount = await page.evaluate(
+        () => window.performance.getEntriesByType('resource').filter((e) => e.name.endsWith('/config')).length
+      )
+
+      expect(configRequestCount).toBe(1)
+    })
+})
+
+async function waitForRumRemoteConfigurationApplied(page: Page) {
+  await page.waitForFunction((rcId) => window.DD_RUM?.getInitConfiguration()?.applicationId === rcId, RC_ID, {
+    timeout: 10000,
+  })
+}