Fix: Support attributes filtering in /api/v3/traces endpoint

Signed-off-by: Divyansh Khatri <[email protected]>

Author: Divyansh200102

cmd/query/app/apiv3/http_gateway.go

@@ -44,6 +44,7 @@ const (
 	paramDurationMin    = "query.duration_min"
 	paramDurationMax    = "query.duration_max"
 	paramQueryRawTraces = "query.raw_traces"
+	paramAttributes     = "query.attributes"
 
 	routeGetTrace      = "/api/v3/traces/{" + paramTraceID + "}"
 	routeFindTraces    = "/api/v3/traces"
@@ -209,11 +210,31 @@ func (h *HTTPGateway) findTraces(w http.ResponseWriter, r *http.Request) {
 }
 
 func (h *HTTPGateway) parseFindTracesQuery(q url.Values, w http.ResponseWriter) (*querysvc.TraceQueryParams, bool) {
+	// Parse attributes first
+	attributes := pcommon.NewMap() // Initialize empty map
+	attrStr := q.Get(paramAttributes)
+	if attrStr != "" {
+		var attrMap map[string]string
+		// The attributes are expected to be a JSON string map, e.g., {"key":"value"}
+		// This handles URL-encoded JSON like %7B%22driver%22%3A%22T751767C%22%7D
+		if err := json.Unmarshal([]byte(attrStr), &attrMap); err != nil {
+			// Pass the underlying JSON parsing error
+			err := fmt.Errorf("cannot parse attributes JSON: %w", err)
+			if h.tryParamError(w, err, paramAttributes) {
+				return nil, true
+			}
+		}
+		// Populate the pcommon.Map from the parsed map
+		for k, v := range attrMap {
+			attributes.PutStr(k, v)
+		}
+	}
+
 	queryParams := &querysvc.TraceQueryParams{
 		TraceQueryParams: tracestore.TraceQueryParams{
 			ServiceName:   q.Get(paramServiceName),
 			OperationName: q.Get(paramOperationName),
-			Attributes:    pcommon.NewMap(), // most curiously not supported by grpc-gateway
+			Attributes:    attributes, 
 		},
 	}
 

cmd/query/app/apiv3/http_gateway_test.go

@@ -183,6 +183,55 @@ func TestHTTPGatewayFindTracesEmptyResponse(t *testing.T) {
 	assert.Contains(t, w.Body.String(), "No traces found")
 }
 
+func TestHTTPGatewayFindTracesWithAttributes(t *testing.T) {
+	time1 := time.Now().UTC().Truncate(time.Nanosecond)
+	time2 := time1.Add(-time.Second).UTC().Truncate(time.Nanosecond)
+
+	q := url.Values{}
+	q.Set(paramServiceName, "foo")
+	q.Set(paramTimeMin, time1.Format(time.RFC3339Nano))
+	q.Set(paramTimeMax, time2.Format(time.RFC3339Nano))
+	q.Set(paramNumTraces, "10")
+	q.Set(paramAttributes, `{"http.status_code":"200", "error":"true"}`)
+
+	expectedAttrs := pcommon.NewMap()
+	expectedAttrs.PutStr("http.status_code", "200")
+	expectedAttrs.PutStr("error", "true")
+
+	qp := tracestore.TraceQueryParams{
+		ServiceName:   "foo",
+		OperationName: "",
+		Attributes:    expectedAttrs,
+		StartTimeMin:  time1,
+		StartTimeMax:  time2,
+		DurationMin:   0,
+		DurationMax:   0,
+		SearchDepth:   10,
+	}
+
+	r, err := http.NewRequest(http.MethodGet, "/api/v3/traces?"+q.Encode(), http.NoBody)
+	require.NoError(t, err)
+	w := httptest.NewRecorder()
+
+	gw := setupHTTPGatewayNoServer(t, "")
+
+	testTrace := ptrace.NewTraces()
+	rs := testTrace.ResourceSpans().AppendEmpty()
+	ss := rs.ScopeSpans().AppendEmpty()
+	ss.Spans().AppendEmpty().SetName("test-span")
+
+	gw.reader.
+		On("FindTraces", matchContext, qp).
+		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
+			yield([]ptrace.Traces{testTrace}, nil)
+		})).Once()
+
+	gw.router.ServeHTTP(w, r)
+	assert.Equal(t, http.StatusOK, w.Code)
+	gw.reader.AssertExpectations(t)
+}
+
+
 func TestHTTPGatewayGetTraceMalformedInputErrors(t *testing.T) {
 	testCases := []struct {
 		name          string
@@ -328,6 +377,15 @@ func TestHTTPGatewayFindTracesErrors(t *testing.T) {
 			},
 			expErr: paramQueryRawTraces,
 		},
+		{
+			name: "bad attributes json",
+			params: map[string]string{
+				paramTimeMin:    goodTime,
+				paramTimeMax:    goodTime,
+				paramAttributes: `{"key":"value"`,
+			},
+			expErr: paramAttributes,
+		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {