Improvement: Optimize CompressingRequestBody memory usage by removing Okio and redundant buffering

Start by locating CompressingRequestBody.attemptWrite in the profiling-uploader code and inspect its current Okio copy path, compression stream, and buffering. Verify the Java 8-compatible stream-copy behavior and confirm that the change preserves compression output, stream ownership, and the intended memory reduction.

Library Name

dd-java-agent (profiling-uploader)

Library Version(s)

v1.54.0

Describe the feature you'd like

I propose optimizing CompressingRequestBody.attemptWrite to reduce memory allocation.

Currently, the implementation uses Okio for stream copying and wraps the compression stream with an extra BufferedOutputStream. This results in excessive object creation (Segments, Buffers) and double buffering overhead.

Suggested Implementation:
I suggest replacing Okio with a standard Java IO loop using a fixed-size byte[] buffer and removing the redundant outer BufferedOutputStream.

  private void attemptWrite(@Nonnull InputStream inputStream, @Nonnull OutputStream outputStream)
      throws IOException {
    // Keep the inner buffer to aggregate compressed bytes before sending to the socket
    OutputStream bufferedInnerStream = new BufferedOutputStream(outputStream) {
      @Override
      public void close() throws IOException {
        flush(); // Prevent closing the underlying stream
      }
    };

    // Remove the outer BufferedOutputStream.
    // Direct writing to the compression stream is efficient enough with a 8KB copy buffer.
    OutputStream processingStream = isCompressed(inputStream)
        ? bufferedInnerStream
        : outputStreamMapper.apply(bufferedInnerStream);

    try (OutputStream out = processingStream) {
      byte[] buffer = new byte[8192];
      int bytesRead;
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        out.write(buffer, 0, bytesRead);
      }
    }
    // implicit close() on processingStream finalizes compression and flushes the inner stream
  }

Is your feature request related to a problem?

Yes. While profiling our application, we noticed that CompressingRequestBody.attemptWrite is a major contributor to heap usage.

In our specific profile, this method accounted for approximately 94% of the Heap Live Size. The heavy use of Okio intermediate objects for simple stream copying seems to be the primary cause.

Please see the attached Flame Graph for evidence:

Describe alternatives you've considered

Using InputStream.transferTo(OutputStream) is an option for Java 9+, but the proposed byte-array loop ensures compatibility with Java 8, which I believe the agent still supports.

Additional context

Note: I am not a native English speaker, so I used an AI assistant to help draft this issue to ensure clarity. Thank you for your understanding.