Fix memory leak when transaction has parents

Improve sampler cleanup during thread run

Author: jvangaalen

src/core/src/main/java/org/apache/jmeter/samplers/SampleResult.java

@@ -32,7 +32,10 @@
 import org.apache.jmeter.assertions.AssertionResult;
 import org.apache.jmeter.gui.Searchable;
 import org.apache.jmeter.testelement.TestPlan;
+import org.apache.jmeter.threads.JMeterContext;
+import org.apache.jmeter.threads.JMeterContextService;
 import org.apache.jmeter.threads.JMeterContext.TestLogicalAction;
+import org.apache.jmeter.control.TransactionSampler;
 import org.apache.jmeter.util.JMeterUtils;
 import org.apache.jorphan.util.JOrphanUtils;
 import org.apache.jorphan.util.StringUtilities;
@@ -1595,10 +1598,62 @@ public void setStartNextThreadLoop(boolean startNextThreadLoop) {
     }
 
     /**
-     * Clean up cached data
+     * Clean up cached data, but only if this is a root result (no parent)
+     * and not part of a parent transaction.
      */
     public void cleanAfterSample() {
+        // Only clean if this is a root result (no parent)
+        if (parent != null) {
+            return;
+        }
+        
+        // Check if we're part of a parent transaction by walking up the sampler hierarchy
+        JMeterContext context = JMeterContextService.getContext();
+        if (context != null) {
+            Sampler currentSampler = context.getCurrentSampler();
+            if (currentSampler instanceof TransactionSampler) {
+                TransactionSampler transSampler = (TransactionSampler) currentSampler;
+                // Get the parent sampler from the transaction
+                Sampler parentSampler = transSampler.getSubSampler();
+                // If there's a parent sampler and it's a transaction, we're nested
+                if (parentSampler instanceof TransactionSampler) {
+                    return;
+                }
+            }
+        }
+        
+        cleanRecursively();
+    }
+    
+    /**
+     * Internal method to clean this result and all its sub-results
+     */
+    private void cleanRecursively() {   
+        // Clean sub-results first
+        if (subResults != null) {
+            for (SampleResult subResult : subResults) {
+                if (subResult != null) {
+                    subResult.cleanRecursively();
+                }
+            }
+            subResults.clear();
+            subResults = null;
+        }
+        
+        // Clean assertion results
+        if (assertionResults != null) {
+            assertionResults.clear();
+            assertionResults = null;
+        }
+        
+        // Clear only memory-heavy data and caches, preserve samplerData
+        this.parent = null;
         this.responseDataAsString = null;
+        this.responseData = EMPTY_BA;
+        this.responseHeaders = "";
+        this.requestHeaders = "";
+        this.samplerData = null;
+
     }
 
     @Override
@@ -1666,4 +1721,50 @@ public TestLogicalAction getTestLogicalAction() {
     public void setTestLogicalAction(TestLogicalAction testLogicalAction) {
         this.testLogicalAction = testLogicalAction;
     }
+
+    /**
+     * Create a deep copy for async listeners
+     * @return A deep copy of this result
+     */
+    public SampleResult cloneForListeners() {
+        // Create clone with the correct type
+        SampleResult clone;
+        try {
+            // Use the same constructor that was used to create this instance
+            clone = this.getClass().getConstructor(this.getClass()).newInstance(this);
+        } catch (Exception e) {
+            // Fallback to base class if constructor is not available
+            log.debug("Could not create clone with type: " + this.getClass().getName() + ", using base class", e);
+            clone = new SampleResult(this);
+        }
+        
+        // Deep copy mutable fields that the copy constructor doesn't handle deeply
+        if (responseData != EMPTY_BA) {
+            clone.responseData = responseData.clone();
+        }
+        
+        // Deep copy subResults
+        if (subResults != null) {
+            clone.subResults = new ArrayList<>(subResults.size());
+            for (SampleResult sub : subResults) {
+                SampleResult subClone = sub.cloneForListeners();
+                subClone.setParent(clone);
+                clone.subResults.add(subClone);
+            }
+        }
+        
+        // Deep copy assertion results
+        if (assertionResults != null) {
+            clone.assertionResults = new ArrayList<>(assertionResults.size());
+            for (AssertionResult assertionResult : assertionResults) {
+                clone.assertionResults.add(assertionResult); // AssertionResult is immutable
+            }
+        }
+        
+        // Clear only the caches and unnecessary references in the clone
+        clone.responseDataAsString = null;
+        clone.parent = null;  // Parent reference not needed in the clone
+        
+        return clone;
+    }
 }

src/core/src/main/java/org/apache/jmeter/threads/JMeterThread.java

@@ -672,6 +672,12 @@ private SampleResult doEndTransactionSampler(
             notifyListeners(transactionPack.getSampleListeners(), transactionResult);
         }
         compiler.done(transactionPack);
+        
+        // Clean up the transaction result after listeners have processed it
+        if (transactionResult != null) {
+            transactionResult.cleanAfterSample();
+        }
+        
         return transactionResult;
     }
 
@@ -1028,7 +1034,7 @@ void notifyTestListeners() {
     }
 
     private void notifyListeners(List<SampleListener> listeners, SampleResult result) {
-        SampleEvent event = new SampleEvent(result, threadGroup.getName(), threadVars);
+        SampleEvent event = new SampleEvent(result.cloneForListeners(), threadGroup.getName(), threadVars);
         notifier.notifyListeners(event, listeners);
     }