[grpc][v2] Implement FindTraceIDs Call in gRPC reader for remote storage api v2 (#6858)

<!--
!! Please DELETE this comment before posting.
We appreciate your contribution to the Jaeger project! 👋🎉
-->

## Which problem is this PR solving?
- Towards #6789

## Description of the changes
- This PR implements the GetOperations call in the gRPC v2 API client
- In the process, we also had to add a helper to convert a `pcommon.Map`
to the proto representation `[]*KeyValue`.

## How was this change tested?
- Added unit tests

## Checklist
- [x] I have read
https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md
- [x] I have signed all commits
- [x] I have added unit tests for the new functionality
- [x] I have run lint and test steps successfully
  - for `jaeger`: `make lint test`
  - for `jaeger-ui`: `npm run lint` and `npm run test`

---------

Signed-off-by: Mahad Zaryab <[email protected]>

Author: mahadzaryab1

internal/storage/v2/api/tracestore/reader.go

@@ -83,12 +83,13 @@ type GetTraceParams struct {
 type TraceQueryParams struct {
 	ServiceName   string
 	OperationName string
-	Attributes    pcommon.Map
-	StartTimeMin  time.Time
-	StartTimeMax  time.Time
-	DurationMin   time.Duration
-	DurationMax   time.Duration
-	SearchDepth   int
+	// Attributes must initialized with pcommon.NewMap() before use.
+	Attributes   pcommon.Map
+	StartTimeMin time.Time
+	StartTimeMax time.Time
+	DurationMin  time.Duration
+	DurationMax  time.Duration
+	SearchDepth  int
 }
 
 // FoundTraceID is a wrapper around trace ID returned from FindTraceIDs

internal/storage/v2/grpc/tracereader.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"iter"
 
+	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/ptrace"
 	"google.golang.org/grpc"
 
@@ -73,9 +74,114 @@ func (*TraceReader) FindTraces(
 	panic("not implemented")
 }
 
-func (*TraceReader) FindTraceIDs(
-	context.Context,
-	tracestore.TraceQueryParams,
+func (tr *TraceReader) FindTraceIDs(
+	ctx context.Context,
+	params tracestore.TraceQueryParams,
 ) iter.Seq2[[]tracestore.FoundTraceID, error] {
-	panic("not implemented")
+	return func(yield func([]tracestore.FoundTraceID, error) bool) {
+		resp, err := tr.client.FindTraceIDs(ctx, &storage.FindTracesRequest{
+			Query: toProtoQueryParameters(params),
+		})
+		if err != nil {
+			yield(nil, fmt.Errorf("failed to execute FindTraceIDs: %w", err))
+			return
+		}
+		foundTraceIDs := make([]tracestore.FoundTraceID, len(resp.TraceIds))
+		for i, foundTraceID := range resp.TraceIds {
+			var sizedTraceID [16]byte
+			copy(sizedTraceID[:], foundTraceID.TraceId)
+
+			foundTraceIDs[i] = tracestore.FoundTraceID{
+				TraceID: pcommon.TraceID(sizedTraceID),
+				Start:   foundTraceID.Start,
+				End:     foundTraceID.End,
+			}
+		}
+		yield(foundTraceIDs, nil)
+	}
+}
+
+func toProtoQueryParameters(t tracestore.TraceQueryParams) *storage.TraceQueryParameters {
+	return &storage.TraceQueryParameters{
+		ServiceName:   t.ServiceName,
+		OperationName: t.OperationName,
+		Attributes:    convertMapToKeyValueList(t.Attributes),
+		StartTimeMin:  t.StartTimeMin,
+		StartTimeMax:  t.StartTimeMax,
+		DurationMin:   t.DurationMin,
+		DurationMax:   t.DurationMax,
+		SearchDepth:   int32(t.SearchDepth), //nolint: gosec // G115
+	}
+}
+
+func convertMapToKeyValueList(m pcommon.Map) []*storage.KeyValue {
+	keyValues := make([]*storage.KeyValue, 0, m.Len())
+	m.Range(func(k string, v pcommon.Value) bool {
+		keyValues = append(keyValues, &storage.KeyValue{
+			Key:   k,
+			Value: convertValueToAnyValue(v),
+		})
+		return true
+	})
+	return keyValues
+}
+
+func convertValueToAnyValue(v pcommon.Value) *storage.AnyValue {
+	switch v.Type() {
+	case pcommon.ValueTypeStr:
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_StringValue{
+				StringValue: v.Str(),
+			},
+		}
+	case pcommon.ValueTypeBool:
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_BoolValue{
+				BoolValue: v.Bool(),
+			},
+		}
+	case pcommon.ValueTypeInt:
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_IntValue{
+				IntValue: v.Int(),
+			},
+		}
+	case pcommon.ValueTypeDouble:
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_DoubleValue{
+				DoubleValue: v.Double(),
+			},
+		}
+	case pcommon.ValueTypeBytes:
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_BytesValue{
+				BytesValue: v.Bytes().AsRaw(),
+			},
+		}
+	case pcommon.ValueTypeSlice:
+		arr := v.Slice()
+		arrayValues := make([]*storage.AnyValue, 0, arr.Len())
+		for i := 0; i < arr.Len(); i++ {
+			arrayValues = append(arrayValues, convertValueToAnyValue(arr.At(i)))
+		}
+		return &storage.AnyValue{
+			Value: &storage.AnyValue_ArrayValue{
+				ArrayValue: &storage.ArrayValue{
+					Values: arrayValues,
+				},
+			},
+		}
+	case pcommon.ValueTypeMap:
+		kvList := &storage.KeyValueList{}
+		v.Map().Range(func(k string, val pcommon.Value) bool {
+			kvList.Values = append(kvList.Values, &storage.KeyValue{
+				Key:   k,
+				Value: convertValueToAnyValue(val),
+			})
+			return true
+		})
+		return &storage.AnyValue{Value: &storage.AnyValue_KvlistValue{KvlistValue: kvList}}
+	default:
+		return nil
+	}
 }