Merge pull request #355 from DataDog/agent/optional-application-id

fix(browser): make applicationId optional at runtime

Author: btthomas

packages/browser/src/domain/configuration.ts

@@ -1,5 +1,5 @@
 import type { Configuration, EndpointBuilder, InitConfiguration } from '@datadog/browser-core'
-import { display, validateAndBuildConfiguration } from '@datadog/browser-core'
+import { validateAndBuildConfiguration } from '@datadog/browser-core'
 import type { FlagsConfiguration } from '@datadog/flagging-core'
 import type { EvaluationContext } from '@openfeature/web-sdk'
 import type { DDRum } from '../openfeature/rumIntegration'
@@ -90,11 +90,6 @@ export interface FlaggingConfiguration extends Configuration {
 export function validateAndBuildFlaggingConfiguration(
   initConfiguration: FlaggingInitConfiguration
 ): FlaggingConfiguration | undefined {
-  if (!initConfiguration.applicationId) {
-    display.error('Application ID is not configured, no flagging data will be collected.')
-    return
-  }
-
   const baseConfiguration = validateAndBuildConfiguration(initConfiguration)
   if (!baseConfiguration) {
     return

packages/browser/test/openfeature/exposures.spec.ts

@@ -298,6 +298,39 @@ describe('Exposures End-to-End', () => {
     })
   })
 
+  it('should send exposure events without RUM application attribution when applicationId is not provided', async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes('exposures')) {
+        return Promise.resolve({ ok: true, status: 200 })
+      }
+      if (url.includes('precompute-assignments')) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(precomputedServerResponse),
+        })
+      }
+      return Promise.resolve({ ok: true, json: () => Promise.resolve({}) })
+    })
+
+    await OpenFeature.setContext({ targetingKey: 'test-user-123' })
+    const provider = new DatadogProvider({
+      clientToken: 'test-client-token',
+      env: 'test',
+      site: INTAKE_SITE_STAGING,
+      enableExposureLogging: true,
+    })
+    await OpenFeature.setProviderAndWait(provider)
+
+    OpenFeature.getClient().getStringValue('string-flag', 'default')
+    triggerBatch()
+
+    const exposuresCalls = getExposuresCalls()
+    expect(exposuresCalls).toHaveLength(1)
+
+    const [event] = parseExposureEvents(exposuresCalls[0][1].body)
+    expect(event.rum).toEqual({ view: { url: 'http://localhost/' } })
+  })
+
   it('should not send exposure events when exposure logging is disabled', async () => {
     // Mock server response
     fetchMock.mockImplementation((url: string) => {

packages/browser/test/openfeature/provider.spec.ts

@@ -33,7 +33,6 @@ describe('DatadogProvider', () => {
   describe('configuration validation', () => {
     beforeEach(() => {
       setupProvider()
-      OpenFeature.setProvider(provider)
     })
 
     it('should throw error when ddog-gov.com site is provided', () => {
@@ -139,7 +138,6 @@ describe('DatadogProvider', () => {
   describe('metadata', () => {
     beforeEach(() => {
       setupProvider()
-      OpenFeature.setProvider(provider)
     })
 
     it('should have correct metadata', () => {
@@ -520,6 +518,31 @@ describe('DatadogProvider', () => {
     })
   })
 
+  describe('initialization without applicationId', () => {
+    it('should initialize successfully', async () => {
+      const originalFetch = global.fetch
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => precomputedResponse,
+      })
+      const testProvider = new DatadogProvider({
+        clientToken: 'xxx',
+        env: 'test',
+        site: INTAKE_SITE_STAGING,
+        enableExposureLogging: false,
+        enableFlagEvaluationTracking: false,
+        enableRumFeatureFlagTracking: false,
+      })
+
+      try {
+        await expect(testProvider.initialize()).resolves.toBeUndefined()
+        expect(testProvider.status).toBe(ProviderStatus.READY)
+      } finally {
+        global.fetch = originalFetch
+      }
+    })
+  })
+
   describe('error handling integration', () => {
     let originalFetch: (input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>
     let isolatedFetchMock: jest.Mock