Add test for debugger snapshot default capture limits

Add comprehensive test to verify that tracers correctly apply default
capture limits when no capture property is specified in the probe
configuration:

- `maxReferenceDepth`: 3
- `maxCollectionSize`: 100
- `maxFieldCount`: 20
- `maxLength`: 255

Author: watson

tests/debugger/test_debugger_probe_snapshot.py

@@ -6,7 +6,7 @@
 import tests.debugger.utils as debugger
 
 
-from utils import scenarios, features, missing_feature, context, irrelevant, bug
+from utils import scenarios, features, missing_feature, context, irrelevant, bug, logger
 from utils.interfaces._library.miscs import validate_process_tags
 
 
@@ -209,6 +209,12 @@ def _validate_snapshots(self):
 class Test_Debugger_Line_Probe_Snaphots(BaseDebuggerProbeSnaphotTest):
     """Tests for line-level probe snapshots"""
 
+    # Default snapshot capture limits
+    DEFAULT_MAX_REFERENCE_DEPTH = 3
+    DEFAULT_MAX_COLLECTION_SIZE = 100
+    DEFAULT_MAX_FIELD_COUNT = 20
+    DEFAULT_MAX_LENGTH = 255
+
     ### log probe ###
     def setup_log_line_snapshot(self):
         self._setup("probe_snapshot_log_line", "/debugger/log", "log", lines=None)
@@ -218,6 +224,167 @@ def test_log_line_snapshot(self):
         self._assert()
         self._validate_snapshots()
 
+    def setup_default_max_reference_depth(self):
+        """Setup test for default maxReferenceDepth"""
+        self._setup_default_capture_limits()
+
+    def setup_default_max_field_count(self):
+        """Setup test for default maxFieldCount"""
+        self._setup_default_capture_limits()
+
+    def setup_default_max_collection_size(self):
+        """Setup test for default maxCollectionSize"""
+        self._setup_default_capture_limits()
+
+    def setup_default_max_length(self):
+        """Setup test for default maxLength"""
+        self._setup_default_capture_limits()
+
+    def _setup_default_capture_limits(self):
+        """Shared setup method for default capture limit tests"""
+        test_depth = self.DEFAULT_MAX_REFERENCE_DEPTH + 7
+        test_fields = self.DEFAULT_MAX_FIELD_COUNT + 30
+        test_collection_size = self.DEFAULT_MAX_COLLECTION_SIZE + 100
+        test_string_length = self.DEFAULT_MAX_LENGTH + 1000
+
+        # Get the line number dynamically based on the language
+        lines = self.method_and_language_to_line_number("SnapshotLimits", context.library.name)
+
+        self._setup(
+            "probe_snapshot_default_capture_limits",
+            f"/debugger/snapshot/limits?"
+            f"depth={test_depth}&"
+            f"fields={test_fields}&"
+            f"collectionSize={test_collection_size}&"
+            f"stringLength={test_string_length}",
+            "log",
+            lines=lines,
+        )
+
+    def _get_snapshot_locals_variable(self, variable_name: str) -> dict:
+        """Helper method to extract a specific local variable from snapshot for default capture limit tests"""
+        self._assert()
+        self._validate_snapshots()
+
+        for probe_id in self.probe_ids:
+            if probe_id not in self.probe_snapshots:
+                raise ValueError(f"Snapshot {probe_id} was not received.")
+
+            snapshots = self.probe_snapshots[probe_id]
+            if not snapshots:
+                raise ValueError(f"No snapshots found for probe {probe_id}")
+
+            snapshot = snapshots[0]
+            debugger_snapshot = snapshot.get("debugger", {}).get("snapshot") or snapshot.get("debugger.snapshot")
+
+            if not debugger_snapshot:
+                raise ValueError(f"Snapshot data not found in expected format for probe {probe_id}")
+            if "captures" not in debugger_snapshot:
+                raise ValueError(f"No captures found in snapshot for probe {probe_id}")
+
+            captures = debugger_snapshot["captures"]
+            if "lines" in captures:
+                lines = captures["lines"]
+                if isinstance(lines, dict) and len(lines) == 1:
+                    line_key = next(iter(lines))
+                    line_data = lines[line_key]
+                else:
+                    raise ValueError(f"Expected 'lines' to be a dict with a single key, got: {len(lines)}")
+
+                if line_data and "locals" in line_data:
+                    locals_data = line_data["locals"]
+                    assert variable_name in locals_data, f"'{variable_name}' is missing from snapshot locals"
+                    return locals_data[variable_name]
+
+        raise ValueError("No locals data found in snapshot")
+
+    def _measure_captured_depth(self, obj: dict, current_depth: int = 1) -> int:
+        """Measure the actual depth captured before truncation (notCapturedReason='depth')"""
+        fields = obj["fields"]
+        assert isinstance(fields, dict), f"Expected 'fields' to be a dict, got: {type(fields)}"
+        expected_nested_key = "@nested" if context.library.name == "ruby" else "nested"
+        assert (
+            expected_nested_key in fields
+        ), f"Expected '{expected_nested_key}' to be present in the 'fields' object, got: {list(fields.keys())}"
+        nested = fields[expected_nested_key]
+        assert isinstance(nested, dict), f"Expected 'nested' to be a dict, got: {type(nested)}"
+
+        if "notCapturedReason" in nested:
+            assert (
+                nested["notCapturedReason"] == "depth"
+            ), f"Expected notCapturedReason to be 'depth', got: {nested['notCapturedReason']}"
+            return current_depth
+
+        return self._measure_captured_depth(nested, current_depth + 1)
+
+    @bug(
+        context.library.name == "nodejs", reason="DEBUG-4611"
+    )  # Node.js does apply the correct default, but fails if no `capture` object is present
+    @bug(
+        context.library.name == "ruby", reason="DEBUG-0000"
+    )  # TODO: Add real JIRA ticket: Ruby has off-by-one bug: captures 4 levels instead of 3
+    def test_default_max_reference_depth(self):
+        """Test that the tracer uses default maxReferenceDepth=3 when capture property is omitted"""
+        deep_object = self._get_snapshot_locals_variable("deepObject")
+        actual_depth = self._measure_captured_depth(deep_object)
+        assert (
+            actual_depth == self.DEFAULT_MAX_REFERENCE_DEPTH
+        ), f"deepObject should have been captured with {self.DEFAULT_MAX_REFERENCE_DEPTH} levels. Got: {actual_depth}"
+
+    @bug(
+        context.library.name == "nodejs", reason="DEBUG-4611"
+    )  # Node.js does apply the correct default, but fails if no `capture` object is present
+    def test_default_max_field_count(self):
+        """Test that the tracer uses default maxFieldCount=20 when capture property is omitted"""
+        many_fields = self._get_snapshot_locals_variable("manyFields")
+        assert (
+            many_fields.get("notCapturedReason") == "fieldCount"
+        ), f"manyFields should have notCapturedReason='fieldCount'. Got: {many_fields.get('notCapturedReason')}"
+
+        captured_count = len(many_fields["fields"])
+        assert (
+            captured_count == self.DEFAULT_MAX_FIELD_COUNT
+        ), f"manyFields should have exactly {self.DEFAULT_MAX_FIELD_COUNT} fields captured. Got: {captured_count}"
+
+    @bug(
+        context.library.name == "nodejs", reason="DEBUG-4611"
+    )  # Node.js does apply the correct default, but fails if no `capture` object is present
+    def test_default_max_collection_size(self):
+        """Test that the tracer uses default maxCollectionSize=100 when capture property is omitted"""
+        large_collection = self._get_snapshot_locals_variable("largeCollection")
+        assert (
+            large_collection.get("notCapturedReason") == "collectionSize"
+        ), f"largeCollection should have notCapturedReason='collectionSize'. Got: {large_collection.get('notCapturedReason')}"
+
+        actual_size = large_collection.get("size")
+        if isinstance(actual_size, str) and context.library.name == "java":
+            # TODO: Create JIRA ticket: Java size property is a string! Expected an int
+            logger.warning("size property is a string! Expected an int")
+            actual_size = int(actual_size)
+        expected_collection_size = self.DEFAULT_MAX_COLLECTION_SIZE + 100
+        assert (
+            actual_size == expected_collection_size
+        ), f"largeCollection should report size={expected_collection_size}. Got: {actual_size}"
+
+        captured_count = len(large_collection["elements"])
+        assert (
+            captured_count == self.DEFAULT_MAX_COLLECTION_SIZE
+        ), f"largeCollection should have exactly {self.DEFAULT_MAX_COLLECTION_SIZE} elements. Got: {captured_count}"
+
+    @bug(
+        context.library.name == "nodejs", reason="DEBUG-4611"
+    )  # Node.js does apply the correct default, but fails if no `capture` object is present
+    @bug(
+        context.library.name == "dotnet", reason="DEBUG-0000"
+    )  # TODO: Add real JIRA ticket: .NET uses a different default maxLength (1000)
+    def test_default_max_length(self):
+        """Test that the tracer uses default maxLength=255 when capture property is omitted"""
+        long_string = self._get_snapshot_locals_variable("longString")
+        string_value = long_string["value"]
+        assert (
+            len(string_value) <= self.DEFAULT_MAX_LENGTH
+        ), f"longString should have length {self.DEFAULT_MAX_LENGTH}. Got: {len(string_value)}"
+
     def setup_log_line_snapshot_debug_track(self):
         self.use_debugger_endpoint = True
         self._setup("probe_snapshot_log_line", "/debugger/log", "log", lines=None)

tests/debugger/utils.py

@@ -139,6 +139,7 @@ def method_and_language_to_line_number(self, method: str, language: str) -> list
             "StringOperations": {"java": [87], "dotnet": [97], "python": [96], "nodejs": [96]},
             "CollectionOperations": {"java": [114], "dotnet": [114], "python": [123], "nodejs": [120]},
             "Nulls": {"java": [130], "dotnet": [127], "python": [136], "nodejs": [126]},
+            "SnapshotLimits": {"java": [153], "python": [172], "nodejs": [136], "ruby": [78], "dotnet": [150]},
         }
 
         return definitions.get(method, {}).get(language, [])

tests/debugger/utils/probes/probe_snapshot_default_capture_limits.json

@@ -0,0 +1,17 @@
+[
+    {
+        "language": "",
+        "type": "",
+        "id": "",
+        "version": 0,
+        "captureSnapshot": true,
+        "where": {
+            "typeName": null,
+            "sourceFile": "ACTUAL_SOURCE_FILE",
+            "lines": [
+                "0"
+            ]
+        }
+    }
+]
+

utils/build/docker/dotnet/weblog/Controllers/DebuggerController.cs

@@ -137,5 +137,17 @@ public IActionResult Budgets(int loops)
             }
             return Content("Budgets");
         }
+
+        [HttpGet("snapshot/limits")]
+        [Consumes("application/json", "application/xml")]
+        public IActionResult SnapshotLimits(int depth = 0, int collectionSize = 0, int stringLength = 0)
+        {
+            var data = DataGenerator.GenerateTestData(depth, collectionSize, stringLength);
+            var deepObject = data["deepObject"];
+            var manyFields = data["manyFields"];
+            var largeCollection = data["largeCollection"];
+            var longString = data["longString"];
+            return Content("Capture limits probe"); // must be line 150
+        }
     }
 }

utils/build/docker/dotnet/weblog/Models/Debugger/DataGenerator.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+
+namespace weblog.Models.Debugger
+{
+    public class NestedObject
+    {
+        public int level { get; set; }
+        public NestedObject nested { get; set; }
+    }
+
+    public class ManyFieldsObject
+    {
+        // Define 50 public properties to test maxFieldCount
+        public int field0 { get; set; } = 0;
+        public int field1 { get; set; } = 1;
+        public int field2 { get; set; } = 2;
+        public int field3 { get; set; } = 3;
+        public int field4 { get; set; } = 4;
+        public int field5 { get; set; } = 5;
+        public int field6 { get; set; } = 6;
+        public int field7 { get; set; } = 7;
+        public int field8 { get; set; } = 8;
+        public int field9 { get; set; } = 9;
+        public int field10 { get; set; } = 10;
+        public int field11 { get; set; } = 11;
+        public int field12 { get; set; } = 12;
+        public int field13 { get; set; } = 13;
+        public int field14 { get; set; } = 14;
+        public int field15 { get; set; } = 15;
+        public int field16 { get; set; } = 16;
+        public int field17 { get; set; } = 17;
+        public int field18 { get; set; } = 18;
+        public int field19 { get; set; } = 19;
+        public int field20 { get; set; } = 20;
+        public int field21 { get; set; } = 21;
+        public int field22 { get; set; } = 22;
+        public int field23 { get; set; } = 23;
+        public int field24 { get; set; } = 24;
+        public int field25 { get; set; } = 25;
+        public int field26 { get; set; } = 26;
+        public int field27 { get; set; } = 27;
+        public int field28 { get; set; } = 28;
+        public int field29 { get; set; } = 29;
+        public int field30 { get; set; } = 30;
+        public int field31 { get; set; } = 31;
+        public int field32 { get; set; } = 32;
+        public int field33 { get; set; } = 33;
+        public int field34 { get; set; } = 34;
+        public int field35 { get; set; } = 35;
+        public int field36 { get; set; } = 36;
+        public int field37 { get; set; } = 37;
+        public int field38 { get; set; } = 38;
+        public int field39 { get; set; } = 39;
+        public int field40 { get; set; } = 40;
+        public int field41 { get; set; } = 41;
+        public int field42 { get; set; } = 42;
+        public int field43 { get; set; } = 43;
+        public int field44 { get; set; } = 44;
+        public int field45 { get; set; } = 45;
+        public int field46 { get; set; } = 46;
+        public int field47 { get; set; } = 47;
+        public int field48 { get; set; } = 48;
+        public int field49 { get; set; } = 49;
+    }
+
+    public static class DataGenerator
+    {
+        public static Dictionary<string, object> GenerateTestData(int depth, int collectionSize, int stringLength)
+        {
+            var result = new Dictionary<string, object>();
+
+            // Generate deeply nested object (tests maxReferenceDepth)
+            result["deepObject"] = depth > 0 ? CreateNestedObject(depth) : null;
+
+            // Generate object with many fields (tests maxFieldCount)
+            result["manyFields"] = new ManyFieldsObject();
+
+            // Generate large collection (tests maxCollectionSize)
+            var largeCollection = new List<int>();
+            for (int i = 0; i < collectionSize; i++)
+            {
+                largeCollection.Add(i);
+            }
+            result["largeCollection"] = largeCollection;
+
+            // Generate long string (tests maxLength)
+            result["longString"] = stringLength > 0 ? new string('A', stringLength) : "";
+
+            return result;
+        }
+
+        private static NestedObject CreateNestedObject(int maxLevel, int level = 1)
+        {
+            var obj = new NestedObject
+            {
+                level = level,
+                nested = level < maxLevel ? CreateNestedObject(maxLevel, level + 1) : null
+            };
+
+            return obj;
+        }
+    }
+}

utils/build/docker/java/spring-boot/src/main/java/com/datadoghq/system_tests/springboot/debugger/DataGenerator.java

@@ -0,0 +1,60 @@
+package com.datadoghq.system_tests.springboot;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class NestedObject {
+    public int level;
+    public NestedObject nested;
+
+    public NestedObject(int level, NestedObject nested) {
+        this.level = level;
+        this.nested = nested;
+    }
+}
+
+class ManyFieldsObject {
+    // Class with 50 public fields to test maxFieldCount, we can't test generate these dynamically so we just always have 50 fields
+    public Integer field0 = 0, field1 = 1, field2 = 2, field3 = 3, field4 = 4,
+            field5 = 5, field6 = 6, field7 = 7, field8 = 8, field9 = 9,
+            field10 = 10, field11 = 11, field12 = 12, field13 = 13, field14 = 14,
+            field15 = 15, field16 = 16, field17 = 17, field18 = 18, field19 = 19,
+            field20 = 20, field21 = 21, field22 = 22, field23 = 23, field24 = 24,
+            field25 = 25, field26 = 26, field27 = 27, field28 = 28, field29 = 29,
+            field30 = 30, field31 = 31, field32 = 32, field33 = 33, field34 = 34,
+            field35 = 35, field36 = 36, field37 = 37, field38 = 38, field39 = 39,
+            field40 = 40, field41 = 41, field42 = 42, field43 = 43, field44 = 44,
+            field45 = 45, field46 = 46, field47 = 47, field48 = 48, field49 = 49;
+}
+
+public class DataGenerator {
+    public static Map<String, Object> generateTestData(int depth, int collectionSize, int stringLength) {
+        Map<String, Object> result = new HashMap<>();
+
+        // Generate deeply nested object (tests maxReferenceDepth)
+        result.put("deepObject", depth > 0 ? createNestedObject(depth, 1) : null);
+
+        // Generate object with many fields (tests maxFieldCount)
+        result.put("manyFields", new ManyFieldsObject());
+
+        // Generate large collection (tests maxCollectionSize)
+        List<Integer> largeCollection = new ArrayList<>();
+        for (int i = 0; i < collectionSize; i++) {
+            largeCollection.add(i);
+        }
+        result.put("largeCollection", largeCollection);
+
+        // Generate long string (tests maxLength)
+        result.put("longString", stringLength > 0 ? "A".repeat(stringLength) : "");
+
+        return result;
+    }
+
+    private static NestedObject createNestedObject(int maxLevel, int level) {
+        NestedObject nested = level < maxLevel ? createNestedObject(maxLevel, level + 1) : null;
+        return new NestedObject(level, nested);
+    }
+}
+