[grpc][v2] Register gRPC v2 handler in remote-storage server

cmd/remote-storage/app/server.go

@@ -23,6 +23,7 @@ import (
 	"github.com/jaegertracing/jaeger/internal/storage/v1/grpc/shared"
 	"github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
 	"github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
+	grpcstorage "github.com/jaegertracing/jaeger/internal/storage/v2/grpc"
 	"github.com/jaegertracing/jaeger/internal/storage/v2/v1adapter"
 	"github.com/jaegertracing/jaeger/internal/telemetry"
 	"github.com/jaegertracing/jaeger/internal/tenancy"
@@ -45,37 +46,43 @@ func NewServer(
 	tm *tenancy.Manager,
 	telset telemetry.Settings,
 ) (*Server, error) {
-	handler, err := createGRPCHandler(ts, ds)
+	reader, err := ts.CreateTraceReader()
 	if err != nil {
 		return nil, err
 	}
-
-	grpcServer, err := createGRPCServer(options, tm, handler, telset)
+	writer, err := ts.CreateTraceWriter()
 	if err != nil {
 		return nil, err
 	}
-
-	return &Server{
-		opts:       options,
-		grpcServer: grpcServer,
-		telset:     telset,
-	}, nil
-}
-
-func createGRPCHandler(ts tracestore.Factory, ds depstore.Factory) (*shared.GRPCHandler, error) {
-	reader, err := ts.CreateTraceReader()
+	depReader, err := ds.CreateDependencyReader()
 	if err != nil {
 		return nil, err
 	}
-	writer, err := ts.CreateTraceWriter()
+
+	handler, err := createGRPCHandler(reader, writer, depReader)
 	if err != nil {
 		return nil, err
 	}
-	depReader, err := ds.CreateDependencyReader()
+
+	v2Handler := grpcstorage.NewHandler(reader, writer, depReader)
+
+	grpcServer, err := createGRPCServer(options, tm, handler, v2Handler, telset)
 	if err != nil {
 		return nil, err
 	}
 
+	return &Server{
+		opts:       options,
+		grpcServer: grpcServer,
+		telset:     telset,
+	}, nil
+}
+
+func createGRPCHandler(
+	reader tracestore.Reader,
+	writer tracestore.Writer,
+	depReader depstore.Reader,
+) (*shared.GRPCHandler, error) {
 	impl := &shared.GRPCHandlerStorageImpl{
 		SpanReader:          func() spanstore.Reader { return v1adapter.GetV1Reader(reader) },
 		SpanWriter:          func() spanstore.Writer { return v1adapter.GetV1Writer(writer) },
@@ -87,7 +94,13 @@ func createGRPCHandler(ts tracestore.Factory, ds depstore.Factory) (*shared.GRPC
 	return handler, nil
 }
 
-func createGRPCServer(opts *Options, tm *tenancy.Manager, handler *shared.GRPCHandler, telset telemetry.Settings) (*grpc.Server, error) {
+func createGRPCServer(
+	opts *Options,
+	tm *tenancy.Manager,
+	handler *shared.GRPCHandler,
+	v2Handler *grpcstorage.Handler,
+	telset telemetry.Settings,
+) (*grpc.Server, error) {
 	unaryInterceptors := []grpc.UnaryServerInterceptor{
 		bearertoken.NewUnaryServerInterceptor(),
 	}
@@ -111,7 +124,9 @@ func createGRPCServer(opts *Options, tm *tenancy.Manager, handler *shared.GRPCHa
 	}
 	healthServer := health.NewServer()
 	reflection.Register(server)
+
 	handler.Register(server, healthServer)
+	v2Handler.Register(server, healthServer)
 
 	return server, nil
 }

cmd/remote-storage/app/server_test.go

@@ -158,13 +158,7 @@ func TestCreateGRPCHandler(t *testing.T) {
 	writer := new(tracestoremocks.Writer)
 	depReader := new(depstoremocks.Reader)
 
-	f := &fakeFactory{
-		reader:    reader,
-		writer:    writer,
-		depReader: depReader,
-	}
-
-	h, err := createGRPCHandler(f, f)
+	h, err := createGRPCHandler(reader, writer, depReader)
 	require.NoError(t, err)
 
 	writer.On("WriteTraces", mock.Anything, mock.Anything).Return(errors.New("writer error"))

internal/storage/v2/grpc/handler.go

@@ -8,6 +8,9 @@ import (
 
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/health"
+	"google.golang.org/grpc/health/grpc_health_v1"
 
 	"github.com/jaegertracing/jaeger/internal/jptrace"
 	"github.com/jaegertracing/jaeger/internal/proto-gen/storage/v2"
@@ -184,6 +187,16 @@ func (h *Handler) GetDependencies(
 	}, nil
 }
 
+func (h *Handler) Register(ss *grpc.Server, hs *health.Server) {
+	storage.RegisterTraceReaderServer(ss, h)
+	storage.RegisterDependencyReaderServer(ss, h)
+	ptraceotlp.RegisterGRPCServer(ss, h)
+
+	hs.SetServingStatus("jaeger.storage.v2.TraceReader", grpc_health_v1.HealthCheckResponse_SERVING)
+	hs.SetServingStatus("jaeger.storage.v2.DependencyReader", grpc_health_v1.HealthCheckResponse_SERVING)
+	hs.SetServingStatus("jaeger.storage.v2.TraceWriter", grpc_health_v1.HealthCheckResponse_SERVING)
+}
+
 func toTraceQueryParams(t *storage.TraceQueryParameters) tracestore.TraceQueryParams {
 	return tracestore.TraceQueryParams{
 		ServiceName:   t.ServiceName,