Remove archive storage factory

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

@@ -67,6 +67,14 @@ func (e errorFactory) CreateSpanWriter() (spanstore.Writer, error) {
  panic("not implemented")
 }
 
+func (e errorFactory) CreateArchiveSpanReader() (spanstore.Reader, error) {
+ panic("not implemented")
+}
+
+func (e errorFactory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
+ panic("not implemented")
+}
+
 func (e errorFactory) CreateDependencyReader() (dependencystore.Reader, error) {
  panic("not implemented")
 }

cmd/query/app/flags_test.go

@@ -102,22 +102,24 @@ func TestBuildQueryServiceOptions(t *testing.T) {
  require.NoError(t, err)
  assert.NotNil(t, qOpts)
 
- qSvcOpts := qOpts.BuildQueryServiceOptions(&mocks.Factory{}, zap.NewNop())
+ mockFactory := &mocks.Factory{}
+ mockFactory.On("CreateArchiveSpanReader").Return(nil, nil)
+ mockFactory.On("CreateArchiveSpanWriter").Return(nil, nil)
+
+ qSvcOpts := qOpts.BuildQueryServiceOptions(mockFactory, zap.NewNop())
  assert.NotNil(t, qSvcOpts)
  assert.NotNil(t, qSvcOpts.Adjuster)
  assert.Nil(t, qSvcOpts.ArchiveSpanReader)
  assert.Nil(t, qSvcOpts.ArchiveSpanWriter)
 
  comboFactory := struct {
  *mocks.Factory
- *mocks.ArchiveFactory
  }{
  &mocks.Factory{},
- &mocks.ArchiveFactory{},
  }
 
- comboFactory.ArchiveFactory.On("CreateArchiveSpanReader").Return(&spanstore_mocks.Reader{}, nil)
- comboFactory.ArchiveFactory.On("CreateArchiveSpanWriter").Return(&spanstore_mocks.Writer{}, nil)
+ comboFactory.Factory.On("CreateArchiveSpanReader").Return(&spanstore_mocks.Reader{}, nil)
+ comboFactory.Factory.On("CreateArchiveSpanWriter").Return(&spanstore_mocks.Writer{}, nil)
 
  qSvcOpts = qOpts.BuildQueryServiceOptions(comboFactory, zap.NewNop())
  assert.NotNil(t, qSvcOpts)

cmd/query/app/querysvc/query_service.go

@@ -138,12 +138,7 @@ func (qs QueryService) GetCapabilities() StorageCapabilities {
 
 // InitArchiveStorage tries to initialize archive storage reader/writer if storage factory supports them.
 func (opts *QueryServiceOptions) InitArchiveStorage(storageFactory storage.Factory, 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()
+ reader, err := storageFactory.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
@@ -152,7 +147,7 @@ func (opts *QueryServiceOptions) InitArchiveStorage(storageFactory storage.Facto
  logger.Error("Cannot init archive storage reader", zap.Error(err))
  return false
  }
- writer, err := archiveFactory.CreateArchiveSpanWriter()
+ writer, err := storageFactory.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

cmd/query/app/querysvc/query_service_test.go

@@ -305,50 +305,45 @@ func TestGetCapabilitiesWithSupportsArchive(t *testing.T) {
  assert.Equal(t, expectedStorageCapabilities, tqs.queryService.GetCapabilities())
 }
 
-type fakeStorageFactory1 struct{}
-
-type fakeStorageFactory2 struct {
- fakeStorageFactory1
+type fakeStorageFactory struct {
  r spanstore.Reader
  w spanstore.Writer
  rErr error
  wErr error
 }
 
-func (*fakeStorageFactory1) Initialize(metricsFactory metrics.Factory, logger *zap.Logger) error {
+func (*fakeStorageFactory) Initialize(metricsFactory metrics.Factory, logger *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 }
+func (f *fakeStorageFactory) CreateSpanReader() (spanstore.Reader, error) { return f.r, f.rErr }
+func (f *fakeStorageFactory) CreateSpanWriter() (spanstore.Writer, error) { return f.w, f.wErr }
+func (f *fakeStorageFactory) CreateDependencyReader() (dependencystore.Reader, error) {
+ return nil, nil
+}
+func (f *fakeStorageFactory) CreateArchiveSpanReader() (spanstore.Reader, error) { return f.r, f.rErr }
+func (f *fakeStorageFactory) CreateArchiveSpanWriter() (spanstore.Writer, error) { return f.w, f.wErr }
 
-var (
- _ storage.Factory = new(fakeStorageFactory1)
- _ storage.ArchiveFactory = new(fakeStorageFactory2)
-)
+var _ storage.Factory = new(fakeStorageFactory)
 
 func TestInitArchiveStorageErrors(t *testing.T) {
  opts := &QueryServiceOptions{}
  logger := zap.NewNop()
 
- assert.False(t, opts.InitArchiveStorage(new(fakeStorageFactory1), logger))
+ // assert.False(t, opts.InitArchiveStorage(new(fakeStorageFactory), logger))
  assert.False(t, opts.InitArchiveStorage(
- &fakeStorageFactory2{rErr: storage.ErrArchiveStorageNotConfigured},
+ &fakeStorageFactory{rErr: storage.ErrArchiveStorageNotConfigured},
  logger,
  ))
  assert.False(t, opts.InitArchiveStorage(
- &fakeStorageFactory2{rErr: errors.New("error")},
+ &fakeStorageFactory{rErr: errors.New("error")},
  logger,
  ))
  assert.False(t, opts.InitArchiveStorage(
- &fakeStorageFactory2{wErr: storage.ErrArchiveStorageNotConfigured},
+ &fakeStorageFactory{wErr: storage.ErrArchiveStorageNotConfigured},
  logger,
  ))
  assert.False(t, opts.InitArchiveStorage(
- &fakeStorageFactory2{wErr: errors.New("error")},
+ &fakeStorageFactory{wErr: errors.New("error")},
  logger,
  ))
 }
@@ -359,7 +354,7 @@ func TestInitArchiveStorage(t *testing.T) {
  reader := &spanstoremocks.Reader{}
  writer := &spanstoremocks.Writer{}
  assert.True(t, opts.InitArchiveStorage(
- &fakeStorageFactory2{r: reader, w: writer},
+ &fakeStorageFactory{r: reader, w: writer},
  logger,
  ))
  assert.Equal(t, reader, opts.ArchiveSpanReader)

cmd/remote-storage/app/server_test.go

@@ -50,6 +50,10 @@ func TestNewServer_CreateStorageErrors(t *testing.T) {
  factory.On("CreateSpanReader").Return(nil, nil)
  factory.On("CreateSpanWriter").Return(nil, errors.New("no writer")).Once()
  factory.On("CreateSpanWriter").Return(nil, nil)
+ factory.On("CreateArchiveSpanReader").Return(nil, errors.New("no reader")).Once()
+ factory.On("CreateArchiveSpanReader").Return(nil, nil)
+ factory.On("CreateArchiveSpanWriter").Return(nil, errors.New("no writer")).Once()
+ factory.On("CreateArchiveSpanWriter").Return(nil, nil)
  factory.On("CreateDependencyReader").Return(nil, errors.New("no deps")).Once()
  factory.On("CreateDependencyReader").Return(nil, nil)
 
@@ -107,6 +111,8 @@ func newStorageMocks() *storageMocks {
  factory := new(factoryMocks.Factory)
  factory.On("CreateSpanReader").Return(reader, nil)
  factory.On("CreateSpanWriter").Return(writer, nil)
+ factory.On("CreateArchiveSpanReader").Return(nil, nil)
+ factory.On("CreateArchiveSpanWriter").Return(nil, nil)
  factory.On("CreateDependencyReader").Return(depReader, nil)
 
  return &storageMocks{
@@ -154,7 +160,7 @@ func TestCreateGRPCHandler(t *testing.T) {
  require.Error(t, err)
  assert.Contains(t, err.Error(), "not implemented")
 
- _, err = h.WriteArchiveSpan(context.Background(), nil)
+ _, err = h.WriteArchiveSpan(context.Background(), &storage_v1.WriteSpanRequest{})
  require.Error(t, err)
  assert.Contains(t, err.Error(), "not implemented")
 

plugin/storage/badger/factory.go

@@ -189,6 +189,16 @@
  return badgerStore.NewSpanWriter(f.store, f.cache, f.Options.Primary.SpanStoreTTL), nil
 }
 
+// CreateSpanReader implements storage.Factory
+func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
+ return badgerStore.NewTraceReader(f.store, f.cache), nil
+}
+
+// CreateSpanWriter implements storage.Factory
+func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
+ return badgerStore.NewSpanWriter(f.store, f.cache, f.Options.Primary.SpanStoreTTL), nil
+}
+
 // CreateDependencyReader implements storage.Factory
 func (f *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
  sr, _ := f.CreateSpanReader() // err is always nil

plugin/storage/blackhole/factory.go

@@ -24,10 +24,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 {
@@ -59,12 +57,12 @@ func (f *Factory) CreateSpanWriter() (spanstore.Writer, error) {
  return f.store, nil
 }
 
-// CreateArchiveSpanReader implements storage.ArchiveFactory
+// CreateArchiveSpanReader implements storage.Factory
 func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
  return f.store, nil
 }
 
-// CreateArchiveSpanWriter implements storage.ArchiveFactory
+// CreateArchiveSpanWriter implements storage.Factory
 func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
  return f.store, nil
 }

plugin/storage/cassandra/factory.go

@@ -49,7 +49,6 @@ const (
 
 var ( // interface comformance checks
  _ storage.Factory = (*Factory)(nil)
- _ storage.ArchiveFactory = (*Factory)(nil)
  _ storage.SamplingStoreFactory = (*Factory)(nil)
  _ io.Closer = (*Factory)(nil)
  _ plugin.Configurable = (*Factory)(nil)
@@ -163,15 +162,15 @@ func (f *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
  return cDepStore.NewDependencyStore(f.primarySession, f.primaryMetricsFactory, f.logger, version)
 }
 
-// CreateArchiveSpanReader implements storage.ArchiveFactory
+// CreateArchiveSpanReader implements storage.Factory
 func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
  if f.archiveSession == nil {
  return nil, storage.ErrArchiveStorageNotConfigured
  }
  return cSpanStore.NewSpanReader(f.archiveSession, f.archiveMetricsFactory, f.logger, f.tracer.Tracer("cSpanStore.SpanReader")), nil
 }
 
-// CreateArchiveSpanWriter implements storage.ArchiveFactory
+// CreateArchiveSpanWriter implements storage.Factory
 func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
  if f.archiveSession == nil {
  return nil, storage.ErrArchiveStorageNotConfigured

plugin/storage/es/factory.go

@@ -51,10 +51,9 @@ const (
 )
 
 var ( // interface comformance checks
- _ storage.Factory = (*Factory)(nil)
- _ storage.ArchiveFactory = (*Factory)(nil)
- _ io.Closer = (*Factory)(nil)
- _ plugin.Configurable = (*Factory)(nil)
+ _ storage.Factory = (*Factory)(nil)
+ _ io.Closer = (*Factory)(nil)
+ _ plugin.Configurable = (*Factory)(nil)
 )
 
 // Factory implements storage.Factory for Elasticsearch backend.
@@ -203,15 +202,15 @@ func (f *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
  return createDependencyReader(f.getPrimaryClient, f.primaryConfig, f.logger)
 }
 
-// CreateArchiveSpanReader implements storage.ArchiveFactory
+// CreateArchiveSpanReader implements storage.Factory
 func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
  if !f.archiveConfig.Enabled {
  return nil, nil
  }
  return createSpanReader(f.getArchiveClient, f.archiveConfig, true, f.metricsFactory, f.logger, f.tracer)
 }
 
-// CreateArchiveSpanWriter implements storage.ArchiveFactory
+// CreateArchiveSpanWriter implements storage.Factory
 func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
  if !f.archiveConfig.Enabled {
  return nil, nil

plugin/storage/factory.go

@@ -84,10 +84,9 @@ func AllSamplingStorageTypes() []string {
 }
 
 var ( // interface comformance checks
- _ storage.Factory = (*Factory)(nil)
- _ storage.ArchiveFactory = (*Factory)(nil)
- _ io.Closer = (*Factory)(nil)
- _ plugin.Configurable = (*Factory)(nil)
+ _ storage.Factory = (*Factory)(nil)
+ _ io.Closer = (*Factory)(nil)
+ _ plugin.Configurable = (*Factory)(nil)
 )
 
 // Factory implements storage.Factory interface as a meta-factory for storage components.
@@ -293,30 +292,22 @@ func (f *Factory) initDownsamplingFromViper(v *viper.Viper) {
  f.FactoryConfig.DownsamplingHashSalt = v.GetString(downsamplingHashSalt)
 }
 
-// CreateArchiveSpanReader implements storage.ArchiveFactory
+// CreateArchiveSpanReader implements storage.Factory
 func (f *Factory) CreateArchiveSpanReader() (spanstore.Reader, error) {
  factory, ok := f.factories[f.SpanReaderType]
  if !ok {
  return nil, fmt.Errorf("no %s backend registered for span store", f.SpanReaderType)
  }
- archive, ok := factory.(storage.ArchiveFactory)
- if !ok {
- return nil, storage.ErrArchiveStorageNotSupported
- }
- return archive.CreateArchiveSpanReader()
+ return factory.CreateArchiveSpanReader()
 }
 
-// CreateArchiveSpanWriter implements storage.ArchiveFactory
+// CreateArchiveSpanWriter implements storage.Factory
 func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
  factory, ok := f.factories[f.SpanWriterTypes[0]]
  if !ok {
  return nil, fmt.Errorf("no %s backend registered for span store", f.SpanWriterTypes[0])
  }
- archive, ok := factory.(storage.ArchiveFactory)
- if !ok {
- return nil, storage.ErrArchiveStorageNotSupported
- }
- return archive.CreateArchiveSpanWriter()
+ return factory.CreateArchiveSpanWriter()
 }
 
 var _ io.Closer = (*Factory)(nil)

plugin/storage/factory_test.go

@@ -132,6 +132,8 @@ func TestCreate(t *testing.T) {
  mock.On("CreateSpanReader").Return(spanReader, errors.New("span-reader-error"))
  mock.On("CreateSpanWriter").Once().Return(spanWriter, errors.New("span-writer-error"))
  mock.On("CreateDependencyReader").Return(depReader, errors.New("dep-reader-error"))
+ mock.On("CreateArchiveSpanReader").Return(spanReader, errors.New("span-reader-error"))
+ mock.On("CreateArchiveSpanWriter").Once().Return(spanWriter, errors.New("span-writer-error"))
 
  r, err := f.CreateSpanReader()
  assert.Equal(t, spanReader, r)
@@ -146,10 +148,10 @@ func TestCreate(t *testing.T) {
  require.EqualError(t, err, "dep-reader-error")
 
  _, err = f.CreateArchiveSpanReader()
- require.EqualError(t, err, "archive storage not supported")
+ require.EqualError(t, err, "span-reader-error")
 
  _, err = f.CreateArchiveSpanWriter()
- require.EqualError(t, err, "archive storage not supported")
+ require.EqualError(t, err, "span-writer-error")
 
  mock.On("CreateSpanWriter").Return(spanWriter, nil)
  m := metrics.NullFactory
@@ -234,15 +236,14 @@ func TestCreateArchive(t *testing.T) {
 
  mock := &struct {
  mocks.Factory
- mocks.ArchiveFactory
  }{}
  f.factories[cassandraStorageType] = mock
 
  archiveSpanReader := new(spanStoreMocks.Reader)
  archiveSpanWriter := new(spanStoreMocks.Writer)
 
- mock.ArchiveFactory.On("CreateArchiveSpanReader").Return(archiveSpanReader, errors.New("archive-span-reader-error"))
- mock.ArchiveFactory.On("CreateArchiveSpanWriter").Return(archiveSpanWriter, errors.New("archive-span-writer-error"))
+ mock.Factory.On("CreateArchiveSpanReader").Return(archiveSpanReader, errors.New("archive-span-reader-error"))
+ mock.Factory.On("CreateArchiveSpanWriter").Return(archiveSpanWriter, errors.New("archive-span-writer-error"))
 
  ar, err := f.CreateArchiveSpanReader()
  assert.Equal(t, archiveSpanReader, ar)
@@ -451,6 +452,14 @@ func (e errorFactory) CreateSpanWriter() (spanstore.Writer, error) {
  panic("implement me")
 }
 
+func (e errorFactory) CreateArchiveSpanReader() (spanstore.Reader, error) {
+ panic("implement me")
+}
+
+func (e errorFactory) CreateArchiveSpanWriter() (spanstore.Writer, error) {
+ panic("implement me")
+}
+
 func (e errorFactory) CreateDependencyReader() (dependencystore.Reader, error) {
  panic("implement me")
 }