add env var to configure ffe init time (#6948)

* feat(openfeature): add env vars for flagging provider configuration

Add environment variable support for:
- DD_FLAGGING_PROVIDER_ENABLED / DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED
- DD_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS / DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS

* fix(openfeature): use only DD_EXPERIMENTAL_* env vars for flagging provider

Remove support for non-experimental env vars (DD_FLAGGING_PROVIDER_ENABLED
and DD_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS) to align with other
Datadog tracers (Go, Python, Ruby, Java, .NET) which only support the
DD_EXPERIMENTAL_* variants.

Author: leoromanovsky

index.d.ts

@@ -148,7 +148,7 @@ interface Tracer extends opentracing.Tracer {
    * OpenFeature Provider with Remote Config integration.
    *
    * Extends DatadogNodeServerProvider with Remote Config integration for dynamic flag configuration.
-   * Enable with DD_FLAGGING_PROVIDER_ENABLED=true.
+   * Enable with DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true.
    *
    * @beta This feature is in preview and not ready for production use
    */
@@ -692,13 +692,15 @@ declare namespace tracer {
         /**
          * Whether to enable the feature flagging provider.
          * Requires Remote Config to be properly configured.
+         * Can be configured via DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED environment variable.
          *
          * @default false
          */
         enabled?: boolean
         /**
          * Timeout in milliseconds for OpenFeature provider initialization.
          * If configuration is not received within this time, initialization fails.
+         * Can be configured via DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS environment variable.
          *
          * @default 30000
          */

packages/dd-trace/src/config/index.js

@@ -600,6 +600,7 @@ class Config {
       OTEL_TRACES_SAMPLER,
       OTEL_TRACES_SAMPLER_ARG,
       DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED,
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS,
       OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
       OTEL_EXPORTER_OTLP_LOGS_HEADERS,
       OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
@@ -776,7 +777,15 @@ class Config {
       maybeFloat(DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS)
     unprocessedTarget['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this.#setString(target, 'env', DD_ENV || tags.env)
-    this.#setBoolean(target, 'experimental.flaggingProvider.enabled', DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED)
+    this.#setBoolean(
+      target,
+      'experimental.flaggingProvider.enabled',
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED
+    )
+    if (DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS != null) {
+      target['experimental.flaggingProvider.initializationTimeoutMs'] =
+        maybeInt(DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS)
+    }
     this.#setBoolean(target, 'traceEnabled', DD_TRACE_ENABLED)
     this.#setBoolean(target, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
     this.#setString(target, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
@@ -1112,6 +1121,11 @@ class Config {
     this.#setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this.#setString(opts, 'experimental.exporter', options.experimental?.exporter)
     this.#setBoolean(opts, 'experimental.flaggingProvider.enabled', options.experimental?.flaggingProvider?.enabled)
+    opts['experimental.flaggingProvider.initializationTimeoutMs'] = maybeInt(
+      options.experimental?.flaggingProvider?.initializationTimeoutMs
+    )
+    this.#optsUnprocessed['experimental.flaggingProvider.initializationTimeoutMs'] =
+      options.experimental?.flaggingProvider?.initializationTimeoutMs
     opts.flushInterval = maybeInt(options.flushInterval)
     this.#optsUnprocessed.flushInterval = options.flushInterval
     opts.flushMinSpans = maybeInt(options.flushMinSpans)

packages/dd-trace/src/config/supported-configurations.json

@@ -73,11 +73,11 @@
     "DD_ENV": ["A"],
     "DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": ["A"],
+    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS": ["A"],
     "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_DIR": ["A"],
     "DD_EXTERNAL_ENV": ["A"],
-    "DD_FLAGGING_PROVIDER_ENABLED": ["A"],
     "DD_GIT_BRANCH": ["A"],
     "DD_GIT_COMMIT_AUTHOR_DATE": ["A"],
     "DD_GIT_COMMIT_AUTHOR_EMAIL": ["A"],

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

@@ -255,4 +255,103 @@ describe('FlaggingProvider Initialization Timeout', () => {
       assert.strictEqual(errorArg.message, 'Initialization timeout after 10000ms')
     })
   })
+
+  describe('environment variable timeout configuration', () => {
+    let originalEnv
+
+    beforeEach(() => {
+      // Save original environment variable
+      originalEnv = {
+        DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS:
+          process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS
+      }
+    })
+
+    afterEach(() => {
+      // Restore original environment variable
+      if (originalEnv.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS !== undefined) {
+        process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS =
+          originalEnv.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS
+      } else {
+        delete process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS
+      }
+    })
+
+    it('should use DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS environment variable', async () => {
+      // Set environment variable for 6-second timeout
+      process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS = '6000'
+
+      // Need to reload the config module to pick up env var
+      delete require.cache[require.resolve('../../src/config')]
+      const Config = require('../../src/config')
+      const config = new Config({})
+
+      const provider = new FlaggingProvider(mockTracer, config)
+
+      // Spy on setError method to verify timeout message
+      const setErrorSpy = sinon.spy(provider, 'setError')
+
+      const initPromise = provider.initialize()
+
+      // Attach catch handler
+      initPromise.catch(() => {
+        // Expected to reject
+      })
+
+      // Advance time to trigger env var timeout
+      await clock.tickAsync(6000)
+
+      await initPromise.catch(() => {})
+
+      // Verify setError was called with env var timeout error
+      assert.strictEqual(setErrorSpy.calledOnce, true)
+      const errorArg = setErrorSpy.firstCall.args[0]
+      assert.ok(errorArg instanceof Error)
+      assert.ok(errorArg.message.includes('Initialization timeout'))
+      assert.ok(errorArg.message.includes('6000ms'))
+    })
+
+    it('should use config object value over environment variables', async () => {
+      // Set environment variable
+      process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS = '7000'
+
+      // Config with explicit timeout (should override env var)
+      const configWithTimeout = {
+        ...mockConfig,
+        experimental: {
+          flaggingProvider: {
+            enabled: true,
+            initializationTimeoutMs: 3000 // This should override env var
+          }
+        }
+      }
+
+      const provider = new FlaggingProvider(mockTracer, configWithTimeout)
+
+      const initPromise = provider.initialize()
+
+      // Attach catch handler
+      initPromise.catch(() => {
+        // Expected to reject on timeout
+      })
+
+      // Verify initialization is in progress
+      assert.strictEqual(provider.initController.isInitializing(), true)
+
+      // Advance time by 2.9 seconds (before config timeout)
+      await clock.tickAsync(2900)
+
+      // Should still be initializing
+      assert.strictEqual(provider.initController.isInitializing(), true)
+
+      // Advance by another 200ms to trigger the 3-second timeout (config takes priority)
+      await clock.tickAsync(200)
+
+      // Wait for promise to settle
+      await initPromise.catch(() => {})
+
+      // Should now be timed out (using config value, not env var)
+      assert.strictEqual(provider.initController.isInitializing(), false)
+    })
+  })
 })