Repository: DataDog/dd-trace-go
Pull request #3498: fix(baggage): drop entire baggage header when malformed
Author: login: rachelyangdog
Labels: name: mergequeue-status: rejected
Created: 2025-05-06T20:15:46Z | Merged: 2025-05-12T09:36:58Z

According to the RFC, 
> "When APM SDKs are extracting baggage from propagation headers, they may encounter malformed header contents. When this occurs, the APM SDK should not try to extract any values from the entire header. In other words, APM SDKs should ignore the header and not try to extract "good" values while ignoring "bad" ones." 

So instead of dropping individual baggage items, we drop the entire header and log a warning. 

<!--
* New contributors are highly encouraged to read our
  [CONTRIBUTING](/CONTRIBUTING.md) documentation.
* Commit and PR titles should be prefixed with the general area of the pull request's change.

-->
### What does this PR do?

<!--
* A brief description of the change being made with this pull request.
* If the description here cannot be expressed in a succinct form, consider
  opening multiple pull requests instead of a single one.
-->

### Motivation

<!--
* What inspired you to submit this pull request?
* Link any related GitHub issues or PRs here.
* If this resolves a GitHub issue, include "Fixes #XXXX" to link the issue and auto-close it on merge.
-->

### Reviewer's Checklist
<!--
* Authors can use this list as a reference to ensure that there are no problems
  during the review but the signing off is to be done by the reviewer(s).
-->

- [ ] Changed code has unit tests for its functionality at or near 100% coverage.
- [ ] [System-Tests](https://github.com/DataDog/system-tests/) covering this feature have been added and enabled with the va.b.c-dev version tag.
- [ ] There is a benchmark for any new code, or changes to existing code.
- [ ] If this interacts with the agent in a new way, a system test has been added.
- [ ] New code is free of linting errors. You can check this by running `golangci-lint run` locally.
- [ ] Add an appropriate team label so this PR gets put in the right place for the release notes.
- [ ] Non-trivial go.mod changes, e.g. adding new modules, are reviewed by @DataDog/dd-trace-go-guild.


Unsure? Have a question? Request a review!



Diff:
diff --git a/ddtrace/tracer/textmap.go b/ddtrace/tracer/textmap.go
index 04614ec32ea..33f1bcfcd27 100644
--- a/ddtrace/tracer/textmap.go
+++ b/ddtrace/tracer/textmap.go
@@ -1428,24 +1428,28 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		return &ctx, nil
 	}
 
-	keyVals := strings.Split(baggageHeader, ",")
-	for _, kv := range keyVals {
-		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
-		key, val, ok := strings.Cut(kv, "=")
-		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
-		}
-		key = strings.TrimSpace(key)
-		val = strings.TrimSpace(val)
-		if key == "" || val == "" {
-			log.Warn("invalid baggage item: '%s', dropping", kv)
-		}
-		key, errKey := url.QueryUnescape(key)
-		val, errVal := url.QueryUnescape(val)
-		if errKey != nil || errVal != nil {
-			log.Warn("failed to decode baggage item: %s, dropping", kv)
+	parts := strings.Split(baggageHeader, ",")
+
+	// 1) validation & single-trim pass
+	for i, kv := range parts {
+		k, v, ok := strings.Cut(kv, "=")
+		trimmedK := strings.TrimSpace(k)
+		trimmedV := strings.TrimSpace(v)
+		if !ok || trimmedK == "" || trimmedV == "" {
+			log.Warn("invalid baggage item: %q, dropping entire header", kv)
+			return &ctx, nil
 		}
+		// store back the trimmed pair so we don't re-trim below
+		parts[i] = trimmedK + "=" + trimmedV
+	}
+
+	// 2) safe to URL-decode & apply
+	for _, kv := range parts {
+		rawK, rawV, _ := strings.Cut(kv, "=")
+		key, _ := url.QueryUnescape(rawK)
+		val, _ := url.QueryUnescape(rawV)
 		ctx.setBaggageItem(key, val)
 	}
+
 	return &ctx, nil
 }
diff --git a/ddtrace/tracer/textmap_test.go b/ddtrace/tracer/textmap_test.go
index 07a2eaa746c..f93e360d12f 100644
--- a/ddtrace/tracer/textmap_test.go
+++ b/ddtrace/tracer/textmap_test.go
@@ -2777,3 +2777,101 @@ func TestInjectBaggageMaxBytes(t *testing.T) {
 	headerSize := len([]byte(headerValue))
 	assert.LessOrEqual(headerSize, baggageMaxBytes)
 }
+
+func TestExtractBaggagePropagatorMalformedHeader(t *testing.T) {
+	t.Run("missing equal sign", func(t *testing.T) {
+		tracer, err := newTracer()
+		assert.NoError(t, err)
+		defer tracer.Stop()
+		headers := TextMapCarrier{
+			DefaultTraceIDHeader:  "4",
+			DefaultParentIDHeader: "1",
+			DefaultBaggageHeader:  "key1,key2=value2",
+		}
+		s, err := tracer.Extract(headers)
+		assert.NoError(t, err)
+		// since the header is malformed, we should not have any baggage items
+		got := make(map[string]string)
+		s.ForeachBaggageItem(func(k, v string) bool {
+			got[k] = v
+			return true
+		})
+		assert.Len(t, got, 0)
+	})
+	t.Run("missing value", func(t *testing.T) {
+		tracer, err := newTracer()
+		assert.NoError(t, err)
+		defer tracer.Stop()
+		headers := TextMapCarrier{
+			DefaultTraceIDHeader:  "4",
+			DefaultParentIDHeader: "1",
+			DefaultBaggageHeader:  "key1=value1,key2=",
+		}
+		s, err := tracer.Extract(headers)
+		assert.NoError(t, err)
+		// since the header is malformed, we should not have any baggage items
+		got := make(map[string]string)
+		s.ForeachBaggageItem(func(k, v string) bool {
+			got[k] = v
+			return true
+		})
+		assert.Len(t, got, 0)
+	})
+	t.Run("missing key", func(t *testing.T) {
+		tracer, err := newTracer()
+		assert.NoError(t, err)
+		defer tracer.Stop()
+		headers := TextMapCarrier{
+			DefaultTraceIDHeader:  "4",
+			DefaultParentIDHeader: "1",
+			DefaultBaggageHeader:  "key1=value1,=value2",
+		}
+		s, err := tracer.Extract(headers)
+		assert.NoError(t, err)
+		// since the header is malformed, we should not have any baggage items
+		got := make(map[string]string)
+		s.ForeachBaggageItem(func(k, v string) bool {
+			got[k] = v
+			return true
+		})
+		assert.Len(t, got, 0)
+	})
+	t.Run("missing key and value", func(t *testing.T) {
+		tracer, err := newTracer()
+		assert.NoError(t, err)
+		defer tracer.Stop()
+		headers := TextMapCarrier{
+			DefaultTraceIDHeader:  "4",
+			DefaultParentIDHeader: "1",
+			DefaultBaggageHeader:  "=,key1=value1",
+		}
+		s, err := tracer.Extract(headers)
+		assert.NoError(t, err)
+		// since the header is malformed, we should not have any baggage items
+		got := make(map[string]string)
+		s.ForeachBaggageItem(func(k, v string) bool {
+			got[k] = v
+			return true
+		})
+		assert.Len(t, got, 0)
+	})
+	t.Run("missing key-value pair", func(t *testing.T) {
+		tracer, err := newTracer()
+		assert.NoError(t, err)
+		defer tracer.Stop()
+		headers := TextMapCarrier{
+			DefaultTraceIDHeader:  "4",
+			DefaultParentIDHeader: "1",
+			DefaultBaggageHeader:  "key1=value1,",
+		}
+		s, err := tracer.Extract(headers)
+		assert.NoError(t, err)
+		// since the header is malformed, we should not have any baggage items
+		got := make(map[string]string)
+		s.ForeachBaggageItem(func(k, v string) bool {
+			got[k] = v
+			return true
+		})
+		assert.Len(t, got, 0)
+	})
+}


Reviews:
user: login: darccio
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-05-07T15:36:05Z
user: login: rachelyangdog
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-07T18:49:07Z
user: login: darccio
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-05-08T07:58:01Z
user: login: darccio
state: APPROVED
author_association: MEMBER
submitted_at: 2025-05-08T07:58:15Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T14:24:52Z
user: login: rachelyangdog
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T14:29:26Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:14:01Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:15:26Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:15:57Z
user: login: rachelyangdog
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:17:44Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:18:19Z
user: login: mtoffl01
body: Just some nits in terms of implementation, but would love to see an approach to testing that tries to break the behavior, to show that our implementation is robust
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:19:10Z
user: login: mtoffl01
body: Just some nits in terms of implementation, but would love to see an approach to testing that tries to break the behavior, to show that our implementation is robust
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:19:13Z
user: login: rachelyangdog
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T15:19:28Z
user: login: mtoffl01
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T17:50:40Z
user: login: mtoffl01
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-08T17:52:32Z
user: login: kakkoyun
state: APPROVED
author_association: MEMBER
submitted_at: 2025-05-12T09:26:24Z

Review comments:
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: darccio
body: @rachelyangdog At this point, it could be that the baggage contains previously extracted key-values. Is this something expected? From the rationale in the PR I thought that if the header is malformed we drop all the key-values.
created_at: 2025-05-07T15:36:01Z
author_association: MEMBER
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: rachelyangdog
body: Hmm... I think the expected behavior is that the entire header gets dropped if there's at least 1 malformed key or value. This is regardless of pre-existing extracted key-values. 
created_at: 2025-05-07T18:49:07Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: darccio
body: Ok, sounds reasonable as long as pre-existing extracted key-values from a malformed header don't introduce weird behaviours. AFAIK, baggage values are not used to make decisions, right?
created_at: 2025-05-08T07:58:00Z
author_association: MEMBER
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: mtoffl01
body: Baggage will be used to set span tags, and span tags can be used to make decisions. So I think it may be confusing UX if a newly introduced malformed baggage header causes pre-existing span tags to be lost. @rachelyangdog , wdyt?

How would a malformed baggage header get set? As I understand it, the API for setting baggage is only `baggage.Set`, which takes in a key value pair, and then we build the header from baggage. The only scenario I can envision is if some other instrumentation has injected something, or a user is manually setting `baggage` header with malformed keys. Right?
created_at: 2025-05-08T14:24:52Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: rachelyangdog
body: Yes, technically the only way for a user to set baggage is via the API. However, headers are coming from everywhere (third parties, instrumentations, non-datadog places) so they can definitely have malformed headers. 

In terms of span tags, if there's a malformed header, no span tags would be set (including valid ones). Also,  span tagging for baggage happens only at extraction time. So, I think the expected behavior is that if there's a malformed baggage header, all span tags would be dropped. 

Also, to clarify, baggage is within a request. Therefore, across requests, there's no correlation between baggages.
created_at: 2025-05-08T14:29:26Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: mtoffl01
body: The "decision" we could be concerned about is stuff like sampling (which can be configured by span tags). However, I suppose it's unlikely that a user would set a sampling decision on a baggage key (that's become a span tag), given that baggage only exists on a per-request basis.

I assume this behavior ("if any part of baggage header is malformed, baggage will be dropped") will be documented publicly, but it may be a good idea to begin an internal troubleshooting document that includes edge case behaviors like this one -- not only will the baggage header be dropped, but baggage span tags will too. 
created_at: 2025-05-08T15:14:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: mtoffl01
body: Note: Also, if we decide to implement some sort of caching for baggage header in the future, this may give us a way to differentiate between "old" and "new" baggage
created_at: 2025-05-08T15:15:26Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
 		}
 		key = strings.TrimSpace(key)
 		val = strings.TrimSpace(val)
 		if key == "" || val == "" {
-			log.Warn("invalid baggage item: '%s', dropping", kv)
+			log.Warn("invalid baggage item: '%s', droppin header", kv)
path: ddtrace/tracer/textmap.go
user: login: mtoffl01
body: ```suggestion
			log.Warn("invalid baggage item: '%s', dropping header", kv)
```
created_at: 2025-05-08T15:15:57Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1433,17 +1433,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
 		key, val, ok := strings.Cut(kv, "=")
 		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
+			log.Warn("invalid baggage item: %s, dropping header", kv)
+			return &ctx, nil
path: ddtrace/tracer/textmap.go
user: login: rachelyangdog
body: > I assume this behavior ("if any part of baggage header is malformed, baggage will be dropped") will be documented publicly, but it may be a good idea to begin an internal troubleshooting document that includes edge case behaviors like this one -- not only will the baggage header be dropped, but baggage span tags will too.

Will do! I'm not sure how well 
> "if any part of baggage header is malformed, baggage will be dropped"  

this is publicly documented but I can check. This behavior aligns with W3C baggage headers as well. 

> "not only will the baggage header be dropped, but baggage span tags will too"

I will make sure this part is well documented on my end as well! 

Thanks so much!! 
created_at: 2025-05-08T15:17:44Z
author_association: CONTRIBUTOR
diff_hunk: @@ -2777,3 +2777,23 @@ func TestInjectBaggageMaxBytes(t *testing.T) {
 	headerSize := len([]byte(headerValue))
 	assert.LessOrEqual(headerSize, baggageMaxBytes)
 }
+
+func TestExtractBaggagePropagatorMalformedHeader(t *testing.T) {
+	tracer, err := newTracer()
+	assert.NoError(t, err)
+	defer tracer.Stop()
+	headers := TextMapCarrier{
+		DefaultTraceIDHeader:  "4",
+		DefaultParentIDHeader: "1",
+		DefaultBaggageHeader:  "foo=,bar,key1=val1,key2=val2,key3=val3",
path: ddtrace/tracer/textmap_test.go
user: login: mtoffl01
body: Can we add individual tests for multiple malformed baggage headers, as documented [here](https://docs.google.com/document/d/1cX4bWYW-EPqKc64oynXpeHOI8FCW3XI-h0uH1tnzV3Q/edit?tab=t.0#heading=h.5xra5z6871b3)?
Note that each "malform" case should have its own test, since the behavior is that the first malformed key will cause the header to be dropped
created_at: 2025-05-08T15:18:19Z
author_association: CONTRIBUTOR
diff_hunk: @@ -2777,3 +2777,23 @@ func TestInjectBaggageMaxBytes(t *testing.T) {
 	headerSize := len([]byte(headerValue))
 	assert.LessOrEqual(headerSize, baggageMaxBytes)
 }
+
+func TestExtractBaggagePropagatorMalformedHeader(t *testing.T) {
+	tracer, err := newTracer()
+	assert.NoError(t, err)
+	defer tracer.Stop()
+	headers := TextMapCarrier{
+		DefaultTraceIDHeader:  "4",
+		DefaultParentIDHeader: "1",
+		DefaultBaggageHeader:  "foo=,bar,key1=val1,key2=val2,key3=val3",
path: ddtrace/tracer/textmap_test.go
user: login: rachelyangdog
body: Got it! Will add them now. Thank youu 
created_at: 2025-05-08T15:19:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1428,23 +1428,20 @@ func (*propagatorBaggage) extractTextMap(reader TextMapReader) (*SpanContext, er
 		return &ctx, nil
 	}
 
-	keyVals := strings.Split(baggageHeader, ",")
-	for _, kv := range keyVals {
-		// Split on the first instance of "=" i.e, `a=b=c` becomes `a: b=c`.
-		key, val, ok := strings.Cut(kv, "=")
-		if !ok {
-			log.Warn("invalid baggage item: %s, dropping", kv)
-		}
-		key = strings.TrimSpace(key)
-		val = strings.TrimSpace(val)
-		if key == "" || val == "" {
-			log.Warn("invalid baggage item: '%s', dropping", kv)
-		}
-		key, errKey := url.QueryUnescape(key)
-		val, errVal := url.QueryUnescape(val)
-		if errKey != nil || errVal != nil {
-			log.Warn("failed to decode baggage item: %s, dropping", kv)
+	// 1) validation pass
+	parts := strings.Split(baggageHeader, ",")
+	for _, kv := range parts {
+		k, v, ok := strings.Cut(kv, "=")
+		if !ok || strings.TrimSpace(k) == "" || strings.TrimSpace(v) == "" {
+			log.Warn("invalid baggage item: %q, dropping entire header", kv)
+			return &ctx, nil
 		}
path: ddtrace/tracer/textmap.go
user: login: mtoffl01
body: I can get behind this two-pass approach, but I do see an opportunity to do a small optimization to avoid doing strings.TrimSpace on the same k/v twice:
You could change line 1435 to store variables for `strings.TrimSpace(k)` and `strings.TrimSpace(v)`, then introduce an else block after line 1438 that basically sets k and v to those respective values.

You should then be able to remove the strings.TrimSpace on lines 1443 and 1444
created_at: 2025-05-08T17:50:40Z
author_association: CONTRIBUTOR

PR comments:
user: login: datadog-datadog-prod-us1[bot]
created_at: 2025-05-06T20:24:21Z
body: 
## Datadog Report

Branch report: [`rachel.yang/baggage-malformed-header`](https://app.datadoghq.com/ci/test-branch/github.com%2Fdatadog%2Fdd-trace-go/dd-trace-go/rachel.yang%2Fbaggage-malformed-header?env=none&index=citest&_user_click_origin_=github)
Commit report: [`17cfecb`](https://app.datadoghq.com/ci/test-commit/github.com%2Fdatadog%2Fdd-trace-go/dd-trace-go/rachel.yang%2Fbaggage-malformed-header/17cfecb26f1229a47758115a8a7b1202fb187c5d?env=none&index=citest&_user_click_origin_=github)
Test service: `dd-trace-go`

:white_check_mark: 0 Failed, 4526 Passed, 65 Skipped, 3m 13.39s Total Time




author_association: NONE
user: login: pr-commenter[bot]
created_at: 2025-05-06T20:53:43Z
body: ## Benchmarks

Benchmark execution time: 2025-05-09 14:47:43

Comparing candidate commit 0db2d6b3a3faadca18fc184436e39608ad52bfd1 in PR branch `rachel.yang/baggage-malformed-header` with baseline commit 448466c5e1f35320b92ed3b412e8635fd252f5c8 in branch `main`.

Found 0 performance improvements and 0 performance regressions! Performance is the same for 56 metrics, 0 unstable metrics.


author_association: NONE
user: login: rachelyangdog
created_at: 2025-05-09T14:13:47Z
body: /merge
author_association: CONTRIBUTOR
user: login: dd-devflow[bot]
created_at: 2025-05-09T14:13:52Z
body: <!-- "FeedbackWorkflowId":"268abc0f-7a1e-48b2-b9db-d48b391f90d7_36" -->
[View all feedbacks in Devflow UI.](https://mosaic.us1.ddbuild.io/devflow/logs/268abc0f-7a1e-48b2-b9db-d48b391f90d7_36)

`2025-05-09 14:13:51 UTC` :information_source: Start processing command `/merge`

---
`2025-05-09 14:13:55 UTC` :information_source: **MergeQueue:** queue is disabled

Added to the queue but the mergequeue is not enabled for now.

---
`2025-05-09 14:18:11 UTC` :x: **MergeQueue:** This merge request was updated

This PR is rejected because it was updated

author_association: NONE
user: login: datadog-datadog-prod-us1[bot]
created_at: 2025-05-12T09:30:09Z
body: # Datadog Summary

<b>✅&nbsp;Code Quality</b>&nbsp;&nbsp;&nbsp;&nbsp;<b>✅&nbsp;Code Security</b>&nbsp;&nbsp;&nbsp;&nbsp;<b>✅&nbsp;Dependencies</b>



---
Was this helpful? Give us [feedback](https://dd.enterprise.slack.com/archives/C01FA7FASUR)!

author_association: NONE