[mq] [skip ddci] working branch - merge 9034d27 on top of main at b65de16

{"baseBranch":"main","baseCommit":"b65de168bd2b5bb47f4f361a207dfb410b50a1b8","createdAt":"2026-07-02T11:19:24.699118Z","headSha":"9034d27a3e61ad5bd94632b058378580024e2b68","id":"917b4059-b5da-4fd9-9d3c-cf23429affc9","priority":"200","pullRequestNumber":"4960","queuedAt":"2026-07-02T11:19:24.698001Z","status":"STATUS_QUEUED"}

Author: gh-worker-dd-mergequeue-cf854d[bot]

ddtrace/tracer/option.go

@@ -1372,6 +1372,32 @@ func (t *dummyTransport) endpoint() string {
 	return "http://localhost:9/v1.0/traces"
 }
 
+// discardTransport drains and discards trace payloads without decoding them.
+// It reads the whole body like a real HTTP send would (so encoded-buffer
+// lifetime and flush timing stay realistic) but never returns decoded
+// spans.
+// To use over dummyTransport in benchmarks that measure span creation/encoding
+// and doesn't care for decoding overhead that a customer app never performs.
+type discardTransport struct{}
+
+var _ ddTransport = discardTransport{}
+
+func (discardTransport) send(p payload) (io.ReadCloser, error) {
+	defer p.Close()
+	if _, err := io.Copy(io.Discard, p); err != nil {
+		return nil, err
+	}
+	return io.NopCloser(strings.NewReader("OK")), nil
+}
+
+func (discardTransport) sendStats(*pb.ClientStatsPayload, int) error {
+	return nil
+}
+
+func (discardTransport) endpoint() string {
+	return "http://localhost:9/v1.0/traces"
+}
+
 func decode(p payloadReader) (spanLists, []uint64, error) {
 	br := bufio.NewReader(p)
 	head, err := br.Peek(1)
@@ -1401,12 +1427,11 @@ func decode(p payloadReader) (spanLists, []uint64, error) {
 		}
 		return traces, ids, nil
 	case first == msgpackMap16 || first == msgpackMap32 || first&0xf0 == msgpackMapFix:
-		buf, err := io.ReadAll(br)
-		if err != nil {
+		payload := newPayloadV1()
+		payload.buf = make([]byte, 0, p.size())
+		if _, err := io.Copy(payload, br); err != nil {
 			return nil, nil, err
 		}
-		payload := newPayloadV1()
-		payload.buf = buf
 		if _, err := payload.decodeBuffer(); err != nil {
 			return nil, nil, err
 		}

ddtrace/tracer/tracer_test.go

@@ -2455,13 +2455,14 @@ func BenchmarkPartialFlushing(b *testing.B) {
 }
 
 func BenchmarkPartialFlushingSpanPool(b *testing.B) {
+	addr := mockAgentEndpoint(b, "/v1.0/traces")
 	b.Run("Enabled", func(b *testing.B) {
 		b.Setenv("DD_TRACE_PARTIAL_FLUSH_ENABLED", "true")
 		b.Setenv("DD_TRACE_PARTIAL_FLUSH_MIN_SPANS", "500")
-		genBigTraces(b, WithSpanPool(true))
+		genBigTraces(b, WithAgentAddr(addr.Host), WithSpanPool(true))
 	})
 	b.Run("Disabled", func(b *testing.B) {
-		genBigTraces(b, WithSpanPool(true))
+		genBigTraces(b, WithAgentAddr(addr.Host), WithSpanPool(true))
 	})
 }
 
@@ -2473,7 +2474,8 @@ func BenchmarkBigTraces(b *testing.B) {
 }
 
 func genBigTraces(b *testing.B, opts ...StartOption) {
-	tracer, transport, flush, stop, err := startTestTracer(b, append(opts, WithLogger(log.DiscardLogger{}))...)
+	opts = append(opts, withTransport(discardTransport{}))
+	tracer, _, flush, stop, err := startTestTracer(b, append(opts, WithLogger(log.DiscardLogger{}))...)
 	assert.Nil(b, err)
 	defer stop()
 
@@ -2510,20 +2512,14 @@ func genBigTraces(b *testing.B, opts ...StartOption) {
 				sp.Finish()
 			}
 			parent.Finish()
-			// TODO(fg): This test has historically not waited for the two
-			// goroutines below to finish. This was causing test failures when
+			// TODO(fg): This test has historically not waited for the flush
+			// goroutine below to finish. This was causing test failures when
 			// goroutine leak checks were added to TestMain. However, looking at
 			// the code, perhaps these goroutines should be required to finish
 			// before b.StopTimer() is called?
-			wg.Add(2)
-			go func() {
+			wg.Go(func() {
 				flush(-1) // act like a ticker
-				wg.Done()
-			}()
-			go func() {
-				transport.Reset() // pretend we sent any payloads
-				wg.Done()
-			}()
+			})
 		}
 	}
 	b.StopTimer()

ddtrace/tracer/tracertest_test.go

@@ -136,13 +136,12 @@ func (a *testAgent) handleTracesV04(w http.ResponseWriter, r *http.Request) {
 }
 
 func (a *testAgent) handleTracesV1(w http.ResponseWriter, r *http.Request) {
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
+	// Copy the body directly into the payload buffer rather than buffering the
+	// whole request with io.ReadAll first: payloadV1.Write appends to p.buf,
+	// which decodeBuffer consumes in place, so a separate full-body slice would
+	// just be an extra copy.
 	p := newPayloadV1()
-	if _, err := p.Write(body); err != nil {
+	if _, err := io.Copy(p, r.Body); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}