feat(dsm): set context for sns->lambda

datadog_lambda/dsm.py

@@ -0,0 +1,73 @@
+from datadog_lambda import logger
+from datadog_lambda.trigger import EventTypes
+
+
+def set_dsm_context(event, event_source):
+
+    if event_source.equals(EventTypes.SQS):
+        _dsm_set_sqs_context(event)
+    elif event_source.equals(EventTypes.SNS):
+        _dsm_set_sns_context(event)
+
+
+def _dsm_set_context_helper(event, service_type, arn_extractor, payload_size_calculator):
+    """
+    Common helper function for setting DSM context for both SQS and SNS events.
+
+    Args:
+        event: The Lambda event containing records
+        service_type: The service type string ('sqs' or 'sns')
+        arn_extractor: Function to extract the ARN from the record
+        payload_size_calculator: Function to calculate payload size
+    """
+    from datadog_lambda.wrapper import format_err_with_traceback
+    from ddtrace.internal.datastreams import data_streams_processor
+    from ddtrace.internal.datastreams.processor import DsmPathwayCodec
+    from ddtrace.internal.datastreams.botocore import get_datastreams_context
+
+    records = event.get("Records")
+    if records is None:
+        return
+    processor = data_streams_processor()
+
+    for record in records:
+        try:
+            arn = arn_extractor(record)
+            context_json = get_datastreams_context(record)
+            payload_size = payload_size_calculator(record, context_json)
+
+            ctx = DsmPathwayCodec.decode(context_json, processor)
+            ctx.set_checkpoint(
+                ["direction:in", f"topic:{arn}", f"type:{service_type}"],
+                payload_size=payload_size,
+            )
+        except Exception as e:
+            logger.error(format_err_with_traceback(e))
+
+
+def _dsm_set_sns_context(event):
+    from ddtrace.internal.datastreams.botocore import calculate_sns_payload_size
+
+    def sns_payload_calculator(record, context_json):
+        return calculate_sns_payload_size(record, context_json)
+
+    def sns_arn_extractor(record):
+        sns_data = record.get("Sns")
+        if not sns_data:
+            return ""
+        return sns_data.get("TopicArn", "")
+
+    _dsm_set_context_helper(
+        event, "sns", sns_arn_extractor, sns_payload_calculator
+    )
+
+
+def _dsm_set_sqs_context(event):
+    from ddtrace.internal.datastreams.botocore import calculate_sqs_payload_size
+
+    def sqs_payload_calculator(record, context_json):
+        return calculate_sqs_payload_size(record)
+
+    def sqs_arn_extractor(record):
+        return record.get("eventSourceARN", "")
+    _dsm_set_context_helper(event, "sqs", sqs_arn_extractor, sqs_payload_calculator)

datadog_lambda/wrapper.py

@@ -9,6 +9,7 @@
 from importlib import import_module
 from time import time_ns
 
+from datadog_lambda.dsm import set_dsm_context
 from datadog_lambda.extension import should_use_extension, flush_extension
 from datadog_lambda.cold_start import (
     set_cold_start,
@@ -79,6 +80,7 @@
 DD_REQUESTS_SERVICE_NAME = "DD_REQUESTS_SERVICE_NAME"
 DD_SERVICE = "DD_SERVICE"
 DD_ENV = "DD_ENV"
+DD_DATA_STREAMS_ENABLED = "DD_DATA_STREAMS_ENABLED"
 
 
 def get_env_as_int(env_key, default_value: int) -> int:
@@ -190,6 +192,9 @@ def __init__(self, func):
             self.min_cold_start_trace_duration = get_env_as_int(
                 DD_MIN_COLD_START_DURATION, 3
             )
+            self.data_streams_enabled = (
+                os.environ.get(DD_DATA_STREAMS_ENABLED, "false").lower() == "true"
+            )
             self.local_testing_mode = os.environ.get(
                 DD_LOCAL_TEST, "false"
             ).lower() in ("true", "1")
@@ -322,6 +327,8 @@ def _before(self, event, context):
                     self.inferred_span = create_inferred_span(
                         event, context, event_source, self.decode_authorizer_context
                     )
+                if self.data_streams_enabled:
+                    set_dsm_context(event, event_source)
                 self.span = create_function_execution_span(
                     context=context,
                     function_name=self.function_name,

tests/test_dsm.py

@@ -0,0 +1,116 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from datadog_lambda.dsm import set_dsm_context, _dsm_set_sqs_context
+from datadog_lambda.trigger import EventTypes
+
+
+class TestDsmContext(unittest.TestCase):
+    def setUp(self):
+        patcher = patch("datadog_lambda.dsm._dsm_set_sqs_context")
+        self.mock_dsm_set_sqs_context = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        patcher = patch("ddtrace.internal.datastreams.data_streams_processor")
+        self.mock_data_streams_processor = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        patcher = patch("ddtrace.internal.datastreams.botocore.get_datastreams_context")
+        self.mock_get_datastreams_context = patcher.start()
+        self.mock_get_datastreams_context.return_value = {}
+        self.addCleanup(patcher.stop)
+
+        patcher = patch(
+            "ddtrace.internal.datastreams.botocore.calculate_sqs_payload_size"
+        )
+        self.mock_calculate_sqs_payload_size = patcher.start()
+        self.mock_calculate_sqs_payload_size.return_value = 100
+        self.addCleanup(patcher.stop)
+
+        patcher = patch("ddtrace.internal.datastreams.processor.DsmPathwayCodec.decode")
+        self.mock_dsm_pathway_codec_decode = patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_non_sqs_event_source_does_nothing(self):
+        """Test that non-SQS event sources don't trigger DSM context setting"""
+        event = {"Records": [{"body": "test"}]}
+
+        mock_event_source = MagicMock()
+        mock_event_source.equals.return_value = False  # Not SQS
+
+        set_dsm_context(event, mock_event_source)
+
+        mock_event_source.equals.assert_called_once_with(EventTypes.SQS)
+        self.mock_dsm_set_sqs_context.assert_not_called()
+
+    def test_event_with_no_records_does_nothing(self):
+        """Test that events where Records is None don't trigger DSM processing"""
+        events_with_no_records = [
+            {},
+            {"Records": None},
+            {"someOtherField": "value"},
+        ]
+
+        for event in events_with_no_records:
+            _dsm_set_sqs_context(event)
+            self.mock_data_streams_processor.assert_not_called()
+
+    def test_sqs_event_triggers_dsm_sqs_context(self):
+        """Test that SQS event sources trigger the SQS-specific DSM context function"""
+        sqs_event = {
+            "Records": [
+                {
+                    "eventSource": "aws:sqs",
+                    "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:my-queue",
+                    "body": "Hello from SQS!",
+                }
+            ]
+        }
+
+        mock_event_source = MagicMock()
+        mock_event_source.equals.return_value = True
+
+        set_dsm_context(sqs_event, mock_event_source)
+
+        self.mock_dsm_set_sqs_context.assert_called_once_with(sqs_event)
+
+    def test_multiple_records_process_each_record(self):
+        """Test that each record in an SQS event gets processed individually"""
+        multi_record_event = {
+            "Records": [
+                {
+                    "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:queue1",
+                    "body": "Message 1",
+                },
+                {
+                    "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:queue2",
+                    "body": "Message 2",
+                },
+                {
+                    "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:queue3",
+                    "body": "Message 3",
+                },
+            ]
+        }
+
+        mock_context = MagicMock()
+        self.mock_dsm_pathway_codec_decode.return_value = mock_context
+
+        _dsm_set_sqs_context(multi_record_event)
+
+        self.assertEqual(mock_context.set_checkpoint.call_count, 3)
+
+        calls = mock_context.set_checkpoint.call_args_list
+        expected_arns = [
+            "arn:aws:sqs:us-east-1:123456789012:queue1",
+            "arn:aws:sqs:us-east-1:123456789012:queue2",
+            "arn:aws:sqs:us-east-1:123456789012:queue3",
+        ]
+
+        for i, call in enumerate(calls):
+            args, kwargs = call
+            tags = args[0]
+            self.assertIn("direction:in", tags)
+            self.assertIn(f"topic:{expected_arns[i]}", tags)
+            self.assertIn("type:sqs", tags)
+            self.assertEqual(kwargs["payload_size"], 100)

tests/test_wrapper.py

@@ -76,6 +76,10 @@ def setUp(self):
         self.mock_dd_lambda_layer_tag = patcher.start()
         self.addCleanup(patcher.stop)
 
+        patcher = patch("datadog_lambda.wrapper.set_dsm_context")
+        self.mock_set_dsm_context = patcher.start()
+        self.addCleanup(patcher.stop)
+
     def test_datadog_lambda_wrapper(self):
         wrapper.dd_tracing_enabled = False
 
@@ -563,6 +567,62 @@ def return_type_test(event, context):
             self.assertEqual(result, test_result)
             self.assertFalse(MockPrintExc.called)
 
+    def test_set_dsm_context_called_when_DSM_and_tracing_enabled(self):
+        os.environ["DD_DATA_STREAMS_ENABLED"] = "true"
+        wrapper.dd_tracing_enabled = True
+
+        @wrapper.datadog_lambda_wrapper
+        def lambda_handler(event, context):
+            return "ok"
+
+        result = lambda_handler({}, get_mock_context())
+        self.assertEqual(result, "ok")
+        self.mock_set_dsm_context.assert_called_once()
+
+        del os.environ["DD_DATA_STREAMS_ENABLED"]
+
+    def test_set_dsm_context_not_called_when_only_DSM_enabled(self):
+        os.environ["DD_DATA_STREAMS_ENABLED"] = "true"
+        wrapper.dd_tracing_enabled = False
+
+        @wrapper.datadog_lambda_wrapper
+        def lambda_handler(event, context):
+            return "ok"
+
+        result = lambda_handler({}, get_mock_context())
+        self.assertEqual(result, "ok")
+        self.mock_set_dsm_context.assert_not_called()
+
+        del os.environ["DD_DATA_STREAMS_ENABLED"]
+
+    def test_set_dsm_context_not_called_when_only_tracing_enabled(self):
+        os.environ["DD_DATA_STREAMS_ENABLED"] = "false"
+        wrapper.dd_tracing_enabled = True
+
+        @wrapper.datadog_lambda_wrapper
+        def lambda_handler(event, context):
+            return "ok"
+
+        result = lambda_handler({}, get_mock_context())
+        self.assertEqual(result, "ok")
+        self.mock_set_dsm_context.assert_not_called()
+
+        del os.environ["DD_DATA_STREAMS_ENABLED"]
+
+    def test_set_dsm_context_not_called_when_tracing_and_DSM_disabled(self):
+        os.environ["DD_DATA_STREAMS_ENABLED"] = "false"
+        wrapper.dd_tracing_enabled = False
+
+        @wrapper.datadog_lambda_wrapper
+        def lambda_handler(event, context):
+            return "ok"
+
+        result = lambda_handler({}, get_mock_context())
+        self.assertEqual(result, "ok")
+        self.mock_set_dsm_context.assert_not_called()
+
+        del os.environ["DD_DATA_STREAMS_ENABLED"]
+
 
 class TestLambdaDecoratorSettings(unittest.TestCase):
     def test_some_envs_should_depend_on_dd_tracing_enabled(self):