allow providing a custom timeout to openfeature datadog provider (#6930)

Author: leoromanovsky

index.d.ts

@@ -654,6 +654,13 @@ declare namespace tracer {
          * @default false
          */
         enabled?: boolean
+        /**
+         * Timeout in milliseconds for OpenFeature provider initialization.
+         * If configuration is not received within this time, initialization fails.
+         *
+         * @default 30000
+         */
+        initializationTimeoutMs?: number
       }
     };
 

packages/dd-trace/src/config_defaults.js

@@ -77,6 +77,7 @@ module.exports = {
   'experimental.enableGetRumData': false,
   'experimental.exporter': undefined,
   'experimental.flaggingProvider.enabled': false,
+  'experimental.flaggingProvider.initializationTimeoutMs': 30_000,
   flushInterval: 2000,
   flushMinSpans: 1000,
   gitMetadataEnabled: true,

packages/dd-trace/src/openfeature/flagging_provider.js

@@ -15,15 +15,17 @@ class FlaggingProvider extends DatadogNodeServerProvider {
    * @param {import('../config')} config - Tracer configuration object
    */
   constructor (tracer, config) {
-    // Call parent constructor with required options
+    // Call parent constructor with required options and timeout
     super({
-      exposureChannel: channel(EXPOSURE_CHANNEL)
+      exposureChannel: channel(EXPOSURE_CHANNEL),
+      initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs
     })
 
     this._tracer = tracer
     this._config = config
 
-    log.debug(this.constructor.name + ' created')
+    log.debug(this.constructor.name + ' created with timeout: ' +
+      config.experimental.flaggingProvider.initializationTimeoutMs + 'ms')
   }
 
   /**

packages/dd-trace/test/openfeature/flagging_provider.spec.js

@@ -23,7 +23,13 @@ describe('FlaggingProvider', () => {
     mockConfig = {
       service: 'test-service',
       version: '1.0.0',
-      env: 'test'
+      env: 'test',
+      experimental: {
+        flaggingProvider: {
+          enabled: true,
+          initializationTimeoutMs: 30_000
+        }
+      }
     }
 
     mockChannel = {
@@ -65,7 +71,7 @@ describe('FlaggingProvider', () => {
       const provider = new FlaggingProvider(mockTracer, mockConfig)
 
       expect(provider).to.exist
-      expect(log.debug).to.have.been.calledWith('FlaggingProvider created')
+      expect(log.debug).to.have.been.calledWith('FlaggingProvider created with timeout: 30000ms')
     })
   })
 

packages/dd-trace/test/openfeature/flagging_provider_timeout.spec.js

@@ -28,7 +28,13 @@ describe('FlaggingProvider Initialization Timeout', () => {
     mockConfig = {
       service: 'test-service',
       version: '1.0.0',
-      env: 'test'
+      env: 'test',
+      experimental: {
+        flaggingProvider: {
+          enabled: true,
+          initializationTimeoutMs: 30_000 // Default timeout
+        }
+      }
     }
 
     mockChannel = {
@@ -173,4 +179,81 @@ describe('FlaggingProvider Initialization Timeout', () => {
     expect(readyEventSpy).to.have.been.calledOnce
     expect(provider.getConfiguration()).to.equal(ufc)
   })
+
+  describe('custom timeout configuration', () => {
+    it('should use custom timeout when specified in config', async () => {
+      const customConfig = {
+        ...mockConfig,
+        experimental: {
+          flaggingProvider: {
+            enabled: true,
+            initializationTimeoutMs: 5000 // Custom 5-second timeout
+          }
+        }
+      }
+
+      const provider = new FlaggingProvider(mockTracer, customConfig)
+
+      const initPromise = provider.initialize()
+
+      // Attach catch handler
+      initPromise.catch(() => {
+        // Expected to reject on timeout
+      })
+
+      // Verify initialization is in progress
+      expect(provider.initController.isInitializing()).to.be.true
+
+      // Advance time by 4.9 seconds (before custom timeout)
+      await clock.tickAsync(4900)
+
+      // Should still be initializing
+      expect(provider.initController.isInitializing()).to.be.true
+
+      // Advance by another 200ms to trigger the 5-second timeout
+      await clock.tickAsync(200)
+
+      // Wait for promise to settle
+      await initPromise.catch(() => {})
+
+      // Should now be timed out
+      expect(provider.initController.isInitializing()).to.be.false
+    })
+
+    it('should call setError with custom timeout value in message', async () => {
+      const customConfig = {
+        ...mockConfig,
+        experimental: {
+          flaggingProvider: {
+            enabled: true,
+            initializationTimeoutMs: 10_000 // Custom 10-second timeout
+          }
+        }
+      }
+
+      const provider = new FlaggingProvider(mockTracer, customConfig)
+
+      // Spy on setError method
+      const setErrorSpy = sinon.spy(provider, 'setError')
+
+      const initPromise = provider.initialize()
+
+      // Attach catch handler
+      initPromise.catch(() => {
+        // Expected to reject
+      })
+
+      // Advance time to trigger custom timeout
+      await clock.tickAsync(10000)
+
+      await initPromise.catch(() => {})
+
+      // Verify setError was called with custom timeout error
+      expect(setErrorSpy).to.have.been.calledOnce
+      const errorArg = setErrorSpy.firstCall.args[0]
+      expect(errorArg).to.be.instanceOf(Error)
+      expect(errorArg.message).to.include('Initialization timeout')
+      expect(errorArg.message).to.include('10000ms')
+    })
+  })
 })