[WIP] Remove distinction between primary and archive storage in jaeger-v1

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

@@ -74,7 +74,7 @@
 	}
 	if conf.IsSet("cassandra") {
 		cfg.Cassandra = &cassandra.Options{
-			Primary: cassandra.NamespaceConfig{
+			NamespaceConfig: cassandra.NamespaceConfig{
 				Configuration: casCfg.DefaultConfiguration(),
 				Enabled:       true,
 			},

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

@@ -83,7 +83,7 @@ backends:
 `)
 	cfg := createDefaultConfig().(*Config)
 	require.NoError(t, conf.Unmarshal(cfg))
-	assert.NotEmpty(t, cfg.TraceBackends["some_storage"].Cassandra.Primary.Connection.Servers)
+	assert.NotEmpty(t, cfg.TraceBackends["some_storage"].Cassandra.Configuration.Connection.Servers)
 }
 
 func TestConfigDefaultElasticsearch(t *testing.T) {

cmd/query/app/flags.go

@@ -29,8 +29,8 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/config"
 	"github.com/jaegertracing/jaeger/pkg/config/tlscfg"
 	"github.com/jaegertracing/jaeger/pkg/tenancy"
+	"github.com/jaegertracing/jaeger/plugin/storage"
 	"github.com/jaegertracing/jaeger/ports"
-	"github.com/jaegertracing/jaeger/storage"
 	"github.com/jaegertracing/jaeger/storage_v2/v1adapter"
 )
 
@@ -139,9 +139,13 @@ func (qOpts *QueryOptions) InitFromViper(v *viper.Viper, logger *zap.Logger) (*Q
 }
 
 // BuildQueryServiceOptions creates a QueryServiceOptions struct with appropriate adjusters and archive config
-func (qOpts *QueryOptions) BuildQueryServiceOptions(storageFactory storage.BaseFactory, logger *zap.Logger) *querysvc.QueryServiceOptions {
+func (qOpts *QueryOptions) BuildQueryServiceOptions(storageFactory *storage.Factory, logger *zap.Logger) *querysvc.QueryServiceOptions {
 	opts := &querysvc.QueryServiceOptions{}
-	if !opts.InitArchiveStorage(storageFactory, logger) {
+	ar, aw := storageFactory.InitArchiveStorage(logger)
+	if ar != nil && aw != nil {
+		opts.ArchiveSpanReader = ar
+		opts.ArchiveSpanWriter = aw
+	} else {
 		logger.Info("Archive storage not initialized")
 	}
 
@@ -150,13 +154,13 @@ func (qOpts *QueryOptions) BuildQueryServiceOptions(storageFactory storage.BaseF
 	return opts
 }
 
-func (qOpts *QueryOptions) BuildQueryServiceOptionsV2(storageFactory storage.BaseFactory, logger *zap.Logger) *v2querysvc.QueryServiceOptions {
+func (qOpts *QueryOptions) BuildQueryServiceOptionsV2(storageFactory *storage.Factory, logger *zap.Logger) *v2querysvc.QueryServiceOptions {
 	opts := &v2querysvc.QueryServiceOptions{}
 
-	ar, aw := v1adapter.InitializeArchiveStorage(storageFactory, logger)
+	ar, aw := storageFactory.InitArchiveStorage(logger)
 	if ar != nil && aw != nil {
-		opts.ArchiveTraceReader = ar
-		opts.ArchiveTraceWriter = aw
+		opts.ArchiveTraceReader = v1adapter.NewTraceReader(ar)
+		opts.ArchiveTraceWriter = v1adapter.NewTraceWriter(aw)
 	} else {
 		logger.Info("Archive storage not initialized")
 	}

cmd/query/app/querysvc/query_service.go

@@ -8,11 +8,8 @@ import (
 	"errors"
 	"time"
 
-	"go.uber.org/zap"
-
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/model/adjuster"
-	"github.com/jaegertracing/jaeger/storage"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 	"github.com/jaegertracing/jaeger/storage_v2/depstore"
 	"github.com/jaegertracing/jaeger/storage_v2/tracestore"
@@ -164,36 +161,6 @@ func (qs QueryService) GetCapabilities() StorageCapabilities {
 	}
 }
 
-// InitArchiveStorage tries to initialize archive storage reader/writer if storage factory supports them.
-func (opts *QueryServiceOptions) InitArchiveStorage(storageFactory storage.BaseFactory, logger *zap.Logger) bool {
-	archiveFactory, ok := storageFactory.(storage.ArchiveFactory)
-	if !ok {
-		logger.Info("Archive storage not supported by the factory")
-		return false
-	}
-	reader, err := archiveFactory.CreateArchiveSpanReader()
-	if errors.Is(err, storage.ErrArchiveStorageNotConfigured) || errors.Is(err, storage.ErrArchiveStorageNotSupported) {
-		logger.Info("Archive storage not created", zap.String("reason", err.Error()))
-		return false
-	}
-	if err != nil {
-		logger.Error("Cannot init archive storage reader", zap.Error(err))
-		return false
-	}
-	writer, err := archiveFactory.CreateArchiveSpanWriter()
-	if errors.Is(err, storage.ErrArchiveStorageNotConfigured) || errors.Is(err, storage.ErrArchiveStorageNotSupported) {
-		logger.Info("Archive storage not created", zap.String("reason", err.Error()))
-		return false
-	}
-	if err != nil {
-		logger.Error("Cannot init archive storage writer", zap.Error(err))
-		return false
-	}
-	opts.ArchiveSpanReader = reader
-	opts.ArchiveSpanWriter = writer
-	return true
-}
-
 // hasArchiveStorage returns true if archive storage reader/writer are initialized.
 func (opts *QueryServiceOptions) hasArchiveStorage() bool {
 	return opts.ArchiveSpanReader != nil && opts.ArchiveSpanWriter != nil

cmd/query/app/querysvc/query_service_test.go

@@ -451,64 +451,14 @@ func TestGetCapabilitiesWithSupportsArchive(t *testing.T) {
 
 type fakeStorageFactory1 struct{}
 
-type fakeStorageFactory2 struct {
-	fakeStorageFactory1
-	r    spanstore.Reader
-	w    spanstore.Writer
-	rErr error
-	wErr error
-}
-
 func (*fakeStorageFactory1) Initialize(metrics.Factory, *zap.Logger) error {
 	return nil
 }
 func (*fakeStorageFactory1) CreateSpanReader() (spanstore.Reader, error)             { return nil, nil }
 func (*fakeStorageFactory1) CreateSpanWriter() (spanstore.Writer, error)             { return nil, nil }
 func (*fakeStorageFactory1) CreateDependencyReader() (dependencystore.Reader, error) { return nil, nil }
 
-func (f *fakeStorageFactory2) CreateArchiveSpanReader() (spanstore.Reader, error) { return f.r, f.rErr }
-func (f *fakeStorageFactory2) CreateArchiveSpanWriter() (spanstore.Writer, error) { return f.w, f.wErr }
-
-var (
-	_ storage.Factory        = new(fakeStorageFactory1)
-	_ storage.ArchiveFactory = new(fakeStorageFactory2)
-)
-
-func TestInitArchiveStorageErrors(t *testing.T) {
-	opts := &QueryServiceOptions{}
-	logger := zap.NewNop()
-
-	assert.False(t, opts.InitArchiveStorage(new(fakeStorageFactory1), logger))
-	assert.False(t, opts.InitArchiveStorage(
-		&fakeStorageFactory2{rErr: storage.ErrArchiveStorageNotConfigured},
-		logger,
-	))
-	assert.False(t, opts.InitArchiveStorage(
-		&fakeStorageFactory2{rErr: errors.New("error")},
-		logger,
-	))
-	assert.False(t, opts.InitArchiveStorage(
-		&fakeStorageFactory2{wErr: storage.ErrArchiveStorageNotConfigured},
-		logger,
-	))
-	assert.False(t, opts.InitArchiveStorage(
-		&fakeStorageFactory2{wErr: errors.New("error")},
-		logger,
-	))
-}
-
-func TestInitArchiveStorage(t *testing.T) {
-	opts := &QueryServiceOptions{}
-	logger := zap.NewNop()
-	reader := &spanstoremocks.Reader{}
-	writer := &spanstoremocks.Writer{}
-	assert.True(t, opts.InitArchiveStorage(
-		&fakeStorageFactory2{r: reader, w: writer},
-		logger,
-	))
-	assert.Equal(t, reader, opts.ArchiveSpanReader)
-	assert.Equal(t, writer, opts.ArchiveSpanWriter)
-}
+var _ storage.Factory = new(fakeStorageFactory1)
 
 func TestMain(m *testing.M) {
 	testutils.VerifyGoLeaks(m)

cmd/query/app/token_propagation_test.go

@@ -81,7 +81,7 @@ func runQueryService(t *testing.T, esURL string) *Server {
 	}))
 	f.InitFromViper(v, flagsSvc.Logger)
 	// set AllowTokenFromContext manually because we don't register the respective CLI flag from query svc
-	f.Options.Primary.Authentication.BearerTokenAuthentication.AllowFromContext = true
+	f.Options.Config.Authentication.BearerTokenAuthentication.AllowFromContext = true
 	require.NoError(t, f.Initialize(telset.Metrics, telset.Logger))
 	defer f.Close()
 

cmd/remote-storage/app/server.go

@@ -17,12 +17,11 @@ import (
 	"google.golang.org/grpc/health"
 	"google.golang.org/grpc/reflection"
 
-	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
 	"github.com/jaegertracing/jaeger/pkg/bearertoken"
 	"github.com/jaegertracing/jaeger/pkg/telemetry"
 	"github.com/jaegertracing/jaeger/pkg/tenancy"
+	"github.com/jaegertracing/jaeger/plugin/storage"
 	"github.com/jaegertracing/jaeger/plugin/storage/grpc/shared"
-	"github.com/jaegertracing/jaeger/storage"
 	"github.com/jaegertracing/jaeger/storage/dependencystore"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
@@ -37,7 +36,7 @@ type Server struct {
 }
 
 // NewServer creates and initializes Server.
-func NewServer(options *Options, storageFactory storage.BaseFactory, tm *tenancy.Manager, telset telemetry.Settings) (*Server, error) {
+func NewServer(options *Options, storageFactory *storage.Factory, tm *tenancy.Manager, telset telemetry.Settings) (*Server, error) {
 	handler, err := createGRPCHandler(storageFactory, telset.Logger)
 	if err != nil {
 		return nil, err
@@ -55,7 +54,7 @@ func NewServer(options *Options, storageFactory storage.BaseFactory, tm *tenancy
 	}, nil
 }
 
-func createGRPCHandler(f storage.BaseFactory, logger *zap.Logger) (*shared.GRPCHandler, error) {
+func createGRPCHandler(f *storage.Factory, logger *zap.Logger) (*shared.GRPCHandler, error) {
 	reader, err := f.CreateSpanReader()
 	if err != nil {
 		return nil, err
@@ -76,12 +75,9 @@ func createGRPCHandler(f storage.BaseFactory, logger *zap.Logger) (*shared.GRPCH
 		StreamingSpanWriter: func() spanstore.Writer { return nil },
 	}
 
-	// borrow code from Query service for archive storage
-	qOpts := &querysvc.QueryServiceOptions{}
-	// when archive storage not initialized (returns false), the reader/writer will be nil
-	_ = qOpts.InitArchiveStorage(f, logger)
-	impl.ArchiveSpanReader = func() spanstore.Reader { return qOpts.ArchiveSpanReader }
-	impl.ArchiveSpanWriter = func() spanstore.Writer { return qOpts.ArchiveSpanWriter }
+	ar, aw := f.InitArchiveStorage(logger)
+	impl.ArchiveSpanReader = func() spanstore.Reader { return ar }
+	impl.ArchiveSpanWriter = func() spanstore.Writer { return aw }
 
 	handler := shared.NewGRPCHandler(impl)
 	return handler, nil

pkg/es/config/config.go

@@ -114,7 +114,9 @@ type Configuration struct {
 	// UseReadWriteAliases, if set to true, will use read and write aliases for indices.
 	// Use this option with Elasticsearch rollover API. It requires an external component
 	// to create aliases before startup and then performing its management.
-	UseReadWriteAliases bool `mapstructure:"use_aliases"`
+	UseReadWriteAliases bool   `mapstructure:"use_aliases"`
+	ReadAliasSuffix     string `mapstructure:"-"`
+	WriteAliasSuffix    string `mapstructure:"-"`
 	// CreateIndexTemplates, if set to true, creates index templates at application startup.
 	// This configuration should be set to false when templates are installed manually.
 	CreateIndexTemplates bool `mapstructure:"create_mappings"`

plugin/storage/badger/factory.go

@@ -38,14 +38,10 @@ const (
 )
 
 var ( // interface comformance checks
-	_ storage.Factory     = (*Factory)(nil)
-	_ io.Closer           = (*Factory)(nil)
-	_ plugin.Configurable = (*Factory)(nil)
-	_ storage.Purger      = (*Factory)(nil)
-
-	// TODO badger could implement archive storage
-	// _ storage.ArchiveFactory       = (*Factory)(nil)
-
+	_ storage.Factory              = (*Factory)(nil)
+	_ io.Closer                    = (*Factory)(nil)
+	_ plugin.Configurable          = (*Factory)(nil)
+	_ storage.Purger               = (*Factory)(nil)
 	_ storage.SamplingStoreFactory = (*Factory)(nil)
 )
 

plugin/storage/blackhole/factory.go

@@ -13,10 +13,8 @@ import (
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
-var ( // interface comformance checks
-	_ storage.Factory        = (*Factory)(nil)
-	_ storage.ArchiveFactory = (*Factory)(nil)
-)
+// interface comformance checks
+var _ storage.Factory = (*Factory)(nil)
 
 // Factory implements storage.Factory and creates blackhole storage components.
 type Factory struct {
@@ -48,16 +46,6 @@ func (f *Factory) CreateSpanWriter() (spanstore.Writer, error) {
 	return f.store, nil
 }
 
-// CreateArchiveSpanReader implements storage.ArchiveFactory
-func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
-	return f.store, nil
-}
-
-// CreateArchiveSpanWriter implements storage.ArchiveFactory
-func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
-	return f.store, nil
-}
-
 // CreateDependencyReader implements storage.Factory
 func (f *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
 	return f.store, nil

plugin/storage/blackhole/factory_test.go

@@ -27,12 +27,6 @@ func TestStorageFactory(t *testing.T) {
 	writer, err := f.CreateSpanWriter()
 	require.NoError(t, err)
 	assert.Equal(t, f.store, writer)
-	reader, err = f.CreateArchiveSpanReader()
-	require.NoError(t, err)
-	assert.Equal(t, f.store, reader)
-	writer, err = f.CreateArchiveSpanWriter()
-	require.NoError(t, err)
-	assert.Equal(t, f.store, writer)
 	depReader, err := f.CreateDependencyReader()
 	require.NoError(t, err)
 	assert.Equal(t, f.store, depReader)