test(ffe): enable Node.js agentless flag evaluation (#7355)

Co-authored-by: leo.romanovsky <leo.romanovsky@datadoghq.com>

Author: leoromanovsky

manifests/nodejs.yml

@@ -103,6 +103,7 @@ refs:
   - &ref_6_0_0 '>=6.0.0-pre'
   - &ref_6_5_0 '>=6.5.0 || ^5.116.0'
   - &ref_6_7_0 '>=6.7.0 || ^5.118.0'
+  - &ref_6_8_0 '>=6.8.0 || ^5.119.0'
 manifest:
   tests/ai_guard/test_ai_guard_sdk.py::Test_AIGuardEvent_Tag:
     - weblog_declaration:
@@ -1715,7 +1716,7 @@ manifest:
     - declaration: missing_feature (Not implemented yet)
       component_version: <5.66.0
   tests/docker_ssi/test_docker_ssi_appsec.py::TestDockerSSIAppsecFeatures::test_telemetry_source_ssi: *ref_5_83_0
-  tests/ffe/test_agentless_configuration.py: missing_feature (FFL-2697 tracks Node.js agentless configuration-source implementation; FFL-2731 tracks the system-tests contract)
+  tests/ffe/test_agentless_configuration.py: *ref_6_8_0
   tests/ffe/test_dynamic_evaluation.py:
     - weblog_declaration:
         "*": incomplete_test_app
@@ -2078,7 +2079,7 @@ manifest:
   tests/parametric/test_extract_behavior.py::Test_ExtractBehavior_Restart::test_baggage: incomplete_test_app (The parametric test app does not preserve baggage after extraction)
   tests/parametric/test_extract_behavior.py::Test_ExtractBehavior_Restart_With_Extract_First: *ref_5_47_0
   tests/parametric/test_extract_behavior.py::Test_ExtractBehavior_Restart_With_Extract_First::test_baggage: incomplete_test_app (The parametric test app does not preserve baggage after extraction)
-  tests/parametric/test_ffe/test_configuration_sources.py: missing_feature (FFL-2697 tracks Node.js agentless configuration-source implementation; FFL-2731 tracks system-tests configuration-source contract)
+  tests/parametric/test_ffe/test_configuration_sources.py: *ref_6_8_0
   tests/parametric/test_ffe/test_dynamic_evaluation.py::Test_Feature_Flag_Dynamic_Evaluation: *ref_5_75_0
   tests/parametric/test_ffe/test_span_enrichment.py: "missing_feature (dd-trace-js#8343)"
   tests/parametric/test_headers_b3.py::Test_Headers_B3::test_headers_b3_migrated_extract_invalid: missing_feature (Need to remove b3=b3multi alias)

tests/ffe/test_agentless_configuration.py

@@ -29,4 +29,3 @@ def test_default_agentless_source(self) -> None:
         assert backend_status is not None
         assert backend_status["requests_total"] >= 1
         assert backend_status["last_path"] == CONFIG_PATH
-        assert backend_status["last_auth_present"] is True

tests/test_the_test/test_docker_scenario.py

@@ -107,14 +107,17 @@ def __init__(self) -> None:
 
 
 @scenarios.test_the_test
-@pytest.mark.parametrize(("is_empty_test_run", "flush"), [(True, False), (False, True)])
-def test_end_to_end_scenario_only_flushes_non_empty_test_runs(
-    monkeypatch: pytest.MonkeyPatch, *, is_empty_test_run: bool, flush: bool
+@pytest.mark.parametrize(
+    ("include_agent", "is_empty_test_run", "flush"),
+    [(True, True, False), (True, False, True), (False, True, False), (False, False, False)],
+)
+def test_end_to_end_scenario_only_flushes_agent_backed_non_empty_test_runs(
+    monkeypatch: pytest.MonkeyPatch, *, include_agent: bool, is_empty_test_run: bool, flush: bool
 ) -> None:
     scenario = DdTraceEndToEndScenario(
         "FAKE_END_TO_END",
         doc="",
-        include_agent=False,
+        include_agent=include_agent,
         use_proxy_for_agent=False,
         use_proxy_for_weblog=False,
     )

tests/test_the_test/test_mock_ffe_agentless_backend.py

@@ -1,5 +1,6 @@
 """Unit coverage for the mock FFE agentless backend test fixture."""
 
+from pathlib import Path
 from unittest.mock import MagicMock
 
 import requests
@@ -155,3 +156,41 @@ def test_agentless_end_to_end_scenario_closes_backend_when_status_fails() -> Non
 
     backend.close.assert_called_once_with()
     assert scenario._mock_backend is None  # noqa: SLF001 - focused lifecycle test
+
+
+@scenarios.test_the_test
+def test_agentless_end_to_end_scenario_persists_backend_status_for_replay(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    recording_scenario = FeatureFlaggingAgentlessEndToEndScenario("MOCK_FFE_AGENTLESS_REPLAY", doc="test")
+    recording_scenario._mock_backend_status_path.parent.mkdir()  # noqa: SLF001 - focused lifecycle test
+
+    expected_status = {
+        "requests_total": 1,
+        "in_flight": 0,
+        "max_in_flight": 1,
+        "last_path": CONFIG_PATH,
+        "last_if_none_match": None,
+        "last_auth_present": True,
+        "last_status_code": 200,
+        "status_codes": [200],
+    }
+    backend = MagicMock(spec=MockFFEAgentlessBackendServer)
+    backend.status.return_value = expected_status
+    recording_scenario._mock_backend = backend  # noqa: SLF001 - focused lifecycle test
+
+    recording_scenario._stop_mock_backend()  # noqa: SLF001 - focused lifecycle test
+
+    replay_scenario = FeatureFlaggingAgentlessEndToEndScenario("MOCK_FFE_AGENTLESS_REPLAY", doc="test")
+    replay_scenario.replay = True
+    base_configure = MagicMock()
+    monkeypatch.setattr(endtoend_scenarios.DdTraceEndToEndScenario, "configure", base_configure)
+    config = MagicMock(spec=pytest.Config)
+    replay_scenario.configure(config)
+
+    backend.close.assert_called_once_with()
+    base_configure.assert_called_once_with(config)
+    assert replay_scenario.mock_backend_status() == expected_status

utils/_context/_scenarios/endtoend.py

@@ -1,5 +1,8 @@
-from typing import Literal
+import json
 import os
+from pathlib import Path
+from typing import Literal, cast
+
 import pytest
 
 from docker.models.networks import Network
@@ -466,9 +469,9 @@ def _wait_and_stop_containers(self, *, is_empty_test_run: bool):
         else:
             self._wait_interface(interfaces.library, 0 if is_empty_test_run else self.library_interface_timeout)
 
-            # An empty selection has no test-generated data to flush. This also avoids waiting on
-            # Agent-backed writers in scenarios that intentionally do not start an Agent.
-            self.weblog_infra.stop(flush=not is_empty_test_run)
+            # An empty selection has no test-generated data to flush. An Agentless scenario also
+            # has no Agent-backed writer target, so its flush endpoint can only time out.
+            self.weblog_infra.stop(flush=not is_empty_test_run and self.include_agent)
             interfaces.library.check_deserialization_errors()
 
             for container in self.buddies:
@@ -615,6 +618,7 @@ class FeatureFlaggingAgentlessEndToEndScenario(DdTraceEndToEndScenario):
     """FFE end-to-end scenario with UFC available before the weblog starts."""
 
     _default_scenario_groups: tuple[ScenarioGroup, ...] = ()
+    _mock_backend_status_filename = "mock_ffe_agentless_backend_status.json"
 
     _mock_backend: MockFFEAgentlessBackendServer | None = None
     _last_mock_backend_status: MockFFEAgentlessBackendStatus | None = None
@@ -627,7 +631,6 @@ def __init__(
         weblog_env: dict[str, str | None] | None = None,
     ) -> None:
         environment: dict[str, str | None] = {
-            "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": "true",
             "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS": "0.2",
             "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS": "2",
             "DD_REMOTE_CONFIGURATION_ENABLED": "false",
@@ -647,12 +650,15 @@ def __init__(
 
     def configure(self, config: pytest.Config) -> None:
         try:
-            if not self.replay:
+            if self.replay:
+                self._load_mock_backend_status()
+            else:
+                self._last_mock_backend_status = None
                 self._start_mock_backend()
 
             super().configure(config)
         except BaseException:
-            self._stop_mock_backend()
+            self._stop_mock_backend(persist_status=False)
             raise
 
     def _start_mock_backend(self) -> None:
@@ -673,14 +679,30 @@ def mock_backend_status(self) -> MockFFEAgentlessBackendStatus | None:
             return self._mock_backend.status()
         return self._last_mock_backend_status
 
-    def _stop_mock_backend(self) -> None:
+    @property
+    def _mock_backend_status_path(self) -> Path:
+        return Path(self.host_log_folder) / self._mock_backend_status_filename
+
+    def _load_mock_backend_status(self) -> None:
+        self._last_mock_backend_status = cast(
+            "MockFFEAgentlessBackendStatus",
+            json.loads(self._mock_backend_status_path.read_text(encoding="utf-8")),
+        )
+
+    def _stop_mock_backend(self, *, persist_status: bool = True) -> None:
         backend = self._mock_backend
         if backend is None:
             return
 
         self._mock_backend = None
         try:
-            self._last_mock_backend_status = backend.status()
+            if persist_status:
+                self._last_mock_backend_status = backend.status()
+                self._mock_backend_status_path.parent.mkdir(parents=True, exist_ok=True)
+                self._mock_backend_status_path.write_text(
+                    json.dumps(self._last_mock_backend_status, indent=2) + "\n",
+                    encoding="utf-8",
+                )
         finally:
             backend.close()
 

utils/build/docker/nodejs/express/app.js

@@ -867,20 +867,40 @@ app.post('/ai_guard/evaluate', async (req, res) => {
 })
 
 let openFeatureClient = null
+let openFeatureClientPromise = null
 
-// Initialize OpenFeature provider if FFE is enabled
-if (process.env.DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED === 'true') {
-  const { openfeature } = tracer
-  OpenFeature.setProvider(openfeature)
-  openFeatureClient = OpenFeature.getClient()
+async function getOpenFeatureClient () {
+  if (openFeatureClient) {
+    return openFeatureClient
+  }
+
+  if (process.env.DD_FEATURE_FLAGS_ENABLED === 'false') {
+    return null
+  }
+
+  if (!openFeatureClientPromise) {
+    const { openfeature } = tracer
+    openFeatureClientPromise = OpenFeature.setProviderAndWait(openfeature)
+      .then(() => {
+        openFeatureClient = OpenFeature.getClient()
+        return openFeatureClient
+      })
+      .catch(error => {
+        openFeatureClientPromise = null
+        throw error
+      })
+  }
+
+  return openFeatureClientPromise
 }
 
 // Single FFE endpoint that evaluates feature flags
 app.post('/ffe', async (req, res) => {
   try {
     const { flag, variationType, defaultValue, targetingKey, targetingKeys, attributes } = req.body
+    const client = await getOpenFeatureClient()
 
-    if (!openFeatureClient) {
+    if (!client) {
       return res.status(500).json({ error: 'FFE provider not initialized' })
     }
 
@@ -892,17 +912,17 @@ app.post('/ffe', async (req, res) => {
 
       switch (variationType) {
         case 'BOOLEAN':
-          value = await openFeatureClient.getBooleanValue(flag, defaultValue, context)
+          value = await client.getBooleanValue(flag, defaultValue, context)
           break
         case 'STRING':
-          value = await openFeatureClient.getStringValue(flag, defaultValue, context)
+          value = await client.getStringValue(flag, defaultValue, context)
           break
         case 'INTEGER':
         case 'NUMERIC':
-          value = await openFeatureClient.getNumberValue(flag, defaultValue, context)
+          value = await client.getNumberValue(flag, defaultValue, context)
           break
         case 'JSON':
-          value = await openFeatureClient.getObjectValue(flag, defaultValue, context)
+          value = await client.getObjectValue(flag, defaultValue, context)
           break
         default:
           return res.status(400).json({ error: `Unknown variation type: ${variationType}` })

utils/build/docker/nodejs/express4-typescript.Dockerfile

@@ -10,6 +10,11 @@ ENV PGPORT=5433
 
 ENV DD_DATA_STREAMS_ENABLED=true
 
+# Refresh the application code and dependencies baked into the base image.
+COPY utils/build/docker/nodejs/express4-typescript/package.json utils/build/docker/nodejs/express4-typescript/bun.lock ./
+COPY utils/build/docker/nodejs/express4-typescript/app.ts app.ts
+RUN bun install --frozen-lockfile --network-concurrency 8 --linker=hoisted
+
 COPY utils/build/docker/nodejs/install_ddtrace.sh binaries* /binaries/
 RUN /binaries/install_ddtrace.sh && rm -rf /root/.bun
 RUN bun run build

utils/build/docker/nodejs/express4-typescript/app.ts

@@ -1,11 +1,13 @@
 'use strict'
 
 import { Request, Response } from "express";
+import type { Client } from '@openfeature/server-sdk'
 import http from 'http';
 
 const tracer = require('dd-trace').init();
 const { tags: { MANUAL_KEEP, MANUAL_DROP } } = require('dd-trace/ext');
 
+const { OpenFeature } = require('@openfeature/server-sdk')
 const { promisify } = require('util')
 const app = require('express')()
 const axios = require('axios')
@@ -555,6 +557,74 @@ app.get('/external_request/redirect', (req: Request, res: Response) => {
 
 require('./rasp')(app)
 
+let openFeatureClient: Client | null = null
+let openFeatureClientPromise: Promise<Client> | null = null
+
+async function getOpenFeatureClient (): Promise<Client | null> {
+  if (openFeatureClient) {
+    return openFeatureClient
+  }
+
+  if (process.env.DD_FEATURE_FLAGS_ENABLED === 'false') {
+    return null
+  }
+
+  if (!openFeatureClientPromise) {
+    openFeatureClientPromise = OpenFeature.setProviderAndWait(tracer.openfeature)
+      .then(() => {
+        openFeatureClient = OpenFeature.getClient()
+        return openFeatureClient
+      })
+      .catch((error: unknown) => {
+        openFeatureClientPromise = null
+        throw error
+      })
+  }
+
+  return openFeatureClientPromise
+}
+
+app.post('/ffe', async (req: Request, res: Response) => {
+  try {
+    const { flag, variationType, defaultValue, targetingKey, targetingKeys, attributes } = req.body
+    const client = await getOpenFeatureClient()
+
+    if (!client) {
+      return res.status(500).json({ error: 'FFE provider not initialized' })
+    }
+
+    let value
+    const keys = Array.isArray(targetingKeys) && targetingKeys.length > 0 ? targetingKeys : [targetingKey]
+
+    for (const key of keys) {
+      const context = { targetingKey: key, ...attributes }
+
+      switch (variationType) {
+        case 'BOOLEAN':
+          value = await client.getBooleanValue(flag, defaultValue, context)
+          break
+        case 'STRING':
+          value = await client.getStringValue(flag, defaultValue, context)
+          break
+        case 'INTEGER':
+        case 'NUMERIC':
+          value = await client.getNumberValue(flag, defaultValue, context)
+          break
+        case 'JSON':
+          value = await client.getObjectValue(flag, defaultValue, context)
+          break
+        default:
+          return res.status(400).json({ error: `Unknown variation type: ${variationType}` })
+      }
+    }
+
+    return res.status(200).json({ value, count: keys.length })
+  } catch (error: any) {
+    console.error('[FFE] Error:', error)
+    return res.status(500).json({ error: error.message })
+  }
+})
+
 const startServer = () => {
   return new Promise((resolve) => {
     const server = http.createServer((req: http.IncomingMessage, res: http.ServerResponse) => {