[v2] Implement FindTraceIDs for ES/OS (jaegertracing#7035)

## Which problem is this PR solving?
- Fixes a part of: jaegertracing#7034 

## Description of the changes
- Implement `FindTraceIDs` for ES/OS 

## How was this change tested?
- 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: Manik2708 <[email protected]>

Author: Manik2708

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

@@ -56,6 +56,41 @@ func (*TraceReader) FindTraces(_ context.Context, _ v2api.TraceQueryParams) iter
 	panic("not implemented")
 }
 
-func (*TraceReader) FindTraceIDs(_ context.Context, _ v2api.TraceQueryParams) iter.Seq2[[]v2api.FoundTraceID, error] {
-	panic("not implemented")
+func (t *TraceReader) FindTraceIDs(ctx context.Context, query v2api.TraceQueryParams) iter.Seq2[[]v2api.FoundTraceID, error] {
+	return func(yield func([]v2api.FoundTraceID, error) bool) {
+		traceIds, err := t.spanReader.FindTraceIDs(ctx, toDBTraceQueryParams(query))
+		if err != nil {
+			yield(nil, err)
+			return
+		}
+		otelTraceIds := make([]v2api.FoundTraceID, 0, len(traceIds))
+		for _, traceId := range traceIds {
+			dbTraceId, err := fromDbTraceId(traceId)
+			if err != nil {
+				yield(nil, err)
+				return
+			}
+			otelTraceIds = append(otelTraceIds, v2api.FoundTraceID{
+				TraceID: dbTraceId,
+			})
+		}
+		yield(otelTraceIds, nil)
+	}
+}
+
+func toDBTraceQueryParams(query v2api.TraceQueryParams) dbmodel.TraceQueryParameters {
+	tags := make(map[string]string)
+	for key, val := range query.Attributes.All() {
+		tags[key] = val.AsString()
+	}
+	return dbmodel.TraceQueryParameters{
+		ServiceName:   query.ServiceName,
+		OperationName: query.OperationName,
+		StartTimeMin:  query.StartTimeMin,
+		StartTimeMax:  query.StartTimeMax,
+		Tags:          tags,
+		NumTraces:     query.SearchDepth,
+		DurationMin:   query.DurationMin,
+		DurationMax:   query.DurationMax,
+	}
 }

internal/storage/v2/elasticsearch/tracestore/reader_test.go

@@ -7,10 +7,12 @@ import (
 	"context"
 	"errors"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
@@ -86,10 +88,84 @@ func TestTraceReader_FindTraces(t *testing.T) {
 }
 
 func TestTraceReader_FindTraceIDs(t *testing.T) {
-	reader := NewTraceReader(spanstore.SpanReaderParams{
-		Logger: zap.NewNop(),
-	})
-	assert.Panics(t, func() {
-		reader.FindTraceIDs(context.Background(), v2api.TraceQueryParams{})
-	})
+	coreReader := &mocks.CoreSpanReader{}
+	reader := TraceReader{spanReader: coreReader}
+	dbTraceIDs := []dbmodel.TraceID{
+		"00000000000000010000000000000000",
+		"00000000000000020000000000000000",
+		"00000000000000030000000000000000",
+	}
+	expected := make([]v2api.FoundTraceID, 0, len(dbTraceIDs))
+	for _, dbTraceID := range dbTraceIDs {
+		expected = append(expected, fromDBTraceId(t, dbTraceID))
+	}
+	coreReader.On("FindTraceIDs", mock.Anything, mock.Anything).Return(dbTraceIDs, nil)
+	for traceIds, err := range reader.FindTraceIDs(context.Background(), v2api.TraceQueryParams{
+		Attributes: pcommon.NewMap(),
+	}) {
+		require.NoError(t, err)
+		require.Equal(t, expected, traceIds)
+	}
+}
+
+func TestTraceReader_FindTraceIDs_Error(t *testing.T) {
+	tests := []struct {
+		name                   string
+		errFromCoreReader      error
+		traceIdsFromCoreReader []dbmodel.TraceID
+		expectedErr            string
+	}{
+		{
+			name:              "some error from core reader",
+			errFromCoreReader: errors.New("some error from core reader"),
+			expectedErr:       "some error from core reader",
+		},
+		{
+			name:                   "wrong trace id sent from core reader",
+			traceIdsFromCoreReader: []dbmodel.TraceID{"wrong-id"},
+			expectedErr:            "encoding/hex: invalid byte: U+0077 'w'",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			coreReader := &mocks.CoreSpanReader{}
+			attrs := pcommon.NewMap()
+			attrs.PutStr("key1", "val1")
+			ts := time.Now()
+			traceQueryParams := v2api.TraceQueryParams{
+				Attributes:    attrs,
+				StartTimeMin:  ts,
+				ServiceName:   "testing-service-name",
+				OperationName: "testing-operation-name",
+				StartTimeMax:  ts.Add(1 * time.Hour),
+				DurationMin:   1 * time.Hour,
+				DurationMax:   1 * time.Hour,
+				SearchDepth:   10,
+			}
+			dbTraceQueryParams := dbmodel.TraceQueryParameters{
+				Tags:          map[string]string{"key1": "val1"},
+				StartTimeMin:  ts,
+				ServiceName:   "testing-service-name",
+				OperationName: "testing-operation-name",
+				StartTimeMax:  ts.Add(1 * time.Hour),
+				DurationMin:   1 * time.Hour,
+				DurationMax:   1 * time.Hour,
+				NumTraces:     10,
+			}
+			coreReader.On("FindTraceIDs", mock.Anything, dbTraceQueryParams).Return(test.traceIdsFromCoreReader, test.errFromCoreReader)
+			reader := TraceReader{spanReader: coreReader}
+			for traceIds, err := range reader.FindTraceIDs(context.Background(), traceQueryParams) {
+				require.ErrorContains(t, err, test.expectedErr)
+				require.Nil(t, traceIds)
+			}
+		})
+	}
+}
+
+func fromDBTraceId(t *testing.T, traceID dbmodel.TraceID) v2api.FoundTraceID {
+	traceId, err := fromDbTraceId(traceID)
+	require.NoError(t, err)
+	return v2api.FoundTraceID{
+		TraceID: traceId,
+	}
 }