[v2] Add v1 factory converter to v2 storage factory

cmd/jaeger/internal/exporters/storageexporter/exporter.go

@@ -5,22 +5,20 @@
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
-	otlp2jaeger "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/jaeger"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/pdata/ptrace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage"
-	"github.com/jaegertracing/jaeger/storage/spanstore"
+	"github.com/jaegertracing/jaeger/storage_v2/spanstore"
 )
 
 type storageExporter struct {
-	config     *Config
-	logger     *zap.Logger
-	spanWriter spanstore.Writer
+	config      *Config
+	logger      *zap.Logger
+	traceWriter spanstore.Writer
 }
 
 func newExporter(config *Config, otel component.TelemetrySettings) *storageExporter {
@@ -31,13 +29,13 @@
 }
 
 func (exp *storageExporter) start(_ context.Context, host component.Host) error {
-	f, err := jaegerstorage.GetStorageFactory(exp.config.TraceStorage, host)
+	f, err := jaegerstorage.GetStorageFactoryV2(exp.logger, exp.config.TraceStorage, host)
 	if err != nil {
 		return fmt.Errorf("cannot find storage factory: %w", err)
 	}
 
-	if exp.spanWriter, err = f.CreateSpanWriter(); err != nil {
-		return fmt.Errorf("cannot create span writer: %w", err)
+	if exp.traceWriter, err = f.CreateTraceWriter(); err != nil {
+		return fmt.Errorf("cannot create trace writer: %w", err)
 	}
 
 	return nil
@@ -49,18 +47,5 @@
 }
 
 func (exp *storageExporter) pushTraces(ctx context.Context, td ptrace.Traces) error {
-	batches, err := otlp2jaeger.ProtoFromTraces(td)
-	if err != nil {
-		return fmt.Errorf("cannot transform OTLP traces to Jaeger format: %w", err)
-	}
-	var errs []error
-	for _, batch := range batches {
-		for _, span := range batch.Spans {
-			if span.Process == nil {
-				span.Process = batch.Process
-			}
-			errs = append(errs, exp.spanWriter.WriteSpan(ctx, span))
-		}
-	}
-	return errors.Join(errs...)
+	return exp.traceWriter.WriteTraces(ctx, td)
 }

cmd/jaeger/internal/extension/jaegerstorage/extension.go

@@ -13,6 +13,7 @@
 	"go.opentelemetry.io/collector/extension"
 	"go.uber.org/zap"
 
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage/factoryadapter"
 	esCfg "github.com/jaegertracing/jaeger/pkg/es/config"
 	memoryCfg "github.com/jaegertracing/jaeger/pkg/memory/config"
 	"github.com/jaegertracing/jaeger/pkg/metrics"
@@ -24,6 +25,7 @@
 	grpcCfg "github.com/jaegertracing/jaeger/plugin/storage/grpc/config"
 	"github.com/jaegertracing/jaeger/plugin/storage/memory"
 	"github.com/jaegertracing/jaeger/storage"
+	"github.com/jaegertracing/jaeger/storage_v2/spanstore"
 )
 
 var _ Extension = (*storageExt)(nil)
@@ -64,6 +66,15 @@
 	return f, nil
 }
 
+func GetStorageFactoryV2(logger *zap.Logger, name string, host component.Host) (spanstore.Factory, error) {
+	f, err := GetStorageFactory(name, host)
+	if err != nil {
+		return nil, err
+	}
+
+	return factoryadapter.NewFactory(logger, f), nil
+}
+
 func newStorageExt(config *Config, otel component.TelemetrySettings) *storageExt {
 	return &storageExt{
 		config:    config,

cmd/jaeger/internal/extension/jaegerstorage/factoryadapter/README.md

@@ -0,0 +1,5 @@
+# Storage Factory Converter
+
+A temporary v1 storage factory wrapper to implement v2 storage APIs.
+This way, the existing v1 storage factories declared in `jaegerstorageextension`
+can act as v2 storage while we migrate to v2 storage APIs.

cmd/jaeger/internal/extension/jaegerstorage/factoryadapter/empty_test.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package factoryadapter
+
+import (
+	"testing"
+
+	"github.com/jaegertracing/jaeger/pkg/testutils"
+)
+
+func TestMain(m *testing.M) {
+	testutils.VerifyGoLeaks(m)
+}

cmd/jaeger/internal/extension/jaegerstorage/factoryadapter/factory.go

@@ -0,0 +1,54 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package factoryadapter
+
+import (
+	"context"
+	"io"
+
+	"go.uber.org/zap"
+
+	"github.com/jaegertracing/jaeger/pkg/metrics"
+	storage_v1 "github.com/jaegertracing/jaeger/storage"
+	"github.com/jaegertracing/jaeger/storage_v2/spanstore"
+)
+
+type Factory struct {
+	logger *zap.Logger
+	ss     storage_v1.Factory
+}
+
+func NewFactory(logger *zap.Logger, ss storage_v1.Factory) spanstore.Factory {
+	return &Factory{
+		logger: logger,
+		ss:     ss,
+	}
+}
+
+// Initialize implements spanstore.Factory.
+func (f *Factory) Initialize(_ context.Context) error {
+	return f.ss.Initialize(metrics.NullFactory, f.logger)
+}
+
+// Close implements spanstore.Factory.
+func (f *Factory) Close(_ context.Context) error {
+	if closer, ok := f.ss.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+// CreateTraceReader implements spanstore.Factory.
+func (*Factory) CreateTraceReader() (spanstore.Reader, error) {
+	panic("not implemented")
+}
+
+// CreateTraceWriter implements spanstore.Factory.
+func (f *Factory) CreateTraceWriter() (spanstore.Writer, error) {
+	spanWriter, err := f.ss.CreateSpanWriter()
+	if err != nil {
+		return nil, err
+	}
+	return NewTraceWriter(spanWriter), nil
+}

cmd/jaeger/internal/extension/jaegerstorage/factoryadapter/writer.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package factoryadapter
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	otlp2jaeger "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/jaeger"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+
+	spanstore_v1 "github.com/jaegertracing/jaeger/storage/spanstore"
+	"github.com/jaegertracing/jaeger/storage_v2/spanstore"
+)
+
+type TraceWriter struct {
+	spanWriter spanstore_v1.Writer
+}
+
+func NewTraceWriter(spanWriter spanstore_v1.Writer) spanstore.Writer {
+	return &TraceWriter{
+		spanWriter: spanWriter,
+	}
+}
+
+// WriteTraces implements spanstore.Writer.
+func (t *TraceWriter) WriteTraces(ctx context.Context, td ptrace.Traces) error {
+	batches, err := otlp2jaeger.ProtoFromTraces(td)
+	if err != nil {
+		return fmt.Errorf("cannot transform OTLP traces to Jaeger format: %w", err)
+	}
+	var errs []error
+	for _, batch := range batches {
+		for _, span := range batch.Spans {
+			if span.Process == nil {
+				span.Process = batch.Process
+			}
+			errs = append(errs, t.spanWriter.WriteSpan(ctx, span))
+		}
+	}
+	return errors.Join(errs...)
+}