Fix: Body serialization should respect max_nesting_depth config

- Add maxDepth parameter to Body constructor
- Update Body::serialize() to use maxDepth when calling serializeForRollbar
- Update DataBuilder to pass maxNestingDepth config to Body constructor
- Add test to verify deep nesting is properly truncated

This fixes memory exhaustion issues when logging errors with complex
nested data structures (like Drupal form arrays) by respecting the
configured max_nesting_depth limit during Body serialization.

Previously, Body::serialize() always used unlimited depth (-1) via
serializeForRollbarInternal(), ignoring the max_nesting_depth config.

Fixes memory issues similar to those described in issue reports about
Rollbar consuming excessive memory with deeply nested context data.

Author: AronNovak

src/DataBuilder.php

@@ -59,6 +59,8 @@ class DataBuilder implements DataBuilderInterface
     protected $captureEmail;
     protected $captureUsername;
 
+    protected $maxNestingDepth;
+    
     /**
      * @var Utilities
      */
@@ -99,6 +101,7 @@ public function __construct(array $config)
         $this->setCustom($config);
         $this->setFingerprint($config);
         $this->setTitle($config);
+        $this->setMaxNestingDepth($config);
         $this->setNotifier($config);
         $this->setBaseException($config);
         $this->setIncludeCodeContext($config);
@@ -129,6 +132,12 @@ protected function setCaptureUsername($config)
         $fromConfig = $config['capture_username'] ?? null;
         $this->captureUsername = self::$defaults->captureUsername($fromConfig);
     }
+    
+    protected function setMaxNestingDepth($config)
+    {
+        $fromConfig = $config['max_nesting_depth'] ?? null;
+        $this->maxNestingDepth = self::$defaults->maxNestingDepth($fromConfig);
+    }
 
     protected function setEnvironment($config)
     {
@@ -411,7 +420,7 @@ protected function getBody(Throwable|string|Stringable $toLog, array $context):
         } else {
             $content = $this->getMessage($toLog);
         }
-        return new Body($content, $context, $this->getTelemetry());
+        return new Body($content, $context, $this->getTelemetry(), $this->maxNestingDepth);
     }
 
     public function getErrorTrace(ErrorWrapper $error)

src/Payload/Body.php

@@ -23,7 +23,8 @@ class Body implements SerializerInterface
     public function __construct(
         private ContentInterface $value,
         private array $extra = [],
-        private ?array $telemetry = null
+        private ?array $telemetry = null,
+        private int $maxDepth = -1
     ) {
     }
 
@@ -122,6 +123,11 @@ public function serialize()
             $result['telemetry'] = $this->telemetry;
         }
 
-        return $this->utilities()->serializeForRollbarInternal($result, array('extra'));
+        if ($this->maxDepth === -1) {
+            return $this->utilities()->serializeForRollbarInternal($result, array('extra'));
+        } else {
+            $objectHashes = array();
+            return $this->utilities()->serializeForRollbar($result, array('extra'), $objectHashes, $this->maxDepth);
+        }
     }
 }

tests/BodyTest.php

@@ -46,4 +46,37 @@ public function testSerialize(): void
             $encoded
         );
     }
+
+    public function testSerializeWithMaxNestingDepth(): void
+    {
+        $value = m::mock(ContentInterface::class)
+            ->shouldReceive("serialize")
+            ->andReturn("{CONTENT}")
+            ->shouldReceive("getKey")
+            ->andReturn("content_interface")
+            ->mock();
+        
+        // Create deeply nested array that would cause memory issues
+        $deepArray = array('level1' => array('level2' => array('level3' => array('level4' => 'deep_value'))));
+        
+        // Test without depth limit - should serialize completely  
+        $bodyNoLimit = new Body($value, array('deep' => $deepArray), null, -1);
+        $resultNoLimit = $bodyNoLimit->serialize();
+        
+        // Test with depth limit - should truncate deep nesting
+        $bodyWithLimit = new Body($value, array('deep' => $deepArray), null, 2);
+        $resultWithLimit = $bodyWithLimit->serialize();
+        
+        // Verify basic structure exists
+        $this->assertArrayHasKey('extra', $resultNoLimit);
+        $this->assertArrayHasKey('extra', $resultWithLimit);
+        
+        // Without limit should have all nested levels
+        $this->assertEquals('deep_value', $resultNoLimit['extra']['deep']['level1']['level2']['level3']['level4']);
+        
+        // With limit should truncate the 'deep' array due to depth constraint
+        // At depth 2: root -> extra -> deep (gets truncated to empty array)
+        $this->assertArrayHasKey('deep', $resultWithLimit['extra']);
+        $this->assertEmpty($resultWithLimit['extra']['deep']); // Truncated due to depth limit
+    }
 }