[jaeger-v2] Add support for Badger

cmd/jaeger/badger_config.yaml

@@ -0,0 +1,41 @@
+service:
+  extensions: [jaeger_storage, jaeger_query]
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [jaeger_storage_exporter]
+
+extensions:
+  jaeger_query:
+    trace_storage: badger_main
+    trace_storage_archive: badger_archive
+    ui_config: ./cmd/jaeger/config-ui.json
+
+  jaeger_storage:
+    badger:
+      badger_main:
+        directory_key: "/tmp/jaeger/"
+        directory_value: "/tmp/jaeger/"
+        ephemeral: false
+        maintenance_interval: 5
+        metrics_update_interval: 10
+      badger_archive:
+        directory_key: "/tmp/jaeger_archive/"
+        directory_value: "/tmp/jaeger_archive/"
+        ephemeral: false
+        maintenance_interval: 5
+        metrics_update_interval: 10
+
+receivers:
+  otlp:
+    protocols:
+      grpc:
+      http:
+
+processors:
+  batch:
+
+exporters:
+  jaeger_storage_exporter:
+    trace_storage: badger_main

cmd/jaeger/config.yaml

@@ -25,7 +25,6 @@ extensions:
       memstore_archive:
         max_traces: 100000
 
-
 receivers:
   otlp:
     protocols:

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

@@ -8,11 +8,13 @@ import (
 	"reflect"
 
 	memoryCfg "github.com/jaegertracing/jaeger/pkg/memory/config"
+	badgerCfg "github.com/jaegertracing/jaeger/plugin/storage/badger"
 )
 
 // Config has the configuration for jaeger-query,
 type Config struct {
-	Memory map[string]memoryCfg.Configuration `mapstructure:"memory"`
+	Memory map[string]memoryCfg.Configuration   `mapstructure:"memory"`
+	Badger map[string]badgerCfg.NamespaceConfig `mapstructure:"badger"`
 	// TODO add other storage types here
 	// TODO how will this work with 3rd party storage implementations?
 	//      Option: instead of looking for specific name, check interface.

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

@@ -14,6 +14,7 @@ import (
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/pkg/metrics"
+	"github.com/jaegertracing/jaeger/plugin/storage/badger"
 	"github.com/jaegertracing/jaeger/plugin/storage/memory"
 	"github.com/jaegertracing/jaeger/storage"
 )
@@ -70,6 +71,23 @@ func (s *storageExt) Start(ctx context.Context, host component.Host) error {
 			s.logger.With(zap.String("storage_name", name)),
 		)
 	}
+
+	for name, b := range s.config.Badger {
+		if _, ok := s.factories[name]; ok {
+			return fmt.Errorf("duplicate badger storage name %s", name)
+		}
+		var err error
+		factory, err := badger.NewFactoryWithConfig(
+			b,
+			metrics.NullFactory,
+			s.logger.With(zap.String("storage_name", name)),
+		)
+		if err != nil {
+			return fmt.Errorf("failed to initialize badger storage: %w", err)
+		}
+		s.factories[name] = factory
+	}
+
 	// TODO add support for other backends
 	return nil
 }

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

@@ -18,12 +18,16 @@ import (
 
 	memoryCfg "github.com/jaegertracing/jaeger/pkg/memory/config"
 	"github.com/jaegertracing/jaeger/pkg/metrics"
+	badgerCfg "github.com/jaegertracing/jaeger/plugin/storage/badger"
 	"github.com/jaegertracing/jaeger/storage"
 	"github.com/jaegertracing/jaeger/storage/dependencystore"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
-const memstoreName = "memstore"
+const (
+	memstoreName = "memstore"
+	badgerName   = "badgerstore"
+)
 
 type storageHost struct {
 	t                *testing.T
@@ -129,6 +133,61 @@ func TestStorageExtension(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestBadgerStorageExtension(t *testing.T) {
+	ctx := context.Background()
+	telemetrySettings := component.TelemetrySettings{
+		Logger:         zap.NewNop(),
+		TracerProvider: nooptrace.NewTracerProvider(),
+		MeterProvider:  noopmetric.NewMeterProvider(),
+	}
+
+	config := &Config{
+		Badger: map[string]badgerCfg.NamespaceConfig{
+			badgerName: {
+				Ephemeral:             true,
+				MaintenanceInterval:   5,
+				MetricsUpdateInterval: 10,
+			},
+		},
+	}
+
+	require.NoError(t, config.Validate())
+
+	extensionFactory := NewFactory()
+	storageExtension, err := extensionFactory.CreateExtension(ctx, extension.CreateSettings{
+		ID:                ID,
+		TelemetrySettings: telemetrySettings,
+		BuildInfo:         component.NewDefaultBuildInfo(),
+	}, config)
+	require.NoError(t, err)
+
+	host := componenttest.NewNopHost()
+	err = storageExtension.Start(ctx, host)
+	require.NoError(t, err)
+
+	err = storageExtension.Start(ctx, host)
+	t.Cleanup(func() { require.NoError(t, storageExtension.Shutdown(ctx)) })
+	require.Error(t, err)
+	require.EqualError(t, err, fmt.Sprintf("duplicate badger storage name %s", badgerName))
+}
+
+func TestBadgerStorageExtensionError(t *testing.T) {
+	ctx := context.Background()
+	factory, _ := badgerCfg.NewFactoryWithConfig(badgerCfg.NamespaceConfig{}, metrics.NullFactory, zap.NewNop())
+	ext := storageExt{
+		config: &Config{
+			Badger: map[string]badgerCfg.NamespaceConfig{
+				badgerName: {},
+			},
+		},
+		logger:    zap.NewNop(),
+		factories: map[string]storage.Factory{"badger": factory},
+	}
+	err := ext.Start(ctx, componenttest.NewNopHost())
+	require.Error(t, err)
+	require.EqualError(t, err, "failed to initialize badger storage: Error Creating Dir: \"\" error: mkdir : no such file or directory")
+}
+
 func makeStorageExtension(t *testing.T, memstoreName string) component.Component {
 	extensionFactory := NewFactory()
 

plugin/storage/badger/factory.go

@@ -91,6 +91,20 @@ func NewFactory() *Factory {
 	}
 }
 
+func NewFactoryWithConfig(
+	cfg NamespaceConfig,
+	metricsFactory metrics.Factory,
+	logger *zap.Logger,
+) (*Factory, error) {
+	f := NewFactory()
+	f.InitFromOptions(Options{Primary: cfg})
+	err := f.Initialize(metricsFactory, logger)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
 // AddFlags implements plugin.Configurable
 func (f *Factory) AddFlags(flagSet *flag.FlagSet) {
 	f.Options.AddFlags(flagSet)

plugin/storage/badger/factory_test.go

@@ -200,3 +200,23 @@ func TestInitFromOptions(t *testing.T) {
 	f.InitFromOptions(opts)
 	assert.Equal(t, &opts, f.Options)
 }
+
+func TestBadgerStorageFactoryWithConfig(t *testing.T) {
+	cfg := NamespaceConfig{}
+	_, err := NewFactoryWithConfig(cfg, metrics.NullFactory, zap.NewNop())
+	require.Error(t, err)
+	require.ErrorContains(t, err, "Error Creating Dir")
+
+	tmp := os.TempDir()
+	defer os.Remove(tmp)
+	cfg = NamespaceConfig{
+		ValueDirectory:        tmp,
+		KeyDirectory:          tmp,
+		Ephemeral:             false,
+		MaintenanceInterval:   5,
+		MetricsUpdateInterval: 10,
+	}
+	factory, err := NewFactoryWithConfig(cfg, metrics.NullFactory, zap.NewNop())
+	require.NoError(t, err)
+	defer factory.Close()
+}