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

@@ -81,6 +81,11 @@ def _validate_spans(self):
             if not self.probe_spans[expected_trace]:
                 raise ValueError(f"No spans found for trace {expected_trace}")
 
+    def _assert_keys_present(self, data: dict, required_keys: list):
+        missing = [key for key in required_keys if key not in data]
+        if missing:
+            raise KeyError(f"Missing required keys: {', '.join(missing)}")
+
 
 @features.debugger_method_probe
 @scenarios.debugger_probes_snapshot
@@ -209,6 +214,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 +229,124 @@ def test_log_line_snapshot(self):
         self._assert()
         self._validate_snapshots()
 
+    def setup_default_capture_values(self):
+        """Setup test with endpoint that generates data exceeding default capture limits"""
+        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 + 245
+
+        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=None,
+        )
+
+    @missing_feature(context.library != "nodejs", reason="Endpoint only implemented for Node.js", force_skip=True)
+    def test_default_capture_values(self):
+        """Test that the tracer uses default capture values when capture property is omitted"""
+        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"]
+                    self._assert_keys_present(
+                        locals_data, ["manyFields", "largeCollection", "deepObject", "longString"]
+                    )
+
+                    # Validate maxFieldCount
+                    many_fields = locals_data["manyFields"]
+                    assert many_fields.get("notCapturedReason") == "fieldCount", (
+                        f"manyFields should have notCapturedReason='fieldCount' to indicate "
+                        f"maxFieldCount limit was applied. Got: {many_fields.get('notCapturedReason')}"
+                    )
+
+                    actual_size = many_fields.get("size")
+                    expected_field_count = self.DEFAULT_MAX_FIELD_COUNT + 30
+                    assert (
+                        actual_size == expected_field_count
+                    ), f"manyFields should report size={expected_field_count}, got: {actual_size}"
+
+                    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 "
+                        f"(maxFieldCount default), got: {captured_count}"
+                    )
+
+                    # Validate maxCollectionSize
+                    large_collection = locals_data["largeCollection"]
+                    assert large_collection.get("notCapturedReason") == "collectionSize", (
+                        f"largeCollection should have notCapturedReason='collectionSize' to indicate "
+                        f"maxCollectionSize limit was applied. Got: {large_collection.get('notCapturedReason')}"
+                    )
+
+                    actual_size = large_collection.get("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 "
+                        f"captured (maxCollectionSize default), got: {captured_count}"
+                    )
+
+                    # Validate maxReferenceDepth
+                    self._assert_max_depth(locals_data["deepObject"], max_depth=self.DEFAULT_MAX_REFERENCE_DEPTH)
+
+                    # Validate maxLength
+                    string_value = locals_data["longString"]["value"]
+                    assert len(string_value) <= self.DEFAULT_MAX_LENGTH, (
+                        f"longString has length {len(string_value)}, exceeds maxLength default "
+                        f"({self.DEFAULT_MAX_LENGTH}). String should be truncated."
+                    )
+
+    def _assert_max_depth(self, obj: dict, max_depth: int, current_depth: int = 1) -> None:
+        """Asserts that nested objects are truncated at maxReferenceDepth with notCapturedReason='depth'"""
+        assert "fields" in obj, f"Expected 'fields' to be present in the object, got: {list(obj.keys())}"
+        fields = obj["fields"]
+        assert isinstance(fields, dict), f"Expected 'fields' to be a dict, got: {type(fields)}"
+        assert "nested" in fields, f"Expected 'nested' to be present in the 'fields' object, got: {list(fields.keys())}"
+        nested = fields["nested"]
+        assert isinstance(nested, dict), f"Expected 'nested' to be a dict, got: {type(nested)}"
+        if current_depth == max_depth:
+            assert (
+                nested.get("notCapturedReason") == "depth"
+            ), f"Expected 'notCapturedReason' to be 'depth', got: {nested.get('notCapturedReason')}"
+        else:
+            self._assert_max_depth(nested, max_depth, current_depth + 1)
+
     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/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": [
+                "136"
+            ]
+        }
+    }
+]
+

utils/build/docker/nodejs/express/debugger/data_generator.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = ({ depth, fields, collectionSize, stringLength }) => {
+  // Generate deeply nested object (tests maxReferenceDepth)
+  const deepObject = depth > 0 ? createNestedObject(depth) : null
+
+  // Generate object with many fields (tests maxFieldCount)
+  const manyFields = {}
+  for (let i = 0; i < fields; i++) {
+    manyFields[`field${i}`] = i
+  }
+
+  // Generate large collection (tests maxCollectionSize)
+  const largeCollection = []
+  for (let i = 0; i < collectionSize; i++) {
+    largeCollection.push(i)
+  }
+
+  // Generate long string (tests maxLength)
+  const longString = stringLength > 0 ? 'A'.repeat(stringLength) : ''
+
+  return {
+    deepObject,
+    manyFields,
+    largeCollection,
+    longString
+  }
+}
+
+function createNestedObject (maxLevel, level = 1) {
+  if (level === maxLevel) return { level }
+  return {
+    level,
+    nested: createNestedObject(maxLevel, level + 1)
+  }
+}

utils/build/docker/nodejs/express/debugger/index.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-unused-vars, camelcase */
 
 const Pii = require('./pii')
+const dataGenerator = require('./data_generator')
 
 module.exports = {
   initRoutes (app) {
@@ -14,7 +15,6 @@ module.exports = {
     // Padding
     // Padding
     // Padding
-    // Padding
 
     app.get('/debugger/log', (req, res) => {
       res.send('Log probe') // This needs to be line 20
@@ -125,5 +125,15 @@ module.exports = {
       const pii = boolValue ? new Pii() : null
       res.send('Expression probe') // This needs to be line 126
     })
+
+    app.get('/debugger/snapshot/limits', (req, res) => {
+      const { deepObject, manyFields, largeCollection, longString } = dataGenerator({
+        depth: parseInt(req.query.depth, 10) || 0,
+        fields: parseInt(req.query.fields, 10) || 0,
+        collectionSize: parseInt(req.query.collectionSize, 10) || 0,
+        stringLength: parseInt(req.query.stringLength, 10) || 0,
+      })
+      res.send('Capture limits probe') // This needs to be line 136
+    })
   }
 }

utils/build/docker/nodejs/express4-typescript/debugger/data_generator.ts

@@ -0,0 +1,48 @@
+interface DataGeneratorOptions {
+  depth: number
+  fields: number
+  collectionSize: number
+  stringLength: number
+}
+
+interface GeneratedData {
+  deepObject: any
+  manyFields: Record<string, number>
+  largeCollection: number[]
+  longString: string
+}
+
+export function dataGenerator ({ depth, fields, collectionSize, stringLength }: DataGeneratorOptions): GeneratedData {
+  // Generate deeply nested object (tests maxReferenceDepth)
+  const deepObject = depth > 0 ? createNestedObject(depth) : null
+
+  // Generate object with many fields (tests maxFieldCount)
+  const manyFields: Record<string, number> = {}
+  for (let i = 0; i < fields; i++) {
+    manyFields[`field${i}`] = i
+  }
+
+  // Generate large collection (tests maxCollectionSize)
+  const largeCollection: number[] = []
+  for (let i = 0; i < collectionSize; i++) {
+    largeCollection.push(i)
+  }
+
+  // Generate long string (tests maxLength)
+  const longString = stringLength > 0 ? 'A'.repeat(stringLength) : ''
+
+  return {
+    deepObject,
+    manyFields,
+    largeCollection,
+    longString
+  }
+}
+
+function createNestedObject (maxLevel: number, level = 1): any {
+  if (level === maxLevel) return { level }
+  return {
+    level,
+    nested: createNestedObject(maxLevel, level + 1)
+  }
+}

utils/build/docker/nodejs/express4-typescript/debugger/index.ts

@@ -2,6 +2,7 @@
 
 import type { Express, Request, Response } from 'express'
 import { Pii } from './pii'
+import { dataGenerator } from './data_generator'
 
 export function initRoutes (app: Express) {
   // Padding
@@ -14,7 +15,6 @@ export function initRoutes (app: Express) {
   // Padding
   // Padding
   // Padding
-  // Padding
 
   app.get('/debugger/log', (req: Request, res: Response) => {
     res.send('Log probe') // This needs to be line 20
@@ -125,4 +125,14 @@ export function initRoutes (app: Express) {
     const pii = boolValue ? new Pii() : null
     res.send('Expression probe') // This needs to be line 126
   })
+
+  app.get('/debugger/snapshot/limits', (req: Request, res: Response) => {
+    const { deepObject, manyFields, largeCollection, longString } = dataGenerator({
+      depth: parseInt(req.query.depth as string, 10) || 0,
+      fields: parseInt(req.query.fields as string, 10) || 0,
+      collectionSize: parseInt(req.query.collectionSize as string, 10) || 0,
+      stringLength: parseInt(req.query.stringLength as string, 10) || 0
+    })
+    res.send('Capture limits probe') // This needs to be line 136
+  })
 }

utils/build/docker/nodejs/fastify/debugger/data_generator.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = ({ depth, fields, collectionSize, stringLength }) => {
+  // Generate deeply nested object (tests maxReferenceDepth)
+  const deepObject = depth > 0 ? createNestedObject(depth) : null
+
+  // Generate object with many fields (tests maxFieldCount)
+  const manyFields = {}
+  for (let i = 0; i < fields; i++) {
+    manyFields[`field${i}`] = i
+  }
+
+  // Generate large collection (tests maxCollectionSize)
+  const largeCollection = []
+  for (let i = 0; i < collectionSize; i++) {
+    largeCollection.push(i)
+  }
+
+  // Generate long string (tests maxLength)
+  const longString = stringLength > 0 ? 'A'.repeat(stringLength) : ''
+
+  return {
+    deepObject,
+    manyFields,
+    largeCollection,
+    longString
+  }
+}
+
+function createNestedObject (maxLevel, level = 1) {
+  if (level === maxLevel) return { level }
+  return {
+    level,
+    nested: createNestedObject(maxLevel, level + 1)
+  }
+}

utils/build/docker/nodejs/fastify/debugger/index.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-unused-vars, camelcase */
 
 const Pii = require('./pii')
+const dataGenerator = require('./data_generator')
 
 module.exports = {
   initRoutes (fastify) {
@@ -14,7 +15,6 @@ module.exports = {
     // Padding
     // Padding
     // Padding
-    // Padding
 
     fastify.get('/debugger/log', async (request, reply) => {
       return 'Log probe' // This needs to be line 20
@@ -125,5 +125,15 @@ module.exports = {
       const pii = boolValue ? new Pii() : null
       return 'Expression probe' // This needs to be line 126
     })
+
+    fastify.get('/debugger/snapshot/limits', async (request, reply) => {
+      const { deepObject, manyFields, largeCollection, longString } = dataGenerator({
+        depth: parseInt(request.query.depth, 10) || 0,
+        fields: parseInt(request.query.fields, 10) || 0,
+        collectionSize: parseInt(request.query.collectionSize, 10) || 0,
+        stringLength: parseInt(request.query.stringLength, 10) || 0,
+      })
+      return 'Capture limits probe' // This needs to be line 136
+    })
   }
 }