fix: preserve flag flush fallback and wait for smoke readiness

Keep invalid timeout defaults numeric, initialize the smoke provider before invocation, and assert older tracer compatibility.

Environment: Datadog workspace

Co-Authored-By: Codex GPT-6 <noreply@localhost>

Author: vjfridge

datadog_lambda/config.py

@@ -86,7 +86,7 @@ def _resolve_env(self, key, default=None, cast=None, depends_on_tracing=False):
 
     flush_in_thread = _get_env("DD_FLUSH_IN_THREAD", "false", as_bool)
     feature_flag_flush_timeout_ms = _get_env(
-        "DD_FEATURE_FLAG_FLUSH_TIMEOUT_MS", "500", float
+        "DD_FEATURE_FLAG_FLUSH_TIMEOUT_MS", 500.0, float
     )
     flush_to_log = _get_env("DD_FLUSH_TO_LOG", "false", as_bool)
     logs_injection = _get_env("DD_LOGS_INJECTION", "true", as_bool)

tests/integration/FEATURE_FLAG_FLUSH.md

@@ -7,7 +7,8 @@ layer until the release record below is populated.
 ## Existing examples and access
 
 The smoke handler initializes its provider and client once at module scope and
-reuses them across invocations.
+reuses them across invocations. Registration waits for provider initialization
+before the first invocation, bounded by the provider's default 10-second timeout.
 
 This repository's `scripts/run_integration_tests.sh` documents
 `sso-serverless-sandbox-account-admin`. `tests/integration/serverless.yml` uses
@@ -22,7 +23,8 @@ Verify that the selected profile can access the approved account before deployin
    internal flush contract version 1 and this Lambda library. The ordinary layer
    build installs the declared tracer dependency, so verify the zip actually
    contains the candidate tracer instead of a published version without the fix.
-2. Package `feature_flags.py` and `openfeature-sdk`. Configure its handler as
+2. Package `feature_flags.py` and `openfeature-sdk==0.10.0` (which provides
+   `set_provider_and_wait`). Configure its handler as
    `feature_flags.handle`. It uses the ordinary Datadog wrapper and has no flush
    or shutdown calls. Reuse the approved sandbox's IAM and deployment settings
    from `serverless.yml`, with a unique `integration-tests-*` function name.

tests/integration/feature_flags.py

@@ -11,7 +11,7 @@
 from openfeature.evaluation_context import EvaluationContext
 
 provider = DataDogProvider()
-api.set_provider(provider)
+api.set_provider_and_wait(provider)
 client = api.get_client("lambda-flush-smoke")
 sandbox_id = uuid.uuid4().hex
 invocations = 0

tests/test_feature_flags.py

@@ -1,9 +1,11 @@
 import importlib.util
+import os
 import unittest
 from unittest.mock import Mock, patch
 
 from datadog_lambda import feature_flags
 from datadog_lambda import wrapper
+from datadog_lambda.config import Config
 
 
 class FeatureFlagFlushTest(unittest.TestCase):
@@ -48,8 +50,37 @@ def test_no_budget(self):
 
     def test_old_tracer(self):
         for telemetry in [None, Mock(FLUSH_API_VERSION=2)]:
-            with patch.object(feature_flags, "_telemetry", telemetry):
-                feature_flags.flush_feature_flag_telemetry(None)
+            with self.subTest(telemetry=telemetry), patch.object(
+                feature_flags, "_telemetry", telemetry
+            ):
+                context = Mock()
+                context.get_remaining_time_in_millis.return_value = 1000
+                feature_flags.flush_feature_flag_telemetry(context)
+                context.get_remaining_time_in_millis.assert_not_called()
+                if telemetry is not None:
+                    telemetry.flush.assert_not_called()
+
+    def test_timeout_environment_parsing_preserves_flush(self):
+        for value, expected in [
+            (None, 0.5),
+            ("250.5", 0.2505),
+            ("", 0.5),
+            ("garbage", 0.5),
+            ("500ms", 0.5),
+        ]:
+            with self.subTest(value=value), patch.dict(os.environ), patch.object(
+                feature_flags, "config", Config()
+            ), patch.object(feature_flags, "_telemetry") as telemetry:
+                if value is None:
+                    os.environ.pop("DD_FEATURE_FLAG_FLUSH_TIMEOUT_MS", None)
+                else:
+                    os.environ["DD_FEATURE_FLAG_FLUSH_TIMEOUT_MS"] = value
+                telemetry.FLUSH_API_VERSION = 1
+                telemetry.flush.return_value = "completed"
+                feature_flags.flush_feature_flag_telemetry(
+                    Mock(get_remaining_time_in_millis=lambda: 1000)
+                )
+                telemetry.flush.assert_called_once_with(expected)
 
     def test_missing_context_and_telemetry_errors_are_safe(self):
         with patch.object(feature_flags, "_telemetry") as telemetry: