refactor: simplify durable status extraction

Return status string directly instead of wrapping in a dict.
Remove redundant comments.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jchrostek-dd

datadog_lambda/durable.py

@@ -52,25 +52,16 @@ def extract_durable_function_tags(event):
 VALID_DURABLE_STATUSES = {"SUCCEEDED", "FAILED", "PENDING"}
 
 
-def extract_durable_function_status_tag(response, event):
+def extract_durable_execution_status(response, event):
     """
     Extract durable function execution status from handler response.
-
-    Returns a dict with the status tag if:
-    - The event indicates a durable function invocation (has DurableExecutionArn)
-    - The response is a dict with a valid Status field
-
-    Returns empty dict otherwise.
+    Returns the status string if valid, None otherwise.
     """
-    # Only add status tag for durable function invocations
     if not isinstance(event, dict) or "DurableExecutionArn" not in event:
-        return {}
-
+        return None
     if not isinstance(response, dict):
-        return {}
-
+        return None
     status = response.get("Status")
     if status not in VALID_DURABLE_STATUSES:
-        return {}
-
-    return {"durable_function_execution_status": status}
+        return None
+    return status

datadog_lambda/wrapper.py

@@ -44,7 +44,7 @@
 )
 from datadog_lambda.durable import (
     extract_durable_function_tags,
-    extract_durable_function_status_tag,
+    extract_durable_execution_status,
 )
 from datadog_lambda.trigger import (
     extract_trigger_tags,
@@ -343,12 +343,9 @@ def _after(self, event, context):
                 if status_code:
                     self.span.set_tag("http.status_code", status_code)
 
-                # Extract and set durable function execution status
-                durable_status_tags = extract_durable_function_status_tag(
-                    self.response, event
-                )
-                for tag_name, tag_value in durable_status_tags.items():
-                    self.span.set_tag(tag_name, tag_value)
+                durable_status = extract_durable_execution_status(self.response, event)
+                if durable_status:
+                    self.span.set_tag("durable_function_execution_status", durable_status)
 
                 self.span.finish()
 

tests/test_durable.py

@@ -7,7 +7,7 @@
 from datadog_lambda.durable import (
     _parse_durable_execution_arn,
     extract_durable_function_tags,
-    extract_durable_function_status_tag,
+    extract_durable_execution_status,
 )
 
 
@@ -92,63 +92,49 @@ def test_returns_empty_dict_when_event_is_empty(self):
         self.assertEqual(result, {})
 
 
-class TestExtractDurableFunctionStatusTag(unittest.TestCase):
-    def test_succeeded_status(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
+class TestExtractDurableExecutionStatus(unittest.TestCase):
+    def test_returns_succeeded(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
         response = {"Status": "SUCCEEDED", "Result": "some-result"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {"durable_function_execution_status": "SUCCEEDED"})
+        self.assertEqual(extract_durable_execution_status(response, event), "SUCCEEDED")
 
-    def test_failed_status(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
+    def test_returns_failed(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
         response = {"Status": "FAILED", "Error": "some-error"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {"durable_function_execution_status": "FAILED"})
+        self.assertEqual(extract_durable_execution_status(response, event), "FAILED")
 
-    def test_pending_status(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
+    def test_returns_pending(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
         response = {"Status": "PENDING"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {"durable_function_execution_status": "PENDING"})
+        self.assertEqual(extract_durable_execution_status(response, event), "PENDING")
 
-    def test_non_durable_event_returns_empty(self):
-        event = {"key": "value"}  # No DurableExecutionArn
+    def test_returns_none_for_non_durable_event(self):
+        event = {"key": "value"}
         response = {"Status": "SUCCEEDED"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+        self.assertIsNone(extract_durable_execution_status(response, event))
 
-    def test_non_dict_response_returns_empty(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
-        response = "string response"
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+    def test_returns_none_for_non_dict_response(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
+        self.assertIsNone(extract_durable_execution_status("string", event))
 
-    def test_missing_status_returns_empty(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
-        response = {"Result": "some-result"}  # No Status field
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+    def test_returns_none_for_missing_status(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
+        response = {"Result": "some-result"}
+        self.assertIsNone(extract_durable_execution_status(response, event))
 
-    def test_invalid_status_returns_empty(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
+    def test_returns_none_for_invalid_status(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
         response = {"Status": "INVALID"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+        self.assertIsNone(extract_durable_execution_status(response, event))
 
-    def test_non_dict_event_returns_empty(self):
-        event = "not-a-dict"
+    def test_returns_none_for_non_dict_event(self):
         response = {"Status": "SUCCEEDED"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+        self.assertIsNone(extract_durable_execution_status(response, "not-a-dict"))
 
-    def test_none_event_returns_empty(self):
-        event = None
+    def test_returns_none_for_none_event(self):
         response = {"Status": "SUCCEEDED"}
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+        self.assertIsNone(extract_durable_execution_status(response, None))
 
-    def test_none_response_returns_empty(self):
-        event = {"DurableExecutionArn": "arn:aws:states:us-east-1:123456789012:..."}
-        response = None
-        result = extract_durable_function_status_tag(response, event)
-        self.assertEqual(result, {})
+    def test_returns_none_for_none_response(self):
+        event = {"DurableExecutionArn": "arn:aws:lambda:us-east-1:123:function:f:1/durable-execution/n/id"}
+        self.assertIsNone(extract_durable_execution_status(None, event))