Merge branch 'development' into HTTP-PARITY-REGRESSION

Author: 3dgiordano

README.md

@@ -1,3 +1,5 @@
+![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/blazemeter/jmeter-http-plugin/total?style=for-the-badge&link=https%3A%2F%2Fgithub.com%2FBlazemeter%2Fjmeter-http-plugin%2Freleases)
+---
 # BlazeMeter HTTP Plugin for JMeter (HTTP/1.1, HTTP/2, HTTP/3/QUIC)
 
 ---
@@ -309,9 +311,23 @@ Common configurations:
 
 
 <a id="readme-buffer-capacity"></a>
-### Buffer capacity
+### Buffer capacity / response store truncation
+
+By default there is no store cap (`blazemeter.http.maxBufferSize` unset → effective **`-1`**): Jetty buffers without a hard fail (unlike Jetty’s own `BufferingResponseListener` 2 MiB default), and the full decoded body is kept in the sample.
+
+When a positive limit applies, behaviour matches Apache JMeter’s
+`httpsampler.max_bytes_to_store_per_request`: the sample stays **successful**, only the first N
+bytes are stored in response data, `bodySize` reflects the full decoded length, and JMeter logs
+`Big response, truncating it to {} bytes` at **DEBUG**. Truncation is skipped while recording.
+
+**Precedence** (first match wins):
+
+1. Plugin `blazemeter.http.maxBufferSize` (aliases `HTTP2Sampler.maxBufferSize` /
+   `httpJettyClient.maxBufferSize`) if set
+2. Else JMeter `httpsampler.max_bytes_to_store_per_request` if set
+3. Else `-1` (no truncation)
 
-By default, the size of downloaded resources is limited to 2 MB (2,097,152 bytes); you can raise the limit by setting `blazemeter.http.maxBufferSize` in `jmeter.properties` or `user.properties` (value in bytes).
+`<= 0` means do not truncate.
 
 
 <a id="readme-alpn"></a>
@@ -375,7 +391,7 @@ Restart JMeter after changing JMeter properties that are applied when affected c
 | **Attribute** | **Description** | **Default** |
 |---|---|---:|
 | **blazemeter.http.proxy_enabled** | When **`true`**, the HTTP(S) Test Script Recorder creates **`bzm - HTTP Sampler`** instead of stock **HTTP Request** (legacy `HTTP2Sampler.proxy_enabled` accepted) | true |
-| **blazemeter.http.maxBufferSize** | Maximum size of the downloaded resources in bytes | 2097152 |
+| **blazemeter.http.maxBufferSize** | Max bytes stored in sample response data (`<=0` / unset default path = no truncation). Overrides JMeter store limit when set | -1 |
 | **blazemeter.http.minThreads** | Minimum number of threads per HTTP client | 1 |
 | **blazemeter.http.maxThreads** | Maximum number of threads per HTTP client | 5 |
 | **blazemeter.http.maxRequestsQueuedPerDestination** | Maximum number of requests that may be queued to a destination | 32767 |

src/main/java/com/blazemeter/jmeter/http2/core/HTTP2FutureResponseListener.java

@@ -37,7 +37,7 @@ public class HTTP2FutureResponseListener extends BufferingResponseListener
   private long responseEnd;
 
   public HTTP2FutureResponseListener() {
-    this(2 * 1024 * 1024);
+    this(-1);
   }
 
   public HTTP2FutureResponseListener(int maxLength) {

src/main/java/com/blazemeter/jmeter/http2/core/HTTP2JettyClient.java

@@ -38,6 +38,7 @@
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Properties;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
@@ -67,6 +68,7 @@
 import org.apache.jmeter.protocol.http.util.HTTPFileArg;
 import org.apache.jmeter.services.FileServer;
 import org.apache.jmeter.testelement.property.JMeterProperty;
+import org.apache.jmeter.threads.JMeterContextService;
 import org.apache.jmeter.util.JMeterUtils;
 import org.brotli.dec.BrotliInputStream;
 import org.eclipse.jetty.client.AbstractAuthentication;
@@ -147,10 +149,17 @@ public class HTTP2JettyClient {
   private static final boolean ADD_CONTENT_TYPE_TO_POST_IF_MISSING = JMeterUtils.getPropDefault(
       "http.post_add_content_type_if_missing", false);
   // Matches HTTPFileImpl: caps stored response data for file:// samples, while sampleEnd's
-  // bodySize still reflects the true total bytes read.
+  // bodySize still reflects the true total bytes read. Separate from HTTP store truncation
+  // ({@link #maxBufferSize}): JMeter also keeps HTTPFileImpl's 10 MiB default distinct from
+  // HTTPSamplerBase's default of 0 for the same property name.
   private static final int MAX_FILE_SAMPLE_BYTES_TO_STORE = JMeterUtils.getPropDefault(
-      "httpsampler.max_bytes_to_store_per_request", 10 * 1024 * 1024);
+      BzmHttpPluginProperties.JMETER_MAX_BYTES_TO_STORE_PER_REQUEST, 10 * 1024 * 1024);
   private static final int FILE_SAMPLE_BUFFER_SIZE = 4096;
+  /**
+   * Jetty {@code BufferingResponseListener} hard cap. Always unlimited so large bodies are not
+   * aborted; SampleResult store truncation uses {@link #maxBufferSize} instead (JMeter parity).
+   */
+  private static final int JETTY_BUFFERING_UNLIMITED = -1;
   private static final Pattern PORT_PATTERN = Pattern.compile("\\d+");
   private static final String MULTI_PART_SEPARATOR = "--";
   private static final String LINE_SEPARATOR = "\r\n";
@@ -190,7 +199,12 @@ public class HTTP2JettyClient {
   private static final Map<String, Http1OnlyEntry> HTTP1_ONLY_CACHE = new ConcurrentHashMap<>();
   private static final Map<String, H2cEntry> H2C_CACHE = new ConcurrentHashMap<>();
   private int requestTimeout = 0;
-  private int maxBufferSize = 21 * 1024 * 1024;
+  /**
+   * Max bytes stored in {@link HTTPSampleResult} response data ({@code <= 0} = no truncation).
+   * Resolved from plugin {@code maxBufferSize} if set, else JMeter
+   * {@code httpsampler.max_bytes_to_store_per_request} if set, else {@code -1}.
+   */
+  private int maxBufferSize = -1;
   private int maxThreads = 5;
   private boolean maxThreadsConfigured = false;
   private int minThreads = 1;
@@ -717,10 +731,19 @@ public HttpClient getHttpClient() {
     return httpClient;
   }
 
+  /**
+   * Max bytes kept in the sample response data (JMeter-style store truncation). {@code <= 0} means
+   * do not truncate.
+   */
   public int getMaxBufferSize() {
     return maxBufferSize;
   }
 
+  /** Length passed to Jetty buffering listeners; always unlimited so truncation is store-only. */
+  public static int getJettyBufferingMaxLength() {
+    return JETTY_BUFFERING_UNLIMITED;
+  }
+
   public int getRequestTimeout() {
     return requestTimeout;
   }
@@ -735,9 +758,7 @@ public void loadProperties(HTTP2ClientProfileConfig profileConfig) {
     byteBufferPoolFactor =
         Integer.parseInt(BzmHttpPluginProperties.getPropDefault(
             "httpJettyClient.byteBufferPoolFactor", String.valueOf(byteBufferPoolFactor)));
-    maxBufferSize =
-        Integer.parseInt(BzmHttpPluginProperties.getPropDefault("httpJettyClient.maxBufferSize",
-            String.valueOf(2 * 1024 * 1024)));
+    maxBufferSize = resolveMaxBytesToStorePerRequest();
     minThreads = Integer
         .parseInt(BzmHttpPluginProperties.getPropDefault("httpJettyClient.minThreads",
             String.valueOf(minThreads)));
@@ -869,6 +890,25 @@ public void loadProperties(HTTP2ClientProfileConfig profileConfig) {
     }
   }
 
+  /**
+   * Plugin {@code maxBufferSize} wins when set; otherwise JMeter
+   * {@code httpsampler.max_bytes_to_store_per_request} when set; otherwise {@code -1} (no
+   * truncation). {@code <= 0} means do not truncate, matching JMeter's store semantics.
+   */
+  private static int resolveMaxBytesToStorePerRequest() {
+    if (BzmHttpPluginProperties.isDefined(BzmHttpPluginProperties.MAX_BUFFER_SIZE_PROP)) {
+      return Integer.parseInt(BzmHttpPluginProperties.getPropDefault(
+          BzmHttpPluginProperties.MAX_BUFFER_SIZE_PROP, "-1").trim());
+    }
+    Properties props = JMeterUtils.getJMeterProperties();
+    if (props != null
+        && props.containsKey(BzmHttpPluginProperties.JMETER_MAX_BYTES_TO_STORE_PER_REQUEST)) {
+      return Integer.parseInt(JMeterUtils.getPropDefault(
+          BzmHttpPluginProperties.JMETER_MAX_BYTES_TO_STORE_PER_REQUEST, "0").trim());
+    }
+    return -1;
+  }
+
   private boolean getBooleanProp(String key, Boolean overrideValue, boolean defaultValue) {
     if (overrideValue != null) {
       return overrideValue;
@@ -1575,8 +1615,9 @@ public HTTPSampleResult sample(HTTP2Sampler sampler, HTTPSampleResult result,
       return cacheManager.buildCachedSampleResult(result);
     }
     lowLevelDebug("=== Creating HTTP2FutureResponseListener ===");
-    lowLevelDebug("maxBufferSize: {}", maxBufferSize);
-    HTTP2FutureResponseListener listener = new HTTP2FutureResponseListener(maxBufferSize);
+    lowLevelDebug("maxBytesToStorePerRequest: {}", maxBufferSize);
+    HTTP2FutureResponseListener listener =
+        new HTTP2FutureResponseListener(JETTY_BUFFERING_UNLIMITED);
     lowLevelDebug("=== HTTP2FutureResponseListener created successfully ===");
     listener.setRequest(request);
     lowLevelDebug("=== About to call send() ===");
@@ -1881,7 +1922,8 @@ private ContentResponse sendWithHappyEyeballs(Request h3Request,
     java.util.concurrent.atomic.AtomicBoolean h2Started =
         new java.util.concurrent.atomic.AtomicBoolean(false);
 
-    HTTP2FutureResponseListener h2Listener = new HTTP2FutureResponseListener(maxBufferSize);
+    HTTP2FutureResponseListener h2Listener =
+        new HTTP2FutureResponseListener(JETTY_BUFFERING_UNLIMITED);
     Request h2Request = cloneRequest(h3Request, httpClientNoH3);
     h2Listener.setRequest(h2Request);
 
@@ -4007,7 +4049,8 @@ private void setResultContentResponse(HTTPSampleResult result,
     // Decode compressed payloads when possible even if the request did not advertise
     // Accept-Encoding (some servers still compress, and JMeter should show decoded body).
     byte[] responseContent = maybeDecodeCompressedContent(contentResponse);
-    // Avoid an extra stream->byte[] copy; content is already fully buffered.
+    // JMeter parity: optionally truncate stored response data while keeping full bodySize.
+    responseContent = maybeTruncateStoredResponseData(result, responseContent);
     result.setResponseData(responseContent);
 
     if (result.getEndTime() == 0) {
@@ -4122,6 +4165,33 @@ private static void debugToFile(String message) {
     }
   }
 
+  /**
+   * Matches {@code HTTPSamplerBase#readResponse}: keep at most {@link #maxBufferSize} bytes in the
+   * sample store, log the same debug line JMeter uses, set {@code bodySize} to the full decoded
+   * length, and leave the sample successful. Skipped while recording.
+   */
+  private byte[] maybeTruncateStoredResponseData(HTTPSampleResult result, byte[] content) {
+    if (content == null) {
+      return new byte[0];
+    }
+    int fullLength = content.length;
+    if (maxBufferSize <= 0 || fullLength <= maxBufferSize || isJMeterRecording()) {
+      return content;
+    }
+    // Same message as Apache JMeter HTTPSamplerBase.readResponse (debug level).
+    LOG.debug("Big response, truncating it to {} bytes", maxBufferSize);
+    result.setBodySize(fullLength);
+    return Arrays.copyOf(content, maxBufferSize);
+  }
+
+  private static boolean isJMeterRecording() {
+    try {
+      return JMeterContextService.getContext().isRecording();
+    } catch (RuntimeException e) {
+      return false;
+    }
+  }
+
   private void resetSamplerDataBeforeResultProcessing(HTTPSampleResult result) {
     if (result == null) {
       return;

src/main/java/com/blazemeter/jmeter/http2/sampler/HTTP2Sampler.java

@@ -402,7 +402,7 @@ protected HTTPSampleResult sample(URL url, String method, boolean areFollowingRe
             this.result.setIgnore();
           }
           HTTP2FutureResponseListener listener =
-              new HTTP2FutureResponseListener(client.getMaxBufferSize());
+              new HTTP2FutureResponseListener(HTTP2JettyClient.getJettyBufferingMaxLength());
           this.asyncListener = listener;
           Request req = client.sampleAsync(this, this.result, listener);
           req.send(listener); // Fire the Async

src/main/java/com/blazemeter/jmeter/http2/util/BzmHttpPluginProperties.java

@@ -29,6 +29,20 @@ public final class BzmHttpPluginProperties {
   /** Legacy prefix for async-controller-related JMeter properties (backward compatibility). */
   public static final String CONTROLLER_LEGACY_PREFIX = "http2AsyncController.";
 
+  /**
+   * Plugin property for max bytes stored in HTTP sample response data (any accepted prefix form).
+   * Aliases: {@code blazemeter.http.maxBufferSize}, {@code HTTP2Sampler.maxBufferSize},
+   * {@code httpJettyClient.maxBufferSize}.
+   */
+  public static final String MAX_BUFFER_SIZE_PROP = "httpJettyClient.maxBufferSize";
+
+  /**
+   * Stock JMeter property for max response bytes stored per request (HTTPSamplerBase /
+   * HTTPFileImpl).
+   */
+  public static final String JMETER_MAX_BYTES_TO_STORE_PER_REQUEST =
+      "httpsampler.max_bytes_to_store_per_request";
+
   private static final String PREFERRED_PREFIX = "blazemeter.http.";
   private static final String LEGACY_SAMPLER_PREFIX = "HTTP2Sampler.";
   private static final String LEGACY_JETTY_PREFIX = "httpJettyClient.";
@@ -70,6 +84,14 @@ private static String[] allKeysInResolveOrder(String propertyName) {
     };
   }
 
+  /**
+   * All accepted JMeter property keys for a plugin setting (preferred + legacy aliases), for
+   * tests or cleanup that must remove every form.
+   */
+  public static String[] keysInResolveOrder(String propertyName) {
+    return allKeysInResolveOrder(propertyName);
+  }
+
   /** Suffix after {@link #CONTROLLER_PREFERRED_PREFIX} or {@link #CONTROLLER_LEGACY_PREFIX}. */
   public static String controllerCanonicalSuffix(String propertyName) {
     if (propertyName.startsWith(CONTROLLER_PREFERRED_PREFIX)) {

src/test/java/com/blazemeter/jmeter/http2/core/HTTP2FutureResponseListenerTest.java

@@ -30,6 +30,13 @@ public void setUp() {
         listener.setRequest(mockRequest);
     }
 
+    @Test
+    public void defaultConstructorUsesUnlimitedBufferingCapacity() {
+        // Jetty BufferingResponseListener's no-arg default is 2 MiB; plugin default must stay -1
+        // (DynamicCapacity maps that to Long.MAX_VALUE) so large responses are not rejected.
+        assertEquals(Long.MAX_VALUE, listener.getMaxLength());
+    }
+
     @Test
     public void getRequestReturnsSetRequest() {
         assertEquals(mockRequest, listener.getRequest());