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

<!--
!! 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 tracereader

## How was this change tested?
- Added a unit test

## 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/grpc/tracereader.go

@@ -5,7 +5,6 @@ package grpc
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"iter"
 
@@ -18,8 +17,6 @@ import (
 
 var _ tracestore.Reader = (*TraceReader)(nil)
 
-var errFailedToGetServices = errors.New("failed to get services")
-
 type TraceReader struct {
 	client storage.TraceReaderClient
 }
@@ -43,16 +40,30 @@ func (*TraceReader) GetTraces(
 func (tr *TraceReader) GetServices(ctx context.Context) ([]string, error) {
 	resp, err := tr.client.GetServices(ctx, &storage.GetServicesRequest{})
 	if err != nil {
-		return nil, fmt.Errorf("%w: %w", errFailedToGetServices, err)
+		return nil, fmt.Errorf("failed to get services: %w", err)
 	}
 	return resp.Services, nil
 }
 
-func (*TraceReader) GetOperations(
-	context.Context,
-	tracestore.OperationQueryParams,
+func (tr *TraceReader) GetOperations(
+	ctx context.Context,
+	params tracestore.OperationQueryParams,
 ) ([]tracestore.Operation, error) {
-	panic("not implemented")
+	resp, err := tr.client.GetOperations(ctx, &storage.GetOperationsRequest{
+		Service:  params.ServiceName,
+		SpanKind: params.SpanKind,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get operations: %w", err)
+	}
+	operations := make([]tracestore.Operation, len(resp.Operations))
+	for i, op := range resp.Operations {
+		operations[i] = tracestore.Operation{
+			Name:     op.Name,
+			SpanKind: op.SpanKind,
+		}
+	}
+	return operations, nil
 }
 
 func (*TraceReader) FindTraces(

internal/storage/v2/grpc/tracereader_test.go

@@ -22,19 +22,27 @@ import (
 type testServer struct {
 	storage.UnimplementedTraceReaderServer
 
-	getServicesError error
+	services   []string
+	operations []*storage.Operation
+	err        error
 }
 
 func (s *testServer) GetServices(
 	context.Context,
 	*storage.GetServicesRequest,
 ) (*storage.GetServicesResponse, error) {
-	if s.getServicesError != nil {
-		return nil, s.getServicesError
-	}
 	return &storage.GetServicesResponse{
-		Services: []string{"service-a", "service-b"},
-	}, nil
+		Services: s.services,
+	}, s.err
+}
+
+func (s *testServer) GetOperations(
+	context.Context,
+	*storage.GetOperationsRequest,
+) (*storage.GetOperationsResponse, error) {
+	return &storage.GetOperationsResponse{
+		Operations: s.operations,
+	}, s.err
 }
 
 func startTestServer(t *testing.T, testServer *testServer) *grpc.ClientConn {
@@ -78,19 +86,21 @@ func TestTraceReader_GetServices(t *testing.T) {
 		name             string
 		testServer       *testServer
 		expectedServices []string
-		expectedError    error
+		expectedError    string
 	}{
 		{
-			name:             "success",
-			testServer:       &testServer{},
+			name: "success",
+			testServer: &testServer{
+				services: []string{"service-a", "service-b"},
+			},
 			expectedServices: []string{"service-a", "service-b"},
 		},
 		{
 			name: "error",
 			testServer: &testServer{
-				getServicesError: assert.AnError,
+				err: assert.AnError,
 			},
-			expectedError: errFailedToGetServices,
+			expectedError: "failed to get services",
 		},
 	}
 
@@ -101,18 +111,61 @@ func TestTraceReader_GetServices(t *testing.T) {
 			reader := NewTraceReader(conn)
 			services, err := reader.GetServices(context.Background())
 
-			require.ErrorIs(t, err, test.expectedError)
-			require.Equal(t, test.expectedServices, services)
+			if test.expectedError != "" {
+				require.ErrorContains(t, err, test.expectedError)
+			} else {
+				require.Equal(t, test.expectedServices, services)
+			}
 		})
 	}
 }
 
 func TestTraceReader_GetOperations(t *testing.T) {
-	tr := &TraceReader{}
+	tests := []struct {
+		name          string
+		testServer    *testServer
+		expectedOps   []tracestore.Operation
+		expectedError string
+	}{
+		{
+			name: "success",
+			testServer: &testServer{
+				operations: []*storage.Operation{
+					{Name: "operation-a", SpanKind: "kind"},
+					{Name: "operation-b", SpanKind: "kind"},
+				},
+			},
+			expectedOps: []tracestore.Operation{
+				{Name: "operation-a", SpanKind: "kind"},
+				{Name: "operation-b", SpanKind: "kind"},
+			},
+		},
+		{
+			name: "error",
+			testServer: &testServer{
+				err: assert.AnError,
+			},
+			expectedError: "failed to get operations",
+		},
+	}
 
-	require.Panics(t, func() {
-		tr.GetOperations(context.Background(), tracestore.OperationQueryParams{})
-	})
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			conn := startTestServer(t, test.testServer)
+
+			reader := NewTraceReader(conn)
+			ops, err := reader.GetOperations(context.Background(), tracestore.OperationQueryParams{
+				ServiceName: "service-a",
+				SpanKind:    "kind",
+			})
+
+			if test.expectedError != "" {
+				require.ErrorContains(t, err, test.expectedError)
+			} else {
+				require.Equal(t, test.expectedOps, ops)
+			}
+		})
+	}
 }
 
 func TestTraceReader_FindTraces(t *testing.T) {