Repository: jaegertracing/jaeger

Issue:
Upgrade mockery to v3
### Requirement

Auto-upgrade failed https://github.com/jaegertracing/jaeger/pull/7007

### Problem

.

### Proposal

_No response_

### Open questions

_No response_

Hints from issue comments:
@yanurag-dev: Hi @yurishkuro, I would like to pick this.

Solution patch:
diff --git a/.github/workflows/ci-e2e-all.yml b/.github/workflows/ci-e2e-all.yml
index b3cb3e0a..49070431 100644
--- a/.github/workflows/ci-e2e-all.yml
+++ b/.github/workflows/ci-e2e-all.yml
@@ -37,3 +37,6 @@ jobs:
   opensearch:
     uses: ./.github/workflows/ci-e2e-opensearch.yml
 
+  query:
+    uses: ./.github/workflows/ci-e2e-query.yml
+
diff --git a/.github/workflows/ci-e2e-grpc.yml b/.github/workflows/ci-e2e-grpc.yml
index 5ba3fc82..4c135a88 100644
--- a/.github/workflows/ci-e2e-grpc.yml
+++ b/.github/workflows/ci-e2e-grpc.yml
@@ -37,7 +37,7 @@ jobs:
             SPAN_STORAGE_TYPE=memory make grpc-storage-integration-test
             ;;
           v2)
-            STORAGE=grpc SPAN_STORAGE_TYPE=memory make jaeger-v2-storage-integration-test
+            STORAGE=grpc make jaeger-v2-storage-integration-test
             ;;
         esac
 
diff --git a/.github/workflows/ci-e2e-query.yaml b/.github/workflows/ci-e2e-query.yml
similarity index 92%
rename from .github/workflows/ci-e2e-query.yaml
rename to .github/workflows/ci-e2e-query.yml
index 8c312a2c..91142cd6 100644
--- a/.github/workflows/ci-e2e-query.yaml
+++ b/.github/workflows/ci-e2e-query.yml
@@ -28,7 +28,7 @@ jobs:
 
     - name: Run Memory storage integration tests
       run: |
-        STORAGE=query SPAN_STORAGE_TYPE=memory make jaeger-v2-storage-integration-test
+        STORAGE=query make jaeger-v2-storage-integration-test
 
     - name: Upload coverage to codecov
       uses: ./.github/actions/upload-codecov
diff --git a/.mockery.yaml b/.mockery.yaml
index fc870cb5..d263a147 100644
--- a/.mockery.yaml
+++ b/.mockery.yaml
@@ -1,69 +1,57 @@
-with-expecter: true
-disable-version-string: true
-outpkg: "mocks"
-dir: "{{.InterfaceDir}}/mocks/"
-mockname: "{{.InterfaceName}}"
-filename: "{{.InterfaceName}}.go"
-boilerplate-file: .mockery.header.txt
-
-# Flags for future v3 compatibility.
-# See https://github.com/vektra/mockery/issues/848
-issue-845-fix: true
-resolve-type-alias: false
-
+dir: '{{.InterfaceDir}}/mocks/'
+structname: '{{.InterfaceName}}'
+pkgname: mocks
+template: testify
+filename: mocks.go
+template-data:
+  boilerplate-file: .mockery.header.txt
 packages:
   github.com/jaegertracing/jaeger/cmd/collector/app/sanitizer/cache:
     interfaces:
-      ServiceAliasMappingExternalSource:
-      ServiceAliasMappingStorage:
+      ServiceAliasMappingExternalSource: {}
+      ServiceAliasMappingStorage: {}
   github.com/jaegertracing/jaeger/cmd/ingester/app/consumer:
     interfaces:
-      Message:
+      Message: {}
   github.com/jaegertracing/jaeger/cmd/ingester/app/processor:
     interfaces:
-      SpanProcessor:
+      SpanProcessor: {}
   github.com/jaegertracing/jaeger/crossdock/services:
     interfaces:
-      CollectorService:
-      QueryService:
-  github.com/jaegertracing/jaeger/internal/storage/cassandra:
-    config:
-      unroll-variadic: false
-    interfaces:
-      Iterator:
-      Query:
-      Session:
+      CollectorService: {}
+      QueryService: {}
   github.com/jaegertracing/jaeger/internal/distributedlock:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/elasticsearch:
+  github.com/jaegertracing/jaeger/internal/leaderelection:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/elasticsearch/client:
+  github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/kafka/consumer:
+  github.com/jaegertracing/jaeger/internal/storage/cassandra:
+    config:
+      template-data:
+        unroll-variadic: false
     interfaces:
-      Consumer:
-  github.com/jaegertracing/jaeger/internal/leaderelection:
+      Iterator: {}
+      Query: {}
+      Session: {}
+  github.com/jaegertracing/jaeger/internal/storage/elasticsearch:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/v1/grpc/shared:
-    interfaces:
-      PluginCapabilities:
-  github.com/jaegertracing/jaeger/internal/storage/v1/kafka:
-    interfaces:
-      Marshaller:
-      Unmarshaller:
-  github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1:
+  github.com/jaegertracing/jaeger/internal/storage/elasticsearch/client:
     config:
       all: true
+  github.com/jaegertracing/jaeger/internal/storage/kafka/consumer:
+    interfaces:
+      Consumer: {}
   github.com/jaegertracing/jaeger/internal/storage/v1:
     config:
       all: true
   github.com/jaegertracing/jaeger/internal/storage/v1/api/dependencystore:
     interfaces:
-      Reader:
+      Reader: {}
   github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore:
     config:
       all: true
@@ -73,16 +61,23 @@ packages:
   github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore:
+  github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/dependencystore:
+    interfaces:
+      CoreDependencyStore: {}
+  github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/spanstore:
+    interfaces:
+      CoreSpanReader: {}
+      CoreSpanWriter: {}
+  github.com/jaegertracing/jaeger/internal/storage/v1/grpc/shared:
+    interfaces:
+      PluginCapabilities: {}
+  github.com/jaegertracing/jaeger/internal/storage/v1/kafka:
+    interfaces:
+      Marshaller: {}
+      Unmarshaller: {}
+  github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore:
+  github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore:
     config:
       all: true
-  github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/spanstore:
-    interfaces:
-      CoreSpanReader:
-      CoreSpanWriter:
-  github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/dependencystore:
-    interfaces:
-      CoreDependencyStore:
diff --git a/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingExternalSource.go b/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingExternalSource.go
deleted file mode 100644
index be785611..00000000
--- a/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingExternalSource.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// ServiceAliasMappingExternalSource is an autogenerated mock type for the ServiceAliasMappingExternalSource type
-type ServiceAliasMappingExternalSource struct {
-	mock.Mock
-}
-
-type ServiceAliasMappingExternalSource_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ServiceAliasMappingExternalSource) EXPECT() *ServiceAliasMappingExternalSource_Expecter {
-	return &ServiceAliasMappingExternalSource_Expecter{mock: &_m.Mock}
-}
-
-// Load provides a mock function with no fields
-func (_m *ServiceAliasMappingExternalSource) Load() (map[string]string, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Load")
-	}
-
-	var r0 map[string]string
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (map[string]string, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() map[string]string); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ServiceAliasMappingExternalSource_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
-type ServiceAliasMappingExternalSource_Load_Call struct {
-	*mock.Call
-}
-
-// Load is a helper method to define mock.On call
-func (_e *ServiceAliasMappingExternalSource_Expecter) Load() *ServiceAliasMappingExternalSource_Load_Call {
-	return &ServiceAliasMappingExternalSource_Load_Call{Call: _e.mock.On("Load")}
-}
-
-func (_c *ServiceAliasMappingExternalSource_Load_Call) Run(run func()) *ServiceAliasMappingExternalSource_Load_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ServiceAliasMappingExternalSource_Load_Call) Return(_a0 map[string]string, _a1 error) *ServiceAliasMappingExternalSource_Load_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ServiceAliasMappingExternalSource_Load_Call) RunAndReturn(run func() (map[string]string, error)) *ServiceAliasMappingExternalSource_Load_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewServiceAliasMappingExternalSource creates a new instance of ServiceAliasMappingExternalSource. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewServiceAliasMappingExternalSource(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ServiceAliasMappingExternalSource {
-	mock := &ServiceAliasMappingExternalSource{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingStorage.go b/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingStorage.go
deleted file mode 100644
index e02ceff4..00000000
--- a/cmd/collector/app/sanitizer/cache/mocks/ServiceAliasMappingStorage.go
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// ServiceAliasMappingStorage is an autogenerated mock type for the ServiceAliasMappingStorage type
-type ServiceAliasMappingStorage struct {
-	mock.Mock
-}
-
-type ServiceAliasMappingStorage_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ServiceAliasMappingStorage) EXPECT() *ServiceAliasMappingStorage_Expecter {
-	return &ServiceAliasMappingStorage_Expecter{mock: &_m.Mock}
-}
-
-// Load provides a mock function with no fields
-func (_m *ServiceAliasMappingStorage) Load() (map[string]string, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Load")
-	}
-
-	var r0 map[string]string
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (map[string]string, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() map[string]string); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ServiceAliasMappingStorage_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
-type ServiceAliasMappingStorage_Load_Call struct {
-	*mock.Call
-}
-
-// Load is a helper method to define mock.On call
-func (_e *ServiceAliasMappingStorage_Expecter) Load() *ServiceAliasMappingStorage_Load_Call {
-	return &ServiceAliasMappingStorage_Load_Call{Call: _e.mock.On("Load")}
-}
-
-func (_c *ServiceAliasMappingStorage_Load_Call) Run(run func()) *ServiceAliasMappingStorage_Load_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ServiceAliasMappingStorage_Load_Call) Return(_a0 map[string]string, _a1 error) *ServiceAliasMappingStorage_Load_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ServiceAliasMappingStorage_Load_Call) RunAndReturn(run func() (map[string]string, error)) *ServiceAliasMappingStorage_Load_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Save provides a mock function with given fields: data
-func (_m *ServiceAliasMappingStorage) Save(data map[string]string) error {
-	ret := _m.Called(data)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Save")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(map[string]string) error); ok {
-		r0 = rf(data)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ServiceAliasMappingStorage_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
-type ServiceAliasMappingStorage_Save_Call struct {
-	*mock.Call
-}
-
-// Save is a helper method to define mock.On call
-//   - data map[string]string
-func (_e *ServiceAliasMappingStorage_Expecter) Save(data interface{}) *ServiceAliasMappingStorage_Save_Call {
-	return &ServiceAliasMappingStorage_Save_Call{Call: _e.mock.On("Save", data)}
-}
-
-func (_c *ServiceAliasMappingStorage_Save_Call) Run(run func(data map[string]string)) *ServiceAliasMappingStorage_Save_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(map[string]string))
-	})
-	return _c
-}
-
-func (_c *ServiceAliasMappingStorage_Save_Call) Return(_a0 error) *ServiceAliasMappingStorage_Save_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ServiceAliasMappingStorage_Save_Call) RunAndReturn(run func(map[string]string) error) *ServiceAliasMappingStorage_Save_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewServiceAliasMappingStorage creates a new instance of ServiceAliasMappingStorage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewServiceAliasMappingStorage(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ServiceAliasMappingStorage {
-	mock := &ServiceAliasMappingStorage{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/cmd/collector/app/sanitizer/cache/mocks/mocks.go b/cmd/collector/app/sanitizer/cache/mocks/mocks.go
new file mode 100644
index 00000000..bd5f726c
--- /dev/null
+++ b/cmd/collector/app/sanitizer/cache/mocks/mocks.go
@@ -0,0 +1,222 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewServiceAliasMappingStorage creates a new instance of ServiceAliasMappingStorage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewServiceAliasMappingStorage(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ServiceAliasMappingStorage {
+	mock := &ServiceAliasMappingStorage{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ServiceAliasMappingStorage is an autogenerated mock type for the ServiceAliasMappingStorage type
+type ServiceAliasMappingStorage struct {
+	mock.Mock
+}
+
+type ServiceAliasMappingStorage_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ServiceAliasMappingStorage) EXPECT() *ServiceAliasMappingStorage_Expecter {
+	return &ServiceAliasMappingStorage_Expecter{mock: &_m.Mock}
+}
+
+// Load provides a mock function for the type ServiceAliasMappingStorage
+func (_mock *ServiceAliasMappingStorage) Load() (map[string]string, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Load")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (map[string]string, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ServiceAliasMappingStorage_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
+type ServiceAliasMappingStorage_Load_Call struct {
+	*mock.Call
+}
+
+// Load is a helper method to define mock.On call
+func (_e *ServiceAliasMappingStorage_Expecter) Load() *ServiceAliasMappingStorage_Load_Call {
+	return &ServiceAliasMappingStorage_Load_Call{Call: _e.mock.On("Load")}
+}
+
+func (_c *ServiceAliasMappingStorage_Load_Call) Run(run func()) *ServiceAliasMappingStorage_Load_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ServiceAliasMappingStorage_Load_Call) Return(stringToString map[string]string, err error) *ServiceAliasMappingStorage_Load_Call {
+	_c.Call.Return(stringToString, err)
+	return _c
+}
+
+func (_c *ServiceAliasMappingStorage_Load_Call) RunAndReturn(run func() (map[string]string, error)) *ServiceAliasMappingStorage_Load_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Save provides a mock function for the type ServiceAliasMappingStorage
+func (_mock *ServiceAliasMappingStorage) Save(data map[string]string) error {
+	ret := _mock.Called(data)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(map[string]string) error); ok {
+		r0 = returnFunc(data)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ServiceAliasMappingStorage_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
+type ServiceAliasMappingStorage_Save_Call struct {
+	*mock.Call
+}
+
+// Save is a helper method to define mock.On call
+//   - data
+func (_e *ServiceAliasMappingStorage_Expecter) Save(data interface{}) *ServiceAliasMappingStorage_Save_Call {
+	return &ServiceAliasMappingStorage_Save_Call{Call: _e.mock.On("Save", data)}
+}
+
+func (_c *ServiceAliasMappingStorage_Save_Call) Run(run func(data map[string]string)) *ServiceAliasMappingStorage_Save_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(map[string]string))
+	})
+	return _c
+}
+
+func (_c *ServiceAliasMappingStorage_Save_Call) Return(err error) *ServiceAliasMappingStorage_Save_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ServiceAliasMappingStorage_Save_Call) RunAndReturn(run func(data map[string]string) error) *ServiceAliasMappingStorage_Save_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewServiceAliasMappingExternalSource creates a new instance of ServiceAliasMappingExternalSource. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewServiceAliasMappingExternalSource(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ServiceAliasMappingExternalSource {
+	mock := &ServiceAliasMappingExternalSource{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ServiceAliasMappingExternalSource is an autogenerated mock type for the ServiceAliasMappingExternalSource type
+type ServiceAliasMappingExternalSource struct {
+	mock.Mock
+}
+
+type ServiceAliasMappingExternalSource_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ServiceAliasMappingExternalSource) EXPECT() *ServiceAliasMappingExternalSource_Expecter {
+	return &ServiceAliasMappingExternalSource_Expecter{mock: &_m.Mock}
+}
+
+// Load provides a mock function for the type ServiceAliasMappingExternalSource
+func (_mock *ServiceAliasMappingExternalSource) Load() (map[string]string, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Load")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (map[string]string, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ServiceAliasMappingExternalSource_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
+type ServiceAliasMappingExternalSource_Load_Call struct {
+	*mock.Call
+}
+
+// Load is a helper method to define mock.On call
+func (_e *ServiceAliasMappingExternalSource_Expecter) Load() *ServiceAliasMappingExternalSource_Load_Call {
+	return &ServiceAliasMappingExternalSource_Load_Call{Call: _e.mock.On("Load")}
+}
+
+func (_c *ServiceAliasMappingExternalSource_Load_Call) Run(run func()) *ServiceAliasMappingExternalSource_Load_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ServiceAliasMappingExternalSource_Load_Call) Return(stringToString map[string]string, err error) *ServiceAliasMappingExternalSource_Load_Call {
+	_c.Call.Return(stringToString, err)
+	return _c
+}
+
+func (_c *ServiceAliasMappingExternalSource_Load_Call) RunAndReturn(run func() (map[string]string, error)) *ServiceAliasMappingExternalSource_Load_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/cmd/ingester/app/consumer/mocks/Message.go b/cmd/ingester/app/consumer/mocks/mocks.go
similarity index 74%
rename from cmd/ingester/app/consumer/mocks/Message.go
rename to cmd/ingester/app/consumer/mocks/mocks.go
index 81ff5c94..3f45f2b2 100644
--- a/cmd/ingester/app/consumer/mocks/Message.go
+++ b/cmd/ingester/app/consumer/mocks/mocks.go
@@ -1,13 +1,30 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
-import mock "github.com/stretchr/testify/mock"
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMessage creates a new instance of Message. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMessage(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Message {
+	mock := &Message{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
 
 // Message is an autogenerated mock type for the Message type
 type Message struct {
@@ -22,23 +39,22 @@ func (_m *Message) EXPECT() *Message_Expecter {
 	return &Message_Expecter{mock: &_m.Mock}
 }
 
-// Key provides a mock function with no fields
-func (_m *Message) Key() []byte {
-	ret := _m.Called()
+// Key provides a mock function for the type Message
+func (_mock *Message) Key() []byte {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Key")
 	}
 
 	var r0 []byte
-	if rf, ok := ret.Get(0).(func() []byte); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
-
 	return r0
 }
 
@@ -59,8 +75,8 @@ func (_c *Message_Key_Call) Run(run func()) *Message_Key_Call {
 	return _c
 }
 
-func (_c *Message_Key_Call) Return(_a0 []byte) *Message_Key_Call {
-	_c.Call.Return(_a0)
+func (_c *Message_Key_Call) Return(bytes []byte) *Message_Key_Call {
+	_c.Call.Return(bytes)
 	return _c
 }
 
@@ -69,21 +85,20 @@ func (_c *Message_Key_Call) RunAndReturn(run func() []byte) *Message_Key_Call {
 	return _c
 }
 
-// Offset provides a mock function with no fields
-func (_m *Message) Offset() int64 {
-	ret := _m.Called()
+// Offset provides a mock function for the type Message
+func (_mock *Message) Offset() int64 {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Offset")
 	}
 
 	var r0 int64
-	if rf, ok := ret.Get(0).(func() int64); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() int64); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(int64)
 	}
-
 	return r0
 }
 
@@ -104,8 +119,8 @@ func (_c *Message_Offset_Call) Run(run func()) *Message_Offset_Call {
 	return _c
 }
 
-func (_c *Message_Offset_Call) Return(_a0 int64) *Message_Offset_Call {
-	_c.Call.Return(_a0)
+func (_c *Message_Offset_Call) Return(n int64) *Message_Offset_Call {
+	_c.Call.Return(n)
 	return _c
 }
 
@@ -114,21 +129,20 @@ func (_c *Message_Offset_Call) RunAndReturn(run func() int64) *Message_Offset_Ca
 	return _c
 }
 
-// Partition provides a mock function with no fields
-func (_m *Message) Partition() int32 {
-	ret := _m.Called()
+// Partition provides a mock function for the type Message
+func (_mock *Message) Partition() int32 {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Partition")
 	}
 
 	var r0 int32
-	if rf, ok := ret.Get(0).(func() int32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() int32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(int32)
 	}
-
 	return r0
 }
 
@@ -149,8 +163,8 @@ func (_c *Message_Partition_Call) Run(run func()) *Message_Partition_Call {
 	return _c
 }
 
-func (_c *Message_Partition_Call) Return(_a0 int32) *Message_Partition_Call {
-	_c.Call.Return(_a0)
+func (_c *Message_Partition_Call) Return(n int32) *Message_Partition_Call {
+	_c.Call.Return(n)
 	return _c
 }
 
@@ -159,21 +173,20 @@ func (_c *Message_Partition_Call) RunAndReturn(run func() int32) *Message_Partit
 	return _c
 }
 
-// Topic provides a mock function with no fields
-func (_m *Message) Topic() string {
-	ret := _m.Called()
+// Topic provides a mock function for the type Message
+func (_mock *Message) Topic() string {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Topic")
 	}
 
 	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
 	return r0
 }
 
@@ -194,8 +207,8 @@ func (_c *Message_Topic_Call) Run(run func()) *Message_Topic_Call {
 	return _c
 }
 
-func (_c *Message_Topic_Call) Return(_a0 string) *Message_Topic_Call {
-	_c.Call.Return(_a0)
+func (_c *Message_Topic_Call) Return(s string) *Message_Topic_Call {
+	_c.Call.Return(s)
 	return _c
 }
 
@@ -204,23 +217,22 @@ func (_c *Message_Topic_Call) RunAndReturn(run func() string) *Message_Topic_Cal
 	return _c
 }
 
-// Value provides a mock function with no fields
-func (_m *Message) Value() []byte {
-	ret := _m.Called()
+// Value provides a mock function for the type Message
+func (_mock *Message) Value() []byte {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Value")
 	}
 
 	var r0 []byte
-	if rf, ok := ret.Get(0).(func() []byte); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
-
 	return r0
 }
 
@@ -241,8 +253,8 @@ func (_c *Message_Value_Call) Run(run func()) *Message_Value_Call {
 	return _c
 }
 
-func (_c *Message_Value_Call) Return(_a0 []byte) *Message_Value_Call {
-	_c.Call.Return(_a0)
+func (_c *Message_Value_Call) Return(bytes []byte) *Message_Value_Call {
+	_c.Call.Return(bytes)
 	return _c
 }
 
@@ -250,17 +262,3 @@ func (_c *Message_Value_Call) RunAndReturn(run func() []byte) *Message_Value_Cal
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMessage creates a new instance of Message. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMessage(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Message {
-	mock := &Message{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/cmd/ingester/app/processor/mocks/SpanProcessor.go b/cmd/ingester/app/processor/mocks/mocks.go
similarity index 73%
rename from cmd/ingester/app/processor/mocks/SpanProcessor.go
rename to cmd/ingester/app/processor/mocks/mocks.go
index c3ba569e..af45a960 100644
--- a/cmd/ingester/app/processor/mocks/SpanProcessor.go
+++ b/cmd/ingester/app/processor/mocks/mocks.go
@@ -1,17 +1,32 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	processor "github.com/jaegertracing/jaeger/cmd/ingester/app/processor"
+	"github.com/jaegertracing/jaeger/cmd/ingester/app/processor"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewSpanProcessor creates a new instance of SpanProcessor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanProcessor(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanProcessor {
+	mock := &SpanProcessor{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // SpanProcessor is an autogenerated mock type for the SpanProcessor type
 type SpanProcessor struct {
 	mock.Mock
@@ -25,21 +40,20 @@ func (_m *SpanProcessor) EXPECT() *SpanProcessor_Expecter {
 	return &SpanProcessor_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *SpanProcessor) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type SpanProcessor
+func (_mock *SpanProcessor) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -60,8 +74,8 @@ func (_c *SpanProcessor_Close_Call) Run(run func()) *SpanProcessor_Close_Call {
 	return _c
 }
 
-func (_c *SpanProcessor_Close_Call) Return(_a0 error) *SpanProcessor_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *SpanProcessor_Close_Call) Return(err error) *SpanProcessor_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -70,21 +84,20 @@ func (_c *SpanProcessor_Close_Call) RunAndReturn(run func() error) *SpanProcesso
 	return _c
 }
 
-// Process provides a mock function with given fields: input
-func (_m *SpanProcessor) Process(input processor.Message) error {
-	ret := _m.Called(input)
+// Process provides a mock function for the type SpanProcessor
+func (_mock *SpanProcessor) Process(input processor.Message) error {
+	ret := _mock.Called(input)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Process")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(processor.Message) error); ok {
-		r0 = rf(input)
+	if returnFunc, ok := ret.Get(0).(func(processor.Message) error); ok {
+		r0 = returnFunc(input)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -94,7 +107,7 @@ type SpanProcessor_Process_Call struct {
 }
 
 // Process is a helper method to define mock.On call
-//   - input processor.Message
+//   - input
 func (_e *SpanProcessor_Expecter) Process(input interface{}) *SpanProcessor_Process_Call {
 	return &SpanProcessor_Process_Call{Call: _e.mock.On("Process", input)}
 }
@@ -106,26 +119,12 @@ func (_c *SpanProcessor_Process_Call) Run(run func(input processor.Message)) *Sp
 	return _c
 }
 
-func (_c *SpanProcessor_Process_Call) Return(_a0 error) *SpanProcessor_Process_Call {
-	_c.Call.Return(_a0)
+func (_c *SpanProcessor_Process_Call) Return(err error) *SpanProcessor_Process_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *SpanProcessor_Process_Call) RunAndReturn(run func(processor.Message) error) *SpanProcessor_Process_Call {
+func (_c *SpanProcessor_Process_Call) RunAndReturn(run func(input processor.Message) error) *SpanProcessor_Process_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewSpanProcessor creates a new instance of SpanProcessor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanProcessor(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanProcessor {
-	mock := &SpanProcessor{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/cmd/jaeger/config-query.yaml b/cmd/jaeger/config-query.yaml
index e997bdee..27d5a370 100644
--- a/cmd/jaeger/config-query.yaml
+++ b/cmd/jaeger/config-query.yaml
@@ -15,8 +15,7 @@ service:
             exporter:
               prometheus:
                 host: 0.0.0.0
-                # use different port to avoid conflict with collector on 8888
-                port: 8887
+                port: 8888
     logs:
       level: info
 
@@ -24,8 +23,6 @@ extensions:
   healthcheckv2:
     use_v2: true
     http:
-      # use different port to avoid conflict with collector on 13133
-      endpoint: 0.0.0.0:12133
 
   jaeger_query:
     storage:
diff --git a/cmd/jaeger/config-remote-storage-backend.yaml b/cmd/jaeger/config-remote-storage-backend.yaml
new file mode 100644
index 00000000..acbd3cb3
--- /dev/null
+++ b/cmd/jaeger/config-remote-storage-backend.yaml
@@ -0,0 +1,67 @@
+service:
+  extensions: [jaeger_storage, jaeger_query, remote_storage, remote_storage/archive, healthcheckv2]
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [jaeger_storage_exporter]
+  telemetry:
+    resource:
+      service.name: jaeger
+    metrics:
+      level: detailed
+      readers:
+        - pull:
+            exporter:
+              prometheus:
+                host: 0.0.0.0
+                port: 8887
+    logs:
+      level: debug
+    # TODO Initialize telemetry tracer once OTEL released new feature.
+    # https://github.com/open-telemetry/opentelemetry-collector/issues/10663
+
+extensions:
+  healthcheckv2:
+    use_v2: true
+    http:
+      # use different port to avoid conflict with collector on 13133
+      endpoint: 0.0.0.0:12133
+
+  jaeger_query:
+    storage:
+      traces: memory-storage
+      traces_archive: memory-storage-archive
+    ui:
+      config_file: ./cmd/jaeger/config-ui.json
+    grpc:
+      endpoint: "${env:JAEGER_QUERY_GRPC_ENDPOINT:-localhost:16685}"
+    http:
+      endpoint: "${env:JAEGER_QUERY_HTTP_ENDPOINT:-localhost:16686}"
+
+  jaeger_storage:
+    backends:
+      memory-storage:
+        memory:
+          max_traces: 100000
+      memory-storage-archive:
+        memory:
+          max_traces: 100000
+  remote_storage:
+    endpoint: localhost:17271
+    storage: memory-storage
+  remote_storage/archive:
+    endpoint: localhost:17272
+    storage: memory-storage-archive
+
+receivers:
+  otlp:
+    protocols:
+      grpc:
+
+processors:
+  batch:
+
+exporters:
+  jaeger_storage_exporter:
+    trace_storage: memory-storage
diff --git a/cmd/jaeger/config-remote-storage.yaml b/cmd/jaeger/config-remote-storage.yaml
index 6c247295..2974d972 100644
--- a/cmd/jaeger/config-remote-storage.yaml
+++ b/cmd/jaeger/config-remote-storage.yaml
@@ -32,10 +32,6 @@ extensions:
       traces_archive: another-storage
     ui:
       config_file: ./cmd/jaeger/config-ui.json
-    grpc:
-      endpoint: "${env:JAEGER_QUERY_GRPC_ENDPOINT:-localhost:16685}"
-    http:
-      endpoint: "${env:JAEGER_QUERY_HTTP_ENDPOINT:-localhost:16686}"
   jaeger_storage:
     backends:
       some-storage:
@@ -53,6 +49,8 @@ receivers:
   otlp:
     protocols:
       grpc:
+        # use different port to avoid conflict with remote storage backend on 4317
+        endpoint: 0.0.0.0:4316
       http:
 
 processors:
diff --git a/cmd/jaeger/internal/components.go b/cmd/jaeger/internal/components.go
index 5441fe91..c979b155 100644
--- a/cmd/jaeger/internal/components.go
+++ b/cmd/jaeger/internal/components.go
@@ -36,6 +36,7 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerquery"
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage"
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/remotesampling"
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/remotestorage"
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/integration/storagecleaner"
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/processors/adaptivesampling"
 )
@@ -69,9 +70,11 @@ func (b builders) build() (otelcol.Factories, error) {
 		// add-ons
 		jaegerquery.NewFactory(),
 		jaegerstorage.NewFactory(),
-		storagecleaner.NewFactory(),
 		remotesampling.NewFactory(),
 		expvar.NewFactory(),
+		// only for e2e testing
+		storagecleaner.NewFactory(),
+		remotestorage.NewFactory(),
 	)
 	if err != nil {
 		return otelcol.Factories{}, err
diff --git a/cmd/jaeger/internal/integration/README.md b/cmd/jaeger/internal/integration/README.md
index cf209117..a8ea3d14 100644
--- a/cmd/jaeger/internal/integration/README.md
+++ b/cmd/jaeger/internal/integration/README.md
@@ -120,5 +120,5 @@ All integration tests can be run locally.
 ### gRPC Integration Test
 
 ```shell
-STORAGE=grpc SPAN_STORAGE_TYPE=memory make jaeger-v2-storage-integration-test
+STORAGE=grpc jaeger-v2-storage-integration-test
 ```
diff --git a/cmd/remote-storage/app/flags.go b/cmd/remote-storage/app/flags.go
index c93d83bf..46ab597c 100644
--- a/cmd/remote-storage/app/flags.go
+++ b/cmd/remote-storage/app/flags.go
@@ -25,9 +25,9 @@ var tlsGRPCFlagsConfig = tlscfg.ServerFlagsConfig{
 
 // Options holds configuration for remote-storage service.
 type Options struct {
-	configgrpc.ServerConfig
+	configgrpc.ServerConfig `mapstructure:",squash"`
 	// Tenancy configuration
-	Tenancy tenancy.Options
+	Tenancy tenancy.Options `mapstructure:"multi_tenancy"`
 }
 
 // AddFlags adds flags to flag set.
diff --git a/cmd/remote-storage/app/server.go b/cmd/remote-storage/app/server.go
index f561388b..432a9c88 100644
--- a/cmd/remote-storage/app/server.go
+++ b/cmd/remote-storage/app/server.go
@@ -40,6 +40,7 @@ type Server struct {
 
 // NewServer creates and initializes Server.
 func NewServer(
+	ctx context.Context,
 	options *Options,
 	ts tracestore.Factory,
 	ds depstore.Factory,
@@ -66,7 +67,7 @@ func NewServer(
 
 	v2Handler := grpcstorage.NewHandler(reader, writer, depReader)
 
-	grpcServer, err := createGRPCServer(options, tm, handler, v2Handler, telset)
+	grpcServer, err := createGRPCServer(ctx, options, tm, handler, v2Handler, telset)
 	if err != nil {
 		return nil, err
 	}
@@ -95,6 +96,7 @@ func createGRPCHandler(
 }
 
 func createGRPCServer(
+	ctx context.Context,
 	opts *Options,
 	tm *tenancy.Manager,
 	handler *shared.GRPCHandler,
@@ -107,13 +109,14 @@ func createGRPCServer(
 	streamInterceptors := []grpc.StreamServerInterceptor{
 		bearertoken.NewStreamServerInterceptor(),
 	}
+	//nolint:contextcheck
 	if tm.Enabled {
 		unaryInterceptors = append(unaryInterceptors, tenancy.NewGuardingUnaryInterceptor(tm))
 		streamInterceptors = append(streamInterceptors, tenancy.NewGuardingStreamInterceptor(tm))
 	}
 
 	opts.NetAddr.Transport = confignet.TransportTypeTCP
-	server, err := opts.ToServer(context.Background(),
+	server, err := opts.ToServer(ctx,
 		telset.Host,
 		telset.ToOtelComponent(),
 		configgrpc.WithGrpcServerOption(grpc.ChainUnaryInterceptor(unaryInterceptors...)),
@@ -132,9 +135,9 @@ func createGRPCServer(
 }
 
 // Start gRPC server concurrently
-func (s *Server) Start() error {
+func (s *Server) Start(ctx context.Context) error {
 	var err error
-	s.grpcConn, err = s.opts.NetAddr.Listen(context.Background())
+	s.grpcConn, err = s.opts.NetAddr.Listen(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to listen on gRPC port: %w", err)
 	}
@@ -158,3 +161,7 @@ func (s *Server) Close() error {
 	s.telset.ReportStatus(componentstatus.NewEvent(componentstatus.StatusStopped))
 	return nil
 }
+
+func (s *Server) GRPCAddr() string {
+	return s.grpcConn.Addr().String()
+}
diff --git a/cmd/remote-storage/main.go b/cmd/remote-storage/main.go
index aaf61cd5..7cd09631 100644
--- a/cmd/remote-storage/main.go
+++ b/cmd/remote-storage/main.go
@@ -4,6 +4,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"os"
@@ -83,12 +84,12 @@ func main() {
 
 			traceFactory := v1adapter.NewFactory(storageFactory)
 			depFactory := traceFactory.(depstore.Factory)
-			server, err := app.NewServer(opts, v1adapter.NewFactory(storageFactory), depFactory, tm, telset)
+			server, err := app.NewServer(context.Background(), opts, v1adapter.NewFactory(storageFactory), depFactory, tm, telset)
 			if err != nil {
 				logger.Fatal("Failed to create server", zap.Error(err))
 			}
 
-			if err := server.Start(); err != nil {
+			if err := server.Start(context.Background()); err != nil {
 				logger.Fatal("Could not start servers", zap.Error(err))
 			}
 
diff --git a/crossdock/services/mocks/CollectorService.go b/crossdock/services/mocks/CollectorService.go
deleted file mode 100644
index e183bc10..00000000
--- a/crossdock/services/mocks/CollectorService.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// CollectorService is an autogenerated mock type for the CollectorService type
-type CollectorService struct {
-	mock.Mock
-}
-
-type CollectorService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *CollectorService) EXPECT() *CollectorService_Expecter {
-	return &CollectorService_Expecter{mock: &_m.Mock}
-}
-
-// GetSamplingRate provides a mock function with given fields: service, operation
-func (_m *CollectorService) GetSamplingRate(service string, operation string) (float64, error) {
-	ret := _m.Called(service, operation)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetSamplingRate")
-	}
-
-	var r0 float64
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string, string) (float64, error)); ok {
-		return rf(service, operation)
-	}
-	if rf, ok := ret.Get(0).(func(string, string) float64); ok {
-		r0 = rf(service, operation)
-	} else {
-		r0 = ret.Get(0).(float64)
-	}
-
-	if rf, ok := ret.Get(1).(func(string, string) error); ok {
-		r1 = rf(service, operation)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CollectorService_GetSamplingRate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSamplingRate'
-type CollectorService_GetSamplingRate_Call struct {
-	*mock.Call
-}
-
-// GetSamplingRate is a helper method to define mock.On call
-//   - service string
-//   - operation string
-func (_e *CollectorService_Expecter) GetSamplingRate(service interface{}, operation interface{}) *CollectorService_GetSamplingRate_Call {
-	return &CollectorService_GetSamplingRate_Call{Call: _e.mock.On("GetSamplingRate", service, operation)}
-}
-
-func (_c *CollectorService_GetSamplingRate_Call) Run(run func(service string, operation string)) *CollectorService_GetSamplingRate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string))
-	})
-	return _c
-}
-
-func (_c *CollectorService_GetSamplingRate_Call) Return(_a0 float64, _a1 error) *CollectorService_GetSamplingRate_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CollectorService_GetSamplingRate_Call) RunAndReturn(run func(string, string) (float64, error)) *CollectorService_GetSamplingRate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewCollectorService creates a new instance of CollectorService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewCollectorService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *CollectorService {
-	mock := &CollectorService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/crossdock/services/mocks/QueryService.go b/crossdock/services/mocks/QueryService.go
deleted file mode 100644
index 81fce056..00000000
--- a/crossdock/services/mocks/QueryService.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-
-	uimodel "github.com/jaegertracing/jaeger/internal/uimodel"
-)
-
-// QueryService is an autogenerated mock type for the QueryService type
-type QueryService struct {
-	mock.Mock
-}
-
-type QueryService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *QueryService) EXPECT() *QueryService_Expecter {
-	return &QueryService_Expecter{mock: &_m.Mock}
-}
-
-// GetTraces provides a mock function with given fields: serviceName, operation, tags
-func (_m *QueryService) GetTraces(serviceName string, operation string, tags map[string]string) ([]*uimodel.Trace, error) {
-	ret := _m.Called(serviceName, operation, tags)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTraces")
-	}
-
-	var r0 []*uimodel.Trace
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string, string, map[string]string) ([]*uimodel.Trace, error)); ok {
-		return rf(serviceName, operation, tags)
-	}
-	if rf, ok := ret.Get(0).(func(string, string, map[string]string) []*uimodel.Trace); ok {
-		r0 = rf(serviceName, operation, tags)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*uimodel.Trace)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(string, string, map[string]string) error); ok {
-		r1 = rf(serviceName, operation, tags)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// QueryService_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
-type QueryService_GetTraces_Call struct {
-	*mock.Call
-}
-
-// GetTraces is a helper method to define mock.On call
-//   - serviceName string
-//   - operation string
-//   - tags map[string]string
-func (_e *QueryService_Expecter) GetTraces(serviceName interface{}, operation interface{}, tags interface{}) *QueryService_GetTraces_Call {
-	return &QueryService_GetTraces_Call{Call: _e.mock.On("GetTraces", serviceName, operation, tags)}
-}
-
-func (_c *QueryService_GetTraces_Call) Run(run func(serviceName string, operation string, tags map[string]string)) *QueryService_GetTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string), args[2].(map[string]string))
-	})
-	return _c
-}
-
-func (_c *QueryService_GetTraces_Call) Return(_a0 []*uimodel.Trace, _a1 error) *QueryService_GetTraces_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *QueryService_GetTraces_Call) RunAndReturn(run func(string, string, map[string]string) ([]*uimodel.Trace, error)) *QueryService_GetTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewQueryService creates a new instance of QueryService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewQueryService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *QueryService {
-	mock := &QueryService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/crossdock/services/mocks/mocks.go b/crossdock/services/mocks/mocks.go
new file mode 100644
index 00000000..b137ed53
--- /dev/null
+++ b/crossdock/services/mocks/mocks.go
@@ -0,0 +1,181 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"github.com/jaegertracing/jaeger/internal/uimodel"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewCollectorService creates a new instance of CollectorService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCollectorService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CollectorService {
+	mock := &CollectorService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// CollectorService is an autogenerated mock type for the CollectorService type
+type CollectorService struct {
+	mock.Mock
+}
+
+type CollectorService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *CollectorService) EXPECT() *CollectorService_Expecter {
+	return &CollectorService_Expecter{mock: &_m.Mock}
+}
+
+// GetSamplingRate provides a mock function for the type CollectorService
+func (_mock *CollectorService) GetSamplingRate(service string, operation string) (float64, error) {
+	ret := _mock.Called(service, operation)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSamplingRate")
+	}
+
+	var r0 float64
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string, string) (float64, error)); ok {
+		return returnFunc(service, operation)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string, string) float64); ok {
+		r0 = returnFunc(service, operation)
+	} else {
+		r0 = ret.Get(0).(float64)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = returnFunc(service, operation)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CollectorService_GetSamplingRate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSamplingRate'
+type CollectorService_GetSamplingRate_Call struct {
+	*mock.Call
+}
+
+// GetSamplingRate is a helper method to define mock.On call
+//   - service
+//   - operation
+func (_e *CollectorService_Expecter) GetSamplingRate(service interface{}, operation interface{}) *CollectorService_GetSamplingRate_Call {
+	return &CollectorService_GetSamplingRate_Call{Call: _e.mock.On("GetSamplingRate", service, operation)}
+}
+
+func (_c *CollectorService_GetSamplingRate_Call) Run(run func(service string, operation string)) *CollectorService_GetSamplingRate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *CollectorService_GetSamplingRate_Call) Return(f float64, err error) *CollectorService_GetSamplingRate_Call {
+	_c.Call.Return(f, err)
+	return _c
+}
+
+func (_c *CollectorService_GetSamplingRate_Call) RunAndReturn(run func(service string, operation string) (float64, error)) *CollectorService_GetSamplingRate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewQueryService creates a new instance of QueryService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewQueryService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *QueryService {
+	mock := &QueryService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// QueryService is an autogenerated mock type for the QueryService type
+type QueryService struct {
+	mock.Mock
+}
+
+type QueryService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *QueryService) EXPECT() *QueryService_Expecter {
+	return &QueryService_Expecter{mock: &_m.Mock}
+}
+
+// GetTraces provides a mock function for the type QueryService
+func (_mock *QueryService) GetTraces(serviceName string, operation string, tags map[string]string) ([]*uimodel.Trace, error) {
+	ret := _mock.Called(serviceName, operation, tags)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTraces")
+	}
+
+	var r0 []*uimodel.Trace
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string, string, map[string]string) ([]*uimodel.Trace, error)); ok {
+		return returnFunc(serviceName, operation, tags)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string, string, map[string]string) []*uimodel.Trace); ok {
+		r0 = returnFunc(serviceName, operation, tags)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*uimodel.Trace)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string, string, map[string]string) error); ok {
+		r1 = returnFunc(serviceName, operation, tags)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// QueryService_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
+type QueryService_GetTraces_Call struct {
+	*mock.Call
+}
+
+// GetTraces is a helper method to define mock.On call
+//   - serviceName
+//   - operation
+//   - tags
+func (_e *QueryService_Expecter) GetTraces(serviceName interface{}, operation interface{}, tags interface{}) *QueryService_GetTraces_Call {
+	return &QueryService_GetTraces_Call{Call: _e.mock.On("GetTraces", serviceName, operation, tags)}
+}
+
+func (_c *QueryService_GetTraces_Call) Run(run func(serviceName string, operation string, tags map[string]string)) *QueryService_GetTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(map[string]string))
+	})
+	return _c
+}
+
+func (_c *QueryService_GetTraces_Call) Return(traces []*uimodel.Trace, err error) *QueryService_GetTraces_Call {
+	_c.Call.Return(traces, err)
+	return _c
+}
+
+func (_c *QueryService_GetTraces_Call) RunAndReturn(run func(serviceName string, operation string, tags map[string]string) ([]*uimodel.Trace, error)) *QueryService_GetTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/distributedlock/mocks/Lock.go b/internal/distributedlock/mocks/mocks.go
similarity index 67%
rename from internal/distributedlock/mocks/Lock.go
rename to internal/distributedlock/mocks/mocks.go
index 30deb88b..3518c89c 100644
--- a/internal/distributedlock/mocks/Lock.go
+++ b/internal/distributedlock/mocks/mocks.go
@@ -1,18 +1,33 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	time "time"
+	"time"
 
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewLock creates a new instance of Lock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewLock(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Lock {
+	mock := &Lock{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // Lock is an autogenerated mock type for the Lock type
 type Lock struct {
 	mock.Mock
@@ -26,9 +41,9 @@ func (_m *Lock) EXPECT() *Lock_Expecter {
 	return &Lock_Expecter{mock: &_m.Mock}
 }
 
-// Acquire provides a mock function with given fields: resource, ttl
-func (_m *Lock) Acquire(resource string, ttl time.Duration) (bool, error) {
-	ret := _m.Called(resource, ttl)
+// Acquire provides a mock function for the type Lock
+func (_mock *Lock) Acquire(resource string, ttl time.Duration) (bool, error) {
+	ret := _mock.Called(resource, ttl)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Acquire")
@@ -36,21 +51,19 @@ func (_m *Lock) Acquire(resource string, ttl time.Duration) (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string, time.Duration) (bool, error)); ok {
-		return rf(resource, ttl)
+	if returnFunc, ok := ret.Get(0).(func(string, time.Duration) (bool, error)); ok {
+		return returnFunc(resource, ttl)
 	}
-	if rf, ok := ret.Get(0).(func(string, time.Duration) bool); ok {
-		r0 = rf(resource, ttl)
+	if returnFunc, ok := ret.Get(0).(func(string, time.Duration) bool); ok {
+		r0 = returnFunc(resource, ttl)
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func(string, time.Duration) error); ok {
-		r1 = rf(resource, ttl)
+	if returnFunc, ok := ret.Get(1).(func(string, time.Duration) error); ok {
+		r1 = returnFunc(resource, ttl)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -60,8 +73,8 @@ type Lock_Acquire_Call struct {
 }
 
 // Acquire is a helper method to define mock.On call
-//   - resource string
-//   - ttl time.Duration
+//   - resource
+//   - ttl
 func (_e *Lock_Expecter) Acquire(resource interface{}, ttl interface{}) *Lock_Acquire_Call {
 	return &Lock_Acquire_Call{Call: _e.mock.On("Acquire", resource, ttl)}
 }
@@ -78,14 +91,14 @@ func (_c *Lock_Acquire_Call) Return(acquired bool, err error) *Lock_Acquire_Call
 	return _c
 }
 
-func (_c *Lock_Acquire_Call) RunAndReturn(run func(string, time.Duration) (bool, error)) *Lock_Acquire_Call {
+func (_c *Lock_Acquire_Call) RunAndReturn(run func(resource string, ttl time.Duration) (bool, error)) *Lock_Acquire_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Forfeit provides a mock function with given fields: resource
-func (_m *Lock) Forfeit(resource string) (bool, error) {
-	ret := _m.Called(resource)
+// Forfeit provides a mock function for the type Lock
+func (_mock *Lock) Forfeit(resource string) (bool, error) {
+	ret := _mock.Called(resource)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Forfeit")
@@ -93,21 +106,19 @@ func (_m *Lock) Forfeit(resource string) (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
-		return rf(resource)
+	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return returnFunc(resource)
 	}
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(resource)
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(resource)
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(resource)
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(resource)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -117,7 +128,7 @@ type Lock_Forfeit_Call struct {
 }
 
 // Forfeit is a helper method to define mock.On call
-//   - resource string
+//   - resource
 func (_e *Lock_Expecter) Forfeit(resource interface{}) *Lock_Forfeit_Call {
 	return &Lock_Forfeit_Call{Call: _e.mock.On("Forfeit", resource)}
 }
@@ -134,21 +145,7 @@ func (_c *Lock_Forfeit_Call) Return(forfeited bool, err error) *Lock_Forfeit_Cal
 	return _c
 }
 
-func (_c *Lock_Forfeit_Call) RunAndReturn(run func(string) (bool, error)) *Lock_Forfeit_Call {
+func (_c *Lock_Forfeit_Call) RunAndReturn(run func(resource string) (bool, error)) *Lock_Forfeit_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewLock creates a new instance of Lock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewLock(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Lock {
-	mock := &Lock{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/leaderelection/mocks/ElectionParticipant.go b/internal/leaderelection/mocks/mocks.go
similarity index 76%
rename from internal/leaderelection/mocks/ElectionParticipant.go
rename to internal/leaderelection/mocks/mocks.go
index e1910c91..9e139701 100644
--- a/internal/leaderelection/mocks/ElectionParticipant.go
+++ b/internal/leaderelection/mocks/mocks.go
@@ -1,13 +1,30 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
-import mock "github.com/stretchr/testify/mock"
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewElectionParticipant creates a new instance of ElectionParticipant. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewElectionParticipant(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ElectionParticipant {
+	mock := &ElectionParticipant{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
 
 // ElectionParticipant is an autogenerated mock type for the ElectionParticipant type
 type ElectionParticipant struct {
@@ -22,21 +39,20 @@ func (_m *ElectionParticipant) EXPECT() *ElectionParticipant_Expecter {
 	return &ElectionParticipant_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *ElectionParticipant) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type ElectionParticipant
+func (_mock *ElectionParticipant) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -57,8 +73,8 @@ func (_c *ElectionParticipant_Close_Call) Run(run func()) *ElectionParticipant_C
 	return _c
 }
 
-func (_c *ElectionParticipant_Close_Call) Return(_a0 error) *ElectionParticipant_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *ElectionParticipant_Close_Call) Return(err error) *ElectionParticipant_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -67,21 +83,20 @@ func (_c *ElectionParticipant_Close_Call) RunAndReturn(run func() error) *Electi
 	return _c
 }
 
-// IsLeader provides a mock function with no fields
-func (_m *ElectionParticipant) IsLeader() bool {
-	ret := _m.Called()
+// IsLeader provides a mock function for the type ElectionParticipant
+func (_mock *ElectionParticipant) IsLeader() bool {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for IsLeader")
 	}
 
 	var r0 bool
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
 	return r0
 }
 
@@ -102,8 +117,8 @@ func (_c *ElectionParticipant_IsLeader_Call) Run(run func()) *ElectionParticipan
 	return _c
 }
 
-func (_c *ElectionParticipant_IsLeader_Call) Return(_a0 bool) *ElectionParticipant_IsLeader_Call {
-	_c.Call.Return(_a0)
+func (_c *ElectionParticipant_IsLeader_Call) Return(b bool) *ElectionParticipant_IsLeader_Call {
+	_c.Call.Return(b)
 	return _c
 }
 
@@ -112,21 +127,20 @@ func (_c *ElectionParticipant_IsLeader_Call) RunAndReturn(run func() bool) *Elec
 	return _c
 }
 
-// Start provides a mock function with no fields
-func (_m *ElectionParticipant) Start() error {
-	ret := _m.Called()
+// Start provides a mock function for the type ElectionParticipant
+func (_mock *ElectionParticipant) Start() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Start")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -147,8 +161,8 @@ func (_c *ElectionParticipant_Start_Call) Run(run func()) *ElectionParticipant_S
 	return _c
 }
 
-func (_c *ElectionParticipant_Start_Call) Return(_a0 error) *ElectionParticipant_Start_Call {
-	_c.Call.Return(_a0)
+func (_c *ElectionParticipant_Start_Call) Return(err error) *ElectionParticipant_Start_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -156,17 +170,3 @@ func (_c *ElectionParticipant_Start_Call) RunAndReturn(run func() error) *Electi
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewElectionParticipant creates a new instance of ElectionParticipant. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewElectionParticipant(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ElectionParticipant {
-	mock := &ElectionParticipant{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginClient.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginClient.go
deleted file mode 100644
index 43f2e643..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginClient.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// ArchiveSpanReaderPluginClient is an autogenerated mock type for the ArchiveSpanReaderPluginClient type
-type ArchiveSpanReaderPluginClient struct {
-	mock.Mock
-}
-
-type ArchiveSpanReaderPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanReaderPluginClient) EXPECT() *ArchiveSpanReaderPluginClient_Expecter {
-	return &ArchiveSpanReaderPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// GetArchiveTrace provides a mock function with given fields: ctx, in, opts
-func (_m *ArchiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetArchiveTrace")
-	}
-
-	var r0 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ArchiveSpanReaderPluginClient_GetArchiveTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArchiveTrace'
-type ArchiveSpanReaderPluginClient_GetArchiveTrace_Call struct {
-	*mock.Call
-}
-
-// GetArchiveTrace is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.GetTraceRequest
-//   - opts ...grpc.CallOption
-func (_e *ArchiveSpanReaderPluginClient_Expecter) GetArchiveTrace(ctx interface{}, in interface{}, opts ...interface{}) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
-	return &ArchiveSpanReaderPluginClient_GetArchiveTrace_Call{Call: _e.mock.On("GetArchiveTrace",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) Run(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption)) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.GetTraceRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) Return(_a0 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, _a1 error) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) RunAndReturn(run func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error)) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveSpanReaderPluginClient creates a new instance of ArchiveSpanReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanReaderPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanReaderPluginClient {
-	mock := &ArchiveSpanReaderPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginServer.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginServer.go
deleted file mode 100644
index 6f980c87..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPluginServer.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// ArchiveSpanReaderPluginServer is an autogenerated mock type for the ArchiveSpanReaderPluginServer type
-type ArchiveSpanReaderPluginServer struct {
-	mock.Mock
-}
-
-type ArchiveSpanReaderPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanReaderPluginServer) EXPECT() *ArchiveSpanReaderPluginServer_Expecter {
-	return &ArchiveSpanReaderPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// GetArchiveTrace provides a mock function with given fields: _a0, _a1
-func (_m *ArchiveSpanReaderPluginServer) GetArchiveTrace(_a0 *storage_v1.GetTraceRequest, _a1 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetArchiveTrace")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.GetTraceRequest, storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPluginServer_GetArchiveTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArchiveTrace'
-type ArchiveSpanReaderPluginServer_GetArchiveTrace_Call struct {
-	*mock.Call
-}
-
-// GetArchiveTrace is a helper method to define mock.On call
-//   - _a0 *storage_v1.GetTraceRequest
-//   - _a1 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer
-func (_e *ArchiveSpanReaderPluginServer_Expecter) GetArchiveTrace(_a0 interface{}, _a1 interface{}) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
-	return &ArchiveSpanReaderPluginServer_GetArchiveTrace_Call{Call: _e.mock.On("GetArchiveTrace", _a0, _a1)}
-}
-
-func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) Run(run func(_a0 *storage_v1.GetTraceRequest, _a1 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer)) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.GetTraceRequest), args[1].(storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) Return(_a0 error) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) RunAndReturn(run func(*storage_v1.GetTraceRequest, storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveSpanReaderPluginServer creates a new instance of ArchiveSpanReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanReaderPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanReaderPluginServer {
-	mock := &ArchiveSpanReaderPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceClient.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceClient.go
deleted file mode 100644
index 4e452c39..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceClient.go
+++ /dev/null
@@ -1,389 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient is an autogenerated mock type for the ArchiveSpanReaderPlugin_GetArchiveTraceClient type
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient struct {
-	mock.Mock
-}
-
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) EXPECT() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter{mock: &_m.Mock}
-}
-
-// CloseSend provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call struct {
-	*mock.Call
-}
-
-// CloseSend is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) CloseSend() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) RunAndReturn(run func() error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Context provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Context() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) Return(_a0 context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) RunAndReturn(run func() context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Header provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call struct {
-	*mock.Call
-}
-
-// Header is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Header() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call{Call: _e.mock.On("Header")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Recv provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Recv() (*storage_v1.SpansResponseChunk, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Recv")
-	}
-
-	var r0 *storage_v1.SpansResponseChunk
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call struct {
-	*mock.Call
-}
-
-// Recv is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Recv() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call{Call: _e.mock.On("Recv")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) Return(_a0 *storage_v1.SpansResponseChunk, _a1 error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) RecvMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) RunAndReturn(run func(any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) SendMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) RunAndReturn(run func(any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Trailer provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
-type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call struct {
-	*mock.Call
-}
-
-// Trailer is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Trailer() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call{Call: _e.mock.On("Trailer")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) Return(_a0 metadata.MD) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveSpanReaderPlugin_GetArchiveTraceClient creates a new instance of ArchiveSpanReaderPlugin_GetArchiveTraceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanReaderPlugin_GetArchiveTraceClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient {
-	mock := &ArchiveSpanReaderPlugin_GetArchiveTraceClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceServer.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceServer.go
deleted file mode 100644
index 3abf7704..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanReaderPlugin_GetArchiveTraceServer.go
+++ /dev/null
@@ -1,354 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer is an autogenerated mock type for the ArchiveSpanReaderPlugin_GetArchiveTraceServer type
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer struct {
-	mock.Mock
-}
-
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) EXPECT() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter{mock: &_m.Mock}
-}
-
-// Context provides a mock function with no fields
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) Context() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) Return(_a0 context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) RunAndReturn(run func() context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) RecvMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) RunAndReturn(run func(any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) Send(_a0 *storage_v1.SpansResponseChunk) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call struct {
-	*mock.Call
-}
-
-// Send is a helper method to define mock.On call
-//   - _a0 *storage_v1.SpansResponseChunk
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) Send(_a0 interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call{Call: _e.mock.On("Send", _a0)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) Run(run func(_a0 *storage_v1.SpansResponseChunk)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.SpansResponseChunk))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) RunAndReturn(run func(*storage_v1.SpansResponseChunk) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendHeader provides a mock function with given fields: _a0
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SendHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call struct {
-	*mock.Call
-}
-
-// SendHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SendHeader(_a0 interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SendMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) RunAndReturn(run func(any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetHeader provides a mock function with given fields: _a0
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SetHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SetHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call struct {
-	*mock.Call
-}
-
-// SetHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SetHeader(_a0 interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) Return(_a0 error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetTrailer provides a mock function with given fields: _a0
-func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SetTrailer(_a0 metadata.MD) {
-	_m.Called(_a0)
-}
-
-// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
-type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call struct {
-	*mock.Call
-}
-
-// SetTrailer is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SetTrailer(_a0 interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
-	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)}
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) Return() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewArchiveSpanReaderPlugin_GetArchiveTraceServer creates a new instance of ArchiveSpanReaderPlugin_GetArchiveTraceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanReaderPlugin_GetArchiveTraceServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer {
-	mock := &ArchiveSpanReaderPlugin_GetArchiveTraceServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginClient.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginClient.go
deleted file mode 100644
index 139a1837..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginClient.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// ArchiveSpanWriterPluginClient is an autogenerated mock type for the ArchiveSpanWriterPluginClient type
-type ArchiveSpanWriterPluginClient struct {
-	mock.Mock
-}
-
-type ArchiveSpanWriterPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanWriterPluginClient) EXPECT() *ArchiveSpanWriterPluginClient_Expecter {
-	return &ArchiveSpanWriterPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// WriteArchiveSpan provides a mock function with given fields: ctx, in, opts
-func (_m *ArchiveSpanWriterPluginClient) WriteArchiveSpan(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteArchiveSpan")
-	}
-
-	var r0 *storage_v1.WriteSpanResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) *storage_v1.WriteSpanResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteArchiveSpan'
-type ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call struct {
-	*mock.Call
-}
-
-// WriteArchiveSpan is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.WriteSpanRequest
-//   - opts ...grpc.CallOption
-func (_e *ArchiveSpanWriterPluginClient_Expecter) WriteArchiveSpan(ctx interface{}, in interface{}, opts ...interface{}) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
-	return &ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call{Call: _e.mock.On("WriteArchiveSpan",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) Run(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption)) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) Return(_a0 *storage_v1.WriteSpanResponse, _a1 error) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) RunAndReturn(run func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveSpanWriterPluginClient creates a new instance of ArchiveSpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanWriterPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanWriterPluginClient {
-	mock := &ArchiveSpanWriterPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginServer.go b/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginServer.go
deleted file mode 100644
index 02900103..00000000
--- a/internal/proto-gen/storage_v1/mocks/ArchiveSpanWriterPluginServer.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// ArchiveSpanWriterPluginServer is an autogenerated mock type for the ArchiveSpanWriterPluginServer type
-type ArchiveSpanWriterPluginServer struct {
-	mock.Mock
-}
-
-type ArchiveSpanWriterPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveSpanWriterPluginServer) EXPECT() *ArchiveSpanWriterPluginServer_Expecter {
-	return &ArchiveSpanWriterPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// WriteArchiveSpan provides a mock function with given fields: _a0, _a1
-func (_m *ArchiveSpanWriterPluginServer) WriteArchiveSpan(_a0 context.Context, _a1 *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteArchiveSpan")
-	}
-
-	var r0 *storage_v1.WriteSpanResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) *storage_v1.WriteSpanResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteArchiveSpan'
-type ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call struct {
-	*mock.Call
-}
-
-// WriteArchiveSpan is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.WriteSpanRequest
-func (_e *ArchiveSpanWriterPluginServer_Expecter) WriteArchiveSpan(_a0 interface{}, _a1 interface{}) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
-	return &ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call{Call: _e.mock.On("WriteArchiveSpan", _a0, _a1)}
-}
-
-func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.WriteSpanRequest)) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest))
-	})
-	return _c
-}
-
-func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) Return(_a0 *storage_v1.WriteSpanResponse, _a1 error) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) RunAndReturn(run func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveSpanWriterPluginServer creates a new instance of ArchiveSpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveSpanWriterPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveSpanWriterPluginServer {
-	mock := &ArchiveSpanWriterPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginClient.go b/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginClient.go
deleted file mode 100644
index 52ef3e01..00000000
--- a/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginClient.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// DependenciesReaderPluginClient is an autogenerated mock type for the DependenciesReaderPluginClient type
-type DependenciesReaderPluginClient struct {
-	mock.Mock
-}
-
-type DependenciesReaderPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *DependenciesReaderPluginClient) EXPECT() *DependenciesReaderPluginClient_Expecter {
-	return &DependenciesReaderPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// GetDependencies provides a mock function with given fields: ctx, in, opts
-func (_m *DependenciesReaderPluginClient) GetDependencies(ctx context.Context, in *storage_v1.GetDependenciesRequest, opts ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetDependencies")
-	}
-
-	var r0 *storage_v1.GetDependenciesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) *storage_v1.GetDependenciesResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetDependenciesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DependenciesReaderPluginClient_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
-type DependenciesReaderPluginClient_GetDependencies_Call struct {
-	*mock.Call
-}
-
-// GetDependencies is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.GetDependenciesRequest
-//   - opts ...grpc.CallOption
-func (_e *DependenciesReaderPluginClient_Expecter) GetDependencies(ctx interface{}, in interface{}, opts ...interface{}) *DependenciesReaderPluginClient_GetDependencies_Call {
-	return &DependenciesReaderPluginClient_GetDependencies_Call{Call: _e.mock.On("GetDependencies",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *DependenciesReaderPluginClient_GetDependencies_Call) Run(run func(ctx context.Context, in *storage_v1.GetDependenciesRequest, opts ...grpc.CallOption)) *DependenciesReaderPluginClient_GetDependencies_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.GetDependenciesRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *DependenciesReaderPluginClient_GetDependencies_Call) Return(_a0 *storage_v1.GetDependenciesResponse, _a1 error) *DependenciesReaderPluginClient_GetDependencies_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *DependenciesReaderPluginClient_GetDependencies_Call) RunAndReturn(run func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error)) *DependenciesReaderPluginClient_GetDependencies_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewDependenciesReaderPluginClient creates a new instance of DependenciesReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewDependenciesReaderPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *DependenciesReaderPluginClient {
-	mock := &DependenciesReaderPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginServer.go b/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginServer.go
deleted file mode 100644
index 083f69ef..00000000
--- a/internal/proto-gen/storage_v1/mocks/DependenciesReaderPluginServer.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// DependenciesReaderPluginServer is an autogenerated mock type for the DependenciesReaderPluginServer type
-type DependenciesReaderPluginServer struct {
-	mock.Mock
-}
-
-type DependenciesReaderPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *DependenciesReaderPluginServer) EXPECT() *DependenciesReaderPluginServer_Expecter {
-	return &DependenciesReaderPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// GetDependencies provides a mock function with given fields: _a0, _a1
-func (_m *DependenciesReaderPluginServer) GetDependencies(_a0 context.Context, _a1 *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetDependencies")
-	}
-
-	var r0 *storage_v1.GetDependenciesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest) *storage_v1.GetDependenciesResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetDependenciesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetDependenciesRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DependenciesReaderPluginServer_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
-type DependenciesReaderPluginServer_GetDependencies_Call struct {
-	*mock.Call
-}
-
-// GetDependencies is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.GetDependenciesRequest
-func (_e *DependenciesReaderPluginServer_Expecter) GetDependencies(_a0 interface{}, _a1 interface{}) *DependenciesReaderPluginServer_GetDependencies_Call {
-	return &DependenciesReaderPluginServer_GetDependencies_Call{Call: _e.mock.On("GetDependencies", _a0, _a1)}
-}
-
-func (_c *DependenciesReaderPluginServer_GetDependencies_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.GetDependenciesRequest)) *DependenciesReaderPluginServer_GetDependencies_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.GetDependenciesRequest))
-	})
-	return _c
-}
-
-func (_c *DependenciesReaderPluginServer_GetDependencies_Call) Return(_a0 *storage_v1.GetDependenciesResponse, _a1 error) *DependenciesReaderPluginServer_GetDependencies_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *DependenciesReaderPluginServer_GetDependencies_Call) RunAndReturn(run func(context.Context, *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error)) *DependenciesReaderPluginServer_GetDependencies_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewDependenciesReaderPluginServer creates a new instance of DependenciesReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewDependenciesReaderPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *DependenciesReaderPluginServer {
-	mock := &DependenciesReaderPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesClient.go b/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesClient.go
deleted file mode 100644
index e918c11c..00000000
--- a/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesClient.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// PluginCapabilitiesClient is an autogenerated mock type for the PluginCapabilitiesClient type
-type PluginCapabilitiesClient struct {
-	mock.Mock
-}
-
-type PluginCapabilitiesClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *PluginCapabilitiesClient) EXPECT() *PluginCapabilitiesClient_Expecter {
-	return &PluginCapabilitiesClient_Expecter{mock: &_m.Mock}
-}
-
-// Capabilities provides a mock function with given fields: ctx, in, opts
-func (_m *PluginCapabilitiesClient) Capabilities(ctx context.Context, in *storage_v1.CapabilitiesRequest, opts ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Capabilities")
-	}
-
-	var r0 *storage_v1.CapabilitiesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) *storage_v1.CapabilitiesResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.CapabilitiesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PluginCapabilitiesClient_Capabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Capabilities'
-type PluginCapabilitiesClient_Capabilities_Call struct {
-	*mock.Call
-}
-
-// Capabilities is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.CapabilitiesRequest
-//   - opts ...grpc.CallOption
-func (_e *PluginCapabilitiesClient_Expecter) Capabilities(ctx interface{}, in interface{}, opts ...interface{}) *PluginCapabilitiesClient_Capabilities_Call {
-	return &PluginCapabilitiesClient_Capabilities_Call{Call: _e.mock.On("Capabilities",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *PluginCapabilitiesClient_Capabilities_Call) Run(run func(ctx context.Context, in *storage_v1.CapabilitiesRequest, opts ...grpc.CallOption)) *PluginCapabilitiesClient_Capabilities_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.CapabilitiesRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *PluginCapabilitiesClient_Capabilities_Call) Return(_a0 *storage_v1.CapabilitiesResponse, _a1 error) *PluginCapabilitiesClient_Capabilities_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *PluginCapabilitiesClient_Capabilities_Call) RunAndReturn(run func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error)) *PluginCapabilitiesClient_Capabilities_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewPluginCapabilitiesClient creates a new instance of PluginCapabilitiesClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewPluginCapabilitiesClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *PluginCapabilitiesClient {
-	mock := &PluginCapabilitiesClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesServer.go b/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesServer.go
deleted file mode 100644
index b7421040..00000000
--- a/internal/proto-gen/storage_v1/mocks/PluginCapabilitiesServer.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// PluginCapabilitiesServer is an autogenerated mock type for the PluginCapabilitiesServer type
-type PluginCapabilitiesServer struct {
-	mock.Mock
-}
-
-type PluginCapabilitiesServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *PluginCapabilitiesServer) EXPECT() *PluginCapabilitiesServer_Expecter {
-	return &PluginCapabilitiesServer_Expecter{mock: &_m.Mock}
-}
-
-// Capabilities provides a mock function with given fields: _a0, _a1
-func (_m *PluginCapabilitiesServer) Capabilities(_a0 context.Context, _a1 *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Capabilities")
-	}
-
-	var r0 *storage_v1.CapabilitiesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest) *storage_v1.CapabilitiesResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.CapabilitiesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.CapabilitiesRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PluginCapabilitiesServer_Capabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Capabilities'
-type PluginCapabilitiesServer_Capabilities_Call struct {
-	*mock.Call
-}
-
-// Capabilities is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.CapabilitiesRequest
-func (_e *PluginCapabilitiesServer_Expecter) Capabilities(_a0 interface{}, _a1 interface{}) *PluginCapabilitiesServer_Capabilities_Call {
-	return &PluginCapabilitiesServer_Capabilities_Call{Call: _e.mock.On("Capabilities", _a0, _a1)}
-}
-
-func (_c *PluginCapabilitiesServer_Capabilities_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.CapabilitiesRequest)) *PluginCapabilitiesServer_Capabilities_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.CapabilitiesRequest))
-	})
-	return _c
-}
-
-func (_c *PluginCapabilitiesServer_Capabilities_Call) Return(_a0 *storage_v1.CapabilitiesResponse, _a1 error) *PluginCapabilitiesServer_Capabilities_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *PluginCapabilitiesServer_Capabilities_Call) RunAndReturn(run func(context.Context, *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error)) *PluginCapabilitiesServer_Capabilities_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewPluginCapabilitiesServer creates a new instance of PluginCapabilitiesServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewPluginCapabilitiesServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *PluginCapabilitiesServer {
-	mock := &PluginCapabilitiesServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPluginClient.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPluginClient.go
deleted file mode 100644
index 0e49aaf7..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPluginClient.go
+++ /dev/null
@@ -1,415 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanReaderPluginClient is an autogenerated mock type for the SpanReaderPluginClient type
-type SpanReaderPluginClient struct {
-	mock.Mock
-}
-
-type SpanReaderPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPluginClient) EXPECT() *SpanReaderPluginClient_Expecter {
-	return &SpanReaderPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// FindTraceIDs provides a mock function with given fields: ctx, in, opts
-func (_m *SpanReaderPluginClient) FindTraceIDs(ctx context.Context, in *storage_v1.FindTraceIDsRequest, opts ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraceIDs")
-	}
-
-	var r0 *storage_v1.FindTraceIDsResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) *storage_v1.FindTraceIDsResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.FindTraceIDsResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginClient_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
-type SpanReaderPluginClient_FindTraceIDs_Call struct {
-	*mock.Call
-}
-
-// FindTraceIDs is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.FindTraceIDsRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanReaderPluginClient_Expecter) FindTraceIDs(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_FindTraceIDs_Call {
-	return &SpanReaderPluginClient_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanReaderPluginClient_FindTraceIDs_Call) Run(run func(ctx context.Context, in *storage_v1.FindTraceIDsRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_FindTraceIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.FindTraceIDsRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_FindTraceIDs_Call) Return(_a0 *storage_v1.FindTraceIDsResponse, _a1 error) *SpanReaderPluginClient_FindTraceIDs_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_FindTraceIDs_Call) RunAndReturn(run func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error)) *SpanReaderPluginClient_FindTraceIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTraces provides a mock function with given fields: ctx, in, opts
-func (_m *SpanReaderPluginClient) FindTraces(ctx context.Context, in *storage_v1.FindTracesRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraces")
-	}
-
-	var r0 storage_v1.SpanReaderPlugin_FindTracesClient
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) storage_v1.SpanReaderPlugin_FindTracesClient); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(storage_v1.SpanReaderPlugin_FindTracesClient)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginClient_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
-type SpanReaderPluginClient_FindTraces_Call struct {
-	*mock.Call
-}
-
-// FindTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.FindTracesRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanReaderPluginClient_Expecter) FindTraces(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_FindTraces_Call {
-	return &SpanReaderPluginClient_FindTraces_Call{Call: _e.mock.On("FindTraces",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanReaderPluginClient_FindTraces_Call) Run(run func(ctx context.Context, in *storage_v1.FindTracesRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_FindTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.FindTracesRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_FindTraces_Call) Return(_a0 storage_v1.SpanReaderPlugin_FindTracesClient, _a1 error) *SpanReaderPluginClient_FindTraces_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_FindTraces_Call) RunAndReturn(run func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error)) *SpanReaderPluginClient_FindTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetOperations provides a mock function with given fields: ctx, in, opts
-func (_m *SpanReaderPluginClient) GetOperations(ctx context.Context, in *storage_v1.GetOperationsRequest, opts ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetOperations")
-	}
-
-	var r0 *storage_v1.GetOperationsResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) *storage_v1.GetOperationsResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetOperationsResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginClient_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
-type SpanReaderPluginClient_GetOperations_Call struct {
-	*mock.Call
-}
-
-// GetOperations is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.GetOperationsRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanReaderPluginClient_Expecter) GetOperations(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetOperations_Call {
-	return &SpanReaderPluginClient_GetOperations_Call{Call: _e.mock.On("GetOperations",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanReaderPluginClient_GetOperations_Call) Run(run func(ctx context.Context, in *storage_v1.GetOperationsRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetOperations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.GetOperationsRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetOperations_Call) Return(_a0 *storage_v1.GetOperationsResponse, _a1 error) *SpanReaderPluginClient_GetOperations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetOperations_Call) RunAndReturn(run func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error)) *SpanReaderPluginClient_GetOperations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetServices provides a mock function with given fields: ctx, in, opts
-func (_m *SpanReaderPluginClient) GetServices(ctx context.Context, in *storage_v1.GetServicesRequest, opts ...grpc.CallOption) (*storage_v1.GetServicesResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetServices")
-	}
-
-	var r0 *storage_v1.GetServicesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) (*storage_v1.GetServicesResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) *storage_v1.GetServicesResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetServicesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginClient_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
-type SpanReaderPluginClient_GetServices_Call struct {
-	*mock.Call
-}
-
-// GetServices is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.GetServicesRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanReaderPluginClient_Expecter) GetServices(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetServices_Call {
-	return &SpanReaderPluginClient_GetServices_Call{Call: _e.mock.On("GetServices",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanReaderPluginClient_GetServices_Call) Run(run func(ctx context.Context, in *storage_v1.GetServicesRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetServices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.GetServicesRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetServices_Call) Return(_a0 *storage_v1.GetServicesResponse, _a1 error) *SpanReaderPluginClient_GetServices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetServices_Call) RunAndReturn(run func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) (*storage_v1.GetServicesResponse, error)) *SpanReaderPluginClient_GetServices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTrace provides a mock function with given fields: ctx, in, opts
-func (_m *SpanReaderPluginClient) GetTrace(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTrace")
-	}
-
-	var r0 storage_v1.SpanReaderPlugin_GetTraceClient
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) storage_v1.SpanReaderPlugin_GetTraceClient); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(storage_v1.SpanReaderPlugin_GetTraceClient)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginClient_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
-type SpanReaderPluginClient_GetTrace_Call struct {
-	*mock.Call
-}
-
-// GetTrace is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.GetTraceRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanReaderPluginClient_Expecter) GetTrace(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetTrace_Call {
-	return &SpanReaderPluginClient_GetTrace_Call{Call: _e.mock.On("GetTrace",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanReaderPluginClient_GetTrace_Call) Run(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetTrace_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.GetTraceRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetTrace_Call) Return(_a0 storage_v1.SpanReaderPlugin_GetTraceClient, _a1 error) *SpanReaderPluginClient_GetTrace_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginClient_GetTrace_Call) RunAndReturn(run func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error)) *SpanReaderPluginClient_GetTrace_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanReaderPluginClient creates a new instance of SpanReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPluginClient {
-	mock := &SpanReaderPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPluginServer.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPluginServer.go
deleted file mode 100644
index 1de13112..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPluginServer.go
+++ /dev/null
@@ -1,313 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// SpanReaderPluginServer is an autogenerated mock type for the SpanReaderPluginServer type
-type SpanReaderPluginServer struct {
-	mock.Mock
-}
-
-type SpanReaderPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPluginServer) EXPECT() *SpanReaderPluginServer_Expecter {
-	return &SpanReaderPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// FindTraceIDs provides a mock function with given fields: _a0, _a1
-func (_m *SpanReaderPluginServer) FindTraceIDs(_a0 context.Context, _a1 *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraceIDs")
-	}
-
-	var r0 *storage_v1.FindTraceIDsResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest) *storage_v1.FindTraceIDsResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.FindTraceIDsResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTraceIDsRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginServer_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
-type SpanReaderPluginServer_FindTraceIDs_Call struct {
-	*mock.Call
-}
-
-// FindTraceIDs is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.FindTraceIDsRequest
-func (_e *SpanReaderPluginServer_Expecter) FindTraceIDs(_a0 interface{}, _a1 interface{}) *SpanReaderPluginServer_FindTraceIDs_Call {
-	return &SpanReaderPluginServer_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", _a0, _a1)}
-}
-
-func (_c *SpanReaderPluginServer_FindTraceIDs_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.FindTraceIDsRequest)) *SpanReaderPluginServer_FindTraceIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.FindTraceIDsRequest))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_FindTraceIDs_Call) Return(_a0 *storage_v1.FindTraceIDsResponse, _a1 error) *SpanReaderPluginServer_FindTraceIDs_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_FindTraceIDs_Call) RunAndReturn(run func(context.Context, *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error)) *SpanReaderPluginServer_FindTraceIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTraces provides a mock function with given fields: _a0, _a1
-func (_m *SpanReaderPluginServer) FindTraces(_a0 *storage_v1.FindTracesRequest, _a1 storage_v1.SpanReaderPlugin_FindTracesServer) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraces")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.FindTracesRequest, storage_v1.SpanReaderPlugin_FindTracesServer) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPluginServer_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
-type SpanReaderPluginServer_FindTraces_Call struct {
-	*mock.Call
-}
-
-// FindTraces is a helper method to define mock.On call
-//   - _a0 *storage_v1.FindTracesRequest
-//   - _a1 storage_v1.SpanReaderPlugin_FindTracesServer
-func (_e *SpanReaderPluginServer_Expecter) FindTraces(_a0 interface{}, _a1 interface{}) *SpanReaderPluginServer_FindTraces_Call {
-	return &SpanReaderPluginServer_FindTraces_Call{Call: _e.mock.On("FindTraces", _a0, _a1)}
-}
-
-func (_c *SpanReaderPluginServer_FindTraces_Call) Run(run func(_a0 *storage_v1.FindTracesRequest, _a1 storage_v1.SpanReaderPlugin_FindTracesServer)) *SpanReaderPluginServer_FindTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.FindTracesRequest), args[1].(storage_v1.SpanReaderPlugin_FindTracesServer))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_FindTraces_Call) Return(_a0 error) *SpanReaderPluginServer_FindTraces_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_FindTraces_Call) RunAndReturn(run func(*storage_v1.FindTracesRequest, storage_v1.SpanReaderPlugin_FindTracesServer) error) *SpanReaderPluginServer_FindTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetOperations provides a mock function with given fields: _a0, _a1
-func (_m *SpanReaderPluginServer) GetOperations(_a0 context.Context, _a1 *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetOperations")
-	}
-
-	var r0 *storage_v1.GetOperationsResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest) *storage_v1.GetOperationsResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetOperationsResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetOperationsRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginServer_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
-type SpanReaderPluginServer_GetOperations_Call struct {
-	*mock.Call
-}
-
-// GetOperations is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.GetOperationsRequest
-func (_e *SpanReaderPluginServer_Expecter) GetOperations(_a0 interface{}, _a1 interface{}) *SpanReaderPluginServer_GetOperations_Call {
-	return &SpanReaderPluginServer_GetOperations_Call{Call: _e.mock.On("GetOperations", _a0, _a1)}
-}
-
-func (_c *SpanReaderPluginServer_GetOperations_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.GetOperationsRequest)) *SpanReaderPluginServer_GetOperations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.GetOperationsRequest))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetOperations_Call) Return(_a0 *storage_v1.GetOperationsResponse, _a1 error) *SpanReaderPluginServer_GetOperations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetOperations_Call) RunAndReturn(run func(context.Context, *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error)) *SpanReaderPluginServer_GetOperations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetServices provides a mock function with given fields: _a0, _a1
-func (_m *SpanReaderPluginServer) GetServices(_a0 context.Context, _a1 *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetServices")
-	}
-
-	var r0 *storage_v1.GetServicesResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest) *storage_v1.GetServicesResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.GetServicesResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetServicesRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPluginServer_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
-type SpanReaderPluginServer_GetServices_Call struct {
-	*mock.Call
-}
-
-// GetServices is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.GetServicesRequest
-func (_e *SpanReaderPluginServer_Expecter) GetServices(_a0 interface{}, _a1 interface{}) *SpanReaderPluginServer_GetServices_Call {
-	return &SpanReaderPluginServer_GetServices_Call{Call: _e.mock.On("GetServices", _a0, _a1)}
-}
-
-func (_c *SpanReaderPluginServer_GetServices_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.GetServicesRequest)) *SpanReaderPluginServer_GetServices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.GetServicesRequest))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetServices_Call) Return(_a0 *storage_v1.GetServicesResponse, _a1 error) *SpanReaderPluginServer_GetServices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetServices_Call) RunAndReturn(run func(context.Context, *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error)) *SpanReaderPluginServer_GetServices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTrace provides a mock function with given fields: _a0, _a1
-func (_m *SpanReaderPluginServer) GetTrace(_a0 *storage_v1.GetTraceRequest, _a1 storage_v1.SpanReaderPlugin_GetTraceServer) error {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTrace")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.GetTraceRequest, storage_v1.SpanReaderPlugin_GetTraceServer) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPluginServer_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
-type SpanReaderPluginServer_GetTrace_Call struct {
-	*mock.Call
-}
-
-// GetTrace is a helper method to define mock.On call
-//   - _a0 *storage_v1.GetTraceRequest
-//   - _a1 storage_v1.SpanReaderPlugin_GetTraceServer
-func (_e *SpanReaderPluginServer_Expecter) GetTrace(_a0 interface{}, _a1 interface{}) *SpanReaderPluginServer_GetTrace_Call {
-	return &SpanReaderPluginServer_GetTrace_Call{Call: _e.mock.On("GetTrace", _a0, _a1)}
-}
-
-func (_c *SpanReaderPluginServer_GetTrace_Call) Run(run func(_a0 *storage_v1.GetTraceRequest, _a1 storage_v1.SpanReaderPlugin_GetTraceServer)) *SpanReaderPluginServer_GetTrace_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.GetTraceRequest), args[1].(storage_v1.SpanReaderPlugin_GetTraceServer))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetTrace_Call) Return(_a0 error) *SpanReaderPluginServer_GetTrace_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPluginServer_GetTrace_Call) RunAndReturn(run func(*storage_v1.GetTraceRequest, storage_v1.SpanReaderPlugin_GetTraceServer) error) *SpanReaderPluginServer_GetTrace_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanReaderPluginServer creates a new instance of SpanReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPluginServer {
-	mock := &SpanReaderPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesClient.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesClient.go
deleted file mode 100644
index 17ee5ea0..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesClient.go
+++ /dev/null
@@ -1,389 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanReaderPlugin_FindTracesClient is an autogenerated mock type for the SpanReaderPlugin_FindTracesClient type
-type SpanReaderPlugin_FindTracesClient struct {
-	mock.Mock
-}
-
-type SpanReaderPlugin_FindTracesClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPlugin_FindTracesClient) EXPECT() *SpanReaderPlugin_FindTracesClient_Expecter {
-	return &SpanReaderPlugin_FindTracesClient_Expecter{mock: &_m.Mock}
-}
-
-// CloseSend provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
-type SpanReaderPlugin_FindTracesClient_CloseSend_Call struct {
-	*mock.Call
-}
-
-// CloseSend is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) CloseSend() *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
-	return &SpanReaderPlugin_FindTracesClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) RunAndReturn(run func() error) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Context provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type SpanReaderPlugin_FindTracesClient_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Context() *SpanReaderPlugin_FindTracesClient_Context_Call {
-	return &SpanReaderPlugin_FindTracesClient_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) Return(_a0 context.Context) *SpanReaderPlugin_FindTracesClient_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_FindTracesClient_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Header provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPlugin_FindTracesClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
-type SpanReaderPlugin_FindTracesClient_Header_Call struct {
-	*mock.Call
-}
-
-// Header is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Header() *SpanReaderPlugin_FindTracesClient_Header_Call {
-	return &SpanReaderPlugin_FindTracesClient_Header_Call{Call: _e.mock.On("Header")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Header_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *SpanReaderPlugin_FindTracesClient_Header_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *SpanReaderPlugin_FindTracesClient_Header_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Recv provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesClient) Recv() (*storage_v1.SpansResponseChunk, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Recv")
-	}
-
-	var r0 *storage_v1.SpansResponseChunk
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPlugin_FindTracesClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
-type SpanReaderPlugin_FindTracesClient_Recv_Call struct {
-	*mock.Call
-}
-
-// Recv is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Recv() *SpanReaderPlugin_FindTracesClient_Recv_Call {
-	return &SpanReaderPlugin_FindTracesClient_Recv_Call{Call: _e.mock.On("Recv")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Recv_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) Return(_a0 *storage_v1.SpansResponseChunk, _a1 error) *SpanReaderPlugin_FindTracesClient_Recv_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *SpanReaderPlugin_FindTracesClient_Recv_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_FindTracesClient) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type SpanReaderPlugin_FindTracesClient_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
-	return &SpanReaderPlugin_FindTracesClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_FindTracesClient) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type SpanReaderPlugin_FindTracesClient_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
-	return &SpanReaderPlugin_FindTracesClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Trailer provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
-type SpanReaderPlugin_FindTracesClient_Trailer_Call struct {
-	*mock.Call
-}
-
-// Trailer is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Trailer() *SpanReaderPlugin_FindTracesClient_Trailer_Call {
-	return &SpanReaderPlugin_FindTracesClient_Trailer_Call{Call: _e.mock.On("Trailer")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) Return(_a0 metadata.MD) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanReaderPlugin_FindTracesClient creates a new instance of SpanReaderPlugin_FindTracesClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPlugin_FindTracesClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPlugin_FindTracesClient {
-	mock := &SpanReaderPlugin_FindTracesClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesServer.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesServer.go
deleted file mode 100644
index 8674051c..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_FindTracesServer.go
+++ /dev/null
@@ -1,354 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanReaderPlugin_FindTracesServer is an autogenerated mock type for the SpanReaderPlugin_FindTracesServer type
-type SpanReaderPlugin_FindTracesServer struct {
-	mock.Mock
-}
-
-type SpanReaderPlugin_FindTracesServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPlugin_FindTracesServer) EXPECT() *SpanReaderPlugin_FindTracesServer_Expecter {
-	return &SpanReaderPlugin_FindTracesServer_Expecter{mock: &_m.Mock}
-}
-
-// Context provides a mock function with no fields
-func (_m *SpanReaderPlugin_FindTracesServer) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type SpanReaderPlugin_FindTracesServer_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) Context() *SpanReaderPlugin_FindTracesServer_Context_Call {
-	return &SpanReaderPlugin_FindTracesServer_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) Run(run func()) *SpanReaderPlugin_FindTracesServer_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) Return(_a0 context.Context) *SpanReaderPlugin_FindTracesServer_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_FindTracesServer_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_FindTracesServer) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type SpanReaderPlugin_FindTracesServer_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
-	return &SpanReaderPlugin_FindTracesServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_FindTracesServer) Send(_a0 *storage_v1.SpansResponseChunk) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
-type SpanReaderPlugin_FindTracesServer_Send_Call struct {
-	*mock.Call
-}
-
-// Send is a helper method to define mock.On call
-//   - _a0 *storage_v1.SpansResponseChunk
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) Send(_a0 interface{}) *SpanReaderPlugin_FindTracesServer_Send_Call {
-	return &SpanReaderPlugin_FindTracesServer_Send_Call{Call: _e.mock.On("Send", _a0)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) Run(run func(_a0 *storage_v1.SpansResponseChunk)) *SpanReaderPlugin_FindTracesServer_Send_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.SpansResponseChunk))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesServer_Send_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) RunAndReturn(run func(*storage_v1.SpansResponseChunk) error) *SpanReaderPlugin_FindTracesServer_Send_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendHeader provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_FindTracesServer) SendHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
-type SpanReaderPlugin_FindTracesServer_SendHeader_Call struct {
-	*mock.Call
-}
-
-// SendHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SendHeader(_a0 interface{}) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
-	return &SpanReaderPlugin_FindTracesServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_FindTracesServer) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type SpanReaderPlugin_FindTracesServer_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
-	return &SpanReaderPlugin_FindTracesServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetHeader provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_FindTracesServer) SetHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SetHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_FindTracesServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
-type SpanReaderPlugin_FindTracesServer_SetHeader_Call struct {
-	*mock.Call
-}
-
-// SetHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SetHeader(_a0 interface{}) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
-	return &SpanReaderPlugin_FindTracesServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) Return(_a0 error) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetTrailer provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_FindTracesServer) SetTrailer(_a0 metadata.MD) {
-	_m.Called(_a0)
-}
-
-// SpanReaderPlugin_FindTracesServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
-type SpanReaderPlugin_FindTracesServer_SetTrailer_Call struct {
-	*mock.Call
-}
-
-// SetTrailer is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SetTrailer(_a0 interface{}) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
-	return &SpanReaderPlugin_FindTracesServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)}
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) Return() *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewSpanReaderPlugin_FindTracesServer creates a new instance of SpanReaderPlugin_FindTracesServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPlugin_FindTracesServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPlugin_FindTracesServer {
-	mock := &SpanReaderPlugin_FindTracesServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceClient.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceClient.go
deleted file mode 100644
index 224684e0..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceClient.go
+++ /dev/null
@@ -1,389 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanReaderPlugin_GetTraceClient is an autogenerated mock type for the SpanReaderPlugin_GetTraceClient type
-type SpanReaderPlugin_GetTraceClient struct {
-	mock.Mock
-}
-
-type SpanReaderPlugin_GetTraceClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPlugin_GetTraceClient) EXPECT() *SpanReaderPlugin_GetTraceClient_Expecter {
-	return &SpanReaderPlugin_GetTraceClient_Expecter{mock: &_m.Mock}
-}
-
-// CloseSend provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
-type SpanReaderPlugin_GetTraceClient_CloseSend_Call struct {
-	*mock.Call
-}
-
-// CloseSend is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) CloseSend() *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
-	return &SpanReaderPlugin_GetTraceClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) RunAndReturn(run func() error) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Context provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type SpanReaderPlugin_GetTraceClient_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Context() *SpanReaderPlugin_GetTraceClient_Context_Call {
-	return &SpanReaderPlugin_GetTraceClient_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) Return(_a0 context.Context) *SpanReaderPlugin_GetTraceClient_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_GetTraceClient_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Header provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPlugin_GetTraceClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
-type SpanReaderPlugin_GetTraceClient_Header_Call struct {
-	*mock.Call
-}
-
-// Header is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Header() *SpanReaderPlugin_GetTraceClient_Header_Call {
-	return &SpanReaderPlugin_GetTraceClient_Header_Call{Call: _e.mock.On("Header")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Header_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *SpanReaderPlugin_GetTraceClient_Header_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *SpanReaderPlugin_GetTraceClient_Header_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Recv provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceClient) Recv() (*storage_v1.SpansResponseChunk, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Recv")
-	}
-
-	var r0 *storage_v1.SpansResponseChunk
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanReaderPlugin_GetTraceClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
-type SpanReaderPlugin_GetTraceClient_Recv_Call struct {
-	*mock.Call
-}
-
-// Recv is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Recv() *SpanReaderPlugin_GetTraceClient_Recv_Call {
-	return &SpanReaderPlugin_GetTraceClient_Recv_Call{Call: _e.mock.On("Recv")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Recv_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) Return(_a0 *storage_v1.SpansResponseChunk, _a1 error) *SpanReaderPlugin_GetTraceClient_Recv_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *SpanReaderPlugin_GetTraceClient_Recv_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_GetTraceClient) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type SpanReaderPlugin_GetTraceClient_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
-	return &SpanReaderPlugin_GetTraceClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_GetTraceClient) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type SpanReaderPlugin_GetTraceClient_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
-	return &SpanReaderPlugin_GetTraceClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Trailer provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
-type SpanReaderPlugin_GetTraceClient_Trailer_Call struct {
-	*mock.Call
-}
-
-// Trailer is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Trailer() *SpanReaderPlugin_GetTraceClient_Trailer_Call {
-	return &SpanReaderPlugin_GetTraceClient_Trailer_Call{Call: _e.mock.On("Trailer")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) Return(_a0 metadata.MD) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanReaderPlugin_GetTraceClient creates a new instance of SpanReaderPlugin_GetTraceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPlugin_GetTraceClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPlugin_GetTraceClient {
-	mock := &SpanReaderPlugin_GetTraceClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceServer.go b/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceServer.go
deleted file mode 100644
index 27f3bab0..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanReaderPlugin_GetTraceServer.go
+++ /dev/null
@@ -1,354 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanReaderPlugin_GetTraceServer is an autogenerated mock type for the SpanReaderPlugin_GetTraceServer type
-type SpanReaderPlugin_GetTraceServer struct {
-	mock.Mock
-}
-
-type SpanReaderPlugin_GetTraceServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanReaderPlugin_GetTraceServer) EXPECT() *SpanReaderPlugin_GetTraceServer_Expecter {
-	return &SpanReaderPlugin_GetTraceServer_Expecter{mock: &_m.Mock}
-}
-
-// Context provides a mock function with no fields
-func (_m *SpanReaderPlugin_GetTraceServer) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type SpanReaderPlugin_GetTraceServer_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) Context() *SpanReaderPlugin_GetTraceServer_Context_Call {
-	return &SpanReaderPlugin_GetTraceServer_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) Run(run func()) *SpanReaderPlugin_GetTraceServer_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) Return(_a0 context.Context) *SpanReaderPlugin_GetTraceServer_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_GetTraceServer_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_GetTraceServer) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type SpanReaderPlugin_GetTraceServer_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
-	return &SpanReaderPlugin_GetTraceServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_GetTraceServer) Send(_a0 *storage_v1.SpansResponseChunk) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
-type SpanReaderPlugin_GetTraceServer_Send_Call struct {
-	*mock.Call
-}
-
-// Send is a helper method to define mock.On call
-//   - _a0 *storage_v1.SpansResponseChunk
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) Send(_a0 interface{}) *SpanReaderPlugin_GetTraceServer_Send_Call {
-	return &SpanReaderPlugin_GetTraceServer_Send_Call{Call: _e.mock.On("Send", _a0)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) Run(run func(_a0 *storage_v1.SpansResponseChunk)) *SpanReaderPlugin_GetTraceServer_Send_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.SpansResponseChunk))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceServer_Send_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) RunAndReturn(run func(*storage_v1.SpansResponseChunk) error) *SpanReaderPlugin_GetTraceServer_Send_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendHeader provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_GetTraceServer) SendHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
-type SpanReaderPlugin_GetTraceServer_SendHeader_Call struct {
-	*mock.Call
-}
-
-// SendHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SendHeader(_a0 interface{}) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
-	return &SpanReaderPlugin_GetTraceServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *SpanReaderPlugin_GetTraceServer) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type SpanReaderPlugin_GetTraceServer_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
-	return &SpanReaderPlugin_GetTraceServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) RunAndReturn(run func(any) error) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetHeader provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_GetTraceServer) SetHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SetHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SpanReaderPlugin_GetTraceServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
-type SpanReaderPlugin_GetTraceServer_SetHeader_Call struct {
-	*mock.Call
-}
-
-// SetHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SetHeader(_a0 interface{}) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
-	return &SpanReaderPlugin_GetTraceServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) Return(_a0 error) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetTrailer provides a mock function with given fields: _a0
-func (_m *SpanReaderPlugin_GetTraceServer) SetTrailer(_a0 metadata.MD) {
-	_m.Called(_a0)
-}
-
-// SpanReaderPlugin_GetTraceServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
-type SpanReaderPlugin_GetTraceServer_SetTrailer_Call struct {
-	*mock.Call
-}
-
-// SetTrailer is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SetTrailer(_a0 interface{}) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
-	return &SpanReaderPlugin_GetTraceServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)}
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) Return() *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewSpanReaderPlugin_GetTraceServer creates a new instance of SpanReaderPlugin_GetTraceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanReaderPlugin_GetTraceServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanReaderPlugin_GetTraceServer {
-	mock := &SpanReaderPlugin_GetTraceServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanWriterPluginClient.go b/internal/proto-gen/storage_v1/mocks/SpanWriterPluginClient.go
deleted file mode 100644
index 6ff08b34..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanWriterPluginClient.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// SpanWriterPluginClient is an autogenerated mock type for the SpanWriterPluginClient type
-type SpanWriterPluginClient struct {
-	mock.Mock
-}
-
-type SpanWriterPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanWriterPluginClient) EXPECT() *SpanWriterPluginClient_Expecter {
-	return &SpanWriterPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with given fields: ctx, in, opts
-func (_m *SpanWriterPluginClient) Close(ctx context.Context, in *storage_v1.CloseWriterRequest, opts ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 *storage_v1.CloseWriterResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) *storage_v1.CloseWriterResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.CloseWriterResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanWriterPluginClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type SpanWriterPluginClient_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.CloseWriterRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanWriterPluginClient_Expecter) Close(ctx interface{}, in interface{}, opts ...interface{}) *SpanWriterPluginClient_Close_Call {
-	return &SpanWriterPluginClient_Close_Call{Call: _e.mock.On("Close",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanWriterPluginClient_Close_Call) Run(run func(ctx context.Context, in *storage_v1.CloseWriterRequest, opts ...grpc.CallOption)) *SpanWriterPluginClient_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.CloseWriterRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanWriterPluginClient_Close_Call) Return(_a0 *storage_v1.CloseWriterResponse, _a1 error) *SpanWriterPluginClient_Close_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanWriterPluginClient_Close_Call) RunAndReturn(run func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error)) *SpanWriterPluginClient_Close_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteSpan provides a mock function with given fields: ctx, in, opts
-func (_m *SpanWriterPluginClient) WriteSpan(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, in)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteSpan")
-	}
-
-	var r0 *storage_v1.WriteSpanResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)); ok {
-		return rf(ctx, in, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) *storage_v1.WriteSpanResponse); ok {
-		r0 = rf(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanWriterPluginClient_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
-type SpanWriterPluginClient_WriteSpan_Call struct {
-	*mock.Call
-}
-
-// WriteSpan is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *storage_v1.WriteSpanRequest
-//   - opts ...grpc.CallOption
-func (_e *SpanWriterPluginClient_Expecter) WriteSpan(ctx interface{}, in interface{}, opts ...interface{}) *SpanWriterPluginClient_WriteSpan_Call {
-	return &SpanWriterPluginClient_WriteSpan_Call{Call: _e.mock.On("WriteSpan",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *SpanWriterPluginClient_WriteSpan_Call) Run(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption)) *SpanWriterPluginClient_WriteSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-2)
-		for i, a := range args[2:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *SpanWriterPluginClient_WriteSpan_Call) Return(_a0 *storage_v1.WriteSpanResponse, _a1 error) *SpanWriterPluginClient_WriteSpan_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanWriterPluginClient_WriteSpan_Call) RunAndReturn(run func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)) *SpanWriterPluginClient_WriteSpan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanWriterPluginClient creates a new instance of SpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanWriterPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanWriterPluginClient {
-	mock := &SpanWriterPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/SpanWriterPluginServer.go b/internal/proto-gen/storage_v1/mocks/SpanWriterPluginServer.go
deleted file mode 100644
index 249b5d1d..00000000
--- a/internal/proto-gen/storage_v1/mocks/SpanWriterPluginServer.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// SpanWriterPluginServer is an autogenerated mock type for the SpanWriterPluginServer type
-type SpanWriterPluginServer struct {
-	mock.Mock
-}
-
-type SpanWriterPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SpanWriterPluginServer) EXPECT() *SpanWriterPluginServer_Expecter {
-	return &SpanWriterPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with given fields: _a0, _a1
-func (_m *SpanWriterPluginServer) Close(_a0 context.Context, _a1 *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 *storage_v1.CloseWriterResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest) *storage_v1.CloseWriterResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.CloseWriterResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.CloseWriterRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanWriterPluginServer_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type SpanWriterPluginServer_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.CloseWriterRequest
-func (_e *SpanWriterPluginServer_Expecter) Close(_a0 interface{}, _a1 interface{}) *SpanWriterPluginServer_Close_Call {
-	return &SpanWriterPluginServer_Close_Call{Call: _e.mock.On("Close", _a0, _a1)}
-}
-
-func (_c *SpanWriterPluginServer_Close_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.CloseWriterRequest)) *SpanWriterPluginServer_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.CloseWriterRequest))
-	})
-	return _c
-}
-
-func (_c *SpanWriterPluginServer_Close_Call) Return(_a0 *storage_v1.CloseWriterResponse, _a1 error) *SpanWriterPluginServer_Close_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanWriterPluginServer_Close_Call) RunAndReturn(run func(context.Context, *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error)) *SpanWriterPluginServer_Close_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteSpan provides a mock function with given fields: _a0, _a1
-func (_m *SpanWriterPluginServer) WriteSpan(_a0 context.Context, _a1 *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error) {
-	ret := _m.Called(_a0, _a1)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteSpan")
-	}
-
-	var r0 *storage_v1.WriteSpanResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)); ok {
-		return rf(_a0, _a1)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) *storage_v1.WriteSpanResponse); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SpanWriterPluginServer_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
-type SpanWriterPluginServer_WriteSpan_Call struct {
-	*mock.Call
-}
-
-// WriteSpan is a helper method to define mock.On call
-//   - _a0 context.Context
-//   - _a1 *storage_v1.WriteSpanRequest
-func (_e *SpanWriterPluginServer_Expecter) WriteSpan(_a0 interface{}, _a1 interface{}) *SpanWriterPluginServer_WriteSpan_Call {
-	return &SpanWriterPluginServer_WriteSpan_Call{Call: _e.mock.On("WriteSpan", _a0, _a1)}
-}
-
-func (_c *SpanWriterPluginServer_WriteSpan_Call) Run(run func(_a0 context.Context, _a1 *storage_v1.WriteSpanRequest)) *SpanWriterPluginServer_WriteSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest))
-	})
-	return _c
-}
-
-func (_c *SpanWriterPluginServer_WriteSpan_Call) Return(_a0 *storage_v1.WriteSpanResponse, _a1 error) *SpanWriterPluginServer_WriteSpan_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SpanWriterPluginServer_WriteSpan_Call) RunAndReturn(run func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)) *SpanWriterPluginServer_WriteSpan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSpanWriterPluginServer creates a new instance of SpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSpanWriterPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SpanWriterPluginServer {
-	mock := &SpanWriterPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginClient.go b/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginClient.go
deleted file mode 100644
index 0db7d028..00000000
--- a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginClient.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	grpc "google.golang.org/grpc"
-
-	mock "github.com/stretchr/testify/mock"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// StreamingSpanWriterPluginClient is an autogenerated mock type for the StreamingSpanWriterPluginClient type
-type StreamingSpanWriterPluginClient struct {
-	mock.Mock
-}
-
-type StreamingSpanWriterPluginClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StreamingSpanWriterPluginClient) EXPECT() *StreamingSpanWriterPluginClient_Expecter {
-	return &StreamingSpanWriterPluginClient_Expecter{mock: &_m.Mock}
-}
-
-// WriteSpanStream provides a mock function with given fields: ctx, opts
-func (_m *StreamingSpanWriterPluginClient) WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteSpanStream")
-	}
-
-	var r0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error)); ok {
-		return rf(ctx, opts...)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient); ok {
-		r0 = rf(ctx, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, ...grpc.CallOption) error); ok {
-		r1 = rf(ctx, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StreamingSpanWriterPluginClient_WriteSpanStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpanStream'
-type StreamingSpanWriterPluginClient_WriteSpanStream_Call struct {
-	*mock.Call
-}
-
-// WriteSpanStream is a helper method to define mock.On call
-//   - ctx context.Context
-//   - opts ...grpc.CallOption
-func (_e *StreamingSpanWriterPluginClient_Expecter) WriteSpanStream(ctx interface{}, opts ...interface{}) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
-	return &StreamingSpanWriterPluginClient_WriteSpanStream_Call{Call: _e.mock.On("WriteSpanStream",
-		append([]interface{}{ctx}, opts...)...)}
-}
-
-func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]grpc.CallOption, len(args)-1)
-		for i, a := range args[1:] {
-			if a != nil {
-				variadicArgs[i] = a.(grpc.CallOption)
-			}
-		}
-		run(args[0].(context.Context), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) Return(_a0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, _a1 error) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) RunAndReturn(run func(context.Context, ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error)) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewStreamingSpanWriterPluginClient creates a new instance of StreamingSpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStreamingSpanWriterPluginClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *StreamingSpanWriterPluginClient {
-	mock := &StreamingSpanWriterPluginClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginServer.go b/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginServer.go
deleted file mode 100644
index 035553ee..00000000
--- a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPluginServer.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// StreamingSpanWriterPluginServer is an autogenerated mock type for the StreamingSpanWriterPluginServer type
-type StreamingSpanWriterPluginServer struct {
-	mock.Mock
-}
-
-type StreamingSpanWriterPluginServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StreamingSpanWriterPluginServer) EXPECT() *StreamingSpanWriterPluginServer_Expecter {
-	return &StreamingSpanWriterPluginServer_Expecter{mock: &_m.Mock}
-}
-
-// WriteSpanStream provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPluginServer) WriteSpanStream(_a0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteSpanStream")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPluginServer_WriteSpanStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpanStream'
-type StreamingSpanWriterPluginServer_WriteSpanStream_Call struct {
-	*mock.Call
-}
-
-// WriteSpanStream is a helper method to define mock.On call
-//   - _a0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer
-func (_e *StreamingSpanWriterPluginServer_Expecter) WriteSpanStream(_a0 interface{}) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
-	return &StreamingSpanWriterPluginServer_WriteSpanStream_Call{Call: _e.mock.On("WriteSpanStream", _a0)}
-}
-
-func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) Run(run func(_a0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer)) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) Return(_a0 error) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) RunAndReturn(run func(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewStreamingSpanWriterPluginServer creates a new instance of StreamingSpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStreamingSpanWriterPluginServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *StreamingSpanWriterPluginServer {
-	mock := &StreamingSpanWriterPluginServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamClient.go b/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamClient.go
deleted file mode 100644
index 0846d26a..00000000
--- a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamClient.go
+++ /dev/null
@@ -1,435 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient is an autogenerated mock type for the StreamingSpanWriterPlugin_WriteSpanStreamClient type
-type StreamingSpanWriterPlugin_WriteSpanStreamClient struct {
-	mock.Mock
-}
-
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) EXPECT() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter{mock: &_m.Mock}
-}
-
-// CloseAndRecv provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) CloseAndRecv() (*storage_v1.WriteSpanResponse, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseAndRecv")
-	}
-
-	var r0 *storage_v1.WriteSpanResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*storage_v1.WriteSpanResponse, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *storage_v1.WriteSpanResponse); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseAndRecv'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call struct {
-	*mock.Call
-}
-
-// CloseAndRecv is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) CloseAndRecv() *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call{Call: _e.mock.On("CloseAndRecv")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) Return(_a0 *storage_v1.WriteSpanResponse, _a1 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) RunAndReturn(run func() (*storage_v1.WriteSpanResponse, error)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CloseSend provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call struct {
-	*mock.Call
-}
-
-// CloseSend is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) CloseSend() *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) RunAndReturn(run func() error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Context provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Context() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) Return(_a0 context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) RunAndReturn(run func() context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Header provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call struct {
-	*mock.Call
-}
-
-// Header is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Header() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call{Call: _e.mock.On("Header")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) RecvMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) RunAndReturn(run func(any) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) Send(_a0 *storage_v1.WriteSpanRequest) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.WriteSpanRequest) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call struct {
-	*mock.Call
-}
-
-// Send is a helper method to define mock.On call
-//   - _a0 *storage_v1.WriteSpanRequest
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Send(_a0 interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call{Call: _e.mock.On("Send", _a0)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) Run(run func(_a0 *storage_v1.WriteSpanRequest)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.WriteSpanRequest))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) RunAndReturn(run func(*storage_v1.WriteSpanRequest) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) SendMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) RunAndReturn(run func(any) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Trailer provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
-type StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call struct {
-	*mock.Call
-}
-
-// Trailer is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Trailer() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call{Call: _e.mock.On("Trailer")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) Return(_a0 metadata.MD) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewStreamingSpanWriterPlugin_WriteSpanStreamClient creates a new instance of StreamingSpanWriterPlugin_WriteSpanStreamClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStreamingSpanWriterPlugin_WriteSpanStreamClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *StreamingSpanWriterPlugin_WriteSpanStreamClient {
-	mock := &StreamingSpanWriterPlugin_WriteSpanStreamClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamServer.go b/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamServer.go
deleted file mode 100644
index 6838f551..00000000
--- a/internal/proto-gen/storage_v1/mocks/StreamingSpanWriterPlugin_WriteSpanStreamServer.go
+++ /dev/null
@@ -1,411 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	metadata "google.golang.org/grpc/metadata"
-
-	storage_v1 "github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
-)
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer is an autogenerated mock type for the StreamingSpanWriterPlugin_WriteSpanStreamServer type
-type StreamingSpanWriterPlugin_WriteSpanStreamServer struct {
-	mock.Mock
-}
-
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) EXPECT() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter{mock: &_m.Mock}
-}
-
-// Context provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call struct {
-	*mock.Call
-}
-
-// Context is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) Context() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call{Call: _e.mock.On("Context")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) Return(_a0 context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) RunAndReturn(run func() context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Recv provides a mock function with no fields
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) Recv() (*storage_v1.WriteSpanRequest, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Recv")
-	}
-
-	var r0 *storage_v1.WriteSpanRequest
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*storage_v1.WriteSpanRequest, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *storage_v1.WriteSpanRequest); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*storage_v1.WriteSpanRequest)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call struct {
-	*mock.Call
-}
-
-// Recv is a helper method to define mock.On call
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) Recv() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call{Call: _e.mock.On("Recv")}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) Return(_a0 *storage_v1.WriteSpanRequest, _a1 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) RunAndReturn(run func() (*storage_v1.WriteSpanRequest, error)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) RecvMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call struct {
-	*mock.Call
-}
-
-// RecvMsg is a helper method to define mock.On call
-//   - m any
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) RecvMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) RunAndReturn(run func(any) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendAndClose provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendAndClose(_a0 *storage_v1.WriteSpanResponse) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendAndClose")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*storage_v1.WriteSpanResponse) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAndClose'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call struct {
-	*mock.Call
-}
-
-// SendAndClose is a helper method to define mock.On call
-//   - _a0 *storage_v1.WriteSpanResponse
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendAndClose(_a0 interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call{Call: _e.mock.On("SendAndClose", _a0)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) Run(run func(_a0 *storage_v1.WriteSpanResponse)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*storage_v1.WriteSpanResponse))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) RunAndReturn(run func(*storage_v1.WriteSpanResponse) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendHeader provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call struct {
-	*mock.Call
-}
-
-// SendHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendHeader(_a0 interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendMsg(m any) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(any) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call struct {
-	*mock.Call
-}
-
-// SendMsg is a helper method to define mock.On call
-//   - m any
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) RunAndReturn(run func(any) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetHeader provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) SetHeader(_a0 metadata.MD) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SetHeader")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metadata.MD) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call struct {
-	*mock.Call
-}
-
-// SetHeader is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SetHeader(_a0 interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) Return(_a0 error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetTrailer provides a mock function with given fields: _a0
-func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) SetTrailer(_a0 metadata.MD) {
-	_m.Called(_a0)
-}
-
-// StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
-type StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call struct {
-	*mock.Call
-}
-
-// SetTrailer is a helper method to define mock.On call
-//   - _a0 metadata.MD
-func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SetTrailer(_a0 interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
-	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)}
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metadata.MD))
-	})
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) Return() *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewStreamingSpanWriterPlugin_WriteSpanStreamServer creates a new instance of StreamingSpanWriterPlugin_WriteSpanStreamServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStreamingSpanWriterPlugin_WriteSpanStreamServer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *StreamingSpanWriterPlugin_WriteSpanStreamServer {
-	mock := &StreamingSpanWriterPlugin_WriteSpanStreamServer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/proto-gen/storage_v1/mocks/mocks.go b/internal/proto-gen/storage_v1/mocks/mocks.go
new file mode 100644
index 00000000..64d09b0d
--- /dev/null
+++ b/internal/proto-gen/storage_v1/mocks/mocks.go
@@ -0,0 +1,4766 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+
+	"github.com/jaegertracing/jaeger/internal/proto-gen/storage_v1"
+	mock "github.com/stretchr/testify/mock"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// NewSpanWriterPluginClient creates a new instance of SpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanWriterPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanWriterPluginClient {
+	mock := &SpanWriterPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanWriterPluginClient is an autogenerated mock type for the SpanWriterPluginClient type
+type SpanWriterPluginClient struct {
+	mock.Mock
+}
+
+type SpanWriterPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanWriterPluginClient) EXPECT() *SpanWriterPluginClient_Expecter {
+	return &SpanWriterPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type SpanWriterPluginClient
+func (_mock *SpanWriterPluginClient) Close(ctx context.Context, in *storage_v1.CloseWriterRequest, opts ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 *storage_v1.CloseWriterResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) *storage_v1.CloseWriterResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.CloseWriterResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.CloseWriterRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanWriterPluginClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type SpanWriterPluginClient_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanWriterPluginClient_Expecter) Close(ctx interface{}, in interface{}, opts ...interface{}) *SpanWriterPluginClient_Close_Call {
+	return &SpanWriterPluginClient_Close_Call{Call: _e.mock.On("Close",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanWriterPluginClient_Close_Call) Run(run func(ctx context.Context, in *storage_v1.CloseWriterRequest, opts ...grpc.CallOption)) *SpanWriterPluginClient_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.CloseWriterRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanWriterPluginClient_Close_Call) Return(closeWriterResponse *storage_v1.CloseWriterResponse, err error) *SpanWriterPluginClient_Close_Call {
+	_c.Call.Return(closeWriterResponse, err)
+	return _c
+}
+
+func (_c *SpanWriterPluginClient_Close_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.CloseWriterRequest, opts ...grpc.CallOption) (*storage_v1.CloseWriterResponse, error)) *SpanWriterPluginClient_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WriteSpan provides a mock function for the type SpanWriterPluginClient
+func (_mock *SpanWriterPluginClient) WriteSpan(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteSpan")
+	}
+
+	var r0 *storage_v1.WriteSpanResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) *storage_v1.WriteSpanResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanWriterPluginClient_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
+type SpanWriterPluginClient_WriteSpan_Call struct {
+	*mock.Call
+}
+
+// WriteSpan is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanWriterPluginClient_Expecter) WriteSpan(ctx interface{}, in interface{}, opts ...interface{}) *SpanWriterPluginClient_WriteSpan_Call {
+	return &SpanWriterPluginClient_WriteSpan_Call{Call: _e.mock.On("WriteSpan",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanWriterPluginClient_WriteSpan_Call) Run(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption)) *SpanWriterPluginClient_WriteSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanWriterPluginClient_WriteSpan_Call) Return(writeSpanResponse *storage_v1.WriteSpanResponse, err error) *SpanWriterPluginClient_WriteSpan_Call {
+	_c.Call.Return(writeSpanResponse, err)
+	return _c
+}
+
+func (_c *SpanWriterPluginClient_WriteSpan_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)) *SpanWriterPluginClient_WriteSpan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSpanWriterPluginServer creates a new instance of SpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanWriterPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanWriterPluginServer {
+	mock := &SpanWriterPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanWriterPluginServer is an autogenerated mock type for the SpanWriterPluginServer type
+type SpanWriterPluginServer struct {
+	mock.Mock
+}
+
+type SpanWriterPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanWriterPluginServer) EXPECT() *SpanWriterPluginServer_Expecter {
+	return &SpanWriterPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type SpanWriterPluginServer
+func (_mock *SpanWriterPluginServer) Close(context1 context.Context, closeWriterRequest *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error) {
+	ret := _mock.Called(context1, closeWriterRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 *storage_v1.CloseWriterResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error)); ok {
+		return returnFunc(context1, closeWriterRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CloseWriterRequest) *storage_v1.CloseWriterResponse); ok {
+		r0 = returnFunc(context1, closeWriterRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.CloseWriterResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.CloseWriterRequest) error); ok {
+		r1 = returnFunc(context1, closeWriterRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanWriterPluginServer_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type SpanWriterPluginServer_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+//   - context1
+//   - closeWriterRequest
+func (_e *SpanWriterPluginServer_Expecter) Close(context1 interface{}, closeWriterRequest interface{}) *SpanWriterPluginServer_Close_Call {
+	return &SpanWriterPluginServer_Close_Call{Call: _e.mock.On("Close", context1, closeWriterRequest)}
+}
+
+func (_c *SpanWriterPluginServer_Close_Call) Run(run func(context1 context.Context, closeWriterRequest *storage_v1.CloseWriterRequest)) *SpanWriterPluginServer_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.CloseWriterRequest))
+	})
+	return _c
+}
+
+func (_c *SpanWriterPluginServer_Close_Call) Return(closeWriterResponse *storage_v1.CloseWriterResponse, err error) *SpanWriterPluginServer_Close_Call {
+	_c.Call.Return(closeWriterResponse, err)
+	return _c
+}
+
+func (_c *SpanWriterPluginServer_Close_Call) RunAndReturn(run func(context1 context.Context, closeWriterRequest *storage_v1.CloseWriterRequest) (*storage_v1.CloseWriterResponse, error)) *SpanWriterPluginServer_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WriteSpan provides a mock function for the type SpanWriterPluginServer
+func (_mock *SpanWriterPluginServer) WriteSpan(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error) {
+	ret := _mock.Called(context1, writeSpanRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteSpan")
+	}
+
+	var r0 *storage_v1.WriteSpanResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)); ok {
+		return returnFunc(context1, writeSpanRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) *storage_v1.WriteSpanResponse); ok {
+		r0 = returnFunc(context1, writeSpanRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest) error); ok {
+		r1 = returnFunc(context1, writeSpanRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanWriterPluginServer_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
+type SpanWriterPluginServer_WriteSpan_Call struct {
+	*mock.Call
+}
+
+// WriteSpan is a helper method to define mock.On call
+//   - context1
+//   - writeSpanRequest
+func (_e *SpanWriterPluginServer_Expecter) WriteSpan(context1 interface{}, writeSpanRequest interface{}) *SpanWriterPluginServer_WriteSpan_Call {
+	return &SpanWriterPluginServer_WriteSpan_Call{Call: _e.mock.On("WriteSpan", context1, writeSpanRequest)}
+}
+
+func (_c *SpanWriterPluginServer_WriteSpan_Call) Run(run func(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest)) *SpanWriterPluginServer_WriteSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest))
+	})
+	return _c
+}
+
+func (_c *SpanWriterPluginServer_WriteSpan_Call) Return(writeSpanResponse *storage_v1.WriteSpanResponse, err error) *SpanWriterPluginServer_WriteSpan_Call {
+	_c.Call.Return(writeSpanResponse, err)
+	return _c
+}
+
+func (_c *SpanWriterPluginServer_WriteSpan_Call) RunAndReturn(run func(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)) *SpanWriterPluginServer_WriteSpan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewStreamingSpanWriterPluginClient creates a new instance of StreamingSpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStreamingSpanWriterPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *StreamingSpanWriterPluginClient {
+	mock := &StreamingSpanWriterPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// StreamingSpanWriterPluginClient is an autogenerated mock type for the StreamingSpanWriterPluginClient type
+type StreamingSpanWriterPluginClient struct {
+	mock.Mock
+}
+
+type StreamingSpanWriterPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *StreamingSpanWriterPluginClient) EXPECT() *StreamingSpanWriterPluginClient_Expecter {
+	return &StreamingSpanWriterPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// WriteSpanStream provides a mock function for the type StreamingSpanWriterPluginClient
+func (_mock *StreamingSpanWriterPluginClient) WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, opts)
+	} else {
+		tmpRet = _mock.Called(ctx)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteSpanStream")
+	}
+
+	var r0 storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error)); ok {
+		return returnFunc(ctx, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient); ok {
+		r0 = returnFunc(ctx, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// StreamingSpanWriterPluginClient_WriteSpanStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpanStream'
+type StreamingSpanWriterPluginClient_WriteSpanStream_Call struct {
+	*mock.Call
+}
+
+// WriteSpanStream is a helper method to define mock.On call
+//   - ctx
+//   - opts
+func (_e *StreamingSpanWriterPluginClient_Expecter) WriteSpanStream(ctx interface{}, opts ...interface{}) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
+	return &StreamingSpanWriterPluginClient_WriteSpanStream_Call{Call: _e.mock.On("WriteSpanStream",
+		append([]interface{}{ctx}, opts...)...)}
+}
+
+func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) Return(streamingSpanWriterPlugin_WriteSpanStreamClient storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, err error) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
+	_c.Call.Return(streamingSpanWriterPlugin_WriteSpanStreamClient, err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPluginClient_WriteSpanStream_Call) RunAndReturn(run func(ctx context.Context, opts ...grpc.CallOption) (storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamClient, error)) *StreamingSpanWriterPluginClient_WriteSpanStream_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewStreamingSpanWriterPlugin_WriteSpanStreamClient creates a new instance of StreamingSpanWriterPlugin_WriteSpanStreamClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStreamingSpanWriterPlugin_WriteSpanStreamClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *StreamingSpanWriterPlugin_WriteSpanStreamClient {
+	mock := &StreamingSpanWriterPlugin_WriteSpanStreamClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient is an autogenerated mock type for the StreamingSpanWriterPlugin_WriteSpanStreamClient type
+type StreamingSpanWriterPlugin_WriteSpanStreamClient struct {
+	mock.Mock
+}
+
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *StreamingSpanWriterPlugin_WriteSpanStreamClient) EXPECT() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter{mock: &_m.Mock}
+}
+
+// CloseAndRecv provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) CloseAndRecv() (*storage_v1.WriteSpanResponse, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseAndRecv")
+	}
+
+	var r0 *storage_v1.WriteSpanResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (*storage_v1.WriteSpanResponse, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() *storage_v1.WriteSpanResponse); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseAndRecv'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call struct {
+	*mock.Call
+}
+
+// CloseAndRecv is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) CloseAndRecv() *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call{Call: _e.mock.On("CloseAndRecv")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) Return(writeSpanResponse *storage_v1.WriteSpanResponse, err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
+	_c.Call.Return(writeSpanResponse, err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call) RunAndReturn(run func() (*storage_v1.WriteSpanResponse, error)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseAndRecv_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CloseSend provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) CloseSend() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseSend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call struct {
+	*mock.Call
+}
+
+// CloseSend is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) CloseSend() *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call) RunAndReturn(run func() error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_CloseSend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Context provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Context() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) Return(context1 context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call) RunAndReturn(run func() context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Header provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) Header() (metadata.MD, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Header")
+	}
+
+	var r0 metadata.MD
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call struct {
+	*mock.Call
+}
+
+// Header is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Header() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call{Call: _e.mock.On("Header")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) Return(mD metadata.MD, err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
+	_c.Call.Return(mD, err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Header_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) RecvMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call) RunAndReturn(run func(m any) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Send provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) Send(writeSpanRequest *storage_v1.WriteSpanRequest) error {
+	ret := _mock.Called(writeSpanRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.WriteSpanRequest) error); ok {
+		r0 = returnFunc(writeSpanRequest)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - writeSpanRequest
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Send(writeSpanRequest interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call{Call: _e.mock.On("Send", writeSpanRequest)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) Run(run func(writeSpanRequest *storage_v1.WriteSpanRequest)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.WriteSpanRequest))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call) RunAndReturn(run func(writeSpanRequest *storage_v1.WriteSpanRequest) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) SendMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call) RunAndReturn(run func(m any) error) *StreamingSpanWriterPlugin_WriteSpanStreamClient_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Trailer provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamClient
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamClient) Trailer() metadata.MD {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Trailer")
+	}
+
+	var r0 metadata.MD
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
+type StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call struct {
+	*mock.Call
+}
+
+// Trailer is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamClient_Expecter) Trailer() *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call{Call: _e.mock.On("Trailer")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) Return(mD metadata.MD) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
+	_c.Call.Return(mD)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *StreamingSpanWriterPlugin_WriteSpanStreamClient_Trailer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewStreamingSpanWriterPluginServer creates a new instance of StreamingSpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStreamingSpanWriterPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *StreamingSpanWriterPluginServer {
+	mock := &StreamingSpanWriterPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// StreamingSpanWriterPluginServer is an autogenerated mock type for the StreamingSpanWriterPluginServer type
+type StreamingSpanWriterPluginServer struct {
+	mock.Mock
+}
+
+type StreamingSpanWriterPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *StreamingSpanWriterPluginServer) EXPECT() *StreamingSpanWriterPluginServer_Expecter {
+	return &StreamingSpanWriterPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// WriteSpanStream provides a mock function for the type StreamingSpanWriterPluginServer
+func (_mock *StreamingSpanWriterPluginServer) WriteSpanStream(streamingSpanWriterPlugin_WriteSpanStreamServer storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error {
+	ret := _mock.Called(streamingSpanWriterPlugin_WriteSpanStreamServer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteSpanStream")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error); ok {
+		r0 = returnFunc(streamingSpanWriterPlugin_WriteSpanStreamServer)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPluginServer_WriteSpanStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpanStream'
+type StreamingSpanWriterPluginServer_WriteSpanStream_Call struct {
+	*mock.Call
+}
+
+// WriteSpanStream is a helper method to define mock.On call
+//   - streamingSpanWriterPlugin_WriteSpanStreamServer
+func (_e *StreamingSpanWriterPluginServer_Expecter) WriteSpanStream(streamingSpanWriterPlugin_WriteSpanStreamServer interface{}) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
+	return &StreamingSpanWriterPluginServer_WriteSpanStream_Call{Call: _e.mock.On("WriteSpanStream", streamingSpanWriterPlugin_WriteSpanStreamServer)}
+}
+
+func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) Run(run func(streamingSpanWriterPlugin_WriteSpanStreamServer storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer)) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) Return(err error) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPluginServer_WriteSpanStream_Call) RunAndReturn(run func(streamingSpanWriterPlugin_WriteSpanStreamServer storage_v1.StreamingSpanWriterPlugin_WriteSpanStreamServer) error) *StreamingSpanWriterPluginServer_WriteSpanStream_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewStreamingSpanWriterPlugin_WriteSpanStreamServer creates a new instance of StreamingSpanWriterPlugin_WriteSpanStreamServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStreamingSpanWriterPlugin_WriteSpanStreamServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *StreamingSpanWriterPlugin_WriteSpanStreamServer {
+	mock := &StreamingSpanWriterPlugin_WriteSpanStreamServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer is an autogenerated mock type for the StreamingSpanWriterPlugin_WriteSpanStreamServer type
+type StreamingSpanWriterPlugin_WriteSpanStreamServer struct {
+	mock.Mock
+}
+
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *StreamingSpanWriterPlugin_WriteSpanStreamServer) EXPECT() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter{mock: &_m.Mock}
+}
+
+// Context provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) Context() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) Return(context1 context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call) RunAndReturn(run func() context.Context) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Recv provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) Recv() (*storage_v1.WriteSpanRequest, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Recv")
+	}
+
+	var r0 *storage_v1.WriteSpanRequest
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (*storage_v1.WriteSpanRequest, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() *storage_v1.WriteSpanRequest); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanRequest)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call struct {
+	*mock.Call
+}
+
+// Recv is a helper method to define mock.On call
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) Recv() *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call{Call: _e.mock.On("Recv")}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) Run(run func()) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) Return(writeSpanRequest *storage_v1.WriteSpanRequest, err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
+	_c.Call.Return(writeSpanRequest, err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call) RunAndReturn(run func() (*storage_v1.WriteSpanRequest, error)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_Recv_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) RecvMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call) RunAndReturn(run func(m any) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendAndClose provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendAndClose(writeSpanResponse *storage_v1.WriteSpanResponse) error {
+	ret := _mock.Called(writeSpanResponse)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendAndClose")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.WriteSpanResponse) error); ok {
+		r0 = returnFunc(writeSpanResponse)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAndClose'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call struct {
+	*mock.Call
+}
+
+// SendAndClose is a helper method to define mock.On call
+//   - writeSpanResponse
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendAndClose(writeSpanResponse interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call{Call: _e.mock.On("SendAndClose", writeSpanResponse)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) Run(run func(writeSpanResponse *storage_v1.WriteSpanResponse)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.WriteSpanResponse))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call) RunAndReturn(run func(writeSpanResponse *storage_v1.WriteSpanResponse) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendAndClose_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendHeader provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call struct {
+	*mock.Call
+}
+
+// SendHeader is a helper method to define mock.On call
+//   - mD
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendHeader(mD interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call{Call: _e.mock.On("SendHeader", mD)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) Run(run func(mD metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SendMsg(m interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) Run(run func(m any)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call) RunAndReturn(run func(m any) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetHeader provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) SetHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call struct {
+	*mock.Call
+}
+
+// SetHeader is a helper method to define mock.On call
+//   - mD
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SetHeader(mD interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call{Call: _e.mock.On("SetHeader", mD)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) Run(run func(mD metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) Return(err error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetTrailer provides a mock function for the type StreamingSpanWriterPlugin_WriteSpanStreamServer
+func (_mock *StreamingSpanWriterPlugin_WriteSpanStreamServer) SetTrailer(mD metadata.MD) {
+	_mock.Called(mD)
+	return
+}
+
+// StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
+type StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call struct {
+	*mock.Call
+}
+
+// SetTrailer is a helper method to define mock.On call
+//   - mD
+func (_e *StreamingSpanWriterPlugin_WriteSpanStreamServer_Expecter) SetTrailer(mD interface{}) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
+	return &StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", mD)}
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) Run(run func(mD metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) Return() *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call) RunAndReturn(run func(mD metadata.MD)) *StreamingSpanWriterPlugin_WriteSpanStreamServer_SetTrailer_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewSpanReaderPluginClient creates a new instance of SpanReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPluginClient {
+	mock := &SpanReaderPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPluginClient is an autogenerated mock type for the SpanReaderPluginClient type
+type SpanReaderPluginClient struct {
+	mock.Mock
+}
+
+type SpanReaderPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPluginClient) EXPECT() *SpanReaderPluginClient_Expecter {
+	return &SpanReaderPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// FindTraceIDs provides a mock function for the type SpanReaderPluginClient
+func (_mock *SpanReaderPluginClient) FindTraceIDs(ctx context.Context, in *storage_v1.FindTraceIDsRequest, opts ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraceIDs")
+	}
+
+	var r0 *storage_v1.FindTraceIDsResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) *storage_v1.FindTraceIDsResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.FindTraceIDsResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTraceIDsRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginClient_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
+type SpanReaderPluginClient_FindTraceIDs_Call struct {
+	*mock.Call
+}
+
+// FindTraceIDs is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanReaderPluginClient_Expecter) FindTraceIDs(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_FindTraceIDs_Call {
+	return &SpanReaderPluginClient_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanReaderPluginClient_FindTraceIDs_Call) Run(run func(ctx context.Context, in *storage_v1.FindTraceIDsRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_FindTraceIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.FindTraceIDsRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_FindTraceIDs_Call) Return(findTraceIDsResponse *storage_v1.FindTraceIDsResponse, err error) *SpanReaderPluginClient_FindTraceIDs_Call {
+	_c.Call.Return(findTraceIDsResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_FindTraceIDs_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.FindTraceIDsRequest, opts ...grpc.CallOption) (*storage_v1.FindTraceIDsResponse, error)) *SpanReaderPluginClient_FindTraceIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTraces provides a mock function for the type SpanReaderPluginClient
+func (_mock *SpanReaderPluginClient) FindTraces(ctx context.Context, in *storage_v1.FindTracesRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraces")
+	}
+
+	var r0 storage_v1.SpanReaderPlugin_FindTracesClient
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) storage_v1.SpanReaderPlugin_FindTracesClient); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(storage_v1.SpanReaderPlugin_FindTracesClient)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTracesRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginClient_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
+type SpanReaderPluginClient_FindTraces_Call struct {
+	*mock.Call
+}
+
+// FindTraces is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanReaderPluginClient_Expecter) FindTraces(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_FindTraces_Call {
+	return &SpanReaderPluginClient_FindTraces_Call{Call: _e.mock.On("FindTraces",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanReaderPluginClient_FindTraces_Call) Run(run func(ctx context.Context, in *storage_v1.FindTracesRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_FindTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.FindTracesRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_FindTraces_Call) Return(spanReaderPlugin_FindTracesClient storage_v1.SpanReaderPlugin_FindTracesClient, err error) *SpanReaderPluginClient_FindTraces_Call {
+	_c.Call.Return(spanReaderPlugin_FindTracesClient, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_FindTraces_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.FindTracesRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_FindTracesClient, error)) *SpanReaderPluginClient_FindTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOperations provides a mock function for the type SpanReaderPluginClient
+func (_mock *SpanReaderPluginClient) GetOperations(ctx context.Context, in *storage_v1.GetOperationsRequest, opts ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOperations")
+	}
+
+	var r0 *storage_v1.GetOperationsResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) *storage_v1.GetOperationsResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetOperationsResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetOperationsRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginClient_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
+type SpanReaderPluginClient_GetOperations_Call struct {
+	*mock.Call
+}
+
+// GetOperations is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanReaderPluginClient_Expecter) GetOperations(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetOperations_Call {
+	return &SpanReaderPluginClient_GetOperations_Call{Call: _e.mock.On("GetOperations",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanReaderPluginClient_GetOperations_Call) Run(run func(ctx context.Context, in *storage_v1.GetOperationsRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetOperations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.GetOperationsRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetOperations_Call) Return(getOperationsResponse *storage_v1.GetOperationsResponse, err error) *SpanReaderPluginClient_GetOperations_Call {
+	_c.Call.Return(getOperationsResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetOperations_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.GetOperationsRequest, opts ...grpc.CallOption) (*storage_v1.GetOperationsResponse, error)) *SpanReaderPluginClient_GetOperations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetServices provides a mock function for the type SpanReaderPluginClient
+func (_mock *SpanReaderPluginClient) GetServices(ctx context.Context, in *storage_v1.GetServicesRequest, opts ...grpc.CallOption) (*storage_v1.GetServicesResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetServices")
+	}
+
+	var r0 *storage_v1.GetServicesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) (*storage_v1.GetServicesResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) *storage_v1.GetServicesResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetServicesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetServicesRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginClient_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
+type SpanReaderPluginClient_GetServices_Call struct {
+	*mock.Call
+}
+
+// GetServices is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanReaderPluginClient_Expecter) GetServices(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetServices_Call {
+	return &SpanReaderPluginClient_GetServices_Call{Call: _e.mock.On("GetServices",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanReaderPluginClient_GetServices_Call) Run(run func(ctx context.Context, in *storage_v1.GetServicesRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetServices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.GetServicesRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetServices_Call) Return(getServicesResponse *storage_v1.GetServicesResponse, err error) *SpanReaderPluginClient_GetServices_Call {
+	_c.Call.Return(getServicesResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetServices_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.GetServicesRequest, opts ...grpc.CallOption) (*storage_v1.GetServicesResponse, error)) *SpanReaderPluginClient_GetServices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTrace provides a mock function for the type SpanReaderPluginClient
+func (_mock *SpanReaderPluginClient) GetTrace(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTrace")
+	}
+
+	var r0 storage_v1.SpanReaderPlugin_GetTraceClient
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) storage_v1.SpanReaderPlugin_GetTraceClient); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(storage_v1.SpanReaderPlugin_GetTraceClient)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginClient_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
+type SpanReaderPluginClient_GetTrace_Call struct {
+	*mock.Call
+}
+
+// GetTrace is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *SpanReaderPluginClient_Expecter) GetTrace(ctx interface{}, in interface{}, opts ...interface{}) *SpanReaderPluginClient_GetTrace_Call {
+	return &SpanReaderPluginClient_GetTrace_Call{Call: _e.mock.On("GetTrace",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *SpanReaderPluginClient_GetTrace_Call) Run(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption)) *SpanReaderPluginClient_GetTrace_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.GetTraceRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetTrace_Call) Return(spanReaderPlugin_GetTraceClient storage_v1.SpanReaderPlugin_GetTraceClient, err error) *SpanReaderPluginClient_GetTrace_Call {
+	_c.Call.Return(spanReaderPlugin_GetTraceClient, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginClient_GetTrace_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.SpanReaderPlugin_GetTraceClient, error)) *SpanReaderPluginClient_GetTrace_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSpanReaderPlugin_GetTraceClient creates a new instance of SpanReaderPlugin_GetTraceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPlugin_GetTraceClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPlugin_GetTraceClient {
+	mock := &SpanReaderPlugin_GetTraceClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPlugin_GetTraceClient is an autogenerated mock type for the SpanReaderPlugin_GetTraceClient type
+type SpanReaderPlugin_GetTraceClient struct {
+	mock.Mock
+}
+
+type SpanReaderPlugin_GetTraceClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPlugin_GetTraceClient) EXPECT() *SpanReaderPlugin_GetTraceClient_Expecter {
+	return &SpanReaderPlugin_GetTraceClient_Expecter{mock: &_m.Mock}
+}
+
+// CloseSend provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) CloseSend() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseSend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
+type SpanReaderPlugin_GetTraceClient_CloseSend_Call struct {
+	*mock.Call
+}
+
+// CloseSend is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) CloseSend() *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
+	return &SpanReaderPlugin_GetTraceClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) Return(err error) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_CloseSend_Call) RunAndReturn(run func() error) *SpanReaderPlugin_GetTraceClient_CloseSend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Context provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type SpanReaderPlugin_GetTraceClient_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Context() *SpanReaderPlugin_GetTraceClient_Context_Call {
+	return &SpanReaderPlugin_GetTraceClient_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) Return(context1 context.Context) *SpanReaderPlugin_GetTraceClient_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_GetTraceClient_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Header provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) Header() (metadata.MD, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Header")
+	}
+
+	var r0 metadata.MD
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPlugin_GetTraceClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
+type SpanReaderPlugin_GetTraceClient_Header_Call struct {
+	*mock.Call
+}
+
+// Header is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Header() *SpanReaderPlugin_GetTraceClient_Header_Call {
+	return &SpanReaderPlugin_GetTraceClient_Header_Call{Call: _e.mock.On("Header")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Header_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) Return(mD metadata.MD, err error) *SpanReaderPlugin_GetTraceClient_Header_Call {
+	_c.Call.Return(mD, err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *SpanReaderPlugin_GetTraceClient_Header_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Recv provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) Recv() (*storage_v1.SpansResponseChunk, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Recv")
+	}
+
+	var r0 *storage_v1.SpansResponseChunk
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPlugin_GetTraceClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
+type SpanReaderPlugin_GetTraceClient_Recv_Call struct {
+	*mock.Call
+}
+
+// Recv is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Recv() *SpanReaderPlugin_GetTraceClient_Recv_Call {
+	return &SpanReaderPlugin_GetTraceClient_Recv_Call{Call: _e.mock.On("Recv")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Recv_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) Return(spansResponseChunk *storage_v1.SpansResponseChunk, err error) *SpanReaderPlugin_GetTraceClient_Recv_Call {
+	_c.Call.Return(spansResponseChunk, err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *SpanReaderPlugin_GetTraceClient_Recv_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type SpanReaderPlugin_GetTraceClient_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
+	return &SpanReaderPlugin_GetTraceClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) Return(err error) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_RecvMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_GetTraceClient_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type SpanReaderPlugin_GetTraceClient_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
+	return &SpanReaderPlugin_GetTraceClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) Return(err error) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_SendMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_GetTraceClient_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Trailer provides a mock function for the type SpanReaderPlugin_GetTraceClient
+func (_mock *SpanReaderPlugin_GetTraceClient) Trailer() metadata.MD {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Trailer")
+	}
+
+	var r0 metadata.MD
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
+type SpanReaderPlugin_GetTraceClient_Trailer_Call struct {
+	*mock.Call
+}
+
+// Trailer is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceClient_Expecter) Trailer() *SpanReaderPlugin_GetTraceClient_Trailer_Call {
+	return &SpanReaderPlugin_GetTraceClient_Trailer_Call{Call: _e.mock.On("Trailer")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) Run(run func()) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) Return(mD metadata.MD) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
+	_c.Call.Return(mD)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *SpanReaderPlugin_GetTraceClient_Trailer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSpanReaderPlugin_FindTracesClient creates a new instance of SpanReaderPlugin_FindTracesClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPlugin_FindTracesClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPlugin_FindTracesClient {
+	mock := &SpanReaderPlugin_FindTracesClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPlugin_FindTracesClient is an autogenerated mock type for the SpanReaderPlugin_FindTracesClient type
+type SpanReaderPlugin_FindTracesClient struct {
+	mock.Mock
+}
+
+type SpanReaderPlugin_FindTracesClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPlugin_FindTracesClient) EXPECT() *SpanReaderPlugin_FindTracesClient_Expecter {
+	return &SpanReaderPlugin_FindTracesClient_Expecter{mock: &_m.Mock}
+}
+
+// CloseSend provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) CloseSend() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseSend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
+type SpanReaderPlugin_FindTracesClient_CloseSend_Call struct {
+	*mock.Call
+}
+
+// CloseSend is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) CloseSend() *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
+	return &SpanReaderPlugin_FindTracesClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) Return(err error) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_CloseSend_Call) RunAndReturn(run func() error) *SpanReaderPlugin_FindTracesClient_CloseSend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Context provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type SpanReaderPlugin_FindTracesClient_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Context() *SpanReaderPlugin_FindTracesClient_Context_Call {
+	return &SpanReaderPlugin_FindTracesClient_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) Return(context1 context.Context) *SpanReaderPlugin_FindTracesClient_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_FindTracesClient_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Header provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) Header() (metadata.MD, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Header")
+	}
+
+	var r0 metadata.MD
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPlugin_FindTracesClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
+type SpanReaderPlugin_FindTracesClient_Header_Call struct {
+	*mock.Call
+}
+
+// Header is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Header() *SpanReaderPlugin_FindTracesClient_Header_Call {
+	return &SpanReaderPlugin_FindTracesClient_Header_Call{Call: _e.mock.On("Header")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Header_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) Return(mD metadata.MD, err error) *SpanReaderPlugin_FindTracesClient_Header_Call {
+	_c.Call.Return(mD, err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *SpanReaderPlugin_FindTracesClient_Header_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Recv provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) Recv() (*storage_v1.SpansResponseChunk, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Recv")
+	}
+
+	var r0 *storage_v1.SpansResponseChunk
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPlugin_FindTracesClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
+type SpanReaderPlugin_FindTracesClient_Recv_Call struct {
+	*mock.Call
+}
+
+// Recv is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Recv() *SpanReaderPlugin_FindTracesClient_Recv_Call {
+	return &SpanReaderPlugin_FindTracesClient_Recv_Call{Call: _e.mock.On("Recv")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Recv_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) Return(spansResponseChunk *storage_v1.SpansResponseChunk, err error) *SpanReaderPlugin_FindTracesClient_Recv_Call {
+	_c.Call.Return(spansResponseChunk, err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *SpanReaderPlugin_FindTracesClient_Recv_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type SpanReaderPlugin_FindTracesClient_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
+	return &SpanReaderPlugin_FindTracesClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) Return(err error) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_RecvMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_FindTracesClient_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type SpanReaderPlugin_FindTracesClient_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
+	return &SpanReaderPlugin_FindTracesClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) Return(err error) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_SendMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_FindTracesClient_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Trailer provides a mock function for the type SpanReaderPlugin_FindTracesClient
+func (_mock *SpanReaderPlugin_FindTracesClient) Trailer() metadata.MD {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Trailer")
+	}
+
+	var r0 metadata.MD
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
+type SpanReaderPlugin_FindTracesClient_Trailer_Call struct {
+	*mock.Call
+}
+
+// Trailer is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesClient_Expecter) Trailer() *SpanReaderPlugin_FindTracesClient_Trailer_Call {
+	return &SpanReaderPlugin_FindTracesClient_Trailer_Call{Call: _e.mock.On("Trailer")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) Run(run func()) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) Return(mD metadata.MD) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
+	_c.Call.Return(mD)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *SpanReaderPlugin_FindTracesClient_Trailer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSpanReaderPluginServer creates a new instance of SpanReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPluginServer {
+	mock := &SpanReaderPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPluginServer is an autogenerated mock type for the SpanReaderPluginServer type
+type SpanReaderPluginServer struct {
+	mock.Mock
+}
+
+type SpanReaderPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPluginServer) EXPECT() *SpanReaderPluginServer_Expecter {
+	return &SpanReaderPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// FindTraceIDs provides a mock function for the type SpanReaderPluginServer
+func (_mock *SpanReaderPluginServer) FindTraceIDs(context1 context.Context, findTraceIDsRequest *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error) {
+	ret := _mock.Called(context1, findTraceIDsRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraceIDs")
+	}
+
+	var r0 *storage_v1.FindTraceIDsResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error)); ok {
+		return returnFunc(context1, findTraceIDsRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.FindTraceIDsRequest) *storage_v1.FindTraceIDsResponse); ok {
+		r0 = returnFunc(context1, findTraceIDsRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.FindTraceIDsResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.FindTraceIDsRequest) error); ok {
+		r1 = returnFunc(context1, findTraceIDsRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginServer_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
+type SpanReaderPluginServer_FindTraceIDs_Call struct {
+	*mock.Call
+}
+
+// FindTraceIDs is a helper method to define mock.On call
+//   - context1
+//   - findTraceIDsRequest
+func (_e *SpanReaderPluginServer_Expecter) FindTraceIDs(context1 interface{}, findTraceIDsRequest interface{}) *SpanReaderPluginServer_FindTraceIDs_Call {
+	return &SpanReaderPluginServer_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", context1, findTraceIDsRequest)}
+}
+
+func (_c *SpanReaderPluginServer_FindTraceIDs_Call) Run(run func(context1 context.Context, findTraceIDsRequest *storage_v1.FindTraceIDsRequest)) *SpanReaderPluginServer_FindTraceIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.FindTraceIDsRequest))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_FindTraceIDs_Call) Return(findTraceIDsResponse *storage_v1.FindTraceIDsResponse, err error) *SpanReaderPluginServer_FindTraceIDs_Call {
+	_c.Call.Return(findTraceIDsResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_FindTraceIDs_Call) RunAndReturn(run func(context1 context.Context, findTraceIDsRequest *storage_v1.FindTraceIDsRequest) (*storage_v1.FindTraceIDsResponse, error)) *SpanReaderPluginServer_FindTraceIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTraces provides a mock function for the type SpanReaderPluginServer
+func (_mock *SpanReaderPluginServer) FindTraces(findTracesRequest *storage_v1.FindTracesRequest, spanReaderPlugin_FindTracesServer storage_v1.SpanReaderPlugin_FindTracesServer) error {
+	ret := _mock.Called(findTracesRequest, spanReaderPlugin_FindTracesServer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraces")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.FindTracesRequest, storage_v1.SpanReaderPlugin_FindTracesServer) error); ok {
+		r0 = returnFunc(findTracesRequest, spanReaderPlugin_FindTracesServer)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPluginServer_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
+type SpanReaderPluginServer_FindTraces_Call struct {
+	*mock.Call
+}
+
+// FindTraces is a helper method to define mock.On call
+//   - findTracesRequest
+//   - spanReaderPlugin_FindTracesServer
+func (_e *SpanReaderPluginServer_Expecter) FindTraces(findTracesRequest interface{}, spanReaderPlugin_FindTracesServer interface{}) *SpanReaderPluginServer_FindTraces_Call {
+	return &SpanReaderPluginServer_FindTraces_Call{Call: _e.mock.On("FindTraces", findTracesRequest, spanReaderPlugin_FindTracesServer)}
+}
+
+func (_c *SpanReaderPluginServer_FindTraces_Call) Run(run func(findTracesRequest *storage_v1.FindTracesRequest, spanReaderPlugin_FindTracesServer storage_v1.SpanReaderPlugin_FindTracesServer)) *SpanReaderPluginServer_FindTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.FindTracesRequest), args[1].(storage_v1.SpanReaderPlugin_FindTracesServer))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_FindTraces_Call) Return(err error) *SpanReaderPluginServer_FindTraces_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_FindTraces_Call) RunAndReturn(run func(findTracesRequest *storage_v1.FindTracesRequest, spanReaderPlugin_FindTracesServer storage_v1.SpanReaderPlugin_FindTracesServer) error) *SpanReaderPluginServer_FindTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOperations provides a mock function for the type SpanReaderPluginServer
+func (_mock *SpanReaderPluginServer) GetOperations(context1 context.Context, getOperationsRequest *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error) {
+	ret := _mock.Called(context1, getOperationsRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOperations")
+	}
+
+	var r0 *storage_v1.GetOperationsResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error)); ok {
+		return returnFunc(context1, getOperationsRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetOperationsRequest) *storage_v1.GetOperationsResponse); ok {
+		r0 = returnFunc(context1, getOperationsRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetOperationsResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetOperationsRequest) error); ok {
+		r1 = returnFunc(context1, getOperationsRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginServer_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
+type SpanReaderPluginServer_GetOperations_Call struct {
+	*mock.Call
+}
+
+// GetOperations is a helper method to define mock.On call
+//   - context1
+//   - getOperationsRequest
+func (_e *SpanReaderPluginServer_Expecter) GetOperations(context1 interface{}, getOperationsRequest interface{}) *SpanReaderPluginServer_GetOperations_Call {
+	return &SpanReaderPluginServer_GetOperations_Call{Call: _e.mock.On("GetOperations", context1, getOperationsRequest)}
+}
+
+func (_c *SpanReaderPluginServer_GetOperations_Call) Run(run func(context1 context.Context, getOperationsRequest *storage_v1.GetOperationsRequest)) *SpanReaderPluginServer_GetOperations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.GetOperationsRequest))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetOperations_Call) Return(getOperationsResponse *storage_v1.GetOperationsResponse, err error) *SpanReaderPluginServer_GetOperations_Call {
+	_c.Call.Return(getOperationsResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetOperations_Call) RunAndReturn(run func(context1 context.Context, getOperationsRequest *storage_v1.GetOperationsRequest) (*storage_v1.GetOperationsResponse, error)) *SpanReaderPluginServer_GetOperations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetServices provides a mock function for the type SpanReaderPluginServer
+func (_mock *SpanReaderPluginServer) GetServices(context1 context.Context, getServicesRequest *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error) {
+	ret := _mock.Called(context1, getServicesRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetServices")
+	}
+
+	var r0 *storage_v1.GetServicesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error)); ok {
+		return returnFunc(context1, getServicesRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetServicesRequest) *storage_v1.GetServicesResponse); ok {
+		r0 = returnFunc(context1, getServicesRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetServicesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetServicesRequest) error); ok {
+		r1 = returnFunc(context1, getServicesRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SpanReaderPluginServer_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
+type SpanReaderPluginServer_GetServices_Call struct {
+	*mock.Call
+}
+
+// GetServices is a helper method to define mock.On call
+//   - context1
+//   - getServicesRequest
+func (_e *SpanReaderPluginServer_Expecter) GetServices(context1 interface{}, getServicesRequest interface{}) *SpanReaderPluginServer_GetServices_Call {
+	return &SpanReaderPluginServer_GetServices_Call{Call: _e.mock.On("GetServices", context1, getServicesRequest)}
+}
+
+func (_c *SpanReaderPluginServer_GetServices_Call) Run(run func(context1 context.Context, getServicesRequest *storage_v1.GetServicesRequest)) *SpanReaderPluginServer_GetServices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.GetServicesRequest))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetServices_Call) Return(getServicesResponse *storage_v1.GetServicesResponse, err error) *SpanReaderPluginServer_GetServices_Call {
+	_c.Call.Return(getServicesResponse, err)
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetServices_Call) RunAndReturn(run func(context1 context.Context, getServicesRequest *storage_v1.GetServicesRequest) (*storage_v1.GetServicesResponse, error)) *SpanReaderPluginServer_GetServices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTrace provides a mock function for the type SpanReaderPluginServer
+func (_mock *SpanReaderPluginServer) GetTrace(getTraceRequest *storage_v1.GetTraceRequest, spanReaderPlugin_GetTraceServer storage_v1.SpanReaderPlugin_GetTraceServer) error {
+	ret := _mock.Called(getTraceRequest, spanReaderPlugin_GetTraceServer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTrace")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.GetTraceRequest, storage_v1.SpanReaderPlugin_GetTraceServer) error); ok {
+		r0 = returnFunc(getTraceRequest, spanReaderPlugin_GetTraceServer)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPluginServer_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
+type SpanReaderPluginServer_GetTrace_Call struct {
+	*mock.Call
+}
+
+// GetTrace is a helper method to define mock.On call
+//   - getTraceRequest
+//   - spanReaderPlugin_GetTraceServer
+func (_e *SpanReaderPluginServer_Expecter) GetTrace(getTraceRequest interface{}, spanReaderPlugin_GetTraceServer interface{}) *SpanReaderPluginServer_GetTrace_Call {
+	return &SpanReaderPluginServer_GetTrace_Call{Call: _e.mock.On("GetTrace", getTraceRequest, spanReaderPlugin_GetTraceServer)}
+}
+
+func (_c *SpanReaderPluginServer_GetTrace_Call) Run(run func(getTraceRequest *storage_v1.GetTraceRequest, spanReaderPlugin_GetTraceServer storage_v1.SpanReaderPlugin_GetTraceServer)) *SpanReaderPluginServer_GetTrace_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.GetTraceRequest), args[1].(storage_v1.SpanReaderPlugin_GetTraceServer))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetTrace_Call) Return(err error) *SpanReaderPluginServer_GetTrace_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPluginServer_GetTrace_Call) RunAndReturn(run func(getTraceRequest *storage_v1.GetTraceRequest, spanReaderPlugin_GetTraceServer storage_v1.SpanReaderPlugin_GetTraceServer) error) *SpanReaderPluginServer_GetTrace_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSpanReaderPlugin_GetTraceServer creates a new instance of SpanReaderPlugin_GetTraceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPlugin_GetTraceServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPlugin_GetTraceServer {
+	mock := &SpanReaderPlugin_GetTraceServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPlugin_GetTraceServer is an autogenerated mock type for the SpanReaderPlugin_GetTraceServer type
+type SpanReaderPlugin_GetTraceServer struct {
+	mock.Mock
+}
+
+type SpanReaderPlugin_GetTraceServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPlugin_GetTraceServer) EXPECT() *SpanReaderPlugin_GetTraceServer_Expecter {
+	return &SpanReaderPlugin_GetTraceServer_Expecter{mock: &_m.Mock}
+}
+
+// Context provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type SpanReaderPlugin_GetTraceServer_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) Context() *SpanReaderPlugin_GetTraceServer_Context_Call {
+	return &SpanReaderPlugin_GetTraceServer_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) Run(run func()) *SpanReaderPlugin_GetTraceServer_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) Return(context1 context.Context) *SpanReaderPlugin_GetTraceServer_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_GetTraceServer_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type SpanReaderPlugin_GetTraceServer_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
+	return &SpanReaderPlugin_GetTraceServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) Return(err error) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_RecvMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_GetTraceServer_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Send provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) Send(spansResponseChunk *storage_v1.SpansResponseChunk) error {
+	ret := _mock.Called(spansResponseChunk)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
+		r0 = returnFunc(spansResponseChunk)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type SpanReaderPlugin_GetTraceServer_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - spansResponseChunk
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) Send(spansResponseChunk interface{}) *SpanReaderPlugin_GetTraceServer_Send_Call {
+	return &SpanReaderPlugin_GetTraceServer_Send_Call{Call: _e.mock.On("Send", spansResponseChunk)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) Run(run func(spansResponseChunk *storage_v1.SpansResponseChunk)) *SpanReaderPlugin_GetTraceServer_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.SpansResponseChunk))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) Return(err error) *SpanReaderPlugin_GetTraceServer_Send_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_Send_Call) RunAndReturn(run func(spansResponseChunk *storage_v1.SpansResponseChunk) error) *SpanReaderPlugin_GetTraceServer_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendHeader provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) SendHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
+type SpanReaderPlugin_GetTraceServer_SendHeader_Call struct {
+	*mock.Call
+}
+
+// SendHeader is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SendHeader(mD interface{}) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
+	return &SpanReaderPlugin_GetTraceServer_SendHeader_Call{Call: _e.mock.On("SendHeader", mD)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) Return(err error) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *SpanReaderPlugin_GetTraceServer_SendHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type SpanReaderPlugin_GetTraceServer_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
+	return &SpanReaderPlugin_GetTraceServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) Return(err error) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SendMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_GetTraceServer_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetHeader provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) SetHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_GetTraceServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
+type SpanReaderPlugin_GetTraceServer_SetHeader_Call struct {
+	*mock.Call
+}
+
+// SetHeader is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SetHeader(mD interface{}) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
+	return &SpanReaderPlugin_GetTraceServer_SetHeader_Call{Call: _e.mock.On("SetHeader", mD)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) Return(err error) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *SpanReaderPlugin_GetTraceServer_SetHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetTrailer provides a mock function for the type SpanReaderPlugin_GetTraceServer
+func (_mock *SpanReaderPlugin_GetTraceServer) SetTrailer(mD metadata.MD) {
+	_mock.Called(mD)
+	return
+}
+
+// SpanReaderPlugin_GetTraceServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
+type SpanReaderPlugin_GetTraceServer_SetTrailer_Call struct {
+	*mock.Call
+}
+
+// SetTrailer is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_GetTraceServer_Expecter) SetTrailer(mD interface{}) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
+	return &SpanReaderPlugin_GetTraceServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", mD)}
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) Return() *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *SpanReaderPlugin_GetTraceServer_SetTrailer_Call) RunAndReturn(run func(mD metadata.MD)) *SpanReaderPlugin_GetTraceServer_SetTrailer_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewSpanReaderPlugin_FindTracesServer creates a new instance of SpanReaderPlugin_FindTracesServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSpanReaderPlugin_FindTracesServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SpanReaderPlugin_FindTracesServer {
+	mock := &SpanReaderPlugin_FindTracesServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SpanReaderPlugin_FindTracesServer is an autogenerated mock type for the SpanReaderPlugin_FindTracesServer type
+type SpanReaderPlugin_FindTracesServer struct {
+	mock.Mock
+}
+
+type SpanReaderPlugin_FindTracesServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpanReaderPlugin_FindTracesServer) EXPECT() *SpanReaderPlugin_FindTracesServer_Expecter {
+	return &SpanReaderPlugin_FindTracesServer_Expecter{mock: &_m.Mock}
+}
+
+// Context provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type SpanReaderPlugin_FindTracesServer_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) Context() *SpanReaderPlugin_FindTracesServer_Context_Call {
+	return &SpanReaderPlugin_FindTracesServer_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) Run(run func()) *SpanReaderPlugin_FindTracesServer_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) Return(context1 context.Context) *SpanReaderPlugin_FindTracesServer_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Context_Call) RunAndReturn(run func() context.Context) *SpanReaderPlugin_FindTracesServer_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type SpanReaderPlugin_FindTracesServer_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) RecvMsg(m interface{}) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
+	return &SpanReaderPlugin_FindTracesServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) Return(err error) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_RecvMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_FindTracesServer_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Send provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) Send(spansResponseChunk *storage_v1.SpansResponseChunk) error {
+	ret := _mock.Called(spansResponseChunk)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
+		r0 = returnFunc(spansResponseChunk)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type SpanReaderPlugin_FindTracesServer_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - spansResponseChunk
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) Send(spansResponseChunk interface{}) *SpanReaderPlugin_FindTracesServer_Send_Call {
+	return &SpanReaderPlugin_FindTracesServer_Send_Call{Call: _e.mock.On("Send", spansResponseChunk)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) Run(run func(spansResponseChunk *storage_v1.SpansResponseChunk)) *SpanReaderPlugin_FindTracesServer_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.SpansResponseChunk))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) Return(err error) *SpanReaderPlugin_FindTracesServer_Send_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_Send_Call) RunAndReturn(run func(spansResponseChunk *storage_v1.SpansResponseChunk) error) *SpanReaderPlugin_FindTracesServer_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendHeader provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) SendHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
+type SpanReaderPlugin_FindTracesServer_SendHeader_Call struct {
+	*mock.Call
+}
+
+// SendHeader is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SendHeader(mD interface{}) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
+	return &SpanReaderPlugin_FindTracesServer_SendHeader_Call{Call: _e.mock.On("SendHeader", mD)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) Return(err error) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *SpanReaderPlugin_FindTracesServer_SendHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type SpanReaderPlugin_FindTracesServer_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SendMsg(m interface{}) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
+	return &SpanReaderPlugin_FindTracesServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) Run(run func(m any)) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) Return(err error) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SendMsg_Call) RunAndReturn(run func(m any) error) *SpanReaderPlugin_FindTracesServer_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetHeader provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) SetHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// SpanReaderPlugin_FindTracesServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
+type SpanReaderPlugin_FindTracesServer_SetHeader_Call struct {
+	*mock.Call
+}
+
+// SetHeader is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SetHeader(mD interface{}) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
+	return &SpanReaderPlugin_FindTracesServer_SetHeader_Call{Call: _e.mock.On("SetHeader", mD)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) Return(err error) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *SpanReaderPlugin_FindTracesServer_SetHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetTrailer provides a mock function for the type SpanReaderPlugin_FindTracesServer
+func (_mock *SpanReaderPlugin_FindTracesServer) SetTrailer(mD metadata.MD) {
+	_mock.Called(mD)
+	return
+}
+
+// SpanReaderPlugin_FindTracesServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
+type SpanReaderPlugin_FindTracesServer_SetTrailer_Call struct {
+	*mock.Call
+}
+
+// SetTrailer is a helper method to define mock.On call
+//   - mD
+func (_e *SpanReaderPlugin_FindTracesServer_Expecter) SetTrailer(mD interface{}) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
+	return &SpanReaderPlugin_FindTracesServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", mD)}
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) Run(run func(mD metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) Return() *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *SpanReaderPlugin_FindTracesServer_SetTrailer_Call) RunAndReturn(run func(mD metadata.MD)) *SpanReaderPlugin_FindTracesServer_SetTrailer_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewArchiveSpanWriterPluginClient creates a new instance of ArchiveSpanWriterPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanWriterPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanWriterPluginClient {
+	mock := &ArchiveSpanWriterPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanWriterPluginClient is an autogenerated mock type for the ArchiveSpanWriterPluginClient type
+type ArchiveSpanWriterPluginClient struct {
+	mock.Mock
+}
+
+type ArchiveSpanWriterPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanWriterPluginClient) EXPECT() *ArchiveSpanWriterPluginClient_Expecter {
+	return &ArchiveSpanWriterPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// WriteArchiveSpan provides a mock function for the type ArchiveSpanWriterPluginClient
+func (_mock *ArchiveSpanWriterPluginClient) WriteArchiveSpan(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteArchiveSpan")
+	}
+
+	var r0 *storage_v1.WriteSpanResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) *storage_v1.WriteSpanResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteArchiveSpan'
+type ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call struct {
+	*mock.Call
+}
+
+// WriteArchiveSpan is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *ArchiveSpanWriterPluginClient_Expecter) WriteArchiveSpan(ctx interface{}, in interface{}, opts ...interface{}) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
+	return &ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call{Call: _e.mock.On("WriteArchiveSpan",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) Run(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption)) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) Return(writeSpanResponse *storage_v1.WriteSpanResponse, err error) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
+	_c.Call.Return(writeSpanResponse, err)
+	return _c
+}
+
+func (_c *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.WriteSpanRequest, opts ...grpc.CallOption) (*storage_v1.WriteSpanResponse, error)) *ArchiveSpanWriterPluginClient_WriteArchiveSpan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewArchiveSpanWriterPluginServer creates a new instance of ArchiveSpanWriterPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanWriterPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanWriterPluginServer {
+	mock := &ArchiveSpanWriterPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanWriterPluginServer is an autogenerated mock type for the ArchiveSpanWriterPluginServer type
+type ArchiveSpanWriterPluginServer struct {
+	mock.Mock
+}
+
+type ArchiveSpanWriterPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanWriterPluginServer) EXPECT() *ArchiveSpanWriterPluginServer_Expecter {
+	return &ArchiveSpanWriterPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// WriteArchiveSpan provides a mock function for the type ArchiveSpanWriterPluginServer
+func (_mock *ArchiveSpanWriterPluginServer) WriteArchiveSpan(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error) {
+	ret := _mock.Called(context1, writeSpanRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteArchiveSpan")
+	}
+
+	var r0 *storage_v1.WriteSpanResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)); ok {
+		return returnFunc(context1, writeSpanRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.WriteSpanRequest) *storage_v1.WriteSpanResponse); ok {
+		r0 = returnFunc(context1, writeSpanRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.WriteSpanResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.WriteSpanRequest) error); ok {
+		r1 = returnFunc(context1, writeSpanRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteArchiveSpan'
+type ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call struct {
+	*mock.Call
+}
+
+// WriteArchiveSpan is a helper method to define mock.On call
+//   - context1
+//   - writeSpanRequest
+func (_e *ArchiveSpanWriterPluginServer_Expecter) WriteArchiveSpan(context1 interface{}, writeSpanRequest interface{}) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
+	return &ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call{Call: _e.mock.On("WriteArchiveSpan", context1, writeSpanRequest)}
+}
+
+func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) Run(run func(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest)) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.WriteSpanRequest))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) Return(writeSpanResponse *storage_v1.WriteSpanResponse, err error) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
+	_c.Call.Return(writeSpanResponse, err)
+	return _c
+}
+
+func (_c *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call) RunAndReturn(run func(context1 context.Context, writeSpanRequest *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error)) *ArchiveSpanWriterPluginServer_WriteArchiveSpan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewArchiveSpanReaderPluginClient creates a new instance of ArchiveSpanReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanReaderPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanReaderPluginClient {
+	mock := &ArchiveSpanReaderPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanReaderPluginClient is an autogenerated mock type for the ArchiveSpanReaderPluginClient type
+type ArchiveSpanReaderPluginClient struct {
+	mock.Mock
+}
+
+type ArchiveSpanReaderPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanReaderPluginClient) EXPECT() *ArchiveSpanReaderPluginClient_Expecter {
+	return &ArchiveSpanReaderPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// GetArchiveTrace provides a mock function for the type ArchiveSpanReaderPluginClient
+func (_mock *ArchiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetArchiveTrace")
+	}
+
+	var r0 storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetTraceRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ArchiveSpanReaderPluginClient_GetArchiveTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArchiveTrace'
+type ArchiveSpanReaderPluginClient_GetArchiveTrace_Call struct {
+	*mock.Call
+}
+
+// GetArchiveTrace is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *ArchiveSpanReaderPluginClient_Expecter) GetArchiveTrace(ctx interface{}, in interface{}, opts ...interface{}) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
+	return &ArchiveSpanReaderPluginClient_GetArchiveTrace_Call{Call: _e.mock.On("GetArchiveTrace",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) Run(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption)) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.GetTraceRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) Return(archiveSpanReaderPlugin_GetArchiveTraceClient storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, err error) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
+	_c.Call.Return(archiveSpanReaderPlugin_GetArchiveTraceClient, err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.GetTraceRequest, opts ...grpc.CallOption) (storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceClient, error)) *ArchiveSpanReaderPluginClient_GetArchiveTrace_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewArchiveSpanReaderPlugin_GetArchiveTraceClient creates a new instance of ArchiveSpanReaderPlugin_GetArchiveTraceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanReaderPlugin_GetArchiveTraceClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient {
+	mock := &ArchiveSpanReaderPlugin_GetArchiveTraceClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient is an autogenerated mock type for the ArchiveSpanReaderPlugin_GetArchiveTraceClient type
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient struct {
+	mock.Mock
+}
+
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceClient) EXPECT() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter{mock: &_m.Mock}
+}
+
+// CloseSend provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) CloseSend() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseSend")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call struct {
+	*mock.Call
+}
+
+// CloseSend is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) CloseSend() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call{Call: _e.mock.On("CloseSend")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call) RunAndReturn(run func() error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_CloseSend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Context provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Context() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) Return(context1 context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call) RunAndReturn(run func() context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Header provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Header() (metadata.MD, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Header")
+	}
+
+	var r0 metadata.MD
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call struct {
+	*mock.Call
+}
+
+// Header is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Header() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call{Call: _e.mock.On("Header")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) Return(mD metadata.MD, err error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
+	_c.Call.Return(mD, err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Header_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Recv provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Recv() (*storage_v1.SpansResponseChunk, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Recv")
+	}
+
+	var r0 *storage_v1.SpansResponseChunk
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (*storage_v1.SpansResponseChunk, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() *storage_v1.SpansResponseChunk); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.SpansResponseChunk)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call struct {
+	*mock.Call
+}
+
+// Recv is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Recv() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call{Call: _e.mock.On("Recv")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) Return(spansResponseChunk *storage_v1.SpansResponseChunk, err error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
+	_c.Call.Return(spansResponseChunk, err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call) RunAndReturn(run func() (*storage_v1.SpansResponseChunk, error)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Recv_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) RecvMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call) RunAndReturn(run func(m any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) SendMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call) RunAndReturn(run func(m any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Trailer provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceClient
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceClient) Trailer() metadata.MD {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Trailer")
+	}
+
+	var r0 metadata.MD
+	if returnFunc, ok := ret.Get(0).(func() metadata.MD); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metadata.MD)
+		}
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer'
+type ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call struct {
+	*mock.Call
+}
+
+// Trailer is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Expecter) Trailer() *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call{Call: _e.mock.On("Trailer")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) Return(mD metadata.MD) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
+	_c.Call.Return(mD)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *ArchiveSpanReaderPlugin_GetArchiveTraceClient_Trailer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewArchiveSpanReaderPluginServer creates a new instance of ArchiveSpanReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanReaderPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanReaderPluginServer {
+	mock := &ArchiveSpanReaderPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanReaderPluginServer is an autogenerated mock type for the ArchiveSpanReaderPluginServer type
+type ArchiveSpanReaderPluginServer struct {
+	mock.Mock
+}
+
+type ArchiveSpanReaderPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanReaderPluginServer) EXPECT() *ArchiveSpanReaderPluginServer_Expecter {
+	return &ArchiveSpanReaderPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// GetArchiveTrace provides a mock function for the type ArchiveSpanReaderPluginServer
+func (_mock *ArchiveSpanReaderPluginServer) GetArchiveTrace(getTraceRequest *storage_v1.GetTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error {
+	ret := _mock.Called(getTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetArchiveTrace")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.GetTraceRequest, storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error); ok {
+		r0 = returnFunc(getTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPluginServer_GetArchiveTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArchiveTrace'
+type ArchiveSpanReaderPluginServer_GetArchiveTrace_Call struct {
+	*mock.Call
+}
+
+// GetArchiveTrace is a helper method to define mock.On call
+//   - getTraceRequest
+//   - archiveSpanReaderPlugin_GetArchiveTraceServer
+func (_e *ArchiveSpanReaderPluginServer_Expecter) GetArchiveTrace(getTraceRequest interface{}, archiveSpanReaderPlugin_GetArchiveTraceServer interface{}) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
+	return &ArchiveSpanReaderPluginServer_GetArchiveTrace_Call{Call: _e.mock.On("GetArchiveTrace", getTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer)}
+}
+
+func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) Run(run func(getTraceRequest *storage_v1.GetTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer)) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.GetTraceRequest), args[1].(storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) Return(err error) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call) RunAndReturn(run func(getTraceRequest *storage_v1.GetTraceRequest, archiveSpanReaderPlugin_GetArchiveTraceServer storage_v1.ArchiveSpanReaderPlugin_GetArchiveTraceServer) error) *ArchiveSpanReaderPluginServer_GetArchiveTrace_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewArchiveSpanReaderPlugin_GetArchiveTraceServer creates a new instance of ArchiveSpanReaderPlugin_GetArchiveTraceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveSpanReaderPlugin_GetArchiveTraceServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer {
+	mock := &ArchiveSpanReaderPlugin_GetArchiveTraceServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer is an autogenerated mock type for the ArchiveSpanReaderPlugin_GetArchiveTraceServer type
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer struct {
+	mock.Mock
+}
+
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveSpanReaderPlugin_GetArchiveTraceServer) EXPECT() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter{mock: &_m.Mock}
+}
+
+// Context provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) Context() context.Context {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 context.Context
+	if returnFunc, ok := ret.Get(0).(func() context.Context); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(context.Context)
+		}
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) Context() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) Run(run func()) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) Return(context1 context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
+	_c.Call.Return(context1)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call) RunAndReturn(run func() context.Context) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RecvMsg provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) RecvMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecvMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call struct {
+	*mock.Call
+}
+
+// RecvMsg is a helper method to define mock.On call
+//   - m
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) RecvMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call) RunAndReturn(run func(m any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_RecvMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Send provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) Send(spansResponseChunk *storage_v1.SpansResponseChunk) error {
+	ret := _mock.Called(spansResponseChunk)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*storage_v1.SpansResponseChunk) error); ok {
+		r0 = returnFunc(spansResponseChunk)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - spansResponseChunk
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) Send(spansResponseChunk interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call{Call: _e.mock.On("Send", spansResponseChunk)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) Run(run func(spansResponseChunk *storage_v1.SpansResponseChunk)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*storage_v1.SpansResponseChunk))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call) RunAndReturn(run func(spansResponseChunk *storage_v1.SpansResponseChunk) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendHeader provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SendHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call struct {
+	*mock.Call
+}
+
+// SendHeader is a helper method to define mock.On call
+//   - mD
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SendHeader(mD interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call{Call: _e.mock.On("SendHeader", mD)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) Run(run func(mD metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendMsg provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SendMsg(m any) error {
+	ret := _mock.Called(m)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendMsg")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(any) error); ok {
+		r0 = returnFunc(m)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call struct {
+	*mock.Call
+}
+
+// SendMsg is a helper method to define mock.On call
+//   - m
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SendMsg(m interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) Run(run func(m any)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call) RunAndReturn(run func(m any) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SendMsg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetHeader provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SetHeader(mD metadata.MD) error {
+	ret := _mock.Called(mD)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetHeader")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metadata.MD) error); ok {
+		r0 = returnFunc(mD)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call struct {
+	*mock.Call
+}
+
+// SetHeader is a helper method to define mock.On call
+//   - mD
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SetHeader(mD interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call{Call: _e.mock.On("SetHeader", mD)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) Run(run func(mD metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) Return(err error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call) RunAndReturn(run func(mD metadata.MD) error) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetTrailer provides a mock function for the type ArchiveSpanReaderPlugin_GetArchiveTraceServer
+func (_mock *ArchiveSpanReaderPlugin_GetArchiveTraceServer) SetTrailer(mD metadata.MD) {
+	_mock.Called(mD)
+	return
+}
+
+// ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer'
+type ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call struct {
+	*mock.Call
+}
+
+// SetTrailer is a helper method to define mock.On call
+//   - mD
+func (_e *ArchiveSpanReaderPlugin_GetArchiveTraceServer_Expecter) SetTrailer(mD interface{}) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
+	return &ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", mD)}
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) Run(run func(mD metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metadata.MD))
+	})
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) Return() *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call) RunAndReturn(run func(mD metadata.MD)) *ArchiveSpanReaderPlugin_GetArchiveTraceServer_SetTrailer_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewDependenciesReaderPluginClient creates a new instance of DependenciesReaderPluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDependenciesReaderPluginClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *DependenciesReaderPluginClient {
+	mock := &DependenciesReaderPluginClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// DependenciesReaderPluginClient is an autogenerated mock type for the DependenciesReaderPluginClient type
+type DependenciesReaderPluginClient struct {
+	mock.Mock
+}
+
+type DependenciesReaderPluginClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *DependenciesReaderPluginClient) EXPECT() *DependenciesReaderPluginClient_Expecter {
+	return &DependenciesReaderPluginClient_Expecter{mock: &_m.Mock}
+}
+
+// GetDependencies provides a mock function for the type DependenciesReaderPluginClient
+func (_mock *DependenciesReaderPluginClient) GetDependencies(ctx context.Context, in *storage_v1.GetDependenciesRequest, opts ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDependencies")
+	}
+
+	var r0 *storage_v1.GetDependenciesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) *storage_v1.GetDependenciesResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetDependenciesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetDependenciesRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// DependenciesReaderPluginClient_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
+type DependenciesReaderPluginClient_GetDependencies_Call struct {
+	*mock.Call
+}
+
+// GetDependencies is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *DependenciesReaderPluginClient_Expecter) GetDependencies(ctx interface{}, in interface{}, opts ...interface{}) *DependenciesReaderPluginClient_GetDependencies_Call {
+	return &DependenciesReaderPluginClient_GetDependencies_Call{Call: _e.mock.On("GetDependencies",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *DependenciesReaderPluginClient_GetDependencies_Call) Run(run func(ctx context.Context, in *storage_v1.GetDependenciesRequest, opts ...grpc.CallOption)) *DependenciesReaderPluginClient_GetDependencies_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.GetDependenciesRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *DependenciesReaderPluginClient_GetDependencies_Call) Return(getDependenciesResponse *storage_v1.GetDependenciesResponse, err error) *DependenciesReaderPluginClient_GetDependencies_Call {
+	_c.Call.Return(getDependenciesResponse, err)
+	return _c
+}
+
+func (_c *DependenciesReaderPluginClient_GetDependencies_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.GetDependenciesRequest, opts ...grpc.CallOption) (*storage_v1.GetDependenciesResponse, error)) *DependenciesReaderPluginClient_GetDependencies_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewDependenciesReaderPluginServer creates a new instance of DependenciesReaderPluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDependenciesReaderPluginServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *DependenciesReaderPluginServer {
+	mock := &DependenciesReaderPluginServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// DependenciesReaderPluginServer is an autogenerated mock type for the DependenciesReaderPluginServer type
+type DependenciesReaderPluginServer struct {
+	mock.Mock
+}
+
+type DependenciesReaderPluginServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *DependenciesReaderPluginServer) EXPECT() *DependenciesReaderPluginServer_Expecter {
+	return &DependenciesReaderPluginServer_Expecter{mock: &_m.Mock}
+}
+
+// GetDependencies provides a mock function for the type DependenciesReaderPluginServer
+func (_mock *DependenciesReaderPluginServer) GetDependencies(context1 context.Context, getDependenciesRequest *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error) {
+	ret := _mock.Called(context1, getDependenciesRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDependencies")
+	}
+
+	var r0 *storage_v1.GetDependenciesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error)); ok {
+		return returnFunc(context1, getDependenciesRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.GetDependenciesRequest) *storage_v1.GetDependenciesResponse); ok {
+		r0 = returnFunc(context1, getDependenciesRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.GetDependenciesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.GetDependenciesRequest) error); ok {
+		r1 = returnFunc(context1, getDependenciesRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// DependenciesReaderPluginServer_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
+type DependenciesReaderPluginServer_GetDependencies_Call struct {
+	*mock.Call
+}
+
+// GetDependencies is a helper method to define mock.On call
+//   - context1
+//   - getDependenciesRequest
+func (_e *DependenciesReaderPluginServer_Expecter) GetDependencies(context1 interface{}, getDependenciesRequest interface{}) *DependenciesReaderPluginServer_GetDependencies_Call {
+	return &DependenciesReaderPluginServer_GetDependencies_Call{Call: _e.mock.On("GetDependencies", context1, getDependenciesRequest)}
+}
+
+func (_c *DependenciesReaderPluginServer_GetDependencies_Call) Run(run func(context1 context.Context, getDependenciesRequest *storage_v1.GetDependenciesRequest)) *DependenciesReaderPluginServer_GetDependencies_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.GetDependenciesRequest))
+	})
+	return _c
+}
+
+func (_c *DependenciesReaderPluginServer_GetDependencies_Call) Return(getDependenciesResponse *storage_v1.GetDependenciesResponse, err error) *DependenciesReaderPluginServer_GetDependencies_Call {
+	_c.Call.Return(getDependenciesResponse, err)
+	return _c
+}
+
+func (_c *DependenciesReaderPluginServer_GetDependencies_Call) RunAndReturn(run func(context1 context.Context, getDependenciesRequest *storage_v1.GetDependenciesRequest) (*storage_v1.GetDependenciesResponse, error)) *DependenciesReaderPluginServer_GetDependencies_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewPluginCapabilitiesClient creates a new instance of PluginCapabilitiesClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPluginCapabilitiesClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PluginCapabilitiesClient {
+	mock := &PluginCapabilitiesClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// PluginCapabilitiesClient is an autogenerated mock type for the PluginCapabilitiesClient type
+type PluginCapabilitiesClient struct {
+	mock.Mock
+}
+
+type PluginCapabilitiesClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *PluginCapabilitiesClient) EXPECT() *PluginCapabilitiesClient_Expecter {
+	return &PluginCapabilitiesClient_Expecter{mock: &_m.Mock}
+}
+
+// Capabilities provides a mock function for the type PluginCapabilitiesClient
+func (_mock *PluginCapabilitiesClient) Capabilities(ctx context.Context, in *storage_v1.CapabilitiesRequest, opts ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Capabilities")
+	}
+
+	var r0 *storage_v1.CapabilitiesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) *storage_v1.CapabilitiesResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.CapabilitiesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.CapabilitiesRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// PluginCapabilitiesClient_Capabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Capabilities'
+type PluginCapabilitiesClient_Capabilities_Call struct {
+	*mock.Call
+}
+
+// Capabilities is a helper method to define mock.On call
+//   - ctx
+//   - in
+//   - opts
+func (_e *PluginCapabilitiesClient_Expecter) Capabilities(ctx interface{}, in interface{}, opts ...interface{}) *PluginCapabilitiesClient_Capabilities_Call {
+	return &PluginCapabilitiesClient_Capabilities_Call{Call: _e.mock.On("Capabilities",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *PluginCapabilitiesClient_Capabilities_Call) Run(run func(ctx context.Context, in *storage_v1.CapabilitiesRequest, opts ...grpc.CallOption)) *PluginCapabilitiesClient_Capabilities_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]grpc.CallOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(grpc.CallOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*storage_v1.CapabilitiesRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *PluginCapabilitiesClient_Capabilities_Call) Return(capabilitiesResponse *storage_v1.CapabilitiesResponse, err error) *PluginCapabilitiesClient_Capabilities_Call {
+	_c.Call.Return(capabilitiesResponse, err)
+	return _c
+}
+
+func (_c *PluginCapabilitiesClient_Capabilities_Call) RunAndReturn(run func(ctx context.Context, in *storage_v1.CapabilitiesRequest, opts ...grpc.CallOption) (*storage_v1.CapabilitiesResponse, error)) *PluginCapabilitiesClient_Capabilities_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewPluginCapabilitiesServer creates a new instance of PluginCapabilitiesServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPluginCapabilitiesServer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PluginCapabilitiesServer {
+	mock := &PluginCapabilitiesServer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// PluginCapabilitiesServer is an autogenerated mock type for the PluginCapabilitiesServer type
+type PluginCapabilitiesServer struct {
+	mock.Mock
+}
+
+type PluginCapabilitiesServer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *PluginCapabilitiesServer) EXPECT() *PluginCapabilitiesServer_Expecter {
+	return &PluginCapabilitiesServer_Expecter{mock: &_m.Mock}
+}
+
+// Capabilities provides a mock function for the type PluginCapabilitiesServer
+func (_mock *PluginCapabilitiesServer) Capabilities(context1 context.Context, capabilitiesRequest *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error) {
+	ret := _mock.Called(context1, capabilitiesRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Capabilities")
+	}
+
+	var r0 *storage_v1.CapabilitiesResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error)); ok {
+		return returnFunc(context1, capabilitiesRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *storage_v1.CapabilitiesRequest) *storage_v1.CapabilitiesResponse); ok {
+		r0 = returnFunc(context1, capabilitiesRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*storage_v1.CapabilitiesResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *storage_v1.CapabilitiesRequest) error); ok {
+		r1 = returnFunc(context1, capabilitiesRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// PluginCapabilitiesServer_Capabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Capabilities'
+type PluginCapabilitiesServer_Capabilities_Call struct {
+	*mock.Call
+}
+
+// Capabilities is a helper method to define mock.On call
+//   - context1
+//   - capabilitiesRequest
+func (_e *PluginCapabilitiesServer_Expecter) Capabilities(context1 interface{}, capabilitiesRequest interface{}) *PluginCapabilitiesServer_Capabilities_Call {
+	return &PluginCapabilitiesServer_Capabilities_Call{Call: _e.mock.On("Capabilities", context1, capabilitiesRequest)}
+}
+
+func (_c *PluginCapabilitiesServer_Capabilities_Call) Run(run func(context1 context.Context, capabilitiesRequest *storage_v1.CapabilitiesRequest)) *PluginCapabilitiesServer_Capabilities_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*storage_v1.CapabilitiesRequest))
+	})
+	return _c
+}
+
+func (_c *PluginCapabilitiesServer_Capabilities_Call) Return(capabilitiesResponse *storage_v1.CapabilitiesResponse, err error) *PluginCapabilitiesServer_Capabilities_Call {
+	_c.Call.Return(capabilitiesResponse, err)
+	return _c
+}
+
+func (_c *PluginCapabilitiesServer_Capabilities_Call) RunAndReturn(run func(context1 context.Context, capabilitiesRequest *storage_v1.CapabilitiesRequest) (*storage_v1.CapabilitiesResponse, error)) *PluginCapabilitiesServer_Capabilities_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/cassandra/mocks/Iterator.go b/internal/storage/cassandra/mocks/Iterator.go
deleted file mode 100644
index 5d42b39a..00000000
--- a/internal/storage/cassandra/mocks/Iterator.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// Iterator is an autogenerated mock type for the Iterator type
-type Iterator struct {
-	mock.Mock
-}
-
-type Iterator_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Iterator) EXPECT() *Iterator_Expecter {
-	return &Iterator_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with no fields
-func (_m *Iterator) Close() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Iterator_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type Iterator_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-func (_e *Iterator_Expecter) Close() *Iterator_Close_Call {
-	return &Iterator_Close_Call{Call: _e.mock.On("Close")}
-}
-
-func (_c *Iterator_Close_Call) Run(run func()) *Iterator_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Iterator_Close_Call) Return(_a0 error) *Iterator_Close_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Iterator_Close_Call) RunAndReturn(run func() error) *Iterator_Close_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Scan provides a mock function with given fields: dest
-func (_m *Iterator) Scan(dest ...any) bool {
-	var tmpRet mock.Arguments
-	if len(dest) > 0 {
-		tmpRet = _m.Called(dest)
-	} else {
-		tmpRet = _m.Called()
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for Scan")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(...any) bool); ok {
-		r0 = rf(dest...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// Iterator_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan'
-type Iterator_Scan_Call struct {
-	*mock.Call
-}
-
-// Scan is a helper method to define mock.On call
-//   - dest ...any
-func (_e *Iterator_Expecter) Scan(dest ...interface{}) *Iterator_Scan_Call {
-	return &Iterator_Scan_Call{Call: _e.mock.On("Scan",
-		append([]interface{}{}, dest...)...)}
-}
-
-func (_c *Iterator_Scan_Call) Run(run func(dest ...any)) *Iterator_Scan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]any, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(any)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Iterator_Scan_Call) Return(_a0 bool) *Iterator_Scan_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Iterator_Scan_Call) RunAndReturn(run func(...any) bool) *Iterator_Scan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIterator creates a new instance of Iterator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIterator(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Iterator {
-	mock := &Iterator{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/cassandra/mocks/Query.go b/internal/storage/cassandra/mocks/Query.go
deleted file mode 100644
index 7ff78616..00000000
--- a/internal/storage/cassandra/mocks/Query.go
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	cassandra "github.com/jaegertracing/jaeger/internal/storage/cassandra"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Query is an autogenerated mock type for the Query type
-type Query struct {
-	mock.Mock
-}
-
-type Query_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Query) EXPECT() *Query_Expecter {
-	return &Query_Expecter{mock: &_m.Mock}
-}
-
-// Bind provides a mock function with given fields: v
-func (_m *Query) Bind(v ...any) cassandra.Query {
-	var tmpRet mock.Arguments
-	if len(v) > 0 {
-		tmpRet = _m.Called(v)
-	} else {
-		tmpRet = _m.Called()
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for Bind")
-	}
-
-	var r0 cassandra.Query
-	if rf, ok := ret.Get(0).(func(...any) cassandra.Query); ok {
-		r0 = rf(v...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(cassandra.Query)
-		}
-	}
-
-	return r0
-}
-
-// Query_Bind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bind'
-type Query_Bind_Call struct {
-	*mock.Call
-}
-
-// Bind is a helper method to define mock.On call
-//   - v ...any
-func (_e *Query_Expecter) Bind(v ...interface{}) *Query_Bind_Call {
-	return &Query_Bind_Call{Call: _e.mock.On("Bind",
-		append([]interface{}{}, v...)...)}
-}
-
-func (_c *Query_Bind_Call) Run(run func(v ...any)) *Query_Bind_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]any, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(any)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Query_Bind_Call) Return(_a0 cassandra.Query) *Query_Bind_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_Bind_Call) RunAndReturn(run func(...any) cassandra.Query) *Query_Bind_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Consistency provides a mock function with given fields: level
-func (_m *Query) Consistency(level cassandra.Consistency) cassandra.Query {
-	ret := _m.Called(level)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Consistency")
-	}
-
-	var r0 cassandra.Query
-	if rf, ok := ret.Get(0).(func(cassandra.Consistency) cassandra.Query); ok {
-		r0 = rf(level)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(cassandra.Query)
-		}
-	}
-
-	return r0
-}
-
-// Query_Consistency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consistency'
-type Query_Consistency_Call struct {
-	*mock.Call
-}
-
-// Consistency is a helper method to define mock.On call
-//   - level cassandra.Consistency
-func (_e *Query_Expecter) Consistency(level interface{}) *Query_Consistency_Call {
-	return &Query_Consistency_Call{Call: _e.mock.On("Consistency", level)}
-}
-
-func (_c *Query_Consistency_Call) Run(run func(level cassandra.Consistency)) *Query_Consistency_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(cassandra.Consistency))
-	})
-	return _c
-}
-
-func (_c *Query_Consistency_Call) Return(_a0 cassandra.Query) *Query_Consistency_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_Consistency_Call) RunAndReturn(run func(cassandra.Consistency) cassandra.Query) *Query_Consistency_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Exec provides a mock function with no fields
-func (_m *Query) Exec() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Exec")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Query_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec'
-type Query_Exec_Call struct {
-	*mock.Call
-}
-
-// Exec is a helper method to define mock.On call
-func (_e *Query_Expecter) Exec() *Query_Exec_Call {
-	return &Query_Exec_Call{Call: _e.mock.On("Exec")}
-}
-
-func (_c *Query_Exec_Call) Run(run func()) *Query_Exec_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Query_Exec_Call) Return(_a0 error) *Query_Exec_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_Exec_Call) RunAndReturn(run func() error) *Query_Exec_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Iter provides a mock function with no fields
-func (_m *Query) Iter() cassandra.Iterator {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Iter")
-	}
-
-	var r0 cassandra.Iterator
-	if rf, ok := ret.Get(0).(func() cassandra.Iterator); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(cassandra.Iterator)
-		}
-	}
-
-	return r0
-}
-
-// Query_Iter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Iter'
-type Query_Iter_Call struct {
-	*mock.Call
-}
-
-// Iter is a helper method to define mock.On call
-func (_e *Query_Expecter) Iter() *Query_Iter_Call {
-	return &Query_Iter_Call{Call: _e.mock.On("Iter")}
-}
-
-func (_c *Query_Iter_Call) Run(run func()) *Query_Iter_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Query_Iter_Call) Return(_a0 cassandra.Iterator) *Query_Iter_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_Iter_Call) RunAndReturn(run func() cassandra.Iterator) *Query_Iter_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// PageSize provides a mock function with given fields: _a0
-func (_m *Query) PageSize(_a0 int) cassandra.Query {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PageSize")
-	}
-
-	var r0 cassandra.Query
-	if rf, ok := ret.Get(0).(func(int) cassandra.Query); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(cassandra.Query)
-		}
-	}
-
-	return r0
-}
-
-// Query_PageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PageSize'
-type Query_PageSize_Call struct {
-	*mock.Call
-}
-
-// PageSize is a helper method to define mock.On call
-//   - _a0 int
-func (_e *Query_Expecter) PageSize(_a0 interface{}) *Query_PageSize_Call {
-	return &Query_PageSize_Call{Call: _e.mock.On("PageSize", _a0)}
-}
-
-func (_c *Query_PageSize_Call) Run(run func(_a0 int)) *Query_PageSize_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(int))
-	})
-	return _c
-}
-
-func (_c *Query_PageSize_Call) Return(_a0 cassandra.Query) *Query_PageSize_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_PageSize_Call) RunAndReturn(run func(int) cassandra.Query) *Query_PageSize_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// ScanCAS provides a mock function with given fields: dest
-func (_m *Query) ScanCAS(dest ...any) (bool, error) {
-	var tmpRet mock.Arguments
-	if len(dest) > 0 {
-		tmpRet = _m.Called(dest)
-	} else {
-		tmpRet = _m.Called()
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for ScanCAS")
-	}
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(...any) (bool, error)); ok {
-		return rf(dest...)
-	}
-	if rf, ok := ret.Get(0).(func(...any) bool); ok {
-		r0 = rf(dest...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(...any) error); ok {
-		r1 = rf(dest...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Query_ScanCAS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanCAS'
-type Query_ScanCAS_Call struct {
-	*mock.Call
-}
-
-// ScanCAS is a helper method to define mock.On call
-//   - dest ...any
-func (_e *Query_Expecter) ScanCAS(dest ...interface{}) *Query_ScanCAS_Call {
-	return &Query_ScanCAS_Call{Call: _e.mock.On("ScanCAS",
-		append([]interface{}{}, dest...)...)}
-}
-
-func (_c *Query_ScanCAS_Call) Run(run func(dest ...any)) *Query_ScanCAS_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]any, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(any)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Query_ScanCAS_Call) Return(_a0 bool, _a1 error) *Query_ScanCAS_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Query_ScanCAS_Call) RunAndReturn(run func(...any) (bool, error)) *Query_ScanCAS_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// String provides a mock function with no fields
-func (_m *Query) String() string {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for String")
-	}
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// Query_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
-type Query_String_Call struct {
-	*mock.Call
-}
-
-// String is a helper method to define mock.On call
-func (_e *Query_Expecter) String() *Query_String_Call {
-	return &Query_String_Call{Call: _e.mock.On("String")}
-}
-
-func (_c *Query_String_Call) Run(run func()) *Query_String_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Query_String_Call) Return(_a0 string) *Query_String_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Query_String_Call) RunAndReturn(run func() string) *Query_String_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewQuery creates a new instance of Query. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewQuery(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Query {
-	mock := &Query{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/cassandra/mocks/Session.go b/internal/storage/cassandra/mocks/Session.go
deleted file mode 100644
index 4138a680..00000000
--- a/internal/storage/cassandra/mocks/Session.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	cassandra "github.com/jaegertracing/jaeger/internal/storage/cassandra"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Session is an autogenerated mock type for the Session type
-type Session struct {
-	mock.Mock
-}
-
-type Session_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Session) EXPECT() *Session_Expecter {
-	return &Session_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with no fields
-func (_m *Session) Close() {
-	_m.Called()
-}
-
-// Session_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type Session_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-func (_e *Session_Expecter) Close() *Session_Close_Call {
-	return &Session_Close_Call{Call: _e.mock.On("Close")}
-}
-
-func (_c *Session_Close_Call) Run(run func()) *Session_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Session_Close_Call) Return() *Session_Close_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *Session_Close_Call) RunAndReturn(run func()) *Session_Close_Call {
-	_c.Run(run)
-	return _c
-}
-
-// Query provides a mock function with given fields: stmt, values
-func (_m *Session) Query(stmt string, values ...any) cassandra.Query {
-	var tmpRet mock.Arguments
-	if len(values) > 0 {
-		tmpRet = _m.Called(stmt, values)
-	} else {
-		tmpRet = _m.Called(stmt)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for Query")
-	}
-
-	var r0 cassandra.Query
-	if rf, ok := ret.Get(0).(func(string, ...any) cassandra.Query); ok {
-		r0 = rf(stmt, values...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(cassandra.Query)
-		}
-	}
-
-	return r0
-}
-
-// Session_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
-type Session_Query_Call struct {
-	*mock.Call
-}
-
-// Query is a helper method to define mock.On call
-//   - stmt string
-//   - values ...any
-func (_e *Session_Expecter) Query(stmt interface{}, values ...interface{}) *Session_Query_Call {
-	return &Session_Query_Call{Call: _e.mock.On("Query",
-		append([]interface{}{stmt}, values...)...)}
-}
-
-func (_c *Session_Query_Call) Run(run func(stmt string, values ...any)) *Session_Query_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]any, len(args)-1)
-		for i, a := range args[1:] {
-			if a != nil {
-				variadicArgs[i] = a.(any)
-			}
-		}
-		run(args[0].(string), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Session_Query_Call) Return(_a0 cassandra.Query) *Session_Query_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Session_Query_Call) RunAndReturn(run func(string, ...any) cassandra.Query) *Session_Query_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSession creates a new instance of Session. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSession(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Session {
-	mock := &Session{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/cassandra/mocks/mocks.go b/internal/storage/cassandra/mocks/mocks.go
new file mode 100644
index 00000000..7fe2ad3a
--- /dev/null
+++ b/internal/storage/cassandra/mocks/mocks.go
@@ -0,0 +1,646 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"github.com/jaegertracing/jaeger/internal/storage/cassandra"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewSession creates a new instance of Session. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSession(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Session {
+	mock := &Session{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Session is an autogenerated mock type for the Session type
+type Session struct {
+	mock.Mock
+}
+
+type Session_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Session) EXPECT() *Session_Expecter {
+	return &Session_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type Session
+func (_mock *Session) Close() {
+	_mock.Called()
+	return
+}
+
+// Session_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type Session_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *Session_Expecter) Close() *Session_Close_Call {
+	return &Session_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *Session_Close_Call) Run(run func()) *Session_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Session_Close_Call) Return() *Session_Close_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *Session_Close_Call) RunAndReturn(run func()) *Session_Close_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Query provides a mock function for the type Session
+func (_mock *Session) Query(stmt string, values ...any) cassandra.Query {
+	var tmpRet mock.Arguments
+	if len(values) > 0 {
+		tmpRet = _mock.Called(stmt, values)
+	} else {
+		tmpRet = _mock.Called(stmt)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Query")
+	}
+
+	var r0 cassandra.Query
+	if returnFunc, ok := ret.Get(0).(func(string, ...any) cassandra.Query); ok {
+		r0 = returnFunc(stmt, values...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cassandra.Query)
+		}
+	}
+	return r0
+}
+
+// Session_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
+type Session_Query_Call struct {
+	*mock.Call
+}
+
+// Query is a helper method to define mock.On call
+//   - stmt
+//   - values
+func (_e *Session_Expecter) Query(stmt interface{}, values ...interface{}) *Session_Query_Call {
+	return &Session_Query_Call{Call: _e.mock.On("Query",
+		append([]interface{}{stmt}, values...)...)}
+}
+
+func (_c *Session_Query_Call) Run(run func(stmt string, values ...any)) *Session_Query_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]any, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(any)
+			}
+		}
+		run(args[0].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Session_Query_Call) Return(query cassandra.Query) *Session_Query_Call {
+	_c.Call.Return(query)
+	return _c
+}
+
+func (_c *Session_Query_Call) RunAndReturn(run func(stmt string, values ...any) cassandra.Query) *Session_Query_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewQuery creates a new instance of Query. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewQuery(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Query {
+	mock := &Query{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Query is an autogenerated mock type for the Query type
+type Query struct {
+	mock.Mock
+}
+
+type Query_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Query) EXPECT() *Query_Expecter {
+	return &Query_Expecter{mock: &_m.Mock}
+}
+
+// Bind provides a mock function for the type Query
+func (_mock *Query) Bind(v ...any) cassandra.Query {
+	var tmpRet mock.Arguments
+	if len(v) > 0 {
+		tmpRet = _mock.Called(v)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Bind")
+	}
+
+	var r0 cassandra.Query
+	if returnFunc, ok := ret.Get(0).(func(...any) cassandra.Query); ok {
+		r0 = returnFunc(v...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cassandra.Query)
+		}
+	}
+	return r0
+}
+
+// Query_Bind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bind'
+type Query_Bind_Call struct {
+	*mock.Call
+}
+
+// Bind is a helper method to define mock.On call
+//   - v
+func (_e *Query_Expecter) Bind(v ...interface{}) *Query_Bind_Call {
+	return &Query_Bind_Call{Call: _e.mock.On("Bind",
+		append([]interface{}{}, v...)...)}
+}
+
+func (_c *Query_Bind_Call) Run(run func(v ...any)) *Query_Bind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]any, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(any)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Query_Bind_Call) Return(query cassandra.Query) *Query_Bind_Call {
+	_c.Call.Return(query)
+	return _c
+}
+
+func (_c *Query_Bind_Call) RunAndReturn(run func(v ...any) cassandra.Query) *Query_Bind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Consistency provides a mock function for the type Query
+func (_mock *Query) Consistency(level cassandra.Consistency) cassandra.Query {
+	ret := _mock.Called(level)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Consistency")
+	}
+
+	var r0 cassandra.Query
+	if returnFunc, ok := ret.Get(0).(func(cassandra.Consistency) cassandra.Query); ok {
+		r0 = returnFunc(level)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cassandra.Query)
+		}
+	}
+	return r0
+}
+
+// Query_Consistency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consistency'
+type Query_Consistency_Call struct {
+	*mock.Call
+}
+
+// Consistency is a helper method to define mock.On call
+//   - level
+func (_e *Query_Expecter) Consistency(level interface{}) *Query_Consistency_Call {
+	return &Query_Consistency_Call{Call: _e.mock.On("Consistency", level)}
+}
+
+func (_c *Query_Consistency_Call) Run(run func(level cassandra.Consistency)) *Query_Consistency_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(cassandra.Consistency))
+	})
+	return _c
+}
+
+func (_c *Query_Consistency_Call) Return(query cassandra.Query) *Query_Consistency_Call {
+	_c.Call.Return(query)
+	return _c
+}
+
+func (_c *Query_Consistency_Call) RunAndReturn(run func(level cassandra.Consistency) cassandra.Query) *Query_Consistency_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Exec provides a mock function for the type Query
+func (_mock *Query) Exec() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Exec")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Query_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec'
+type Query_Exec_Call struct {
+	*mock.Call
+}
+
+// Exec is a helper method to define mock.On call
+func (_e *Query_Expecter) Exec() *Query_Exec_Call {
+	return &Query_Exec_Call{Call: _e.mock.On("Exec")}
+}
+
+func (_c *Query_Exec_Call) Run(run func()) *Query_Exec_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Query_Exec_Call) Return(err error) *Query_Exec_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Query_Exec_Call) RunAndReturn(run func() error) *Query_Exec_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Iter provides a mock function for the type Query
+func (_mock *Query) Iter() cassandra.Iterator {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Iter")
+	}
+
+	var r0 cassandra.Iterator
+	if returnFunc, ok := ret.Get(0).(func() cassandra.Iterator); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cassandra.Iterator)
+		}
+	}
+	return r0
+}
+
+// Query_Iter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Iter'
+type Query_Iter_Call struct {
+	*mock.Call
+}
+
+// Iter is a helper method to define mock.On call
+func (_e *Query_Expecter) Iter() *Query_Iter_Call {
+	return &Query_Iter_Call{Call: _e.mock.On("Iter")}
+}
+
+func (_c *Query_Iter_Call) Run(run func()) *Query_Iter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Query_Iter_Call) Return(iterator cassandra.Iterator) *Query_Iter_Call {
+	_c.Call.Return(iterator)
+	return _c
+}
+
+func (_c *Query_Iter_Call) RunAndReturn(run func() cassandra.Iterator) *Query_Iter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PageSize provides a mock function for the type Query
+func (_mock *Query) PageSize(n int) cassandra.Query {
+	ret := _mock.Called(n)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PageSize")
+	}
+
+	var r0 cassandra.Query
+	if returnFunc, ok := ret.Get(0).(func(int) cassandra.Query); ok {
+		r0 = returnFunc(n)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(cassandra.Query)
+		}
+	}
+	return r0
+}
+
+// Query_PageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PageSize'
+type Query_PageSize_Call struct {
+	*mock.Call
+}
+
+// PageSize is a helper method to define mock.On call
+//   - n
+func (_e *Query_Expecter) PageSize(n interface{}) *Query_PageSize_Call {
+	return &Query_PageSize_Call{Call: _e.mock.On("PageSize", n)}
+}
+
+func (_c *Query_PageSize_Call) Run(run func(n int)) *Query_PageSize_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int))
+	})
+	return _c
+}
+
+func (_c *Query_PageSize_Call) Return(query cassandra.Query) *Query_PageSize_Call {
+	_c.Call.Return(query)
+	return _c
+}
+
+func (_c *Query_PageSize_Call) RunAndReturn(run func(n int) cassandra.Query) *Query_PageSize_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ScanCAS provides a mock function for the type Query
+func (_mock *Query) ScanCAS(dest ...any) (bool, error) {
+	var tmpRet mock.Arguments
+	if len(dest) > 0 {
+		tmpRet = _mock.Called(dest)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for ScanCAS")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(...any) (bool, error)); ok {
+		return returnFunc(dest...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(...any) bool); ok {
+		r0 = returnFunc(dest...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(...any) error); ok {
+		r1 = returnFunc(dest...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Query_ScanCAS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanCAS'
+type Query_ScanCAS_Call struct {
+	*mock.Call
+}
+
+// ScanCAS is a helper method to define mock.On call
+//   - dest
+func (_e *Query_Expecter) ScanCAS(dest ...interface{}) *Query_ScanCAS_Call {
+	return &Query_ScanCAS_Call{Call: _e.mock.On("ScanCAS",
+		append([]interface{}{}, dest...)...)}
+}
+
+func (_c *Query_ScanCAS_Call) Run(run func(dest ...any)) *Query_ScanCAS_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]any, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(any)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Query_ScanCAS_Call) Return(b bool, err error) *Query_ScanCAS_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *Query_ScanCAS_Call) RunAndReturn(run func(dest ...any) (bool, error)) *Query_ScanCAS_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// String provides a mock function for the type Query
+func (_mock *Query) String() string {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for String")
+	}
+
+	var r0 string
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	return r0
+}
+
+// Query_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type Query_String_Call struct {
+	*mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *Query_Expecter) String() *Query_String_Call {
+	return &Query_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *Query_String_Call) Run(run func()) *Query_String_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Query_String_Call) Return(s string) *Query_String_Call {
+	_c.Call.Return(s)
+	return _c
+}
+
+func (_c *Query_String_Call) RunAndReturn(run func() string) *Query_String_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIterator creates a new instance of Iterator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIterator(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Iterator {
+	mock := &Iterator{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Iterator is an autogenerated mock type for the Iterator type
+type Iterator struct {
+	mock.Mock
+}
+
+type Iterator_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Iterator) EXPECT() *Iterator_Expecter {
+	return &Iterator_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type Iterator
+func (_mock *Iterator) Close() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Iterator_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type Iterator_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *Iterator_Expecter) Close() *Iterator_Close_Call {
+	return &Iterator_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *Iterator_Close_Call) Run(run func()) *Iterator_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Iterator_Close_Call) Return(err error) *Iterator_Close_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Iterator_Close_Call) RunAndReturn(run func() error) *Iterator_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Scan provides a mock function for the type Iterator
+func (_mock *Iterator) Scan(dest ...any) bool {
+	var tmpRet mock.Arguments
+	if len(dest) > 0 {
+		tmpRet = _mock.Called(dest)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Scan")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func(...any) bool); ok {
+		r0 = returnFunc(dest...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// Iterator_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan'
+type Iterator_Scan_Call struct {
+	*mock.Call
+}
+
+// Scan is a helper method to define mock.On call
+//   - dest
+func (_e *Iterator_Expecter) Scan(dest ...interface{}) *Iterator_Scan_Call {
+	return &Iterator_Scan_Call{Call: _e.mock.On("Scan",
+		append([]interface{}{}, dest...)...)}
+}
+
+func (_c *Iterator_Scan_Call) Run(run func(dest ...any)) *Iterator_Scan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]any, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(any)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Iterator_Scan_Call) Return(b bool) *Iterator_Scan_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *Iterator_Scan_Call) RunAndReturn(run func(dest ...any) bool) *Iterator_Scan_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/elasticsearch/client/mocks/ClusterAPI.go b/internal/storage/elasticsearch/client/mocks/ClusterAPI.go
deleted file mode 100644
index c811583f..00000000
--- a/internal/storage/elasticsearch/client/mocks/ClusterAPI.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// ClusterAPI is an autogenerated mock type for the ClusterAPI type
-type ClusterAPI struct {
-	mock.Mock
-}
-
-type ClusterAPI_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ClusterAPI) EXPECT() *ClusterAPI_Expecter {
-	return &ClusterAPI_Expecter{mock: &_m.Mock}
-}
-
-// Version provides a mock function with no fields
-func (_m *ClusterAPI) Version() (uint, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Version")
-	}
-
-	var r0 uint
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() uint); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(uint)
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ClusterAPI_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
-type ClusterAPI_Version_Call struct {
-	*mock.Call
-}
-
-// Version is a helper method to define mock.On call
-func (_e *ClusterAPI_Expecter) Version() *ClusterAPI_Version_Call {
-	return &ClusterAPI_Version_Call{Call: _e.mock.On("Version")}
-}
-
-func (_c *ClusterAPI_Version_Call) Run(run func()) *ClusterAPI_Version_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ClusterAPI_Version_Call) Return(_a0 uint, _a1 error) *ClusterAPI_Version_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *ClusterAPI_Version_Call) RunAndReturn(run func() (uint, error)) *ClusterAPI_Version_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewClusterAPI creates a new instance of ClusterAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewClusterAPI(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ClusterAPI {
-	mock := &ClusterAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/client/mocks/IndexAPI.go b/internal/storage/elasticsearch/client/mocks/IndexAPI.go
deleted file mode 100644
index 0a871cfc..00000000
--- a/internal/storage/elasticsearch/client/mocks/IndexAPI.go
+++ /dev/null
@@ -1,488 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	client "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/client"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// IndexAPI is an autogenerated mock type for the IndexAPI type
-type IndexAPI struct {
-	mock.Mock
-}
-
-type IndexAPI_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndexAPI) EXPECT() *IndexAPI_Expecter {
-	return &IndexAPI_Expecter{mock: &_m.Mock}
-}
-
-// AliasExists provides a mock function with given fields: alias
-func (_m *IndexAPI) AliasExists(alias string) (bool, error) {
-	ret := _m.Called(alias)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AliasExists")
-	}
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
-		return rf(alias)
-	}
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(alias)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(alias)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndexAPI_AliasExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AliasExists'
-type IndexAPI_AliasExists_Call struct {
-	*mock.Call
-}
-
-// AliasExists is a helper method to define mock.On call
-//   - alias string
-func (_e *IndexAPI_Expecter) AliasExists(alias interface{}) *IndexAPI_AliasExists_Call {
-	return &IndexAPI_AliasExists_Call{Call: _e.mock.On("AliasExists", alias)}
-}
-
-func (_c *IndexAPI_AliasExists_Call) Run(run func(alias string)) *IndexAPI_AliasExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_AliasExists_Call) Return(_a0 bool, _a1 error) *IndexAPI_AliasExists_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndexAPI_AliasExists_Call) RunAndReturn(run func(string) (bool, error)) *IndexAPI_AliasExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateAlias provides a mock function with given fields: aliases
-func (_m *IndexAPI) CreateAlias(aliases []client.Alias) error {
-	ret := _m.Called(aliases)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateAlias")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func([]client.Alias) error); ok {
-		r0 = rf(aliases)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_CreateAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlias'
-type IndexAPI_CreateAlias_Call struct {
-	*mock.Call
-}
-
-// CreateAlias is a helper method to define mock.On call
-//   - aliases []client.Alias
-func (_e *IndexAPI_Expecter) CreateAlias(aliases interface{}) *IndexAPI_CreateAlias_Call {
-	return &IndexAPI_CreateAlias_Call{Call: _e.mock.On("CreateAlias", aliases)}
-}
-
-func (_c *IndexAPI_CreateAlias_Call) Run(run func(aliases []client.Alias)) *IndexAPI_CreateAlias_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]client.Alias))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_CreateAlias_Call) Return(_a0 error) *IndexAPI_CreateAlias_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_CreateAlias_Call) RunAndReturn(run func([]client.Alias) error) *IndexAPI_CreateAlias_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateIndex provides a mock function with given fields: index
-func (_m *IndexAPI) CreateIndex(index string) error {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateIndex")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(index)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
-type IndexAPI_CreateIndex_Call struct {
-	*mock.Call
-}
-
-// CreateIndex is a helper method to define mock.On call
-//   - index string
-func (_e *IndexAPI_Expecter) CreateIndex(index interface{}) *IndexAPI_CreateIndex_Call {
-	return &IndexAPI_CreateIndex_Call{Call: _e.mock.On("CreateIndex", index)}
-}
-
-func (_c *IndexAPI_CreateIndex_Call) Run(run func(index string)) *IndexAPI_CreateIndex_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_CreateIndex_Call) Return(_a0 error) *IndexAPI_CreateIndex_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_CreateIndex_Call) RunAndReturn(run func(string) error) *IndexAPI_CreateIndex_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateTemplate provides a mock function with given fields: template, name
-func (_m *IndexAPI) CreateTemplate(template string, name string) error {
-	ret := _m.Called(template, name)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateTemplate")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string, string) error); ok {
-		r0 = rf(template, name)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate'
-type IndexAPI_CreateTemplate_Call struct {
-	*mock.Call
-}
-
-// CreateTemplate is a helper method to define mock.On call
-//   - template string
-//   - name string
-func (_e *IndexAPI_Expecter) CreateTemplate(template interface{}, name interface{}) *IndexAPI_CreateTemplate_Call {
-	return &IndexAPI_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", template, name)}
-}
-
-func (_c *IndexAPI_CreateTemplate_Call) Run(run func(template string, name string)) *IndexAPI_CreateTemplate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_CreateTemplate_Call) Return(_a0 error) *IndexAPI_CreateTemplate_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_CreateTemplate_Call) RunAndReturn(run func(string, string) error) *IndexAPI_CreateTemplate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteAlias provides a mock function with given fields: aliases
-func (_m *IndexAPI) DeleteAlias(aliases []client.Alias) error {
-	ret := _m.Called(aliases)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteAlias")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func([]client.Alias) error); ok {
-		r0 = rf(aliases)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_DeleteAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlias'
-type IndexAPI_DeleteAlias_Call struct {
-	*mock.Call
-}
-
-// DeleteAlias is a helper method to define mock.On call
-//   - aliases []client.Alias
-func (_e *IndexAPI_Expecter) DeleteAlias(aliases interface{}) *IndexAPI_DeleteAlias_Call {
-	return &IndexAPI_DeleteAlias_Call{Call: _e.mock.On("DeleteAlias", aliases)}
-}
-
-func (_c *IndexAPI_DeleteAlias_Call) Run(run func(aliases []client.Alias)) *IndexAPI_DeleteAlias_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]client.Alias))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_DeleteAlias_Call) Return(_a0 error) *IndexAPI_DeleteAlias_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_DeleteAlias_Call) RunAndReturn(run func([]client.Alias) error) *IndexAPI_DeleteAlias_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteIndices provides a mock function with given fields: indices
-func (_m *IndexAPI) DeleteIndices(indices []client.Index) error {
-	ret := _m.Called(indices)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteIndices")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func([]client.Index) error); ok {
-		r0 = rf(indices)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_DeleteIndices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIndices'
-type IndexAPI_DeleteIndices_Call struct {
-	*mock.Call
-}
-
-// DeleteIndices is a helper method to define mock.On call
-//   - indices []client.Index
-func (_e *IndexAPI_Expecter) DeleteIndices(indices interface{}) *IndexAPI_DeleteIndices_Call {
-	return &IndexAPI_DeleteIndices_Call{Call: _e.mock.On("DeleteIndices", indices)}
-}
-
-func (_c *IndexAPI_DeleteIndices_Call) Run(run func(indices []client.Index)) *IndexAPI_DeleteIndices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]client.Index))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_DeleteIndices_Call) Return(_a0 error) *IndexAPI_DeleteIndices_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_DeleteIndices_Call) RunAndReturn(run func([]client.Index) error) *IndexAPI_DeleteIndices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetJaegerIndices provides a mock function with given fields: prefix
-func (_m *IndexAPI) GetJaegerIndices(prefix string) ([]client.Index, error) {
-	ret := _m.Called(prefix)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetJaegerIndices")
-	}
-
-	var r0 []client.Index
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) ([]client.Index, error)); ok {
-		return rf(prefix)
-	}
-	if rf, ok := ret.Get(0).(func(string) []client.Index); ok {
-		r0 = rf(prefix)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]client.Index)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(prefix)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndexAPI_GetJaegerIndices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJaegerIndices'
-type IndexAPI_GetJaegerIndices_Call struct {
-	*mock.Call
-}
-
-// GetJaegerIndices is a helper method to define mock.On call
-//   - prefix string
-func (_e *IndexAPI_Expecter) GetJaegerIndices(prefix interface{}) *IndexAPI_GetJaegerIndices_Call {
-	return &IndexAPI_GetJaegerIndices_Call{Call: _e.mock.On("GetJaegerIndices", prefix)}
-}
-
-func (_c *IndexAPI_GetJaegerIndices_Call) Run(run func(prefix string)) *IndexAPI_GetJaegerIndices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_GetJaegerIndices_Call) Return(_a0 []client.Index, _a1 error) *IndexAPI_GetJaegerIndices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndexAPI_GetJaegerIndices_Call) RunAndReturn(run func(string) ([]client.Index, error)) *IndexAPI_GetJaegerIndices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// IndexExists provides a mock function with given fields: index
-func (_m *IndexAPI) IndexExists(index string) (bool, error) {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for IndexExists")
-	}
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
-		return rf(index)
-	}
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(index)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(index)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndexAPI_IndexExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexExists'
-type IndexAPI_IndexExists_Call struct {
-	*mock.Call
-}
-
-// IndexExists is a helper method to define mock.On call
-//   - index string
-func (_e *IndexAPI_Expecter) IndexExists(index interface{}) *IndexAPI_IndexExists_Call {
-	return &IndexAPI_IndexExists_Call{Call: _e.mock.On("IndexExists", index)}
-}
-
-func (_c *IndexAPI_IndexExists_Call) Run(run func(index string)) *IndexAPI_IndexExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_IndexExists_Call) Return(_a0 bool, _a1 error) *IndexAPI_IndexExists_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndexAPI_IndexExists_Call) RunAndReturn(run func(string) (bool, error)) *IndexAPI_IndexExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Rollover provides a mock function with given fields: rolloverTarget, conditions
-func (_m *IndexAPI) Rollover(rolloverTarget string, conditions map[string]any) error {
-	ret := _m.Called(rolloverTarget, conditions)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Rollover")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string, map[string]any) error); ok {
-		r0 = rf(rolloverTarget, conditions)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// IndexAPI_Rollover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rollover'
-type IndexAPI_Rollover_Call struct {
-	*mock.Call
-}
-
-// Rollover is a helper method to define mock.On call
-//   - rolloverTarget string
-//   - conditions map[string]any
-func (_e *IndexAPI_Expecter) Rollover(rolloverTarget interface{}, conditions interface{}) *IndexAPI_Rollover_Call {
-	return &IndexAPI_Rollover_Call{Call: _e.mock.On("Rollover", rolloverTarget, conditions)}
-}
-
-func (_c *IndexAPI_Rollover_Call) Run(run func(rolloverTarget string, conditions map[string]any)) *IndexAPI_Rollover_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(map[string]any))
-	})
-	return _c
-}
-
-func (_c *IndexAPI_Rollover_Call) Return(_a0 error) *IndexAPI_Rollover_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexAPI_Rollover_Call) RunAndReturn(run func(string, map[string]any) error) *IndexAPI_Rollover_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndexAPI creates a new instance of IndexAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndexAPI(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndexAPI {
-	mock := &IndexAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/client/mocks/IndexManagementLifecycleAPI.go b/internal/storage/elasticsearch/client/mocks/IndexManagementLifecycleAPI.go
deleted file mode 100644
index 9469d79f..00000000
--- a/internal/storage/elasticsearch/client/mocks/IndexManagementLifecycleAPI.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// IndexManagementLifecycleAPI is an autogenerated mock type for the IndexManagementLifecycleAPI type
-type IndexManagementLifecycleAPI struct {
-	mock.Mock
-}
-
-type IndexManagementLifecycleAPI_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndexManagementLifecycleAPI) EXPECT() *IndexManagementLifecycleAPI_Expecter {
-	return &IndexManagementLifecycleAPI_Expecter{mock: &_m.Mock}
-}
-
-// Exists provides a mock function with given fields: name
-func (_m *IndexManagementLifecycleAPI) Exists(name string) (bool, error) {
-	ret := _m.Called(name)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Exists")
-	}
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
-		return rf(name)
-	}
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(name)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(name)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndexManagementLifecycleAPI_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists'
-type IndexManagementLifecycleAPI_Exists_Call struct {
-	*mock.Call
-}
-
-// Exists is a helper method to define mock.On call
-//   - name string
-func (_e *IndexManagementLifecycleAPI_Expecter) Exists(name interface{}) *IndexManagementLifecycleAPI_Exists_Call {
-	return &IndexManagementLifecycleAPI_Exists_Call{Call: _e.mock.On("Exists", name)}
-}
-
-func (_c *IndexManagementLifecycleAPI_Exists_Call) Run(run func(name string)) *IndexManagementLifecycleAPI_Exists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexManagementLifecycleAPI_Exists_Call) Return(_a0 bool, _a1 error) *IndexManagementLifecycleAPI_Exists_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndexManagementLifecycleAPI_Exists_Call) RunAndReturn(run func(string) (bool, error)) *IndexManagementLifecycleAPI_Exists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndexManagementLifecycleAPI creates a new instance of IndexManagementLifecycleAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndexManagementLifecycleAPI(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndexManagementLifecycleAPI {
-	mock := &IndexManagementLifecycleAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/client/mocks/mocks.go b/internal/storage/elasticsearch/client/mocks/mocks.go
new file mode 100644
index 00000000..c5e7692f
--- /dev/null
+++ b/internal/storage/elasticsearch/client/mocks/mocks.go
@@ -0,0 +1,638 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/client"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewIndexAPI creates a new instance of IndexAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndexAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndexAPI {
+	mock := &IndexAPI{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndexAPI is an autogenerated mock type for the IndexAPI type
+type IndexAPI struct {
+	mock.Mock
+}
+
+type IndexAPI_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndexAPI) EXPECT() *IndexAPI_Expecter {
+	return &IndexAPI_Expecter{mock: &_m.Mock}
+}
+
+// AliasExists provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) AliasExists(alias string) (bool, error) {
+	ret := _mock.Called(alias)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AliasExists")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return returnFunc(alias)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(alias)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(alias)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndexAPI_AliasExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AliasExists'
+type IndexAPI_AliasExists_Call struct {
+	*mock.Call
+}
+
+// AliasExists is a helper method to define mock.On call
+//   - alias
+func (_e *IndexAPI_Expecter) AliasExists(alias interface{}) *IndexAPI_AliasExists_Call {
+	return &IndexAPI_AliasExists_Call{Call: _e.mock.On("AliasExists", alias)}
+}
+
+func (_c *IndexAPI_AliasExists_Call) Run(run func(alias string)) *IndexAPI_AliasExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_AliasExists_Call) Return(b bool, err error) *IndexAPI_AliasExists_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *IndexAPI_AliasExists_Call) RunAndReturn(run func(alias string) (bool, error)) *IndexAPI_AliasExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateAlias provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) CreateAlias(aliases []client.Alias) error {
+	ret := _mock.Called(aliases)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateAlias")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func([]client.Alias) error); ok {
+		r0 = returnFunc(aliases)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_CreateAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlias'
+type IndexAPI_CreateAlias_Call struct {
+	*mock.Call
+}
+
+// CreateAlias is a helper method to define mock.On call
+//   - aliases
+func (_e *IndexAPI_Expecter) CreateAlias(aliases interface{}) *IndexAPI_CreateAlias_Call {
+	return &IndexAPI_CreateAlias_Call{Call: _e.mock.On("CreateAlias", aliases)}
+}
+
+func (_c *IndexAPI_CreateAlias_Call) Run(run func(aliases []client.Alias)) *IndexAPI_CreateAlias_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]client.Alias))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_CreateAlias_Call) Return(err error) *IndexAPI_CreateAlias_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_CreateAlias_Call) RunAndReturn(run func(aliases []client.Alias) error) *IndexAPI_CreateAlias_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateIndex provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) CreateIndex(index string) error {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateIndex")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(index)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
+type IndexAPI_CreateIndex_Call struct {
+	*mock.Call
+}
+
+// CreateIndex is a helper method to define mock.On call
+//   - index
+func (_e *IndexAPI_Expecter) CreateIndex(index interface{}) *IndexAPI_CreateIndex_Call {
+	return &IndexAPI_CreateIndex_Call{Call: _e.mock.On("CreateIndex", index)}
+}
+
+func (_c *IndexAPI_CreateIndex_Call) Run(run func(index string)) *IndexAPI_CreateIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_CreateIndex_Call) Return(err error) *IndexAPI_CreateIndex_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_CreateIndex_Call) RunAndReturn(run func(index string) error) *IndexAPI_CreateIndex_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateTemplate provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) CreateTemplate(template string, name string) error {
+	ret := _mock.Called(template, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateTemplate")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = returnFunc(template, name)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate'
+type IndexAPI_CreateTemplate_Call struct {
+	*mock.Call
+}
+
+// CreateTemplate is a helper method to define mock.On call
+//   - template
+//   - name
+func (_e *IndexAPI_Expecter) CreateTemplate(template interface{}, name interface{}) *IndexAPI_CreateTemplate_Call {
+	return &IndexAPI_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", template, name)}
+}
+
+func (_c *IndexAPI_CreateTemplate_Call) Run(run func(template string, name string)) *IndexAPI_CreateTemplate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_CreateTemplate_Call) Return(err error) *IndexAPI_CreateTemplate_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_CreateTemplate_Call) RunAndReturn(run func(template string, name string) error) *IndexAPI_CreateTemplate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteAlias provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) DeleteAlias(aliases []client.Alias) error {
+	ret := _mock.Called(aliases)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteAlias")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func([]client.Alias) error); ok {
+		r0 = returnFunc(aliases)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_DeleteAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlias'
+type IndexAPI_DeleteAlias_Call struct {
+	*mock.Call
+}
+
+// DeleteAlias is a helper method to define mock.On call
+//   - aliases
+func (_e *IndexAPI_Expecter) DeleteAlias(aliases interface{}) *IndexAPI_DeleteAlias_Call {
+	return &IndexAPI_DeleteAlias_Call{Call: _e.mock.On("DeleteAlias", aliases)}
+}
+
+func (_c *IndexAPI_DeleteAlias_Call) Run(run func(aliases []client.Alias)) *IndexAPI_DeleteAlias_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]client.Alias))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_DeleteAlias_Call) Return(err error) *IndexAPI_DeleteAlias_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_DeleteAlias_Call) RunAndReturn(run func(aliases []client.Alias) error) *IndexAPI_DeleteAlias_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteIndices provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) DeleteIndices(indices []client.Index) error {
+	ret := _mock.Called(indices)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteIndices")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func([]client.Index) error); ok {
+		r0 = returnFunc(indices)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_DeleteIndices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIndices'
+type IndexAPI_DeleteIndices_Call struct {
+	*mock.Call
+}
+
+// DeleteIndices is a helper method to define mock.On call
+//   - indices
+func (_e *IndexAPI_Expecter) DeleteIndices(indices interface{}) *IndexAPI_DeleteIndices_Call {
+	return &IndexAPI_DeleteIndices_Call{Call: _e.mock.On("DeleteIndices", indices)}
+}
+
+func (_c *IndexAPI_DeleteIndices_Call) Run(run func(indices []client.Index)) *IndexAPI_DeleteIndices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]client.Index))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_DeleteIndices_Call) Return(err error) *IndexAPI_DeleteIndices_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_DeleteIndices_Call) RunAndReturn(run func(indices []client.Index) error) *IndexAPI_DeleteIndices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetJaegerIndices provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) GetJaegerIndices(prefix string) ([]client.Index, error) {
+	ret := _mock.Called(prefix)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetJaegerIndices")
+	}
+
+	var r0 []client.Index
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) ([]client.Index, error)); ok {
+		return returnFunc(prefix)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) []client.Index); ok {
+		r0 = returnFunc(prefix)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]client.Index)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(prefix)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndexAPI_GetJaegerIndices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJaegerIndices'
+type IndexAPI_GetJaegerIndices_Call struct {
+	*mock.Call
+}
+
+// GetJaegerIndices is a helper method to define mock.On call
+//   - prefix
+func (_e *IndexAPI_Expecter) GetJaegerIndices(prefix interface{}) *IndexAPI_GetJaegerIndices_Call {
+	return &IndexAPI_GetJaegerIndices_Call{Call: _e.mock.On("GetJaegerIndices", prefix)}
+}
+
+func (_c *IndexAPI_GetJaegerIndices_Call) Run(run func(prefix string)) *IndexAPI_GetJaegerIndices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_GetJaegerIndices_Call) Return(indexs []client.Index, err error) *IndexAPI_GetJaegerIndices_Call {
+	_c.Call.Return(indexs, err)
+	return _c
+}
+
+func (_c *IndexAPI_GetJaegerIndices_Call) RunAndReturn(run func(prefix string) ([]client.Index, error)) *IndexAPI_GetJaegerIndices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// IndexExists provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) IndexExists(index string) (bool, error) {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IndexExists")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return returnFunc(index)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(index)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(index)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndexAPI_IndexExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexExists'
+type IndexAPI_IndexExists_Call struct {
+	*mock.Call
+}
+
+// IndexExists is a helper method to define mock.On call
+//   - index
+func (_e *IndexAPI_Expecter) IndexExists(index interface{}) *IndexAPI_IndexExists_Call {
+	return &IndexAPI_IndexExists_Call{Call: _e.mock.On("IndexExists", index)}
+}
+
+func (_c *IndexAPI_IndexExists_Call) Run(run func(index string)) *IndexAPI_IndexExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_IndexExists_Call) Return(b bool, err error) *IndexAPI_IndexExists_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *IndexAPI_IndexExists_Call) RunAndReturn(run func(index string) (bool, error)) *IndexAPI_IndexExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Rollover provides a mock function for the type IndexAPI
+func (_mock *IndexAPI) Rollover(rolloverTarget string, conditions map[string]any) error {
+	ret := _mock.Called(rolloverTarget, conditions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Rollover")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string, map[string]any) error); ok {
+		r0 = returnFunc(rolloverTarget, conditions)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// IndexAPI_Rollover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rollover'
+type IndexAPI_Rollover_Call struct {
+	*mock.Call
+}
+
+// Rollover is a helper method to define mock.On call
+//   - rolloverTarget
+//   - conditions
+func (_e *IndexAPI_Expecter) Rollover(rolloverTarget interface{}, conditions interface{}) *IndexAPI_Rollover_Call {
+	return &IndexAPI_Rollover_Call{Call: _e.mock.On("Rollover", rolloverTarget, conditions)}
+}
+
+func (_c *IndexAPI_Rollover_Call) Run(run func(rolloverTarget string, conditions map[string]any)) *IndexAPI_Rollover_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(map[string]any))
+	})
+	return _c
+}
+
+func (_c *IndexAPI_Rollover_Call) Return(err error) *IndexAPI_Rollover_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *IndexAPI_Rollover_Call) RunAndReturn(run func(rolloverTarget string, conditions map[string]any) error) *IndexAPI_Rollover_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewClusterAPI creates a new instance of ClusterAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewClusterAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ClusterAPI {
+	mock := &ClusterAPI{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ClusterAPI is an autogenerated mock type for the ClusterAPI type
+type ClusterAPI struct {
+	mock.Mock
+}
+
+type ClusterAPI_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ClusterAPI) EXPECT() *ClusterAPI_Expecter {
+	return &ClusterAPI_Expecter{mock: &_m.Mock}
+}
+
+// Version provides a mock function for the type ClusterAPI
+func (_mock *ClusterAPI) Version() (uint, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Version")
+	}
+
+	var r0 uint
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (uint, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() uint); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(uint)
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ClusterAPI_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
+type ClusterAPI_Version_Call struct {
+	*mock.Call
+}
+
+// Version is a helper method to define mock.On call
+func (_e *ClusterAPI_Expecter) Version() *ClusterAPI_Version_Call {
+	return &ClusterAPI_Version_Call{Call: _e.mock.On("Version")}
+}
+
+func (_c *ClusterAPI_Version_Call) Run(run func()) *ClusterAPI_Version_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ClusterAPI_Version_Call) Return(v uint, err error) *ClusterAPI_Version_Call {
+	_c.Call.Return(v, err)
+	return _c
+}
+
+func (_c *ClusterAPI_Version_Call) RunAndReturn(run func() (uint, error)) *ClusterAPI_Version_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIndexManagementLifecycleAPI creates a new instance of IndexManagementLifecycleAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndexManagementLifecycleAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndexManagementLifecycleAPI {
+	mock := &IndexManagementLifecycleAPI{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndexManagementLifecycleAPI is an autogenerated mock type for the IndexManagementLifecycleAPI type
+type IndexManagementLifecycleAPI struct {
+	mock.Mock
+}
+
+type IndexManagementLifecycleAPI_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndexManagementLifecycleAPI) EXPECT() *IndexManagementLifecycleAPI_Expecter {
+	return &IndexManagementLifecycleAPI_Expecter{mock: &_m.Mock}
+}
+
+// Exists provides a mock function for the type IndexManagementLifecycleAPI
+func (_mock *IndexManagementLifecycleAPI) Exists(name string) (bool, error) {
+	ret := _mock.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Exists")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return returnFunc(name)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(name)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndexManagementLifecycleAPI_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists'
+type IndexManagementLifecycleAPI_Exists_Call struct {
+	*mock.Call
+}
+
+// Exists is a helper method to define mock.On call
+//   - name
+func (_e *IndexManagementLifecycleAPI_Expecter) Exists(name interface{}) *IndexManagementLifecycleAPI_Exists_Call {
+	return &IndexManagementLifecycleAPI_Exists_Call{Call: _e.mock.On("Exists", name)}
+}
+
+func (_c *IndexManagementLifecycleAPI_Exists_Call) Run(run func(name string)) *IndexManagementLifecycleAPI_Exists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexManagementLifecycleAPI_Exists_Call) Return(b bool, err error) *IndexManagementLifecycleAPI_Exists_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *IndexManagementLifecycleAPI_Exists_Call) RunAndReturn(run func(name string) (bool, error)) *IndexManagementLifecycleAPI_Exists_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/elasticsearch/mocks/Client.go b/internal/storage/elasticsearch/mocks/Client.go
deleted file mode 100644
index cbb1afe9..00000000
--- a/internal/storage/elasticsearch/mocks/Client.go
+++ /dev/null
@@ -1,477 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Client is an autogenerated mock type for the Client type
-type Client struct {
-	mock.Mock
-}
-
-type Client_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Client) EXPECT() *Client_Expecter {
-	return &Client_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with no fields
-func (_m *Client) Close() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Client_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type Client_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-func (_e *Client_Expecter) Close() *Client_Close_Call {
-	return &Client_Close_Call{Call: _e.mock.On("Close")}
-}
-
-func (_c *Client_Close_Call) Run(run func()) *Client_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Client_Close_Call) Return(_a0 error) *Client_Close_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_Close_Call) RunAndReturn(run func() error) *Client_Close_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateIndex provides a mock function with given fields: index
-func (_m *Client) CreateIndex(index string) elasticsearch.IndicesCreateService {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateIndex")
-	}
-
-	var r0 elasticsearch.IndicesCreateService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndicesCreateService); ok {
-		r0 = rf(index)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndicesCreateService)
-		}
-	}
-
-	return r0
-}
-
-// Client_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
-type Client_CreateIndex_Call struct {
-	*mock.Call
-}
-
-// CreateIndex is a helper method to define mock.On call
-//   - index string
-func (_e *Client_Expecter) CreateIndex(index interface{}) *Client_CreateIndex_Call {
-	return &Client_CreateIndex_Call{Call: _e.mock.On("CreateIndex", index)}
-}
-
-func (_c *Client_CreateIndex_Call) Run(run func(index string)) *Client_CreateIndex_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *Client_CreateIndex_Call) Return(_a0 elasticsearch.IndicesCreateService) *Client_CreateIndex_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_CreateIndex_Call) RunAndReturn(run func(string) elasticsearch.IndicesCreateService) *Client_CreateIndex_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateTemplate provides a mock function with given fields: id
-func (_m *Client) CreateTemplate(id string) elasticsearch.TemplateCreateService {
-	ret := _m.Called(id)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateTemplate")
-	}
-
-	var r0 elasticsearch.TemplateCreateService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.TemplateCreateService); ok {
-		r0 = rf(id)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.TemplateCreateService)
-		}
-	}
-
-	return r0
-}
-
-// Client_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate'
-type Client_CreateTemplate_Call struct {
-	*mock.Call
-}
-
-// CreateTemplate is a helper method to define mock.On call
-//   - id string
-func (_e *Client_Expecter) CreateTemplate(id interface{}) *Client_CreateTemplate_Call {
-	return &Client_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", id)}
-}
-
-func (_c *Client_CreateTemplate_Call) Run(run func(id string)) *Client_CreateTemplate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *Client_CreateTemplate_Call) Return(_a0 elasticsearch.TemplateCreateService) *Client_CreateTemplate_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_CreateTemplate_Call) RunAndReturn(run func(string) elasticsearch.TemplateCreateService) *Client_CreateTemplate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// DeleteIndex provides a mock function with given fields: index
-func (_m *Client) DeleteIndex(index string) elasticsearch.IndicesDeleteService {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteIndex")
-	}
-
-	var r0 elasticsearch.IndicesDeleteService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndicesDeleteService); ok {
-		r0 = rf(index)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndicesDeleteService)
-		}
-	}
-
-	return r0
-}
-
-// Client_DeleteIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIndex'
-type Client_DeleteIndex_Call struct {
-	*mock.Call
-}
-
-// DeleteIndex is a helper method to define mock.On call
-//   - index string
-func (_e *Client_Expecter) DeleteIndex(index interface{}) *Client_DeleteIndex_Call {
-	return &Client_DeleteIndex_Call{Call: _e.mock.On("DeleteIndex", index)}
-}
-
-func (_c *Client_DeleteIndex_Call) Run(run func(index string)) *Client_DeleteIndex_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *Client_DeleteIndex_Call) Return(_a0 elasticsearch.IndicesDeleteService) *Client_DeleteIndex_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_DeleteIndex_Call) RunAndReturn(run func(string) elasticsearch.IndicesDeleteService) *Client_DeleteIndex_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetVersion provides a mock function with no fields
-func (_m *Client) GetVersion() uint {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetVersion")
-	}
-
-	var r0 uint
-	if rf, ok := ret.Get(0).(func() uint); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(uint)
-	}
-
-	return r0
-}
-
-// Client_GetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVersion'
-type Client_GetVersion_Call struct {
-	*mock.Call
-}
-
-// GetVersion is a helper method to define mock.On call
-func (_e *Client_Expecter) GetVersion() *Client_GetVersion_Call {
-	return &Client_GetVersion_Call{Call: _e.mock.On("GetVersion")}
-}
-
-func (_c *Client_GetVersion_Call) Run(run func()) *Client_GetVersion_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Client_GetVersion_Call) Return(_a0 uint) *Client_GetVersion_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_GetVersion_Call) RunAndReturn(run func() uint) *Client_GetVersion_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Index provides a mock function with no fields
-func (_m *Client) Index() elasticsearch.IndexService {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Index")
-	}
-
-	var r0 elasticsearch.IndexService
-	if rf, ok := ret.Get(0).(func() elasticsearch.IndexService); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndexService)
-		}
-	}
-
-	return r0
-}
-
-// Client_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
-type Client_Index_Call struct {
-	*mock.Call
-}
-
-// Index is a helper method to define mock.On call
-func (_e *Client_Expecter) Index() *Client_Index_Call {
-	return &Client_Index_Call{Call: _e.mock.On("Index")}
-}
-
-func (_c *Client_Index_Call) Run(run func()) *Client_Index_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Client_Index_Call) Return(_a0 elasticsearch.IndexService) *Client_Index_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_Index_Call) RunAndReturn(run func() elasticsearch.IndexService) *Client_Index_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// IndexExists provides a mock function with given fields: index
-func (_m *Client) IndexExists(index string) elasticsearch.IndicesExistsService {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for IndexExists")
-	}
-
-	var r0 elasticsearch.IndicesExistsService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndicesExistsService); ok {
-		r0 = rf(index)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndicesExistsService)
-		}
-	}
-
-	return r0
-}
-
-// Client_IndexExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexExists'
-type Client_IndexExists_Call struct {
-	*mock.Call
-}
-
-// IndexExists is a helper method to define mock.On call
-//   - index string
-func (_e *Client_Expecter) IndexExists(index interface{}) *Client_IndexExists_Call {
-	return &Client_IndexExists_Call{Call: _e.mock.On("IndexExists", index)}
-}
-
-func (_c *Client_IndexExists_Call) Run(run func(index string)) *Client_IndexExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *Client_IndexExists_Call) Return(_a0 elasticsearch.IndicesExistsService) *Client_IndexExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_IndexExists_Call) RunAndReturn(run func(string) elasticsearch.IndicesExistsService) *Client_IndexExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// MultiSearch provides a mock function with no fields
-func (_m *Client) MultiSearch() elasticsearch.MultiSearchService {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for MultiSearch")
-	}
-
-	var r0 elasticsearch.MultiSearchService
-	if rf, ok := ret.Get(0).(func() elasticsearch.MultiSearchService); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
-		}
-	}
-
-	return r0
-}
-
-// Client_MultiSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiSearch'
-type Client_MultiSearch_Call struct {
-	*mock.Call
-}
-
-// MultiSearch is a helper method to define mock.On call
-func (_e *Client_Expecter) MultiSearch() *Client_MultiSearch_Call {
-	return &Client_MultiSearch_Call{Call: _e.mock.On("MultiSearch")}
-}
-
-func (_c *Client_MultiSearch_Call) Run(run func()) *Client_MultiSearch_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Client_MultiSearch_Call) Return(_a0 elasticsearch.MultiSearchService) *Client_MultiSearch_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_MultiSearch_Call) RunAndReturn(run func() elasticsearch.MultiSearchService) *Client_MultiSearch_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Search provides a mock function with given fields: indices
-func (_m *Client) Search(indices ...string) elasticsearch.SearchService {
-	_va := make([]interface{}, len(indices))
-	for _i := range indices {
-		_va[_i] = indices[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Search")
-	}
-
-	var r0 elasticsearch.SearchService
-	if rf, ok := ret.Get(0).(func(...string) elasticsearch.SearchService); ok {
-		r0 = rf(indices...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.SearchService)
-		}
-	}
-
-	return r0
-}
-
-// Client_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
-type Client_Search_Call struct {
-	*mock.Call
-}
-
-// Search is a helper method to define mock.On call
-//   - indices ...string
-func (_e *Client_Expecter) Search(indices ...interface{}) *Client_Search_Call {
-	return &Client_Search_Call{Call: _e.mock.On("Search",
-		append([]interface{}{}, indices...)...)}
-}
-
-func (_c *Client_Search_Call) Run(run func(indices ...string)) *Client_Search_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Client_Search_Call) Return(_a0 elasticsearch.SearchService) *Client_Search_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Client_Search_Call) RunAndReturn(run func(...string) elasticsearch.SearchService) *Client_Search_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Client {
-	mock := &Client{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/IndexService.go b/internal/storage/elasticsearch/mocks/IndexService.go
deleted file mode 100644
index 13add992..00000000
--- a/internal/storage/elasticsearch/mocks/IndexService.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// IndexService is an autogenerated mock type for the IndexService type
-type IndexService struct {
-	mock.Mock
-}
-
-type IndexService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndexService) EXPECT() *IndexService_Expecter {
-	return &IndexService_Expecter{mock: &_m.Mock}
-}
-
-// Add provides a mock function with no fields
-func (_m *IndexService) Add() {
-	_m.Called()
-}
-
-// IndexService_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
-type IndexService_Add_Call struct {
-	*mock.Call
-}
-
-// Add is a helper method to define mock.On call
-func (_e *IndexService_Expecter) Add() *IndexService_Add_Call {
-	return &IndexService_Add_Call{Call: _e.mock.On("Add")}
-}
-
-func (_c *IndexService_Add_Call) Run(run func()) *IndexService_Add_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *IndexService_Add_Call) Return() *IndexService_Add_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *IndexService_Add_Call) RunAndReturn(run func()) *IndexService_Add_Call {
-	_c.Run(run)
-	return _c
-}
-
-// BodyJson provides a mock function with given fields: body
-func (_m *IndexService) BodyJson(body any) elasticsearch.IndexService {
-	ret := _m.Called(body)
-
-	if len(ret) == 0 {
-		panic("no return value specified for BodyJson")
-	}
-
-	var r0 elasticsearch.IndexService
-	if rf, ok := ret.Get(0).(func(any) elasticsearch.IndexService); ok {
-		r0 = rf(body)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndexService)
-		}
-	}
-
-	return r0
-}
-
-// IndexService_BodyJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BodyJson'
-type IndexService_BodyJson_Call struct {
-	*mock.Call
-}
-
-// BodyJson is a helper method to define mock.On call
-//   - body any
-func (_e *IndexService_Expecter) BodyJson(body interface{}) *IndexService_BodyJson_Call {
-	return &IndexService_BodyJson_Call{Call: _e.mock.On("BodyJson", body)}
-}
-
-func (_c *IndexService_BodyJson_Call) Run(run func(body any)) *IndexService_BodyJson_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(any))
-	})
-	return _c
-}
-
-func (_c *IndexService_BodyJson_Call) Return(_a0 elasticsearch.IndexService) *IndexService_BodyJson_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexService_BodyJson_Call) RunAndReturn(run func(any) elasticsearch.IndexService) *IndexService_BodyJson_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Id provides a mock function with given fields: id
-func (_m *IndexService) Id(id string) elasticsearch.IndexService {
-	ret := _m.Called(id)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Id")
-	}
-
-	var r0 elasticsearch.IndexService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
-		r0 = rf(id)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndexService)
-		}
-	}
-
-	return r0
-}
-
-// IndexService_Id_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Id'
-type IndexService_Id_Call struct {
-	*mock.Call
-}
-
-// Id is a helper method to define mock.On call
-//   - id string
-func (_e *IndexService_Expecter) Id(id interface{}) *IndexService_Id_Call {
-	return &IndexService_Id_Call{Call: _e.mock.On("Id", id)}
-}
-
-func (_c *IndexService_Id_Call) Run(run func(id string)) *IndexService_Id_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexService_Id_Call) Return(_a0 elasticsearch.IndexService) *IndexService_Id_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexService_Id_Call) RunAndReturn(run func(string) elasticsearch.IndexService) *IndexService_Id_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Index provides a mock function with given fields: index
-func (_m *IndexService) Index(index string) elasticsearch.IndexService {
-	ret := _m.Called(index)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Index")
-	}
-
-	var r0 elasticsearch.IndexService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
-		r0 = rf(index)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndexService)
-		}
-	}
-
-	return r0
-}
-
-// IndexService_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
-type IndexService_Index_Call struct {
-	*mock.Call
-}
-
-// Index is a helper method to define mock.On call
-//   - index string
-func (_e *IndexService_Expecter) Index(index interface{}) *IndexService_Index_Call {
-	return &IndexService_Index_Call{Call: _e.mock.On("Index", index)}
-}
-
-func (_c *IndexService_Index_Call) Run(run func(index string)) *IndexService_Index_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexService_Index_Call) Return(_a0 elasticsearch.IndexService) *IndexService_Index_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexService_Index_Call) RunAndReturn(run func(string) elasticsearch.IndexService) *IndexService_Index_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Type provides a mock function with given fields: typ
-func (_m *IndexService) Type(typ string) elasticsearch.IndexService {
-	ret := _m.Called(typ)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Type")
-	}
-
-	var r0 elasticsearch.IndexService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
-		r0 = rf(typ)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndexService)
-		}
-	}
-
-	return r0
-}
-
-// IndexService_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type'
-type IndexService_Type_Call struct {
-	*mock.Call
-}
-
-// Type is a helper method to define mock.On call
-//   - typ string
-func (_e *IndexService_Expecter) Type(typ interface{}) *IndexService_Type_Call {
-	return &IndexService_Type_Call{Call: _e.mock.On("Type", typ)}
-}
-
-func (_c *IndexService_Type_Call) Run(run func(typ string)) *IndexService_Type_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndexService_Type_Call) Return(_a0 elasticsearch.IndexService) *IndexService_Type_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndexService_Type_Call) RunAndReturn(run func(string) elasticsearch.IndexService) *IndexService_Type_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndexService creates a new instance of IndexService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndexService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndexService {
-	mock := &IndexService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/IndicesCreateService.go b/internal/storage/elasticsearch/mocks/IndicesCreateService.go
deleted file mode 100644
index 4b254af4..00000000
--- a/internal/storage/elasticsearch/mocks/IndicesCreateService.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	elastic "github.com/olivere/elastic"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// IndicesCreateService is an autogenerated mock type for the IndicesCreateService type
-type IndicesCreateService struct {
-	mock.Mock
-}
-
-type IndicesCreateService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndicesCreateService) EXPECT() *IndicesCreateService_Expecter {
-	return &IndicesCreateService_Expecter{mock: &_m.Mock}
-}
-
-// Body provides a mock function with given fields: mapping
-func (_m *IndicesCreateService) Body(mapping string) elasticsearch.IndicesCreateService {
-	ret := _m.Called(mapping)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Body")
-	}
-
-	var r0 elasticsearch.IndicesCreateService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.IndicesCreateService); ok {
-		r0 = rf(mapping)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.IndicesCreateService)
-		}
-	}
-
-	return r0
-}
-
-// IndicesCreateService_Body_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Body'
-type IndicesCreateService_Body_Call struct {
-	*mock.Call
-}
-
-// Body is a helper method to define mock.On call
-//   - mapping string
-func (_e *IndicesCreateService_Expecter) Body(mapping interface{}) *IndicesCreateService_Body_Call {
-	return &IndicesCreateService_Body_Call{Call: _e.mock.On("Body", mapping)}
-}
-
-func (_c *IndicesCreateService_Body_Call) Run(run func(mapping string)) *IndicesCreateService_Body_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *IndicesCreateService_Body_Call) Return(_a0 elasticsearch.IndicesCreateService) *IndicesCreateService_Body_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *IndicesCreateService_Body_Call) RunAndReturn(run func(string) elasticsearch.IndicesCreateService) *IndicesCreateService_Body_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *IndicesCreateService) Do(ctx context.Context) (*elastic.IndicesCreateResult, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 *elastic.IndicesCreateResult
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesCreateResult, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *elastic.IndicesCreateResult); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*elastic.IndicesCreateResult)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndicesCreateService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type IndicesCreateService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *IndicesCreateService_Expecter) Do(ctx interface{}) *IndicesCreateService_Do_Call {
-	return &IndicesCreateService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *IndicesCreateService_Do_Call) Run(run func(ctx context.Context)) *IndicesCreateService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *IndicesCreateService_Do_Call) Return(_a0 *elastic.IndicesCreateResult, _a1 error) *IndicesCreateService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndicesCreateService_Do_Call) RunAndReturn(run func(context.Context) (*elastic.IndicesCreateResult, error)) *IndicesCreateService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndicesCreateService creates a new instance of IndicesCreateService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndicesCreateService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndicesCreateService {
-	mock := &IndicesCreateService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/IndicesDeleteService.go b/internal/storage/elasticsearch/mocks/IndicesDeleteService.go
deleted file mode 100644
index 1c3cc4cd..00000000
--- a/internal/storage/elasticsearch/mocks/IndicesDeleteService.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	elastic "github.com/olivere/elastic"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// IndicesDeleteService is an autogenerated mock type for the IndicesDeleteService type
-type IndicesDeleteService struct {
-	mock.Mock
-}
-
-type IndicesDeleteService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndicesDeleteService) EXPECT() *IndicesDeleteService_Expecter {
-	return &IndicesDeleteService_Expecter{mock: &_m.Mock}
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *IndicesDeleteService) Do(ctx context.Context) (*elastic.IndicesDeleteResponse, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 *elastic.IndicesDeleteResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesDeleteResponse, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *elastic.IndicesDeleteResponse); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*elastic.IndicesDeleteResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndicesDeleteService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type IndicesDeleteService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *IndicesDeleteService_Expecter) Do(ctx interface{}) *IndicesDeleteService_Do_Call {
-	return &IndicesDeleteService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *IndicesDeleteService_Do_Call) Run(run func(ctx context.Context)) *IndicesDeleteService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *IndicesDeleteService_Do_Call) Return(_a0 *elastic.IndicesDeleteResponse, _a1 error) *IndicesDeleteService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndicesDeleteService_Do_Call) RunAndReturn(run func(context.Context) (*elastic.IndicesDeleteResponse, error)) *IndicesDeleteService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndicesDeleteService creates a new instance of IndicesDeleteService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndicesDeleteService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndicesDeleteService {
-	mock := &IndicesDeleteService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/IndicesExistsService.go b/internal/storage/elasticsearch/mocks/IndicesExistsService.go
deleted file mode 100644
index a09027fc..00000000
--- a/internal/storage/elasticsearch/mocks/IndicesExistsService.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// IndicesExistsService is an autogenerated mock type for the IndicesExistsService type
-type IndicesExistsService struct {
-	mock.Mock
-}
-
-type IndicesExistsService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *IndicesExistsService) EXPECT() *IndicesExistsService_Expecter {
-	return &IndicesExistsService_Expecter{mock: &_m.Mock}
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *IndicesExistsService) Do(ctx context.Context) (bool, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (bool, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) bool); ok {
-		r0 = rf(ctx)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// IndicesExistsService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type IndicesExistsService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *IndicesExistsService_Expecter) Do(ctx interface{}) *IndicesExistsService_Do_Call {
-	return &IndicesExistsService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *IndicesExistsService_Do_Call) Run(run func(ctx context.Context)) *IndicesExistsService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *IndicesExistsService_Do_Call) Return(_a0 bool, _a1 error) *IndicesExistsService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *IndicesExistsService_Do_Call) RunAndReturn(run func(context.Context) (bool, error)) *IndicesExistsService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewIndicesExistsService creates a new instance of IndicesExistsService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewIndicesExistsService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *IndicesExistsService {
-	mock := &IndicesExistsService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/MultiSearchService.go b/internal/storage/elasticsearch/mocks/MultiSearchService.go
deleted file mode 100644
index c9aeee7b..00000000
--- a/internal/storage/elasticsearch/mocks/MultiSearchService.go
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	elastic "github.com/olivere/elastic"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// MultiSearchService is an autogenerated mock type for the MultiSearchService type
-type MultiSearchService struct {
-	mock.Mock
-}
-
-type MultiSearchService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MultiSearchService) EXPECT() *MultiSearchService_Expecter {
-	return &MultiSearchService_Expecter{mock: &_m.Mock}
-}
-
-// Add provides a mock function with given fields: requests
-func (_m *MultiSearchService) Add(requests ...*elastic.SearchRequest) elasticsearch.MultiSearchService {
-	_va := make([]interface{}, len(requests))
-	for _i := range requests {
-		_va[_i] = requests[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Add")
-	}
-
-	var r0 elasticsearch.MultiSearchService
-	if rf, ok := ret.Get(0).(func(...*elastic.SearchRequest) elasticsearch.MultiSearchService); ok {
-		r0 = rf(requests...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
-		}
-	}
-
-	return r0
-}
-
-// MultiSearchService_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
-type MultiSearchService_Add_Call struct {
-	*mock.Call
-}
-
-// Add is a helper method to define mock.On call
-//   - requests ...*elastic.SearchRequest
-func (_e *MultiSearchService_Expecter) Add(requests ...interface{}) *MultiSearchService_Add_Call {
-	return &MultiSearchService_Add_Call{Call: _e.mock.On("Add",
-		append([]interface{}{}, requests...)...)}
-}
-
-func (_c *MultiSearchService_Add_Call) Run(run func(requests ...*elastic.SearchRequest)) *MultiSearchService_Add_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]*elastic.SearchRequest, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(*elastic.SearchRequest)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MultiSearchService_Add_Call) Return(_a0 elasticsearch.MultiSearchService) *MultiSearchService_Add_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MultiSearchService_Add_Call) RunAndReturn(run func(...*elastic.SearchRequest) elasticsearch.MultiSearchService) *MultiSearchService_Add_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *MultiSearchService) Do(ctx context.Context) (*elastic.MultiSearchResult, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 *elastic.MultiSearchResult
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*elastic.MultiSearchResult, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *elastic.MultiSearchResult); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*elastic.MultiSearchResult)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// MultiSearchService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type MultiSearchService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *MultiSearchService_Expecter) Do(ctx interface{}) *MultiSearchService_Do_Call {
-	return &MultiSearchService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *MultiSearchService_Do_Call) Run(run func(ctx context.Context)) *MultiSearchService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *MultiSearchService_Do_Call) Return(_a0 *elastic.MultiSearchResult, _a1 error) *MultiSearchService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *MultiSearchService_Do_Call) RunAndReturn(run func(context.Context) (*elastic.MultiSearchResult, error)) *MultiSearchService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Index provides a mock function with given fields: indices
-func (_m *MultiSearchService) Index(indices ...string) elasticsearch.MultiSearchService {
-	_va := make([]interface{}, len(indices))
-	for _i := range indices {
-		_va[_i] = indices[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Index")
-	}
-
-	var r0 elasticsearch.MultiSearchService
-	if rf, ok := ret.Get(0).(func(...string) elasticsearch.MultiSearchService); ok {
-		r0 = rf(indices...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
-		}
-	}
-
-	return r0
-}
-
-// MultiSearchService_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
-type MultiSearchService_Index_Call struct {
-	*mock.Call
-}
-
-// Index is a helper method to define mock.On call
-//   - indices ...string
-func (_e *MultiSearchService_Expecter) Index(indices ...interface{}) *MultiSearchService_Index_Call {
-	return &MultiSearchService_Index_Call{Call: _e.mock.On("Index",
-		append([]interface{}{}, indices...)...)}
-}
-
-func (_c *MultiSearchService_Index_Call) Run(run func(indices ...string)) *MultiSearchService_Index_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MultiSearchService_Index_Call) Return(_a0 elasticsearch.MultiSearchService) *MultiSearchService_Index_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MultiSearchService_Index_Call) RunAndReturn(run func(...string) elasticsearch.MultiSearchService) *MultiSearchService_Index_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewMultiSearchService creates a new instance of MultiSearchService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMultiSearchService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MultiSearchService {
-	mock := &MultiSearchService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/SearchService.go b/internal/storage/elasticsearch/mocks/SearchService.go
deleted file mode 100644
index 829c6aea..00000000
--- a/internal/storage/elasticsearch/mocks/SearchService.go
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	elastic "github.com/olivere/elastic"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// SearchService is an autogenerated mock type for the SearchService type
-type SearchService struct {
-	mock.Mock
-}
-
-type SearchService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SearchService) EXPECT() *SearchService_Expecter {
-	return &SearchService_Expecter{mock: &_m.Mock}
-}
-
-// Aggregation provides a mock function with given fields: name, aggregation
-func (_m *SearchService) Aggregation(name string, aggregation elastic.Aggregation) elasticsearch.SearchService {
-	ret := _m.Called(name, aggregation)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Aggregation")
-	}
-
-	var r0 elasticsearch.SearchService
-	if rf, ok := ret.Get(0).(func(string, elastic.Aggregation) elasticsearch.SearchService); ok {
-		r0 = rf(name, aggregation)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.SearchService)
-		}
-	}
-
-	return r0
-}
-
-// SearchService_Aggregation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Aggregation'
-type SearchService_Aggregation_Call struct {
-	*mock.Call
-}
-
-// Aggregation is a helper method to define mock.On call
-//   - name string
-//   - aggregation elastic.Aggregation
-func (_e *SearchService_Expecter) Aggregation(name interface{}, aggregation interface{}) *SearchService_Aggregation_Call {
-	return &SearchService_Aggregation_Call{Call: _e.mock.On("Aggregation", name, aggregation)}
-}
-
-func (_c *SearchService_Aggregation_Call) Run(run func(name string, aggregation elastic.Aggregation)) *SearchService_Aggregation_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(elastic.Aggregation))
-	})
-	return _c
-}
-
-func (_c *SearchService_Aggregation_Call) Return(_a0 elasticsearch.SearchService) *SearchService_Aggregation_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SearchService_Aggregation_Call) RunAndReturn(run func(string, elastic.Aggregation) elasticsearch.SearchService) *SearchService_Aggregation_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *SearchService) Do(ctx context.Context) (*elastic.SearchResult, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 *elastic.SearchResult
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*elastic.SearchResult, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *elastic.SearchResult); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*elastic.SearchResult)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SearchService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type SearchService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *SearchService_Expecter) Do(ctx interface{}) *SearchService_Do_Call {
-	return &SearchService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *SearchService_Do_Call) Run(run func(ctx context.Context)) *SearchService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *SearchService_Do_Call) Return(_a0 *elastic.SearchResult, _a1 error) *SearchService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SearchService_Do_Call) RunAndReturn(run func(context.Context) (*elastic.SearchResult, error)) *SearchService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// IgnoreUnavailable provides a mock function with given fields: ignoreUnavailable
-func (_m *SearchService) IgnoreUnavailable(ignoreUnavailable bool) elasticsearch.SearchService {
-	ret := _m.Called(ignoreUnavailable)
-
-	if len(ret) == 0 {
-		panic("no return value specified for IgnoreUnavailable")
-	}
-
-	var r0 elasticsearch.SearchService
-	if rf, ok := ret.Get(0).(func(bool) elasticsearch.SearchService); ok {
-		r0 = rf(ignoreUnavailable)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.SearchService)
-		}
-	}
-
-	return r0
-}
-
-// SearchService_IgnoreUnavailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IgnoreUnavailable'
-type SearchService_IgnoreUnavailable_Call struct {
-	*mock.Call
-}
-
-// IgnoreUnavailable is a helper method to define mock.On call
-//   - ignoreUnavailable bool
-func (_e *SearchService_Expecter) IgnoreUnavailable(ignoreUnavailable interface{}) *SearchService_IgnoreUnavailable_Call {
-	return &SearchService_IgnoreUnavailable_Call{Call: _e.mock.On("IgnoreUnavailable", ignoreUnavailable)}
-}
-
-func (_c *SearchService_IgnoreUnavailable_Call) Run(run func(ignoreUnavailable bool)) *SearchService_IgnoreUnavailable_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(bool))
-	})
-	return _c
-}
-
-func (_c *SearchService_IgnoreUnavailable_Call) Return(_a0 elasticsearch.SearchService) *SearchService_IgnoreUnavailable_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SearchService_IgnoreUnavailable_Call) RunAndReturn(run func(bool) elasticsearch.SearchService) *SearchService_IgnoreUnavailable_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Query provides a mock function with given fields: query
-func (_m *SearchService) Query(query elastic.Query) elasticsearch.SearchService {
-	ret := _m.Called(query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Query")
-	}
-
-	var r0 elasticsearch.SearchService
-	if rf, ok := ret.Get(0).(func(elastic.Query) elasticsearch.SearchService); ok {
-		r0 = rf(query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.SearchService)
-		}
-	}
-
-	return r0
-}
-
-// SearchService_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
-type SearchService_Query_Call struct {
-	*mock.Call
-}
-
-// Query is a helper method to define mock.On call
-//   - query elastic.Query
-func (_e *SearchService_Expecter) Query(query interface{}) *SearchService_Query_Call {
-	return &SearchService_Query_Call{Call: _e.mock.On("Query", query)}
-}
-
-func (_c *SearchService_Query_Call) Run(run func(query elastic.Query)) *SearchService_Query_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(elastic.Query))
-	})
-	return _c
-}
-
-func (_c *SearchService_Query_Call) Return(_a0 elasticsearch.SearchService) *SearchService_Query_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SearchService_Query_Call) RunAndReturn(run func(elastic.Query) elasticsearch.SearchService) *SearchService_Query_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Size provides a mock function with given fields: size
-func (_m *SearchService) Size(size int) elasticsearch.SearchService {
-	ret := _m.Called(size)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Size")
-	}
-
-	var r0 elasticsearch.SearchService
-	if rf, ok := ret.Get(0).(func(int) elasticsearch.SearchService); ok {
-		r0 = rf(size)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.SearchService)
-		}
-	}
-
-	return r0
-}
-
-// SearchService_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
-type SearchService_Size_Call struct {
-	*mock.Call
-}
-
-// Size is a helper method to define mock.On call
-//   - size int
-func (_e *SearchService_Expecter) Size(size interface{}) *SearchService_Size_Call {
-	return &SearchService_Size_Call{Call: _e.mock.On("Size", size)}
-}
-
-func (_c *SearchService_Size_Call) Run(run func(size int)) *SearchService_Size_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(int))
-	})
-	return _c
-}
-
-func (_c *SearchService_Size_Call) Return(_a0 elasticsearch.SearchService) *SearchService_Size_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SearchService_Size_Call) RunAndReturn(run func(int) elasticsearch.SearchService) *SearchService_Size_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSearchService creates a new instance of SearchService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSearchService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SearchService {
-	mock := &SearchService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/TemplateApplier.go b/internal/storage/elasticsearch/mocks/TemplateApplier.go
deleted file mode 100644
index bb152c94..00000000
--- a/internal/storage/elasticsearch/mocks/TemplateApplier.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	io "io"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// TemplateApplier is an autogenerated mock type for the TemplateApplier type
-type TemplateApplier struct {
-	mock.Mock
-}
-
-type TemplateApplier_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *TemplateApplier) EXPECT() *TemplateApplier_Expecter {
-	return &TemplateApplier_Expecter{mock: &_m.Mock}
-}
-
-// Execute provides a mock function with given fields: wr, data
-func (_m *TemplateApplier) Execute(wr io.Writer, data any) error {
-	ret := _m.Called(wr, data)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Execute")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(io.Writer, any) error); ok {
-		r0 = rf(wr, data)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// TemplateApplier_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
-type TemplateApplier_Execute_Call struct {
-	*mock.Call
-}
-
-// Execute is a helper method to define mock.On call
-//   - wr io.Writer
-//   - data any
-func (_e *TemplateApplier_Expecter) Execute(wr interface{}, data interface{}) *TemplateApplier_Execute_Call {
-	return &TemplateApplier_Execute_Call{Call: _e.mock.On("Execute", wr, data)}
-}
-
-func (_c *TemplateApplier_Execute_Call) Run(run func(wr io.Writer, data any)) *TemplateApplier_Execute_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(io.Writer), args[1].(any))
-	})
-	return _c
-}
-
-func (_c *TemplateApplier_Execute_Call) Return(_a0 error) *TemplateApplier_Execute_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *TemplateApplier_Execute_Call) RunAndReturn(run func(io.Writer, any) error) *TemplateApplier_Execute_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewTemplateApplier creates a new instance of TemplateApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewTemplateApplier(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *TemplateApplier {
-	mock := &TemplateApplier{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/TemplateBuilder.go b/internal/storage/elasticsearch/mocks/TemplateBuilder.go
deleted file mode 100644
index 9803397e..00000000
--- a/internal/storage/elasticsearch/mocks/TemplateBuilder.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// TemplateBuilder is an autogenerated mock type for the TemplateBuilder type
-type TemplateBuilder struct {
-	mock.Mock
-}
-
-type TemplateBuilder_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *TemplateBuilder) EXPECT() *TemplateBuilder_Expecter {
-	return &TemplateBuilder_Expecter{mock: &_m.Mock}
-}
-
-// Parse provides a mock function with given fields: text
-func (_m *TemplateBuilder) Parse(text string) (elasticsearch.TemplateApplier, error) {
-	ret := _m.Called(text)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Parse")
-	}
-
-	var r0 elasticsearch.TemplateApplier
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (elasticsearch.TemplateApplier, error)); ok {
-		return rf(text)
-	}
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.TemplateApplier); ok {
-		r0 = rf(text)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.TemplateApplier)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(text)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TemplateBuilder_Parse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Parse'
-type TemplateBuilder_Parse_Call struct {
-	*mock.Call
-}
-
-// Parse is a helper method to define mock.On call
-//   - text string
-func (_e *TemplateBuilder_Expecter) Parse(text interface{}) *TemplateBuilder_Parse_Call {
-	return &TemplateBuilder_Parse_Call{Call: _e.mock.On("Parse", text)}
-}
-
-func (_c *TemplateBuilder_Parse_Call) Run(run func(text string)) *TemplateBuilder_Parse_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *TemplateBuilder_Parse_Call) Return(_a0 elasticsearch.TemplateApplier, _a1 error) *TemplateBuilder_Parse_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *TemplateBuilder_Parse_Call) RunAndReturn(run func(string) (elasticsearch.TemplateApplier, error)) *TemplateBuilder_Parse_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewTemplateBuilder creates a new instance of TemplateBuilder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewTemplateBuilder(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *TemplateBuilder {
-	mock := &TemplateBuilder{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/TemplateCreateService.go b/internal/storage/elasticsearch/mocks/TemplateCreateService.go
deleted file mode 100644
index 41ee10de..00000000
--- a/internal/storage/elasticsearch/mocks/TemplateCreateService.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	elasticsearch "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
-	elastic "github.com/olivere/elastic"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// TemplateCreateService is an autogenerated mock type for the TemplateCreateService type
-type TemplateCreateService struct {
-	mock.Mock
-}
-
-type TemplateCreateService_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *TemplateCreateService) EXPECT() *TemplateCreateService_Expecter {
-	return &TemplateCreateService_Expecter{mock: &_m.Mock}
-}
-
-// Body provides a mock function with given fields: mapping
-func (_m *TemplateCreateService) Body(mapping string) elasticsearch.TemplateCreateService {
-	ret := _m.Called(mapping)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Body")
-	}
-
-	var r0 elasticsearch.TemplateCreateService
-	if rf, ok := ret.Get(0).(func(string) elasticsearch.TemplateCreateService); ok {
-		r0 = rf(mapping)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(elasticsearch.TemplateCreateService)
-		}
-	}
-
-	return r0
-}
-
-// TemplateCreateService_Body_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Body'
-type TemplateCreateService_Body_Call struct {
-	*mock.Call
-}
-
-// Body is a helper method to define mock.On call
-//   - mapping string
-func (_e *TemplateCreateService_Expecter) Body(mapping interface{}) *TemplateCreateService_Body_Call {
-	return &TemplateCreateService_Body_Call{Call: _e.mock.On("Body", mapping)}
-}
-
-func (_c *TemplateCreateService_Body_Call) Run(run func(mapping string)) *TemplateCreateService_Body_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *TemplateCreateService_Body_Call) Return(_a0 elasticsearch.TemplateCreateService) *TemplateCreateService_Body_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *TemplateCreateService_Body_Call) RunAndReturn(run func(string) elasticsearch.TemplateCreateService) *TemplateCreateService_Body_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Do provides a mock function with given fields: ctx
-func (_m *TemplateCreateService) Do(ctx context.Context) (*elastic.IndicesPutTemplateResponse, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Do")
-	}
-
-	var r0 *elastic.IndicesPutTemplateResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesPutTemplateResponse, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) *elastic.IndicesPutTemplateResponse); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*elastic.IndicesPutTemplateResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TemplateCreateService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
-type TemplateCreateService_Do_Call struct {
-	*mock.Call
-}
-
-// Do is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *TemplateCreateService_Expecter) Do(ctx interface{}) *TemplateCreateService_Do_Call {
-	return &TemplateCreateService_Do_Call{Call: _e.mock.On("Do", ctx)}
-}
-
-func (_c *TemplateCreateService_Do_Call) Run(run func(ctx context.Context)) *TemplateCreateService_Do_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *TemplateCreateService_Do_Call) Return(_a0 *elastic.IndicesPutTemplateResponse, _a1 error) *TemplateCreateService_Do_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *TemplateCreateService_Do_Call) RunAndReturn(run func(context.Context) (*elastic.IndicesPutTemplateResponse, error)) *TemplateCreateService_Do_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewTemplateCreateService creates a new instance of TemplateCreateService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewTemplateCreateService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *TemplateCreateService {
-	mock := &TemplateCreateService{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/elasticsearch/mocks/mocks.go b/internal/storage/elasticsearch/mocks/mocks.go
new file mode 100644
index 00000000..5074fb6b
--- /dev/null
+++ b/internal/storage/elasticsearch/mocks/mocks.go
@@ -0,0 +1,1776 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+	"io"
+
+	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
+	"github.com/olivere/elastic"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Client {
+	mock := &Client{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Client is an autogenerated mock type for the Client type
+type Client struct {
+	mock.Mock
+}
+
+type Client_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Client) EXPECT() *Client_Expecter {
+	return &Client_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type Client
+func (_mock *Client) Close() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Client_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type Client_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *Client_Expecter) Close() *Client_Close_Call {
+	return &Client_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *Client_Close_Call) Run(run func()) *Client_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Client_Close_Call) Return(err error) *Client_Close_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Client_Close_Call) RunAndReturn(run func() error) *Client_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateIndex provides a mock function for the type Client
+func (_mock *Client) CreateIndex(index string) elasticsearch.IndicesCreateService {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateIndex")
+	}
+
+	var r0 elasticsearch.IndicesCreateService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndicesCreateService); ok {
+		r0 = returnFunc(index)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndicesCreateService)
+		}
+	}
+	return r0
+}
+
+// Client_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
+type Client_CreateIndex_Call struct {
+	*mock.Call
+}
+
+// CreateIndex is a helper method to define mock.On call
+//   - index
+func (_e *Client_Expecter) CreateIndex(index interface{}) *Client_CreateIndex_Call {
+	return &Client_CreateIndex_Call{Call: _e.mock.On("CreateIndex", index)}
+}
+
+func (_c *Client_CreateIndex_Call) Run(run func(index string)) *Client_CreateIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_CreateIndex_Call) Return(indicesCreateService elasticsearch.IndicesCreateService) *Client_CreateIndex_Call {
+	_c.Call.Return(indicesCreateService)
+	return _c
+}
+
+func (_c *Client_CreateIndex_Call) RunAndReturn(run func(index string) elasticsearch.IndicesCreateService) *Client_CreateIndex_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateTemplate provides a mock function for the type Client
+func (_mock *Client) CreateTemplate(id string) elasticsearch.TemplateCreateService {
+	ret := _mock.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateTemplate")
+	}
+
+	var r0 elasticsearch.TemplateCreateService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.TemplateCreateService); ok {
+		r0 = returnFunc(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.TemplateCreateService)
+		}
+	}
+	return r0
+}
+
+// Client_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate'
+type Client_CreateTemplate_Call struct {
+	*mock.Call
+}
+
+// CreateTemplate is a helper method to define mock.On call
+//   - id
+func (_e *Client_Expecter) CreateTemplate(id interface{}) *Client_CreateTemplate_Call {
+	return &Client_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", id)}
+}
+
+func (_c *Client_CreateTemplate_Call) Run(run func(id string)) *Client_CreateTemplate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_CreateTemplate_Call) Return(templateCreateService elasticsearch.TemplateCreateService) *Client_CreateTemplate_Call {
+	_c.Call.Return(templateCreateService)
+	return _c
+}
+
+func (_c *Client_CreateTemplate_Call) RunAndReturn(run func(id string) elasticsearch.TemplateCreateService) *Client_CreateTemplate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteIndex provides a mock function for the type Client
+func (_mock *Client) DeleteIndex(index string) elasticsearch.IndicesDeleteService {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteIndex")
+	}
+
+	var r0 elasticsearch.IndicesDeleteService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndicesDeleteService); ok {
+		r0 = returnFunc(index)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndicesDeleteService)
+		}
+	}
+	return r0
+}
+
+// Client_DeleteIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIndex'
+type Client_DeleteIndex_Call struct {
+	*mock.Call
+}
+
+// DeleteIndex is a helper method to define mock.On call
+//   - index
+func (_e *Client_Expecter) DeleteIndex(index interface{}) *Client_DeleteIndex_Call {
+	return &Client_DeleteIndex_Call{Call: _e.mock.On("DeleteIndex", index)}
+}
+
+func (_c *Client_DeleteIndex_Call) Run(run func(index string)) *Client_DeleteIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_DeleteIndex_Call) Return(indicesDeleteService elasticsearch.IndicesDeleteService) *Client_DeleteIndex_Call {
+	_c.Call.Return(indicesDeleteService)
+	return _c
+}
+
+func (_c *Client_DeleteIndex_Call) RunAndReturn(run func(index string) elasticsearch.IndicesDeleteService) *Client_DeleteIndex_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetVersion provides a mock function for the type Client
+func (_mock *Client) GetVersion() uint {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetVersion")
+	}
+
+	var r0 uint
+	if returnFunc, ok := ret.Get(0).(func() uint); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(uint)
+	}
+	return r0
+}
+
+// Client_GetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVersion'
+type Client_GetVersion_Call struct {
+	*mock.Call
+}
+
+// GetVersion is a helper method to define mock.On call
+func (_e *Client_Expecter) GetVersion() *Client_GetVersion_Call {
+	return &Client_GetVersion_Call{Call: _e.mock.On("GetVersion")}
+}
+
+func (_c *Client_GetVersion_Call) Run(run func()) *Client_GetVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Client_GetVersion_Call) Return(v uint) *Client_GetVersion_Call {
+	_c.Call.Return(v)
+	return _c
+}
+
+func (_c *Client_GetVersion_Call) RunAndReturn(run func() uint) *Client_GetVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Index provides a mock function for the type Client
+func (_mock *Client) Index() elasticsearch.IndexService {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Index")
+	}
+
+	var r0 elasticsearch.IndexService
+	if returnFunc, ok := ret.Get(0).(func() elasticsearch.IndexService); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndexService)
+		}
+	}
+	return r0
+}
+
+// Client_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
+type Client_Index_Call struct {
+	*mock.Call
+}
+
+// Index is a helper method to define mock.On call
+func (_e *Client_Expecter) Index() *Client_Index_Call {
+	return &Client_Index_Call{Call: _e.mock.On("Index")}
+}
+
+func (_c *Client_Index_Call) Run(run func()) *Client_Index_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Client_Index_Call) Return(indexService elasticsearch.IndexService) *Client_Index_Call {
+	_c.Call.Return(indexService)
+	return _c
+}
+
+func (_c *Client_Index_Call) RunAndReturn(run func() elasticsearch.IndexService) *Client_Index_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// IndexExists provides a mock function for the type Client
+func (_mock *Client) IndexExists(index string) elasticsearch.IndicesExistsService {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IndexExists")
+	}
+
+	var r0 elasticsearch.IndicesExistsService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndicesExistsService); ok {
+		r0 = returnFunc(index)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndicesExistsService)
+		}
+	}
+	return r0
+}
+
+// Client_IndexExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexExists'
+type Client_IndexExists_Call struct {
+	*mock.Call
+}
+
+// IndexExists is a helper method to define mock.On call
+//   - index
+func (_e *Client_Expecter) IndexExists(index interface{}) *Client_IndexExists_Call {
+	return &Client_IndexExists_Call{Call: _e.mock.On("IndexExists", index)}
+}
+
+func (_c *Client_IndexExists_Call) Run(run func(index string)) *Client_IndexExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_IndexExists_Call) Return(indicesExistsService elasticsearch.IndicesExistsService) *Client_IndexExists_Call {
+	_c.Call.Return(indicesExistsService)
+	return _c
+}
+
+func (_c *Client_IndexExists_Call) RunAndReturn(run func(index string) elasticsearch.IndicesExistsService) *Client_IndexExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MultiSearch provides a mock function for the type Client
+func (_mock *Client) MultiSearch() elasticsearch.MultiSearchService {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MultiSearch")
+	}
+
+	var r0 elasticsearch.MultiSearchService
+	if returnFunc, ok := ret.Get(0).(func() elasticsearch.MultiSearchService); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
+		}
+	}
+	return r0
+}
+
+// Client_MultiSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiSearch'
+type Client_MultiSearch_Call struct {
+	*mock.Call
+}
+
+// MultiSearch is a helper method to define mock.On call
+func (_e *Client_Expecter) MultiSearch() *Client_MultiSearch_Call {
+	return &Client_MultiSearch_Call{Call: _e.mock.On("MultiSearch")}
+}
+
+func (_c *Client_MultiSearch_Call) Run(run func()) *Client_MultiSearch_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Client_MultiSearch_Call) Return(multiSearchService elasticsearch.MultiSearchService) *Client_MultiSearch_Call {
+	_c.Call.Return(multiSearchService)
+	return _c
+}
+
+func (_c *Client_MultiSearch_Call) RunAndReturn(run func() elasticsearch.MultiSearchService) *Client_MultiSearch_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Search provides a mock function for the type Client
+func (_mock *Client) Search(indices ...string) elasticsearch.SearchService {
+	var tmpRet mock.Arguments
+	if len(indices) > 0 {
+		tmpRet = _mock.Called(indices)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Search")
+	}
+
+	var r0 elasticsearch.SearchService
+	if returnFunc, ok := ret.Get(0).(func(...string) elasticsearch.SearchService); ok {
+		r0 = returnFunc(indices...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.SearchService)
+		}
+	}
+	return r0
+}
+
+// Client_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
+type Client_Search_Call struct {
+	*mock.Call
+}
+
+// Search is a helper method to define mock.On call
+//   - indices
+func (_e *Client_Expecter) Search(indices ...interface{}) *Client_Search_Call {
+	return &Client_Search_Call{Call: _e.mock.On("Search",
+		append([]interface{}{}, indices...)...)}
+}
+
+func (_c *Client_Search_Call) Run(run func(indices ...string)) *Client_Search_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Client_Search_Call) Return(searchService elasticsearch.SearchService) *Client_Search_Call {
+	_c.Call.Return(searchService)
+	return _c
+}
+
+func (_c *Client_Search_Call) RunAndReturn(run func(indices ...string) elasticsearch.SearchService) *Client_Search_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIndicesExistsService creates a new instance of IndicesExistsService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndicesExistsService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndicesExistsService {
+	mock := &IndicesExistsService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndicesExistsService is an autogenerated mock type for the IndicesExistsService type
+type IndicesExistsService struct {
+	mock.Mock
+}
+
+type IndicesExistsService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndicesExistsService) EXPECT() *IndicesExistsService_Expecter {
+	return &IndicesExistsService_Expecter{mock: &_m.Mock}
+}
+
+// Do provides a mock function for the type IndicesExistsService
+func (_mock *IndicesExistsService) Do(ctx context.Context) (bool, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (bool, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndicesExistsService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type IndicesExistsService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *IndicesExistsService_Expecter) Do(ctx interface{}) *IndicesExistsService_Do_Call {
+	return &IndicesExistsService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *IndicesExistsService_Do_Call) Run(run func(ctx context.Context)) *IndicesExistsService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *IndicesExistsService_Do_Call) Return(b bool, err error) *IndicesExistsService_Do_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *IndicesExistsService_Do_Call) RunAndReturn(run func(ctx context.Context) (bool, error)) *IndicesExistsService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIndicesCreateService creates a new instance of IndicesCreateService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndicesCreateService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndicesCreateService {
+	mock := &IndicesCreateService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndicesCreateService is an autogenerated mock type for the IndicesCreateService type
+type IndicesCreateService struct {
+	mock.Mock
+}
+
+type IndicesCreateService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndicesCreateService) EXPECT() *IndicesCreateService_Expecter {
+	return &IndicesCreateService_Expecter{mock: &_m.Mock}
+}
+
+// Body provides a mock function for the type IndicesCreateService
+func (_mock *IndicesCreateService) Body(mapping string) elasticsearch.IndicesCreateService {
+	ret := _mock.Called(mapping)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Body")
+	}
+
+	var r0 elasticsearch.IndicesCreateService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndicesCreateService); ok {
+		r0 = returnFunc(mapping)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndicesCreateService)
+		}
+	}
+	return r0
+}
+
+// IndicesCreateService_Body_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Body'
+type IndicesCreateService_Body_Call struct {
+	*mock.Call
+}
+
+// Body is a helper method to define mock.On call
+//   - mapping
+func (_e *IndicesCreateService_Expecter) Body(mapping interface{}) *IndicesCreateService_Body_Call {
+	return &IndicesCreateService_Body_Call{Call: _e.mock.On("Body", mapping)}
+}
+
+func (_c *IndicesCreateService_Body_Call) Run(run func(mapping string)) *IndicesCreateService_Body_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndicesCreateService_Body_Call) Return(indicesCreateService elasticsearch.IndicesCreateService) *IndicesCreateService_Body_Call {
+	_c.Call.Return(indicesCreateService)
+	return _c
+}
+
+func (_c *IndicesCreateService_Body_Call) RunAndReturn(run func(mapping string) elasticsearch.IndicesCreateService) *IndicesCreateService_Body_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Do provides a mock function for the type IndicesCreateService
+func (_mock *IndicesCreateService) Do(ctx context.Context) (*elastic.IndicesCreateResult, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 *elastic.IndicesCreateResult
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesCreateResult, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *elastic.IndicesCreateResult); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*elastic.IndicesCreateResult)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndicesCreateService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type IndicesCreateService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *IndicesCreateService_Expecter) Do(ctx interface{}) *IndicesCreateService_Do_Call {
+	return &IndicesCreateService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *IndicesCreateService_Do_Call) Run(run func(ctx context.Context)) *IndicesCreateService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *IndicesCreateService_Do_Call) Return(indicesCreateResult *elastic.IndicesCreateResult, err error) *IndicesCreateService_Do_Call {
+	_c.Call.Return(indicesCreateResult, err)
+	return _c
+}
+
+func (_c *IndicesCreateService_Do_Call) RunAndReturn(run func(ctx context.Context) (*elastic.IndicesCreateResult, error)) *IndicesCreateService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIndicesDeleteService creates a new instance of IndicesDeleteService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndicesDeleteService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndicesDeleteService {
+	mock := &IndicesDeleteService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndicesDeleteService is an autogenerated mock type for the IndicesDeleteService type
+type IndicesDeleteService struct {
+	mock.Mock
+}
+
+type IndicesDeleteService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndicesDeleteService) EXPECT() *IndicesDeleteService_Expecter {
+	return &IndicesDeleteService_Expecter{mock: &_m.Mock}
+}
+
+// Do provides a mock function for the type IndicesDeleteService
+func (_mock *IndicesDeleteService) Do(ctx context.Context) (*elastic.IndicesDeleteResponse, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 *elastic.IndicesDeleteResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesDeleteResponse, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *elastic.IndicesDeleteResponse); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*elastic.IndicesDeleteResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// IndicesDeleteService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type IndicesDeleteService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *IndicesDeleteService_Expecter) Do(ctx interface{}) *IndicesDeleteService_Do_Call {
+	return &IndicesDeleteService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *IndicesDeleteService_Do_Call) Run(run func(ctx context.Context)) *IndicesDeleteService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *IndicesDeleteService_Do_Call) Return(indicesDeleteResponse *elastic.IndicesDeleteResponse, err error) *IndicesDeleteService_Do_Call {
+	_c.Call.Return(indicesDeleteResponse, err)
+	return _c
+}
+
+func (_c *IndicesDeleteService_Do_Call) RunAndReturn(run func(ctx context.Context) (*elastic.IndicesDeleteResponse, error)) *IndicesDeleteService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewTemplateCreateService creates a new instance of TemplateCreateService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTemplateCreateService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TemplateCreateService {
+	mock := &TemplateCreateService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// TemplateCreateService is an autogenerated mock type for the TemplateCreateService type
+type TemplateCreateService struct {
+	mock.Mock
+}
+
+type TemplateCreateService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *TemplateCreateService) EXPECT() *TemplateCreateService_Expecter {
+	return &TemplateCreateService_Expecter{mock: &_m.Mock}
+}
+
+// Body provides a mock function for the type TemplateCreateService
+func (_mock *TemplateCreateService) Body(mapping string) elasticsearch.TemplateCreateService {
+	ret := _mock.Called(mapping)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Body")
+	}
+
+	var r0 elasticsearch.TemplateCreateService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.TemplateCreateService); ok {
+		r0 = returnFunc(mapping)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.TemplateCreateService)
+		}
+	}
+	return r0
+}
+
+// TemplateCreateService_Body_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Body'
+type TemplateCreateService_Body_Call struct {
+	*mock.Call
+}
+
+// Body is a helper method to define mock.On call
+//   - mapping
+func (_e *TemplateCreateService_Expecter) Body(mapping interface{}) *TemplateCreateService_Body_Call {
+	return &TemplateCreateService_Body_Call{Call: _e.mock.On("Body", mapping)}
+}
+
+func (_c *TemplateCreateService_Body_Call) Run(run func(mapping string)) *TemplateCreateService_Body_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *TemplateCreateService_Body_Call) Return(templateCreateService elasticsearch.TemplateCreateService) *TemplateCreateService_Body_Call {
+	_c.Call.Return(templateCreateService)
+	return _c
+}
+
+func (_c *TemplateCreateService_Body_Call) RunAndReturn(run func(mapping string) elasticsearch.TemplateCreateService) *TemplateCreateService_Body_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Do provides a mock function for the type TemplateCreateService
+func (_mock *TemplateCreateService) Do(ctx context.Context) (*elastic.IndicesPutTemplateResponse, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 *elastic.IndicesPutTemplateResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*elastic.IndicesPutTemplateResponse, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *elastic.IndicesPutTemplateResponse); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*elastic.IndicesPutTemplateResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// TemplateCreateService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type TemplateCreateService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *TemplateCreateService_Expecter) Do(ctx interface{}) *TemplateCreateService_Do_Call {
+	return &TemplateCreateService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *TemplateCreateService_Do_Call) Run(run func(ctx context.Context)) *TemplateCreateService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *TemplateCreateService_Do_Call) Return(indicesPutTemplateResponse *elastic.IndicesPutTemplateResponse, err error) *TemplateCreateService_Do_Call {
+	_c.Call.Return(indicesPutTemplateResponse, err)
+	return _c
+}
+
+func (_c *TemplateCreateService_Do_Call) RunAndReturn(run func(ctx context.Context) (*elastic.IndicesPutTemplateResponse, error)) *TemplateCreateService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewIndexService creates a new instance of IndexService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewIndexService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *IndexService {
+	mock := &IndexService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// IndexService is an autogenerated mock type for the IndexService type
+type IndexService struct {
+	mock.Mock
+}
+
+type IndexService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *IndexService) EXPECT() *IndexService_Expecter {
+	return &IndexService_Expecter{mock: &_m.Mock}
+}
+
+// Add provides a mock function for the type IndexService
+func (_mock *IndexService) Add() {
+	_mock.Called()
+	return
+}
+
+// IndexService_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
+type IndexService_Add_Call struct {
+	*mock.Call
+}
+
+// Add is a helper method to define mock.On call
+func (_e *IndexService_Expecter) Add() *IndexService_Add_Call {
+	return &IndexService_Add_Call{Call: _e.mock.On("Add")}
+}
+
+func (_c *IndexService_Add_Call) Run(run func()) *IndexService_Add_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *IndexService_Add_Call) Return() *IndexService_Add_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *IndexService_Add_Call) RunAndReturn(run func()) *IndexService_Add_Call {
+	_c.Run(run)
+	return _c
+}
+
+// BodyJson provides a mock function for the type IndexService
+func (_mock *IndexService) BodyJson(body any) elasticsearch.IndexService {
+	ret := _mock.Called(body)
+
+	if len(ret) == 0 {
+		panic("no return value specified for BodyJson")
+	}
+
+	var r0 elasticsearch.IndexService
+	if returnFunc, ok := ret.Get(0).(func(any) elasticsearch.IndexService); ok {
+		r0 = returnFunc(body)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndexService)
+		}
+	}
+	return r0
+}
+
+// IndexService_BodyJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BodyJson'
+type IndexService_BodyJson_Call struct {
+	*mock.Call
+}
+
+// BodyJson is a helper method to define mock.On call
+//   - body
+func (_e *IndexService_Expecter) BodyJson(body interface{}) *IndexService_BodyJson_Call {
+	return &IndexService_BodyJson_Call{Call: _e.mock.On("BodyJson", body)}
+}
+
+func (_c *IndexService_BodyJson_Call) Run(run func(body any)) *IndexService_BodyJson_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(any))
+	})
+	return _c
+}
+
+func (_c *IndexService_BodyJson_Call) Return(indexService elasticsearch.IndexService) *IndexService_BodyJson_Call {
+	_c.Call.Return(indexService)
+	return _c
+}
+
+func (_c *IndexService_BodyJson_Call) RunAndReturn(run func(body any) elasticsearch.IndexService) *IndexService_BodyJson_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Id provides a mock function for the type IndexService
+func (_mock *IndexService) Id(id string) elasticsearch.IndexService {
+	ret := _mock.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Id")
+	}
+
+	var r0 elasticsearch.IndexService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
+		r0 = returnFunc(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndexService)
+		}
+	}
+	return r0
+}
+
+// IndexService_Id_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Id'
+type IndexService_Id_Call struct {
+	*mock.Call
+}
+
+// Id is a helper method to define mock.On call
+//   - id
+func (_e *IndexService_Expecter) Id(id interface{}) *IndexService_Id_Call {
+	return &IndexService_Id_Call{Call: _e.mock.On("Id", id)}
+}
+
+func (_c *IndexService_Id_Call) Run(run func(id string)) *IndexService_Id_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexService_Id_Call) Return(indexService elasticsearch.IndexService) *IndexService_Id_Call {
+	_c.Call.Return(indexService)
+	return _c
+}
+
+func (_c *IndexService_Id_Call) RunAndReturn(run func(id string) elasticsearch.IndexService) *IndexService_Id_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Index provides a mock function for the type IndexService
+func (_mock *IndexService) Index(index string) elasticsearch.IndexService {
+	ret := _mock.Called(index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Index")
+	}
+
+	var r0 elasticsearch.IndexService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
+		r0 = returnFunc(index)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndexService)
+		}
+	}
+	return r0
+}
+
+// IndexService_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
+type IndexService_Index_Call struct {
+	*mock.Call
+}
+
+// Index is a helper method to define mock.On call
+//   - index
+func (_e *IndexService_Expecter) Index(index interface{}) *IndexService_Index_Call {
+	return &IndexService_Index_Call{Call: _e.mock.On("Index", index)}
+}
+
+func (_c *IndexService_Index_Call) Run(run func(index string)) *IndexService_Index_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexService_Index_Call) Return(indexService elasticsearch.IndexService) *IndexService_Index_Call {
+	_c.Call.Return(indexService)
+	return _c
+}
+
+func (_c *IndexService_Index_Call) RunAndReturn(run func(index string) elasticsearch.IndexService) *IndexService_Index_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Type provides a mock function for the type IndexService
+func (_mock *IndexService) Type(typ string) elasticsearch.IndexService {
+	ret := _mock.Called(typ)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Type")
+	}
+
+	var r0 elasticsearch.IndexService
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.IndexService); ok {
+		r0 = returnFunc(typ)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.IndexService)
+		}
+	}
+	return r0
+}
+
+// IndexService_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type'
+type IndexService_Type_Call struct {
+	*mock.Call
+}
+
+// Type is a helper method to define mock.On call
+//   - typ
+func (_e *IndexService_Expecter) Type(typ interface{}) *IndexService_Type_Call {
+	return &IndexService_Type_Call{Call: _e.mock.On("Type", typ)}
+}
+
+func (_c *IndexService_Type_Call) Run(run func(typ string)) *IndexService_Type_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *IndexService_Type_Call) Return(indexService elasticsearch.IndexService) *IndexService_Type_Call {
+	_c.Call.Return(indexService)
+	return _c
+}
+
+func (_c *IndexService_Type_Call) RunAndReturn(run func(typ string) elasticsearch.IndexService) *IndexService_Type_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSearchService creates a new instance of SearchService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSearchService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SearchService {
+	mock := &SearchService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SearchService is an autogenerated mock type for the SearchService type
+type SearchService struct {
+	mock.Mock
+}
+
+type SearchService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SearchService) EXPECT() *SearchService_Expecter {
+	return &SearchService_Expecter{mock: &_m.Mock}
+}
+
+// Aggregation provides a mock function for the type SearchService
+func (_mock *SearchService) Aggregation(name string, aggregation elastic.Aggregation) elasticsearch.SearchService {
+	ret := _mock.Called(name, aggregation)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Aggregation")
+	}
+
+	var r0 elasticsearch.SearchService
+	if returnFunc, ok := ret.Get(0).(func(string, elastic.Aggregation) elasticsearch.SearchService); ok {
+		r0 = returnFunc(name, aggregation)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.SearchService)
+		}
+	}
+	return r0
+}
+
+// SearchService_Aggregation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Aggregation'
+type SearchService_Aggregation_Call struct {
+	*mock.Call
+}
+
+// Aggregation is a helper method to define mock.On call
+//   - name
+//   - aggregation
+func (_e *SearchService_Expecter) Aggregation(name interface{}, aggregation interface{}) *SearchService_Aggregation_Call {
+	return &SearchService_Aggregation_Call{Call: _e.mock.On("Aggregation", name, aggregation)}
+}
+
+func (_c *SearchService_Aggregation_Call) Run(run func(name string, aggregation elastic.Aggregation)) *SearchService_Aggregation_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(elastic.Aggregation))
+	})
+	return _c
+}
+
+func (_c *SearchService_Aggregation_Call) Return(searchService elasticsearch.SearchService) *SearchService_Aggregation_Call {
+	_c.Call.Return(searchService)
+	return _c
+}
+
+func (_c *SearchService_Aggregation_Call) RunAndReturn(run func(name string, aggregation elastic.Aggregation) elasticsearch.SearchService) *SearchService_Aggregation_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Do provides a mock function for the type SearchService
+func (_mock *SearchService) Do(ctx context.Context) (*elastic.SearchResult, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 *elastic.SearchResult
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*elastic.SearchResult, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *elastic.SearchResult); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*elastic.SearchResult)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SearchService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type SearchService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *SearchService_Expecter) Do(ctx interface{}) *SearchService_Do_Call {
+	return &SearchService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *SearchService_Do_Call) Run(run func(ctx context.Context)) *SearchService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *SearchService_Do_Call) Return(searchResult *elastic.SearchResult, err error) *SearchService_Do_Call {
+	_c.Call.Return(searchResult, err)
+	return _c
+}
+
+func (_c *SearchService_Do_Call) RunAndReturn(run func(ctx context.Context) (*elastic.SearchResult, error)) *SearchService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// IgnoreUnavailable provides a mock function for the type SearchService
+func (_mock *SearchService) IgnoreUnavailable(ignoreUnavailable bool) elasticsearch.SearchService {
+	ret := _mock.Called(ignoreUnavailable)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IgnoreUnavailable")
+	}
+
+	var r0 elasticsearch.SearchService
+	if returnFunc, ok := ret.Get(0).(func(bool) elasticsearch.SearchService); ok {
+		r0 = returnFunc(ignoreUnavailable)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.SearchService)
+		}
+	}
+	return r0
+}
+
+// SearchService_IgnoreUnavailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IgnoreUnavailable'
+type SearchService_IgnoreUnavailable_Call struct {
+	*mock.Call
+}
+
+// IgnoreUnavailable is a helper method to define mock.On call
+//   - ignoreUnavailable
+func (_e *SearchService_Expecter) IgnoreUnavailable(ignoreUnavailable interface{}) *SearchService_IgnoreUnavailable_Call {
+	return &SearchService_IgnoreUnavailable_Call{Call: _e.mock.On("IgnoreUnavailable", ignoreUnavailable)}
+}
+
+func (_c *SearchService_IgnoreUnavailable_Call) Run(run func(ignoreUnavailable bool)) *SearchService_IgnoreUnavailable_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *SearchService_IgnoreUnavailable_Call) Return(searchService elasticsearch.SearchService) *SearchService_IgnoreUnavailable_Call {
+	_c.Call.Return(searchService)
+	return _c
+}
+
+func (_c *SearchService_IgnoreUnavailable_Call) RunAndReturn(run func(ignoreUnavailable bool) elasticsearch.SearchService) *SearchService_IgnoreUnavailable_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Query provides a mock function for the type SearchService
+func (_mock *SearchService) Query(query elastic.Query) elasticsearch.SearchService {
+	ret := _mock.Called(query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Query")
+	}
+
+	var r0 elasticsearch.SearchService
+	if returnFunc, ok := ret.Get(0).(func(elastic.Query) elasticsearch.SearchService); ok {
+		r0 = returnFunc(query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.SearchService)
+		}
+	}
+	return r0
+}
+
+// SearchService_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
+type SearchService_Query_Call struct {
+	*mock.Call
+}
+
+// Query is a helper method to define mock.On call
+//   - query
+func (_e *SearchService_Expecter) Query(query interface{}) *SearchService_Query_Call {
+	return &SearchService_Query_Call{Call: _e.mock.On("Query", query)}
+}
+
+func (_c *SearchService_Query_Call) Run(run func(query elastic.Query)) *SearchService_Query_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(elastic.Query))
+	})
+	return _c
+}
+
+func (_c *SearchService_Query_Call) Return(searchService elasticsearch.SearchService) *SearchService_Query_Call {
+	_c.Call.Return(searchService)
+	return _c
+}
+
+func (_c *SearchService_Query_Call) RunAndReturn(run func(query elastic.Query) elasticsearch.SearchService) *SearchService_Query_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Size provides a mock function for the type SearchService
+func (_mock *SearchService) Size(size int) elasticsearch.SearchService {
+	ret := _mock.Called(size)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Size")
+	}
+
+	var r0 elasticsearch.SearchService
+	if returnFunc, ok := ret.Get(0).(func(int) elasticsearch.SearchService); ok {
+		r0 = returnFunc(size)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.SearchService)
+		}
+	}
+	return r0
+}
+
+// SearchService_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
+type SearchService_Size_Call struct {
+	*mock.Call
+}
+
+// Size is a helper method to define mock.On call
+//   - size
+func (_e *SearchService_Expecter) Size(size interface{}) *SearchService_Size_Call {
+	return &SearchService_Size_Call{Call: _e.mock.On("Size", size)}
+}
+
+func (_c *SearchService_Size_Call) Run(run func(size int)) *SearchService_Size_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int))
+	})
+	return _c
+}
+
+func (_c *SearchService_Size_Call) Return(searchService elasticsearch.SearchService) *SearchService_Size_Call {
+	_c.Call.Return(searchService)
+	return _c
+}
+
+func (_c *SearchService_Size_Call) RunAndReturn(run func(size int) elasticsearch.SearchService) *SearchService_Size_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMultiSearchService creates a new instance of MultiSearchService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMultiSearchService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MultiSearchService {
+	mock := &MultiSearchService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MultiSearchService is an autogenerated mock type for the MultiSearchService type
+type MultiSearchService struct {
+	mock.Mock
+}
+
+type MultiSearchService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MultiSearchService) EXPECT() *MultiSearchService_Expecter {
+	return &MultiSearchService_Expecter{mock: &_m.Mock}
+}
+
+// Add provides a mock function for the type MultiSearchService
+func (_mock *MultiSearchService) Add(requests ...*elastic.SearchRequest) elasticsearch.MultiSearchService {
+	var tmpRet mock.Arguments
+	if len(requests) > 0 {
+		tmpRet = _mock.Called(requests)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Add")
+	}
+
+	var r0 elasticsearch.MultiSearchService
+	if returnFunc, ok := ret.Get(0).(func(...*elastic.SearchRequest) elasticsearch.MultiSearchService); ok {
+		r0 = returnFunc(requests...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
+		}
+	}
+	return r0
+}
+
+// MultiSearchService_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
+type MultiSearchService_Add_Call struct {
+	*mock.Call
+}
+
+// Add is a helper method to define mock.On call
+//   - requests
+func (_e *MultiSearchService_Expecter) Add(requests ...interface{}) *MultiSearchService_Add_Call {
+	return &MultiSearchService_Add_Call{Call: _e.mock.On("Add",
+		append([]interface{}{}, requests...)...)}
+}
+
+func (_c *MultiSearchService_Add_Call) Run(run func(requests ...*elastic.SearchRequest)) *MultiSearchService_Add_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]*elastic.SearchRequest, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(*elastic.SearchRequest)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MultiSearchService_Add_Call) Return(multiSearchService elasticsearch.MultiSearchService) *MultiSearchService_Add_Call {
+	_c.Call.Return(multiSearchService)
+	return _c
+}
+
+func (_c *MultiSearchService_Add_Call) RunAndReturn(run func(requests ...*elastic.SearchRequest) elasticsearch.MultiSearchService) *MultiSearchService_Add_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Do provides a mock function for the type MultiSearchService
+func (_mock *MultiSearchService) Do(ctx context.Context) (*elastic.MultiSearchResult, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Do")
+	}
+
+	var r0 *elastic.MultiSearchResult
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) (*elastic.MultiSearchResult, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) *elastic.MultiSearchResult); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*elastic.MultiSearchResult)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MultiSearchService_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'
+type MultiSearchService_Do_Call struct {
+	*mock.Call
+}
+
+// Do is a helper method to define mock.On call
+//   - ctx
+func (_e *MultiSearchService_Expecter) Do(ctx interface{}) *MultiSearchService_Do_Call {
+	return &MultiSearchService_Do_Call{Call: _e.mock.On("Do", ctx)}
+}
+
+func (_c *MultiSearchService_Do_Call) Run(run func(ctx context.Context)) *MultiSearchService_Do_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MultiSearchService_Do_Call) Return(multiSearchResult *elastic.MultiSearchResult, err error) *MultiSearchService_Do_Call {
+	_c.Call.Return(multiSearchResult, err)
+	return _c
+}
+
+func (_c *MultiSearchService_Do_Call) RunAndReturn(run func(ctx context.Context) (*elastic.MultiSearchResult, error)) *MultiSearchService_Do_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Index provides a mock function for the type MultiSearchService
+func (_mock *MultiSearchService) Index(indices ...string) elasticsearch.MultiSearchService {
+	var tmpRet mock.Arguments
+	if len(indices) > 0 {
+		tmpRet = _mock.Called(indices)
+	} else {
+		tmpRet = _mock.Called()
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for Index")
+	}
+
+	var r0 elasticsearch.MultiSearchService
+	if returnFunc, ok := ret.Get(0).(func(...string) elasticsearch.MultiSearchService); ok {
+		r0 = returnFunc(indices...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.MultiSearchService)
+		}
+	}
+	return r0
+}
+
+// MultiSearchService_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index'
+type MultiSearchService_Index_Call struct {
+	*mock.Call
+}
+
+// Index is a helper method to define mock.On call
+//   - indices
+func (_e *MultiSearchService_Expecter) Index(indices ...interface{}) *MultiSearchService_Index_Call {
+	return &MultiSearchService_Index_Call{Call: _e.mock.On("Index",
+		append([]interface{}{}, indices...)...)}
+}
+
+func (_c *MultiSearchService_Index_Call) Run(run func(indices ...string)) *MultiSearchService_Index_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MultiSearchService_Index_Call) Return(multiSearchService elasticsearch.MultiSearchService) *MultiSearchService_Index_Call {
+	_c.Call.Return(multiSearchService)
+	return _c
+}
+
+func (_c *MultiSearchService_Index_Call) RunAndReturn(run func(indices ...string) elasticsearch.MultiSearchService) *MultiSearchService_Index_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewTemplateApplier creates a new instance of TemplateApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTemplateApplier(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TemplateApplier {
+	mock := &TemplateApplier{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// TemplateApplier is an autogenerated mock type for the TemplateApplier type
+type TemplateApplier struct {
+	mock.Mock
+}
+
+type TemplateApplier_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *TemplateApplier) EXPECT() *TemplateApplier_Expecter {
+	return &TemplateApplier_Expecter{mock: &_m.Mock}
+}
+
+// Execute provides a mock function for the type TemplateApplier
+func (_mock *TemplateApplier) Execute(wr io.Writer, data any) error {
+	ret := _mock.Called(wr, data)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Execute")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(io.Writer, any) error); ok {
+		r0 = returnFunc(wr, data)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// TemplateApplier_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
+type TemplateApplier_Execute_Call struct {
+	*mock.Call
+}
+
+// Execute is a helper method to define mock.On call
+//   - wr
+//   - data
+func (_e *TemplateApplier_Expecter) Execute(wr interface{}, data interface{}) *TemplateApplier_Execute_Call {
+	return &TemplateApplier_Execute_Call{Call: _e.mock.On("Execute", wr, data)}
+}
+
+func (_c *TemplateApplier_Execute_Call) Run(run func(wr io.Writer, data any)) *TemplateApplier_Execute_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(io.Writer), args[1].(any))
+	})
+	return _c
+}
+
+func (_c *TemplateApplier_Execute_Call) Return(err error) *TemplateApplier_Execute_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *TemplateApplier_Execute_Call) RunAndReturn(run func(wr io.Writer, data any) error) *TemplateApplier_Execute_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewTemplateBuilder creates a new instance of TemplateBuilder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTemplateBuilder(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *TemplateBuilder {
+	mock := &TemplateBuilder{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// TemplateBuilder is an autogenerated mock type for the TemplateBuilder type
+type TemplateBuilder struct {
+	mock.Mock
+}
+
+type TemplateBuilder_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *TemplateBuilder) EXPECT() *TemplateBuilder_Expecter {
+	return &TemplateBuilder_Expecter{mock: &_m.Mock}
+}
+
+// Parse provides a mock function for the type TemplateBuilder
+func (_mock *TemplateBuilder) Parse(text string) (elasticsearch.TemplateApplier, error) {
+	ret := _mock.Called(text)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Parse")
+	}
+
+	var r0 elasticsearch.TemplateApplier
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (elasticsearch.TemplateApplier, error)); ok {
+		return returnFunc(text)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) elasticsearch.TemplateApplier); ok {
+		r0 = returnFunc(text)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(elasticsearch.TemplateApplier)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(text)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// TemplateBuilder_Parse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Parse'
+type TemplateBuilder_Parse_Call struct {
+	*mock.Call
+}
+
+// Parse is a helper method to define mock.On call
+//   - text
+func (_e *TemplateBuilder_Expecter) Parse(text interface{}) *TemplateBuilder_Parse_Call {
+	return &TemplateBuilder_Parse_Call{Call: _e.mock.On("Parse", text)}
+}
+
+func (_c *TemplateBuilder_Parse_Call) Run(run func(text string)) *TemplateBuilder_Parse_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *TemplateBuilder_Parse_Call) Return(templateApplier elasticsearch.TemplateApplier, err error) *TemplateBuilder_Parse_Call {
+	_c.Call.Return(templateApplier, err)
+	return _c
+}
+
+func (_c *TemplateBuilder_Parse_Call) RunAndReturn(run func(text string) (elasticsearch.TemplateApplier, error)) *TemplateBuilder_Parse_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/integration/remote_memory_storage.go b/internal/storage/integration/remote_memory_storage.go
index 6bea7d9d..0119a8cb 100644
--- a/internal/storage/integration/remote_memory_storage.go
+++ b/internal/storage/integration/remote_memory_storage.go
@@ -63,9 +63,9 @@ func StartNewRemoteMemoryStorage(t *testing.T, port int) *RemoteMemoryStorage {
 	traceFactory := v1adapter.NewFactory(storageFactory)
 	depFactory := traceFactory.(depstore.Factory)
 
-	server, err := app.NewServer(opts, traceFactory, depFactory, tm, telset)
+	server, err := app.NewServer(context.Background(), opts, traceFactory, depFactory, tm, telset)
 	require.NoError(t, err)
-	require.NoError(t, server.Start())
+	require.NoError(t, server.Start(context.Background()))
 
 	conn, err := grpc.NewClient(
 		opts.NetAddr.Endpoint,
diff --git a/internal/storage/kafka/consumer/mocks/Consumer.go b/internal/storage/kafka/consumer/mocks/mocks.go
similarity index 75%
rename from internal/storage/kafka/consumer/mocks/Consumer.go
rename to internal/storage/kafka/consumer/mocks/mocks.go
index c69d2d86..0bc4267e 100644
--- a/internal/storage/kafka/consumer/mocks/Consumer.go
+++ b/internal/storage/kafka/consumer/mocks/mocks.go
@@ -1,18 +1,32 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
 	cluster "github.com/bsm/sarama-cluster"
-
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewConsumer creates a new instance of Consumer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewConsumer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Consumer {
+	mock := &Consumer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // Consumer is an autogenerated mock type for the Consumer type
 type Consumer struct {
 	mock.Mock
@@ -26,21 +40,20 @@ func (_m *Consumer) EXPECT() *Consumer_Expecter {
 	return &Consumer_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *Consumer) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type Consumer
+func (_mock *Consumer) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -61,8 +74,8 @@ func (_c *Consumer_Close_Call) Run(run func()) *Consumer_Close_Call {
 	return _c
 }
 
-func (_c *Consumer_Close_Call) Return(_a0 error) *Consumer_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *Consumer_Close_Call) Return(err error) *Consumer_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -71,9 +84,10 @@ func (_c *Consumer_Close_Call) RunAndReturn(run func() error) *Consumer_Close_Ca
 	return _c
 }
 
-// MarkPartitionOffset provides a mock function with given fields: topic, partition, offset, metadata
-func (_m *Consumer) MarkPartitionOffset(topic string, partition int32, offset int64, metadata string) {
-	_m.Called(topic, partition, offset, metadata)
+// MarkPartitionOffset provides a mock function for the type Consumer
+func (_mock *Consumer) MarkPartitionOffset(topic string, partition int32, offset int64, metadata string) {
+	_mock.Called(topic, partition, offset, metadata)
+	return
 }
 
 // Consumer_MarkPartitionOffset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkPartitionOffset'
@@ -82,10 +96,10 @@ type Consumer_MarkPartitionOffset_Call struct {
 }
 
 // MarkPartitionOffset is a helper method to define mock.On call
-//   - topic string
-//   - partition int32
-//   - offset int64
-//   - metadata string
+//   - topic
+//   - partition
+//   - offset
+//   - metadata
 func (_e *Consumer_Expecter) MarkPartitionOffset(topic interface{}, partition interface{}, offset interface{}, metadata interface{}) *Consumer_MarkPartitionOffset_Call {
 	return &Consumer_MarkPartitionOffset_Call{Call: _e.mock.On("MarkPartitionOffset", topic, partition, offset, metadata)}
 }
@@ -102,28 +116,27 @@ func (_c *Consumer_MarkPartitionOffset_Call) Return() *Consumer_MarkPartitionOff
 	return _c
 }
 
-func (_c *Consumer_MarkPartitionOffset_Call) RunAndReturn(run func(string, int32, int64, string)) *Consumer_MarkPartitionOffset_Call {
+func (_c *Consumer_MarkPartitionOffset_Call) RunAndReturn(run func(topic string, partition int32, offset int64, metadata string)) *Consumer_MarkPartitionOffset_Call {
 	_c.Run(run)
 	return _c
 }
 
-// Partitions provides a mock function with no fields
-func (_m *Consumer) Partitions() <-chan cluster.PartitionConsumer {
-	ret := _m.Called()
+// Partitions provides a mock function for the type Consumer
+func (_mock *Consumer) Partitions() <-chan cluster.PartitionConsumer {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Partitions")
 	}
 
 	var r0 <-chan cluster.PartitionConsumer
-	if rf, ok := ret.Get(0).(func() <-chan cluster.PartitionConsumer); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() <-chan cluster.PartitionConsumer); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(<-chan cluster.PartitionConsumer)
 		}
 	}
-
 	return r0
 }
 
@@ -144,8 +157,8 @@ func (_c *Consumer_Partitions_Call) Run(run func()) *Consumer_Partitions_Call {
 	return _c
 }
 
-func (_c *Consumer_Partitions_Call) Return(_a0 <-chan cluster.PartitionConsumer) *Consumer_Partitions_Call {
-	_c.Call.Return(_a0)
+func (_c *Consumer_Partitions_Call) Return(partitionConsumerCh <-chan cluster.PartitionConsumer) *Consumer_Partitions_Call {
+	_c.Call.Return(partitionConsumerCh)
 	return _c
 }
 
@@ -153,17 +166,3 @@ func (_c *Consumer_Partitions_Call) RunAndReturn(run func() <-chan cluster.Parti
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewConsumer creates a new instance of Consumer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewConsumer(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Consumer {
-	mock := &Consumer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/dependencystore/mocks/Reader.go b/internal/storage/v1/api/dependencystore/mocks/mocks.go
similarity index 60%
rename from internal/storage/v1/api/dependencystore/mocks/Reader.go
rename to internal/storage/v1/api/dependencystore/mocks/mocks.go
index fc1edd16..9567b646 100644
--- a/internal/storage/v1/api/dependencystore/mocks/Reader.go
+++ b/internal/storage/v1/api/dependencystore/mocks/mocks.go
@@ -1,21 +1,34 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	context "context"
+	"context"
+	"time"
 
+	"github.com/jaegertracing/jaeger-idl/model/v1"
 	mock "github.com/stretchr/testify/mock"
+)
+
+// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Reader {
+	mock := &Reader{}
+	mock.Mock.Test(t)
 
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
+	t.Cleanup(func() { mock.AssertExpectations(t) })
 
-	time "time"
-)
+	return mock
+}
 
 // Reader is an autogenerated mock type for the Reader type
 type Reader struct {
@@ -30,9 +43,9 @@ func (_m *Reader) EXPECT() *Reader_Expecter {
 	return &Reader_Expecter{mock: &_m.Mock}
 }
 
-// GetDependencies provides a mock function with given fields: ctx, endTs, lookback
-func (_m *Reader) GetDependencies(ctx context.Context, endTs time.Time, lookback time.Duration) ([]model.DependencyLink, error) {
-	ret := _m.Called(ctx, endTs, lookback)
+// GetDependencies provides a mock function for the type Reader
+func (_mock *Reader) GetDependencies(ctx context.Context, endTs time.Time, lookback time.Duration) ([]model.DependencyLink, error) {
+	ret := _mock.Called(ctx, endTs, lookback)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetDependencies")
@@ -40,23 +53,21 @@ func (_m *Reader) GetDependencies(ctx context.Context, endTs time.Time, lookback
 
 	var r0 []model.DependencyLink
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) ([]model.DependencyLink, error)); ok {
-		return rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) ([]model.DependencyLink, error)); ok {
+		return returnFunc(ctx, endTs, lookback)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) []model.DependencyLink); ok {
-		r0 = rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) []model.DependencyLink); ok {
+		r0 = returnFunc(ctx, endTs, lookback)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]model.DependencyLink)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, time.Time, time.Duration) error); ok {
-		r1 = rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, time.Duration) error); ok {
+		r1 = returnFunc(ctx, endTs, lookback)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -66,9 +77,9 @@ type Reader_GetDependencies_Call struct {
 }
 
 // GetDependencies is a helper method to define mock.On call
-//   - ctx context.Context
-//   - endTs time.Time
-//   - lookback time.Duration
+//   - ctx
+//   - endTs
+//   - lookback
 func (_e *Reader_Expecter) GetDependencies(ctx interface{}, endTs interface{}, lookback interface{}) *Reader_GetDependencies_Call {
 	return &Reader_GetDependencies_Call{Call: _e.mock.On("GetDependencies", ctx, endTs, lookback)}
 }
@@ -80,26 +91,12 @@ func (_c *Reader_GetDependencies_Call) Run(run func(ctx context.Context, endTs t
 	return _c
 }
 
-func (_c *Reader_GetDependencies_Call) Return(_a0 []model.DependencyLink, _a1 error) *Reader_GetDependencies_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Reader_GetDependencies_Call) Return(dependencyLinks []model.DependencyLink, err error) *Reader_GetDependencies_Call {
+	_c.Call.Return(dependencyLinks, err)
 	return _c
 }
 
-func (_c *Reader_GetDependencies_Call) RunAndReturn(run func(context.Context, time.Time, time.Duration) ([]model.DependencyLink, error)) *Reader_GetDependencies_Call {
+func (_c *Reader_GetDependencies_Call) RunAndReturn(run func(ctx context.Context, endTs time.Time, lookback time.Duration) ([]model.DependencyLink, error)) *Reader_GetDependencies_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Reader {
-	mock := &Reader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/metricstore/mocks/Reader.go b/internal/storage/v1/api/metricstore/mocks/mocks.go
similarity index 53%
rename from internal/storage/v1/api/metricstore/mocks/Reader.go
rename to internal/storage/v1/api/metricstore/mocks/mocks.go
index 9aa6e2ab..bbcd8dd8 100644
--- a/internal/storage/v1/api/metricstore/mocks/Reader.go
+++ b/internal/storage/v1/api/metricstore/mocks/mocks.go
@@ -1,23 +1,36 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	context "context"
-
-	metrics "github.com/jaegertracing/jaeger/internal/proto-gen/api_v2/metrics"
-	metricstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore"
+	"context"
+	"time"
 
+	"github.com/jaegertracing/jaeger/internal/proto-gen/api_v2/metrics"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore"
 	mock "github.com/stretchr/testify/mock"
-
-	time "time"
 )
 
+// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Reader {
+	mock := &Reader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // Reader is an autogenerated mock type for the Reader type
 type Reader struct {
 	mock.Mock
@@ -31,9 +44,9 @@ func (_m *Reader) EXPECT() *Reader_Expecter {
 	return &Reader_Expecter{mock: &_m.Mock}
 }
 
-// GetCallRates provides a mock function with given fields: ctx, params
-func (_m *Reader) GetCallRates(ctx context.Context, params *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error) {
-	ret := _m.Called(ctx, params)
+// GetCallRates provides a mock function for the type Reader
+func (_mock *Reader) GetCallRates(ctx context.Context, params *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error) {
+	ret := _mock.Called(ctx, params)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetCallRates")
@@ -41,23 +54,21 @@ func (_m *Reader) GetCallRates(ctx context.Context, params *metricstore.CallRate
 
 	var r0 *metrics.MetricFamily
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error)); ok {
-		return rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error)); ok {
+		return returnFunc(ctx, params)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.CallRateQueryParameters) *metrics.MetricFamily); ok {
-		r0 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.CallRateQueryParameters) *metrics.MetricFamily); ok {
+		r0 = returnFunc(ctx, params)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*metrics.MetricFamily)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *metricstore.CallRateQueryParameters) error); ok {
-		r1 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *metricstore.CallRateQueryParameters) error); ok {
+		r1 = returnFunc(ctx, params)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -67,8 +78,8 @@ type Reader_GetCallRates_Call struct {
 }
 
 // GetCallRates is a helper method to define mock.On call
-//   - ctx context.Context
-//   - params *metricstore.CallRateQueryParameters
+//   - ctx
+//   - params
 func (_e *Reader_Expecter) GetCallRates(ctx interface{}, params interface{}) *Reader_GetCallRates_Call {
 	return &Reader_GetCallRates_Call{Call: _e.mock.On("GetCallRates", ctx, params)}
 }
@@ -80,19 +91,19 @@ func (_c *Reader_GetCallRates_Call) Run(run func(ctx context.Context, params *me
 	return _c
 }
 
-func (_c *Reader_GetCallRates_Call) Return(_a0 *metrics.MetricFamily, _a1 error) *Reader_GetCallRates_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Reader_GetCallRates_Call) Return(metricFamily *metrics.MetricFamily, err error) *Reader_GetCallRates_Call {
+	_c.Call.Return(metricFamily, err)
 	return _c
 }
 
-func (_c *Reader_GetCallRates_Call) RunAndReturn(run func(context.Context, *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetCallRates_Call {
+func (_c *Reader_GetCallRates_Call) RunAndReturn(run func(ctx context.Context, params *metricstore.CallRateQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetCallRates_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetErrorRates provides a mock function with given fields: ctx, params
-func (_m *Reader) GetErrorRates(ctx context.Context, params *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error) {
-	ret := _m.Called(ctx, params)
+// GetErrorRates provides a mock function for the type Reader
+func (_mock *Reader) GetErrorRates(ctx context.Context, params *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error) {
+	ret := _mock.Called(ctx, params)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetErrorRates")
@@ -100,23 +111,21 @@ func (_m *Reader) GetErrorRates(ctx context.Context, params *metricstore.ErrorRa
 
 	var r0 *metrics.MetricFamily
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error)); ok {
-		return rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error)); ok {
+		return returnFunc(ctx, params)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.ErrorRateQueryParameters) *metrics.MetricFamily); ok {
-		r0 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.ErrorRateQueryParameters) *metrics.MetricFamily); ok {
+		r0 = returnFunc(ctx, params)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*metrics.MetricFamily)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *metricstore.ErrorRateQueryParameters) error); ok {
-		r1 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *metricstore.ErrorRateQueryParameters) error); ok {
+		r1 = returnFunc(ctx, params)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -126,8 +135,8 @@ type Reader_GetErrorRates_Call struct {
 }
 
 // GetErrorRates is a helper method to define mock.On call
-//   - ctx context.Context
-//   - params *metricstore.ErrorRateQueryParameters
+//   - ctx
+//   - params
 func (_e *Reader_Expecter) GetErrorRates(ctx interface{}, params interface{}) *Reader_GetErrorRates_Call {
 	return &Reader_GetErrorRates_Call{Call: _e.mock.On("GetErrorRates", ctx, params)}
 }
@@ -139,19 +148,19 @@ func (_c *Reader_GetErrorRates_Call) Run(run func(ctx context.Context, params *m
 	return _c
 }
 
-func (_c *Reader_GetErrorRates_Call) Return(_a0 *metrics.MetricFamily, _a1 error) *Reader_GetErrorRates_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Reader_GetErrorRates_Call) Return(metricFamily *metrics.MetricFamily, err error) *Reader_GetErrorRates_Call {
+	_c.Call.Return(metricFamily, err)
 	return _c
 }
 
-func (_c *Reader_GetErrorRates_Call) RunAndReturn(run func(context.Context, *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetErrorRates_Call {
+func (_c *Reader_GetErrorRates_Call) RunAndReturn(run func(ctx context.Context, params *metricstore.ErrorRateQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetErrorRates_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetLatencies provides a mock function with given fields: ctx, params
-func (_m *Reader) GetLatencies(ctx context.Context, params *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error) {
-	ret := _m.Called(ctx, params)
+// GetLatencies provides a mock function for the type Reader
+func (_mock *Reader) GetLatencies(ctx context.Context, params *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error) {
+	ret := _mock.Called(ctx, params)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetLatencies")
@@ -159,23 +168,21 @@ func (_m *Reader) GetLatencies(ctx context.Context, params *metricstore.Latencie
 
 	var r0 *metrics.MetricFamily
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error)); ok {
-		return rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error)); ok {
+		return returnFunc(ctx, params)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.LatenciesQueryParameters) *metrics.MetricFamily); ok {
-		r0 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.LatenciesQueryParameters) *metrics.MetricFamily); ok {
+		r0 = returnFunc(ctx, params)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*metrics.MetricFamily)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *metricstore.LatenciesQueryParameters) error); ok {
-		r1 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *metricstore.LatenciesQueryParameters) error); ok {
+		r1 = returnFunc(ctx, params)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -185,8 +192,8 @@ type Reader_GetLatencies_Call struct {
 }
 
 // GetLatencies is a helper method to define mock.On call
-//   - ctx context.Context
-//   - params *metricstore.LatenciesQueryParameters
+//   - ctx
+//   - params
 func (_e *Reader_Expecter) GetLatencies(ctx interface{}, params interface{}) *Reader_GetLatencies_Call {
 	return &Reader_GetLatencies_Call{Call: _e.mock.On("GetLatencies", ctx, params)}
 }
@@ -198,19 +205,19 @@ func (_c *Reader_GetLatencies_Call) Run(run func(ctx context.Context, params *me
 	return _c
 }
 
-func (_c *Reader_GetLatencies_Call) Return(_a0 *metrics.MetricFamily, _a1 error) *Reader_GetLatencies_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Reader_GetLatencies_Call) Return(metricFamily *metrics.MetricFamily, err error) *Reader_GetLatencies_Call {
+	_c.Call.Return(metricFamily, err)
 	return _c
 }
 
-func (_c *Reader_GetLatencies_Call) RunAndReturn(run func(context.Context, *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetLatencies_Call {
+func (_c *Reader_GetLatencies_Call) RunAndReturn(run func(ctx context.Context, params *metricstore.LatenciesQueryParameters) (*metrics.MetricFamily, error)) *Reader_GetLatencies_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetMinStepDuration provides a mock function with given fields: ctx, params
-func (_m *Reader) GetMinStepDuration(ctx context.Context, params *metricstore.MinStepDurationQueryParameters) (time.Duration, error) {
-	ret := _m.Called(ctx, params)
+// GetMinStepDuration provides a mock function for the type Reader
+func (_mock *Reader) GetMinStepDuration(ctx context.Context, params *metricstore.MinStepDurationQueryParameters) (time.Duration, error) {
+	ret := _mock.Called(ctx, params)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetMinStepDuration")
@@ -218,21 +225,19 @@ func (_m *Reader) GetMinStepDuration(ctx context.Context, params *metricstore.Mi
 
 	var r0 time.Duration
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.MinStepDurationQueryParameters) (time.Duration, error)); ok {
-		return rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.MinStepDurationQueryParameters) (time.Duration, error)); ok {
+		return returnFunc(ctx, params)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *metricstore.MinStepDurationQueryParameters) time.Duration); ok {
-		r0 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *metricstore.MinStepDurationQueryParameters) time.Duration); ok {
+		r0 = returnFunc(ctx, params)
 	} else {
 		r0 = ret.Get(0).(time.Duration)
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *metricstore.MinStepDurationQueryParameters) error); ok {
-		r1 = rf(ctx, params)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *metricstore.MinStepDurationQueryParameters) error); ok {
+		r1 = returnFunc(ctx, params)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -242,8 +247,8 @@ type Reader_GetMinStepDuration_Call struct {
 }
 
 // GetMinStepDuration is a helper method to define mock.On call
-//   - ctx context.Context
-//   - params *metricstore.MinStepDurationQueryParameters
+//   - ctx
+//   - params
 func (_e *Reader_Expecter) GetMinStepDuration(ctx interface{}, params interface{}) *Reader_GetMinStepDuration_Call {
 	return &Reader_GetMinStepDuration_Call{Call: _e.mock.On("GetMinStepDuration", ctx, params)}
 }
@@ -255,26 +260,12 @@ func (_c *Reader_GetMinStepDuration_Call) Run(run func(ctx context.Context, para
 	return _c
 }
 
-func (_c *Reader_GetMinStepDuration_Call) Return(_a0 time.Duration, _a1 error) *Reader_GetMinStepDuration_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Reader_GetMinStepDuration_Call) Return(duration time.Duration, err error) *Reader_GetMinStepDuration_Call {
+	_c.Call.Return(duration, err)
 	return _c
 }
 
-func (_c *Reader_GetMinStepDuration_Call) RunAndReturn(run func(context.Context, *metricstore.MinStepDurationQueryParameters) (time.Duration, error)) *Reader_GetMinStepDuration_Call {
+func (_c *Reader_GetMinStepDuration_Call) RunAndReturn(run func(ctx context.Context, params *metricstore.MinStepDurationQueryParameters) (time.Duration, error)) *Reader_GetMinStepDuration_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Reader {
-	mock := &Reader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/samplingstore/mocks/Store.go b/internal/storage/v1/api/samplingstore/mocks/mocks.go
similarity index 62%
rename from internal/storage/v1/api/samplingstore/mocks/Store.go
rename to internal/storage/v1/api/samplingstore/mocks/mocks.go
index 8369b4d3..4829c9e4 100644
--- a/internal/storage/v1/api/samplingstore/mocks/Store.go
+++ b/internal/storage/v1/api/samplingstore/mocks/mocks.go
@@ -1,19 +1,34 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	model "github.com/jaegertracing/jaeger/internal/storage/v1/api/samplingstore/model"
-	mock "github.com/stretchr/testify/mock"
+	"time"
 
-	time "time"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/samplingstore/model"
+	mock "github.com/stretchr/testify/mock"
 )
 
+// NewStore creates a new instance of Store. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Store {
+	mock := &Store{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // Store is an autogenerated mock type for the Store type
 type Store struct {
 	mock.Mock
@@ -27,9 +42,9 @@ func (_m *Store) EXPECT() *Store_Expecter {
 	return &Store_Expecter{mock: &_m.Mock}
 }
 
-// GetLatestProbabilities provides a mock function with no fields
-func (_m *Store) GetLatestProbabilities() (model.ServiceOperationProbabilities, error) {
-	ret := _m.Called()
+// GetLatestProbabilities provides a mock function for the type Store
+func (_mock *Store) GetLatestProbabilities() (model.ServiceOperationProbabilities, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetLatestProbabilities")
@@ -37,23 +52,21 @@ func (_m *Store) GetLatestProbabilities() (model.ServiceOperationProbabilities,
 
 	var r0 model.ServiceOperationProbabilities
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (model.ServiceOperationProbabilities, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (model.ServiceOperationProbabilities, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() model.ServiceOperationProbabilities); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() model.ServiceOperationProbabilities); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(model.ServiceOperationProbabilities)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -74,8 +87,8 @@ func (_c *Store_GetLatestProbabilities_Call) Run(run func()) *Store_GetLatestPro
 	return _c
 }
 
-func (_c *Store_GetLatestProbabilities_Call) Return(_a0 model.ServiceOperationProbabilities, _a1 error) *Store_GetLatestProbabilities_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Store_GetLatestProbabilities_Call) Return(serviceOperationProbabilities model.ServiceOperationProbabilities, err error) *Store_GetLatestProbabilities_Call {
+	_c.Call.Return(serviceOperationProbabilities, err)
 	return _c
 }
 
@@ -84,9 +97,9 @@ func (_c *Store_GetLatestProbabilities_Call) RunAndReturn(run func() (model.Serv
 	return _c
 }
 
-// GetThroughput provides a mock function with given fields: start, end
-func (_m *Store) GetThroughput(start time.Time, end time.Time) ([]*model.Throughput, error) {
-	ret := _m.Called(start, end)
+// GetThroughput provides a mock function for the type Store
+func (_mock *Store) GetThroughput(start time.Time, end time.Time) ([]*model.Throughput, error) {
+	ret := _mock.Called(start, end)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetThroughput")
@@ -94,23 +107,21 @@ func (_m *Store) GetThroughput(start time.Time, end time.Time) ([]*model.Through
 
 	var r0 []*model.Throughput
 	var r1 error
-	if rf, ok := ret.Get(0).(func(time.Time, time.Time) ([]*model.Throughput, error)); ok {
-		return rf(start, end)
+	if returnFunc, ok := ret.Get(0).(func(time.Time, time.Time) ([]*model.Throughput, error)); ok {
+		return returnFunc(start, end)
 	}
-	if rf, ok := ret.Get(0).(func(time.Time, time.Time) []*model.Throughput); ok {
-		r0 = rf(start, end)
+	if returnFunc, ok := ret.Get(0).(func(time.Time, time.Time) []*model.Throughput); ok {
+		r0 = returnFunc(start, end)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]*model.Throughput)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(time.Time, time.Time) error); ok {
-		r1 = rf(start, end)
+	if returnFunc, ok := ret.Get(1).(func(time.Time, time.Time) error); ok {
+		r1 = returnFunc(start, end)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -120,8 +131,8 @@ type Store_GetThroughput_Call struct {
 }
 
 // GetThroughput is a helper method to define mock.On call
-//   - start time.Time
-//   - end time.Time
+//   - start
+//   - end
 func (_e *Store_Expecter) GetThroughput(start interface{}, end interface{}) *Store_GetThroughput_Call {
 	return &Store_GetThroughput_Call{Call: _e.mock.On("GetThroughput", start, end)}
 }
@@ -133,31 +144,30 @@ func (_c *Store_GetThroughput_Call) Run(run func(start time.Time, end time.Time)
 	return _c
 }
 
-func (_c *Store_GetThroughput_Call) Return(_a0 []*model.Throughput, _a1 error) *Store_GetThroughput_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *Store_GetThroughput_Call) Return(throughputs []*model.Throughput, err error) *Store_GetThroughput_Call {
+	_c.Call.Return(throughputs, err)
 	return _c
 }
 
-func (_c *Store_GetThroughput_Call) RunAndReturn(run func(time.Time, time.Time) ([]*model.Throughput, error)) *Store_GetThroughput_Call {
+func (_c *Store_GetThroughput_Call) RunAndReturn(run func(start time.Time, end time.Time) ([]*model.Throughput, error)) *Store_GetThroughput_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// InsertProbabilitiesAndQPS provides a mock function with given fields: hostname, probabilities, qps
-func (_m *Store) InsertProbabilitiesAndQPS(hostname string, probabilities model.ServiceOperationProbabilities, qps model.ServiceOperationQPS) error {
-	ret := _m.Called(hostname, probabilities, qps)
+// InsertProbabilitiesAndQPS provides a mock function for the type Store
+func (_mock *Store) InsertProbabilitiesAndQPS(hostname string, probabilities model.ServiceOperationProbabilities, qps model.ServiceOperationQPS) error {
+	ret := _mock.Called(hostname, probabilities, qps)
 
 	if len(ret) == 0 {
 		panic("no return value specified for InsertProbabilitiesAndQPS")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, model.ServiceOperationProbabilities, model.ServiceOperationQPS) error); ok {
-		r0 = rf(hostname, probabilities, qps)
+	if returnFunc, ok := ret.Get(0).(func(string, model.ServiceOperationProbabilities, model.ServiceOperationQPS) error); ok {
+		r0 = returnFunc(hostname, probabilities, qps)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -167,9 +177,9 @@ type Store_InsertProbabilitiesAndQPS_Call struct {
 }
 
 // InsertProbabilitiesAndQPS is a helper method to define mock.On call
-//   - hostname string
-//   - probabilities model.ServiceOperationProbabilities
-//   - qps model.ServiceOperationQPS
+//   - hostname
+//   - probabilities
+//   - qps
 func (_e *Store_Expecter) InsertProbabilitiesAndQPS(hostname interface{}, probabilities interface{}, qps interface{}) *Store_InsertProbabilitiesAndQPS_Call {
 	return &Store_InsertProbabilitiesAndQPS_Call{Call: _e.mock.On("InsertProbabilitiesAndQPS", hostname, probabilities, qps)}
 }
@@ -181,31 +191,30 @@ func (_c *Store_InsertProbabilitiesAndQPS_Call) Run(run func(hostname string, pr
 	return _c
 }
 
-func (_c *Store_InsertProbabilitiesAndQPS_Call) Return(_a0 error) *Store_InsertProbabilitiesAndQPS_Call {
-	_c.Call.Return(_a0)
+func (_c *Store_InsertProbabilitiesAndQPS_Call) Return(err error) *Store_InsertProbabilitiesAndQPS_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *Store_InsertProbabilitiesAndQPS_Call) RunAndReturn(run func(string, model.ServiceOperationProbabilities, model.ServiceOperationQPS) error) *Store_InsertProbabilitiesAndQPS_Call {
+func (_c *Store_InsertProbabilitiesAndQPS_Call) RunAndReturn(run func(hostname string, probabilities model.ServiceOperationProbabilities, qps model.ServiceOperationQPS) error) *Store_InsertProbabilitiesAndQPS_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// InsertThroughput provides a mock function with given fields: throughput
-func (_m *Store) InsertThroughput(throughput []*model.Throughput) error {
-	ret := _m.Called(throughput)
+// InsertThroughput provides a mock function for the type Store
+func (_mock *Store) InsertThroughput(throughput []*model.Throughput) error {
+	ret := _mock.Called(throughput)
 
 	if len(ret) == 0 {
 		panic("no return value specified for InsertThroughput")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func([]*model.Throughput) error); ok {
-		r0 = rf(throughput)
+	if returnFunc, ok := ret.Get(0).(func([]*model.Throughput) error); ok {
+		r0 = returnFunc(throughput)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -215,7 +224,7 @@ type Store_InsertThroughput_Call struct {
 }
 
 // InsertThroughput is a helper method to define mock.On call
-//   - throughput []*model.Throughput
+//   - throughput
 func (_e *Store_Expecter) InsertThroughput(throughput interface{}) *Store_InsertThroughput_Call {
 	return &Store_InsertThroughput_Call{Call: _e.mock.On("InsertThroughput", throughput)}
 }
@@ -227,26 +236,12 @@ func (_c *Store_InsertThroughput_Call) Run(run func(throughput []*model.Throughp
 	return _c
 }
 
-func (_c *Store_InsertThroughput_Call) Return(_a0 error) *Store_InsertThroughput_Call {
-	_c.Call.Return(_a0)
+func (_c *Store_InsertThroughput_Call) Return(err error) *Store_InsertThroughput_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *Store_InsertThroughput_Call) RunAndReturn(run func([]*model.Throughput) error) *Store_InsertThroughput_Call {
+func (_c *Store_InsertThroughput_Call) RunAndReturn(run func(throughput []*model.Throughput) error) *Store_InsertThroughput_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewStore creates a new instance of Store. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStore(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Store {
-	mock := &Store{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/spanstore/mocks/Reader.go b/internal/storage/v1/api/spanstore/mocks/Reader.go
deleted file mode 100644
index f16dbccc..00000000
--- a/internal/storage/v1/api/spanstore/mocks/Reader.go
+++ /dev/null
@@ -1,338 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-	mock "github.com/stretchr/testify/mock"
-
-	spanstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore"
-)
-
-// Reader is an autogenerated mock type for the Reader type
-type Reader struct {
-	mock.Mock
-}
-
-type Reader_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Reader) EXPECT() *Reader_Expecter {
-	return &Reader_Expecter{mock: &_m.Mock}
-}
-
-// FindTraceIDs provides a mock function with given fields: ctx, query
-func (_m *Reader) FindTraceIDs(ctx context.Context, query *spanstore.TraceQueryParameters) ([]model.TraceID, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraceIDs")
-	}
-
-	var r0 []model.TraceID
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) ([]model.TraceID, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) []model.TraceID); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]model.TraceID)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *spanstore.TraceQueryParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
-type Reader_FindTraceIDs_Call struct {
-	*mock.Call
-}
-
-// FindTraceIDs is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query *spanstore.TraceQueryParameters
-func (_e *Reader_Expecter) FindTraceIDs(ctx interface{}, query interface{}) *Reader_FindTraceIDs_Call {
-	return &Reader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, query)}
-}
-
-func (_c *Reader_FindTraceIDs_Call) Run(run func(ctx context.Context, query *spanstore.TraceQueryParameters)) *Reader_FindTraceIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*spanstore.TraceQueryParameters))
-	})
-	return _c
-}
-
-func (_c *Reader_FindTraceIDs_Call) Return(_a0 []model.TraceID, _a1 error) *Reader_FindTraceIDs_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_FindTraceIDs_Call) RunAndReturn(run func(context.Context, *spanstore.TraceQueryParameters) ([]model.TraceID, error)) *Reader_FindTraceIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTraces provides a mock function with given fields: ctx, query
-func (_m *Reader) FindTraces(ctx context.Context, query *spanstore.TraceQueryParameters) ([]*model.Trace, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraces")
-	}
-
-	var r0 []*model.Trace
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) ([]*model.Trace, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) []*model.Trace); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*model.Trace)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *spanstore.TraceQueryParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
-type Reader_FindTraces_Call struct {
-	*mock.Call
-}
-
-// FindTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query *spanstore.TraceQueryParameters
-func (_e *Reader_Expecter) FindTraces(ctx interface{}, query interface{}) *Reader_FindTraces_Call {
-	return &Reader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, query)}
-}
-
-func (_c *Reader_FindTraces_Call) Run(run func(ctx context.Context, query *spanstore.TraceQueryParameters)) *Reader_FindTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*spanstore.TraceQueryParameters))
-	})
-	return _c
-}
-
-func (_c *Reader_FindTraces_Call) Return(_a0 []*model.Trace, _a1 error) *Reader_FindTraces_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_FindTraces_Call) RunAndReturn(run func(context.Context, *spanstore.TraceQueryParameters) ([]*model.Trace, error)) *Reader_FindTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetOperations provides a mock function with given fields: ctx, query
-func (_m *Reader) GetOperations(ctx context.Context, query spanstore.OperationQueryParameters) ([]spanstore.Operation, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetOperations")
-	}
-
-	var r0 []spanstore.Operation
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, spanstore.OperationQueryParameters) ([]spanstore.Operation, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, spanstore.OperationQueryParameters) []spanstore.Operation); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]spanstore.Operation)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, spanstore.OperationQueryParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
-type Reader_GetOperations_Call struct {
-	*mock.Call
-}
-
-// GetOperations is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query spanstore.OperationQueryParameters
-func (_e *Reader_Expecter) GetOperations(ctx interface{}, query interface{}) *Reader_GetOperations_Call {
-	return &Reader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
-}
-
-func (_c *Reader_GetOperations_Call) Run(run func(ctx context.Context, query spanstore.OperationQueryParameters)) *Reader_GetOperations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(spanstore.OperationQueryParameters))
-	})
-	return _c
-}
-
-func (_c *Reader_GetOperations_Call) Return(_a0 []spanstore.Operation, _a1 error) *Reader_GetOperations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetOperations_Call) RunAndReturn(run func(context.Context, spanstore.OperationQueryParameters) ([]spanstore.Operation, error)) *Reader_GetOperations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetServices provides a mock function with given fields: ctx
-func (_m *Reader) GetServices(ctx context.Context) ([]string, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetServices")
-	}
-
-	var r0 []string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) []string); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
-type Reader_GetServices_Call struct {
-	*mock.Call
-}
-
-// GetServices is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *Reader_Expecter) GetServices(ctx interface{}) *Reader_GetServices_Call {
-	return &Reader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
-}
-
-func (_c *Reader_GetServices_Call) Run(run func(ctx context.Context)) *Reader_GetServices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *Reader_GetServices_Call) Return(_a0 []string, _a1 error) *Reader_GetServices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetServices_Call) RunAndReturn(run func(context.Context) ([]string, error)) *Reader_GetServices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTrace provides a mock function with given fields: ctx, query
-func (_m *Reader) GetTrace(ctx context.Context, query spanstore.GetTraceParameters) (*model.Trace, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTrace")
-	}
-
-	var r0 *model.Trace
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, spanstore.GetTraceParameters) (*model.Trace, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, spanstore.GetTraceParameters) *model.Trace); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Trace)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, spanstore.GetTraceParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
-type Reader_GetTrace_Call struct {
-	*mock.Call
-}
-
-// GetTrace is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query spanstore.GetTraceParameters
-func (_e *Reader_Expecter) GetTrace(ctx interface{}, query interface{}) *Reader_GetTrace_Call {
-	return &Reader_GetTrace_Call{Call: _e.mock.On("GetTrace", ctx, query)}
-}
-
-func (_c *Reader_GetTrace_Call) Run(run func(ctx context.Context, query spanstore.GetTraceParameters)) *Reader_GetTrace_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(spanstore.GetTraceParameters))
-	})
-	return _c
-}
-
-func (_c *Reader_GetTrace_Call) Return(_a0 *model.Trace, _a1 error) *Reader_GetTrace_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetTrace_Call) RunAndReturn(run func(context.Context, spanstore.GetTraceParameters) (*model.Trace, error)) *Reader_GetTrace_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Reader {
-	mock := &Reader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/spanstore/mocks/Writer.go b/internal/storage/v1/api/spanstore/mocks/Writer.go
deleted file mode 100644
index 3f82c414..00000000
--- a/internal/storage/v1/api/spanstore/mocks/Writer.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Writer is an autogenerated mock type for the Writer type
-type Writer struct {
-	mock.Mock
-}
-
-type Writer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Writer) EXPECT() *Writer_Expecter {
-	return &Writer_Expecter{mock: &_m.Mock}
-}
-
-// WriteSpan provides a mock function with given fields: ctx, span
-func (_m *Writer) WriteSpan(ctx context.Context, span *model.Span) error {
-	ret := _m.Called(ctx, span)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteSpan")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.Span) error); ok {
-		r0 = rf(ctx, span)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Writer_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
-type Writer_WriteSpan_Call struct {
-	*mock.Call
-}
-
-// WriteSpan is a helper method to define mock.On call
-//   - ctx context.Context
-//   - span *model.Span
-func (_e *Writer_Expecter) WriteSpan(ctx interface{}, span interface{}) *Writer_WriteSpan_Call {
-	return &Writer_WriteSpan_Call{Call: _e.mock.On("WriteSpan", ctx, span)}
-}
-
-func (_c *Writer_WriteSpan_Call) Run(run func(ctx context.Context, span *model.Span)) *Writer_WriteSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*model.Span))
-	})
-	return _c
-}
-
-func (_c *Writer_WriteSpan_Call) Return(_a0 error) *Writer_WriteSpan_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Writer_WriteSpan_Call) RunAndReturn(run func(context.Context, *model.Span) error) *Writer_WriteSpan_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewWriter(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Writer {
-	mock := &Writer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/api/spanstore/mocks/mocks.go b/internal/storage/v1/api/spanstore/mocks/mocks.go
new file mode 100644
index 00000000..c84ab962
--- /dev/null
+++ b/internal/storage/v1/api/spanstore/mocks/mocks.go
@@ -0,0 +1,401 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+
+	"github.com/jaegertracing/jaeger-idl/model/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewWriter(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Writer {
+	mock := &Writer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Writer is an autogenerated mock type for the Writer type
+type Writer struct {
+	mock.Mock
+}
+
+type Writer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Writer) EXPECT() *Writer_Expecter {
+	return &Writer_Expecter{mock: &_m.Mock}
+}
+
+// WriteSpan provides a mock function for the type Writer
+func (_mock *Writer) WriteSpan(ctx context.Context, span *model.Span) error {
+	ret := _mock.Called(ctx, span)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteSpan")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *model.Span) error); ok {
+		r0 = returnFunc(ctx, span)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Writer_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
+type Writer_WriteSpan_Call struct {
+	*mock.Call
+}
+
+// WriteSpan is a helper method to define mock.On call
+//   - ctx
+//   - span
+func (_e *Writer_Expecter) WriteSpan(ctx interface{}, span interface{}) *Writer_WriteSpan_Call {
+	return &Writer_WriteSpan_Call{Call: _e.mock.On("WriteSpan", ctx, span)}
+}
+
+func (_c *Writer_WriteSpan_Call) Run(run func(ctx context.Context, span *model.Span)) *Writer_WriteSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*model.Span))
+	})
+	return _c
+}
+
+func (_c *Writer_WriteSpan_Call) Return(err error) *Writer_WriteSpan_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Writer_WriteSpan_Call) RunAndReturn(run func(ctx context.Context, span *model.Span) error) *Writer_WriteSpan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Reader {
+	mock := &Reader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Reader is an autogenerated mock type for the Reader type
+type Reader struct {
+	mock.Mock
+}
+
+type Reader_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Reader) EXPECT() *Reader_Expecter {
+	return &Reader_Expecter{mock: &_m.Mock}
+}
+
+// FindTraceIDs provides a mock function for the type Reader
+func (_mock *Reader) FindTraceIDs(ctx context.Context, query *spanstore.TraceQueryParameters) ([]model.TraceID, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraceIDs")
+	}
+
+	var r0 []model.TraceID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) ([]model.TraceID, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) []model.TraceID); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]model.TraceID)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *spanstore.TraceQueryParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
+type Reader_FindTraceIDs_Call struct {
+	*mock.Call
+}
+
+// FindTraceIDs is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) FindTraceIDs(ctx interface{}, query interface{}) *Reader_FindTraceIDs_Call {
+	return &Reader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, query)}
+}
+
+func (_c *Reader_FindTraceIDs_Call) Run(run func(ctx context.Context, query *spanstore.TraceQueryParameters)) *Reader_FindTraceIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*spanstore.TraceQueryParameters))
+	})
+	return _c
+}
+
+func (_c *Reader_FindTraceIDs_Call) Return(traceIDs []model.TraceID, err error) *Reader_FindTraceIDs_Call {
+	_c.Call.Return(traceIDs, err)
+	return _c
+}
+
+func (_c *Reader_FindTraceIDs_Call) RunAndReturn(run func(ctx context.Context, query *spanstore.TraceQueryParameters) ([]model.TraceID, error)) *Reader_FindTraceIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTraces provides a mock function for the type Reader
+func (_mock *Reader) FindTraces(ctx context.Context, query *spanstore.TraceQueryParameters) ([]*model.Trace, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraces")
+	}
+
+	var r0 []*model.Trace
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) ([]*model.Trace, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *spanstore.TraceQueryParameters) []*model.Trace); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Trace)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *spanstore.TraceQueryParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
+type Reader_FindTraces_Call struct {
+	*mock.Call
+}
+
+// FindTraces is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) FindTraces(ctx interface{}, query interface{}) *Reader_FindTraces_Call {
+	return &Reader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, query)}
+}
+
+func (_c *Reader_FindTraces_Call) Run(run func(ctx context.Context, query *spanstore.TraceQueryParameters)) *Reader_FindTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*spanstore.TraceQueryParameters))
+	})
+	return _c
+}
+
+func (_c *Reader_FindTraces_Call) Return(traces []*model.Trace, err error) *Reader_FindTraces_Call {
+	_c.Call.Return(traces, err)
+	return _c
+}
+
+func (_c *Reader_FindTraces_Call) RunAndReturn(run func(ctx context.Context, query *spanstore.TraceQueryParameters) ([]*model.Trace, error)) *Reader_FindTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOperations provides a mock function for the type Reader
+func (_mock *Reader) GetOperations(ctx context.Context, query spanstore.OperationQueryParameters) ([]spanstore.Operation, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOperations")
+	}
+
+	var r0 []spanstore.Operation
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, spanstore.OperationQueryParameters) ([]spanstore.Operation, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, spanstore.OperationQueryParameters) []spanstore.Operation); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]spanstore.Operation)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, spanstore.OperationQueryParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
+type Reader_GetOperations_Call struct {
+	*mock.Call
+}
+
+// GetOperations is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) GetOperations(ctx interface{}, query interface{}) *Reader_GetOperations_Call {
+	return &Reader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
+}
+
+func (_c *Reader_GetOperations_Call) Run(run func(ctx context.Context, query spanstore.OperationQueryParameters)) *Reader_GetOperations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(spanstore.OperationQueryParameters))
+	})
+	return _c
+}
+
+func (_c *Reader_GetOperations_Call) Return(operations []spanstore.Operation, err error) *Reader_GetOperations_Call {
+	_c.Call.Return(operations, err)
+	return _c
+}
+
+func (_c *Reader_GetOperations_Call) RunAndReturn(run func(ctx context.Context, query spanstore.OperationQueryParameters) ([]spanstore.Operation, error)) *Reader_GetOperations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetServices provides a mock function for the type Reader
+func (_mock *Reader) GetServices(ctx context.Context) ([]string, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetServices")
+	}
+
+	var r0 []string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
+type Reader_GetServices_Call struct {
+	*mock.Call
+}
+
+// GetServices is a helper method to define mock.On call
+//   - ctx
+func (_e *Reader_Expecter) GetServices(ctx interface{}) *Reader_GetServices_Call {
+	return &Reader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
+}
+
+func (_c *Reader_GetServices_Call) Run(run func(ctx context.Context)) *Reader_GetServices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *Reader_GetServices_Call) Return(strings []string, err error) *Reader_GetServices_Call {
+	_c.Call.Return(strings, err)
+	return _c
+}
+
+func (_c *Reader_GetServices_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *Reader_GetServices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTrace provides a mock function for the type Reader
+func (_mock *Reader) GetTrace(ctx context.Context, query spanstore.GetTraceParameters) (*model.Trace, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTrace")
+	}
+
+	var r0 *model.Trace
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, spanstore.GetTraceParameters) (*model.Trace, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, spanstore.GetTraceParameters) *model.Trace); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Trace)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, spanstore.GetTraceParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace'
+type Reader_GetTrace_Call struct {
+	*mock.Call
+}
+
+// GetTrace is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) GetTrace(ctx interface{}, query interface{}) *Reader_GetTrace_Call {
+	return &Reader_GetTrace_Call{Call: _e.mock.On("GetTrace", ctx, query)}
+}
+
+func (_c *Reader_GetTrace_Call) Run(run func(ctx context.Context, query spanstore.GetTraceParameters)) *Reader_GetTrace_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(spanstore.GetTraceParameters))
+	})
+	return _c
+}
+
+func (_c *Reader_GetTrace_Call) Return(trace *model.Trace, err error) *Reader_GetTrace_Call {
+	_c.Call.Return(trace, err)
+	return _c
+}
+
+func (_c *Reader_GetTrace_Call) RunAndReturn(run func(ctx context.Context, query spanstore.GetTraceParameters) (*model.Trace, error)) *Reader_GetTrace_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/v1/elasticsearch/dependencystore/mocks/CoreDependencyStore.go b/internal/storage/v1/elasticsearch/dependencystore/mocks/mocks.go
similarity index 64%
rename from internal/storage/v1/elasticsearch/dependencystore/mocks/CoreDependencyStore.go
rename to internal/storage/v1/elasticsearch/dependencystore/mocks/mocks.go
index 1b886efb..bb460538 100644
--- a/internal/storage/v1/elasticsearch/dependencystore/mocks/CoreDependencyStore.go
+++ b/internal/storage/v1/elasticsearch/dependencystore/mocks/mocks.go
@@ -1,22 +1,35 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	context "context"
-
-	dbmodel "github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/dependencystore/dbmodel"
+	"context"
+	"time"
 
+	"github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/dependencystore/dbmodel"
 	mock "github.com/stretchr/testify/mock"
-
-	time "time"
 )
 
+// NewCoreDependencyStore creates a new instance of CoreDependencyStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCoreDependencyStore(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CoreDependencyStore {
+	mock := &CoreDependencyStore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // CoreDependencyStore is an autogenerated mock type for the CoreDependencyStore type
 type CoreDependencyStore struct {
 	mock.Mock
@@ -30,21 +43,20 @@ func (_m *CoreDependencyStore) EXPECT() *CoreDependencyStore_Expecter {
 	return &CoreDependencyStore_Expecter{mock: &_m.Mock}
 }
 
-// CreateTemplates provides a mock function with given fields: dependenciesTemplate
-func (_m *CoreDependencyStore) CreateTemplates(dependenciesTemplate string) error {
-	ret := _m.Called(dependenciesTemplate)
+// CreateTemplates provides a mock function for the type CoreDependencyStore
+func (_mock *CoreDependencyStore) CreateTemplates(dependenciesTemplate string) error {
+	ret := _mock.Called(dependenciesTemplate)
 
 	if len(ret) == 0 {
 		panic("no return value specified for CreateTemplates")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(dependenciesTemplate)
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(dependenciesTemplate)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -54,7 +66,7 @@ type CoreDependencyStore_CreateTemplates_Call struct {
 }
 
 // CreateTemplates is a helper method to define mock.On call
-//   - dependenciesTemplate string
+//   - dependenciesTemplate
 func (_e *CoreDependencyStore_Expecter) CreateTemplates(dependenciesTemplate interface{}) *CoreDependencyStore_CreateTemplates_Call {
 	return &CoreDependencyStore_CreateTemplates_Call{Call: _e.mock.On("CreateTemplates", dependenciesTemplate)}
 }
@@ -66,19 +78,19 @@ func (_c *CoreDependencyStore_CreateTemplates_Call) Run(run func(dependenciesTem
 	return _c
 }
 
-func (_c *CoreDependencyStore_CreateTemplates_Call) Return(_a0 error) *CoreDependencyStore_CreateTemplates_Call {
-	_c.Call.Return(_a0)
+func (_c *CoreDependencyStore_CreateTemplates_Call) Return(err error) *CoreDependencyStore_CreateTemplates_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *CoreDependencyStore_CreateTemplates_Call) RunAndReturn(run func(string) error) *CoreDependencyStore_CreateTemplates_Call {
+func (_c *CoreDependencyStore_CreateTemplates_Call) RunAndReturn(run func(dependenciesTemplate string) error) *CoreDependencyStore_CreateTemplates_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetDependencies provides a mock function with given fields: ctx, endTs, lookback
-func (_m *CoreDependencyStore) GetDependencies(ctx context.Context, endTs time.Time, lookback time.Duration) ([]dbmodel.DependencyLink, error) {
-	ret := _m.Called(ctx, endTs, lookback)
+// GetDependencies provides a mock function for the type CoreDependencyStore
+func (_mock *CoreDependencyStore) GetDependencies(ctx context.Context, endTs time.Time, lookback time.Duration) ([]dbmodel.DependencyLink, error) {
+	ret := _mock.Called(ctx, endTs, lookback)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetDependencies")
@@ -86,23 +98,21 @@ func (_m *CoreDependencyStore) GetDependencies(ctx context.Context, endTs time.T
 
 	var r0 []dbmodel.DependencyLink
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) ([]dbmodel.DependencyLink, error)); ok {
-		return rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) ([]dbmodel.DependencyLink, error)); ok {
+		return returnFunc(ctx, endTs, lookback)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) []dbmodel.DependencyLink); ok {
-		r0 = rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Duration) []dbmodel.DependencyLink); ok {
+		r0 = returnFunc(ctx, endTs, lookback)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]dbmodel.DependencyLink)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, time.Time, time.Duration) error); ok {
-		r1 = rf(ctx, endTs, lookback)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, time.Duration) error); ok {
+		r1 = returnFunc(ctx, endTs, lookback)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -112,9 +122,9 @@ type CoreDependencyStore_GetDependencies_Call struct {
 }
 
 // GetDependencies is a helper method to define mock.On call
-//   - ctx context.Context
-//   - endTs time.Time
-//   - lookback time.Duration
+//   - ctx
+//   - endTs
+//   - lookback
 func (_e *CoreDependencyStore_Expecter) GetDependencies(ctx interface{}, endTs interface{}, lookback interface{}) *CoreDependencyStore_GetDependencies_Call {
 	return &CoreDependencyStore_GetDependencies_Call{Call: _e.mock.On("GetDependencies", ctx, endTs, lookback)}
 }
@@ -126,31 +136,30 @@ func (_c *CoreDependencyStore_GetDependencies_Call) Run(run func(ctx context.Con
 	return _c
 }
 
-func (_c *CoreDependencyStore_GetDependencies_Call) Return(_a0 []dbmodel.DependencyLink, _a1 error) *CoreDependencyStore_GetDependencies_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *CoreDependencyStore_GetDependencies_Call) Return(dependencyLinks []dbmodel.DependencyLink, err error) *CoreDependencyStore_GetDependencies_Call {
+	_c.Call.Return(dependencyLinks, err)
 	return _c
 }
 
-func (_c *CoreDependencyStore_GetDependencies_Call) RunAndReturn(run func(context.Context, time.Time, time.Duration) ([]dbmodel.DependencyLink, error)) *CoreDependencyStore_GetDependencies_Call {
+func (_c *CoreDependencyStore_GetDependencies_Call) RunAndReturn(run func(ctx context.Context, endTs time.Time, lookback time.Duration) ([]dbmodel.DependencyLink, error)) *CoreDependencyStore_GetDependencies_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// WriteDependencies provides a mock function with given fields: ts, dependencies
-func (_m *CoreDependencyStore) WriteDependencies(ts time.Time, dependencies []dbmodel.DependencyLink) error {
-	ret := _m.Called(ts, dependencies)
+// WriteDependencies provides a mock function for the type CoreDependencyStore
+func (_mock *CoreDependencyStore) WriteDependencies(ts time.Time, dependencies []dbmodel.DependencyLink) error {
+	ret := _mock.Called(ts, dependencies)
 
 	if len(ret) == 0 {
 		panic("no return value specified for WriteDependencies")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(time.Time, []dbmodel.DependencyLink) error); ok {
-		r0 = rf(ts, dependencies)
+	if returnFunc, ok := ret.Get(0).(func(time.Time, []dbmodel.DependencyLink) error); ok {
+		r0 = returnFunc(ts, dependencies)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -160,8 +169,8 @@ type CoreDependencyStore_WriteDependencies_Call struct {
 }
 
 // WriteDependencies is a helper method to define mock.On call
-//   - ts time.Time
-//   - dependencies []dbmodel.DependencyLink
+//   - ts
+//   - dependencies
 func (_e *CoreDependencyStore_Expecter) WriteDependencies(ts interface{}, dependencies interface{}) *CoreDependencyStore_WriteDependencies_Call {
 	return &CoreDependencyStore_WriteDependencies_Call{Call: _e.mock.On("WriteDependencies", ts, dependencies)}
 }
@@ -173,26 +182,12 @@ func (_c *CoreDependencyStore_WriteDependencies_Call) Run(run func(ts time.Time,
 	return _c
 }
 
-func (_c *CoreDependencyStore_WriteDependencies_Call) Return(_a0 error) *CoreDependencyStore_WriteDependencies_Call {
-	_c.Call.Return(_a0)
+func (_c *CoreDependencyStore_WriteDependencies_Call) Return(err error) *CoreDependencyStore_WriteDependencies_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *CoreDependencyStore_WriteDependencies_Call) RunAndReturn(run func(time.Time, []dbmodel.DependencyLink) error) *CoreDependencyStore_WriteDependencies_Call {
+func (_c *CoreDependencyStore_WriteDependencies_Call) RunAndReturn(run func(ts time.Time, dependencies []dbmodel.DependencyLink) error) *CoreDependencyStore_WriteDependencies_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewCoreDependencyStore creates a new instance of CoreDependencyStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewCoreDependencyStore(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *CoreDependencyStore {
-	mock := &CoreDependencyStore{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanReader.go b/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanReader.go
deleted file mode 100644
index 7843986f..00000000
--- a/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanReader.go
+++ /dev/null
@@ -1,336 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	dbmodel "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// CoreSpanReader is an autogenerated mock type for the CoreSpanReader type
-type CoreSpanReader struct {
-	mock.Mock
-}
-
-type CoreSpanReader_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *CoreSpanReader) EXPECT() *CoreSpanReader_Expecter {
-	return &CoreSpanReader_Expecter{mock: &_m.Mock}
-}
-
-// FindTraceIDs provides a mock function with given fields: ctx, traceQuery
-func (_m *CoreSpanReader) FindTraceIDs(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error) {
-	ret := _m.Called(ctx, traceQuery)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraceIDs")
-	}
-
-	var r0 []dbmodel.TraceID
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error)); ok {
-		return rf(ctx, traceQuery)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) []dbmodel.TraceID); ok {
-		r0 = rf(ctx, traceQuery)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]dbmodel.TraceID)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, dbmodel.TraceQueryParameters) error); ok {
-		r1 = rf(ctx, traceQuery)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CoreSpanReader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
-type CoreSpanReader_FindTraceIDs_Call struct {
-	*mock.Call
-}
-
-// FindTraceIDs is a helper method to define mock.On call
-//   - ctx context.Context
-//   - traceQuery dbmodel.TraceQueryParameters
-func (_e *CoreSpanReader_Expecter) FindTraceIDs(ctx interface{}, traceQuery interface{}) *CoreSpanReader_FindTraceIDs_Call {
-	return &CoreSpanReader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, traceQuery)}
-}
-
-func (_c *CoreSpanReader_FindTraceIDs_Call) Run(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters)) *CoreSpanReader_FindTraceIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(dbmodel.TraceQueryParameters))
-	})
-	return _c
-}
-
-func (_c *CoreSpanReader_FindTraceIDs_Call) Return(_a0 []dbmodel.TraceID, _a1 error) *CoreSpanReader_FindTraceIDs_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CoreSpanReader_FindTraceIDs_Call) RunAndReturn(run func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error)) *CoreSpanReader_FindTraceIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTraces provides a mock function with given fields: ctx, traceQuery
-func (_m *CoreSpanReader) FindTraces(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error) {
-	ret := _m.Called(ctx, traceQuery)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraces")
-	}
-
-	var r0 []dbmodel.Trace
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error)); ok {
-		return rf(ctx, traceQuery)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) []dbmodel.Trace); ok {
-		r0 = rf(ctx, traceQuery)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]dbmodel.Trace)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, dbmodel.TraceQueryParameters) error); ok {
-		r1 = rf(ctx, traceQuery)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CoreSpanReader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
-type CoreSpanReader_FindTraces_Call struct {
-	*mock.Call
-}
-
-// FindTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - traceQuery dbmodel.TraceQueryParameters
-func (_e *CoreSpanReader_Expecter) FindTraces(ctx interface{}, traceQuery interface{}) *CoreSpanReader_FindTraces_Call {
-	return &CoreSpanReader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, traceQuery)}
-}
-
-func (_c *CoreSpanReader_FindTraces_Call) Run(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters)) *CoreSpanReader_FindTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(dbmodel.TraceQueryParameters))
-	})
-	return _c
-}
-
-func (_c *CoreSpanReader_FindTraces_Call) Return(_a0 []dbmodel.Trace, _a1 error) *CoreSpanReader_FindTraces_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CoreSpanReader_FindTraces_Call) RunAndReturn(run func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error)) *CoreSpanReader_FindTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetOperations provides a mock function with given fields: ctx, query
-func (_m *CoreSpanReader) GetOperations(ctx context.Context, query dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetOperations")
-	}
-
-	var r0 []dbmodel.Operation
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, dbmodel.OperationQueryParameters) []dbmodel.Operation); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]dbmodel.Operation)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, dbmodel.OperationQueryParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CoreSpanReader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
-type CoreSpanReader_GetOperations_Call struct {
-	*mock.Call
-}
-
-// GetOperations is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query dbmodel.OperationQueryParameters
-func (_e *CoreSpanReader_Expecter) GetOperations(ctx interface{}, query interface{}) *CoreSpanReader_GetOperations_Call {
-	return &CoreSpanReader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
-}
-
-func (_c *CoreSpanReader_GetOperations_Call) Run(run func(ctx context.Context, query dbmodel.OperationQueryParameters)) *CoreSpanReader_GetOperations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(dbmodel.OperationQueryParameters))
-	})
-	return _c
-}
-
-func (_c *CoreSpanReader_GetOperations_Call) Return(_a0 []dbmodel.Operation, _a1 error) *CoreSpanReader_GetOperations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CoreSpanReader_GetOperations_Call) RunAndReturn(run func(context.Context, dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error)) *CoreSpanReader_GetOperations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetServices provides a mock function with given fields: ctx
-func (_m *CoreSpanReader) GetServices(ctx context.Context) ([]string, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetServices")
-	}
-
-	var r0 []string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) []string); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CoreSpanReader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
-type CoreSpanReader_GetServices_Call struct {
-	*mock.Call
-}
-
-// GetServices is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *CoreSpanReader_Expecter) GetServices(ctx interface{}) *CoreSpanReader_GetServices_Call {
-	return &CoreSpanReader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
-}
-
-func (_c *CoreSpanReader_GetServices_Call) Run(run func(ctx context.Context)) *CoreSpanReader_GetServices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *CoreSpanReader_GetServices_Call) Return(_a0 []string, _a1 error) *CoreSpanReader_GetServices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CoreSpanReader_GetServices_Call) RunAndReturn(run func(context.Context) ([]string, error)) *CoreSpanReader_GetServices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTraces provides a mock function with given fields: ctx, query
-func (_m *CoreSpanReader) GetTraces(ctx context.Context, query []dbmodel.TraceID) ([]dbmodel.Trace, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTraces")
-	}
-
-	var r0 []dbmodel.Trace
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, []dbmodel.TraceID) ([]dbmodel.Trace, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, []dbmodel.TraceID) []dbmodel.Trace); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]dbmodel.Trace)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, []dbmodel.TraceID) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CoreSpanReader_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
-type CoreSpanReader_GetTraces_Call struct {
-	*mock.Call
-}
-
-// GetTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query []dbmodel.TraceID
-func (_e *CoreSpanReader_Expecter) GetTraces(ctx interface{}, query interface{}) *CoreSpanReader_GetTraces_Call {
-	return &CoreSpanReader_GetTraces_Call{Call: _e.mock.On("GetTraces", ctx, query)}
-}
-
-func (_c *CoreSpanReader_GetTraces_Call) Run(run func(ctx context.Context, query []dbmodel.TraceID)) *CoreSpanReader_GetTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].([]dbmodel.TraceID))
-	})
-	return _c
-}
-
-func (_c *CoreSpanReader_GetTraces_Call) Return(_a0 []dbmodel.Trace, _a1 error) *CoreSpanReader_GetTraces_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *CoreSpanReader_GetTraces_Call) RunAndReturn(run func(context.Context, []dbmodel.TraceID) ([]dbmodel.Trace, error)) *CoreSpanReader_GetTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewCoreSpanReader creates a new instance of CoreSpanReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewCoreSpanReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *CoreSpanReader {
-	mock := &CoreSpanReader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanWriter.go b/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanWriter.go
deleted file mode 100644
index cd1249d7..00000000
--- a/internal/storage/v1/elasticsearch/spanstore/mocks/CoreSpanWriter.go
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	config "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
-	dbmodel "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
-
-	mock "github.com/stretchr/testify/mock"
-
-	time "time"
-)
-
-// CoreSpanWriter is an autogenerated mock type for the CoreSpanWriter type
-type CoreSpanWriter struct {
-	mock.Mock
-}
-
-type CoreSpanWriter_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *CoreSpanWriter) EXPECT() *CoreSpanWriter_Expecter {
-	return &CoreSpanWriter_Expecter{mock: &_m.Mock}
-}
-
-// Close provides a mock function with no fields
-func (_m *CoreSpanWriter) Close() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// CoreSpanWriter_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type CoreSpanWriter_Close_Call struct {
-	*mock.Call
-}
-
-// Close is a helper method to define mock.On call
-func (_e *CoreSpanWriter_Expecter) Close() *CoreSpanWriter_Close_Call {
-	return &CoreSpanWriter_Close_Call{Call: _e.mock.On("Close")}
-}
-
-func (_c *CoreSpanWriter_Close_Call) Run(run func()) *CoreSpanWriter_Close_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *CoreSpanWriter_Close_Call) Return(_a0 error) *CoreSpanWriter_Close_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *CoreSpanWriter_Close_Call) RunAndReturn(run func() error) *CoreSpanWriter_Close_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateTemplates provides a mock function with given fields: spanTemplate, serviceTemplate, indexPrefix
-func (_m *CoreSpanWriter) CreateTemplates(spanTemplate string, serviceTemplate string, indexPrefix config.IndexPrefix) error {
-	ret := _m.Called(spanTemplate, serviceTemplate, indexPrefix)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateTemplates")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string, string, config.IndexPrefix) error); ok {
-		r0 = rf(spanTemplate, serviceTemplate, indexPrefix)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// CoreSpanWriter_CreateTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplates'
-type CoreSpanWriter_CreateTemplates_Call struct {
-	*mock.Call
-}
-
-// CreateTemplates is a helper method to define mock.On call
-//   - spanTemplate string
-//   - serviceTemplate string
-//   - indexPrefix config.IndexPrefix
-func (_e *CoreSpanWriter_Expecter) CreateTemplates(spanTemplate interface{}, serviceTemplate interface{}, indexPrefix interface{}) *CoreSpanWriter_CreateTemplates_Call {
-	return &CoreSpanWriter_CreateTemplates_Call{Call: _e.mock.On("CreateTemplates", spanTemplate, serviceTemplate, indexPrefix)}
-}
-
-func (_c *CoreSpanWriter_CreateTemplates_Call) Run(run func(spanTemplate string, serviceTemplate string, indexPrefix config.IndexPrefix)) *CoreSpanWriter_CreateTemplates_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string), args[2].(config.IndexPrefix))
-	})
-	return _c
-}
-
-func (_c *CoreSpanWriter_CreateTemplates_Call) Return(_a0 error) *CoreSpanWriter_CreateTemplates_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *CoreSpanWriter_CreateTemplates_Call) RunAndReturn(run func(string, string, config.IndexPrefix) error) *CoreSpanWriter_CreateTemplates_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// WriteSpan provides a mock function with given fields: spanStartTime, span
-func (_m *CoreSpanWriter) WriteSpan(spanStartTime time.Time, span *dbmodel.Span) {
-	_m.Called(spanStartTime, span)
-}
-
-// CoreSpanWriter_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
-type CoreSpanWriter_WriteSpan_Call struct {
-	*mock.Call
-}
-
-// WriteSpan is a helper method to define mock.On call
-//   - spanStartTime time.Time
-//   - span *dbmodel.Span
-func (_e *CoreSpanWriter_Expecter) WriteSpan(spanStartTime interface{}, span interface{}) *CoreSpanWriter_WriteSpan_Call {
-	return &CoreSpanWriter_WriteSpan_Call{Call: _e.mock.On("WriteSpan", spanStartTime, span)}
-}
-
-func (_c *CoreSpanWriter_WriteSpan_Call) Run(run func(spanStartTime time.Time, span *dbmodel.Span)) *CoreSpanWriter_WriteSpan_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(time.Time), args[1].(*dbmodel.Span))
-	})
-	return _c
-}
-
-func (_c *CoreSpanWriter_WriteSpan_Call) Return() *CoreSpanWriter_WriteSpan_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *CoreSpanWriter_WriteSpan_Call) RunAndReturn(run func(time.Time, *dbmodel.Span)) *CoreSpanWriter_WriteSpan_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewCoreSpanWriter creates a new instance of CoreSpanWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewCoreSpanWriter(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *CoreSpanWriter {
-	mock := &CoreSpanWriter{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/elasticsearch/spanstore/mocks/mocks.go b/internal/storage/v1/elasticsearch/spanstore/mocks/mocks.go
new file mode 100644
index 00000000..31d2f459
--- /dev/null
+++ b/internal/storage/v1/elasticsearch/spanstore/mocks/mocks.go
@@ -0,0 +1,482 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+	"time"
+
+	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
+	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewCoreSpanReader creates a new instance of CoreSpanReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCoreSpanReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CoreSpanReader {
+	mock := &CoreSpanReader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// CoreSpanReader is an autogenerated mock type for the CoreSpanReader type
+type CoreSpanReader struct {
+	mock.Mock
+}
+
+type CoreSpanReader_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *CoreSpanReader) EXPECT() *CoreSpanReader_Expecter {
+	return &CoreSpanReader_Expecter{mock: &_m.Mock}
+}
+
+// FindTraceIDs provides a mock function for the type CoreSpanReader
+func (_mock *CoreSpanReader) FindTraceIDs(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error) {
+	ret := _mock.Called(ctx, traceQuery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraceIDs")
+	}
+
+	var r0 []dbmodel.TraceID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error)); ok {
+		return returnFunc(ctx, traceQuery)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) []dbmodel.TraceID); ok {
+		r0 = returnFunc(ctx, traceQuery)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]dbmodel.TraceID)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, dbmodel.TraceQueryParameters) error); ok {
+		r1 = returnFunc(ctx, traceQuery)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CoreSpanReader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
+type CoreSpanReader_FindTraceIDs_Call struct {
+	*mock.Call
+}
+
+// FindTraceIDs is a helper method to define mock.On call
+//   - ctx
+//   - traceQuery
+func (_e *CoreSpanReader_Expecter) FindTraceIDs(ctx interface{}, traceQuery interface{}) *CoreSpanReader_FindTraceIDs_Call {
+	return &CoreSpanReader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, traceQuery)}
+}
+
+func (_c *CoreSpanReader_FindTraceIDs_Call) Run(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters)) *CoreSpanReader_FindTraceIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(dbmodel.TraceQueryParameters))
+	})
+	return _c
+}
+
+func (_c *CoreSpanReader_FindTraceIDs_Call) Return(traceIDs []dbmodel.TraceID, err error) *CoreSpanReader_FindTraceIDs_Call {
+	_c.Call.Return(traceIDs, err)
+	return _c
+}
+
+func (_c *CoreSpanReader_FindTraceIDs_Call) RunAndReturn(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.TraceID, error)) *CoreSpanReader_FindTraceIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTraces provides a mock function for the type CoreSpanReader
+func (_mock *CoreSpanReader) FindTraces(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error) {
+	ret := _mock.Called(ctx, traceQuery)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraces")
+	}
+
+	var r0 []dbmodel.Trace
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error)); ok {
+		return returnFunc(ctx, traceQuery)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.TraceQueryParameters) []dbmodel.Trace); ok {
+		r0 = returnFunc(ctx, traceQuery)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]dbmodel.Trace)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, dbmodel.TraceQueryParameters) error); ok {
+		r1 = returnFunc(ctx, traceQuery)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CoreSpanReader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
+type CoreSpanReader_FindTraces_Call struct {
+	*mock.Call
+}
+
+// FindTraces is a helper method to define mock.On call
+//   - ctx
+//   - traceQuery
+func (_e *CoreSpanReader_Expecter) FindTraces(ctx interface{}, traceQuery interface{}) *CoreSpanReader_FindTraces_Call {
+	return &CoreSpanReader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, traceQuery)}
+}
+
+func (_c *CoreSpanReader_FindTraces_Call) Run(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters)) *CoreSpanReader_FindTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(dbmodel.TraceQueryParameters))
+	})
+	return _c
+}
+
+func (_c *CoreSpanReader_FindTraces_Call) Return(traces []dbmodel.Trace, err error) *CoreSpanReader_FindTraces_Call {
+	_c.Call.Return(traces, err)
+	return _c
+}
+
+func (_c *CoreSpanReader_FindTraces_Call) RunAndReturn(run func(ctx context.Context, traceQuery dbmodel.TraceQueryParameters) ([]dbmodel.Trace, error)) *CoreSpanReader_FindTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOperations provides a mock function for the type CoreSpanReader
+func (_mock *CoreSpanReader) GetOperations(ctx context.Context, query dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOperations")
+	}
+
+	var r0 []dbmodel.Operation
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, dbmodel.OperationQueryParameters) []dbmodel.Operation); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]dbmodel.Operation)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, dbmodel.OperationQueryParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CoreSpanReader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
+type CoreSpanReader_GetOperations_Call struct {
+	*mock.Call
+}
+
+// GetOperations is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *CoreSpanReader_Expecter) GetOperations(ctx interface{}, query interface{}) *CoreSpanReader_GetOperations_Call {
+	return &CoreSpanReader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
+}
+
+func (_c *CoreSpanReader_GetOperations_Call) Run(run func(ctx context.Context, query dbmodel.OperationQueryParameters)) *CoreSpanReader_GetOperations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(dbmodel.OperationQueryParameters))
+	})
+	return _c
+}
+
+func (_c *CoreSpanReader_GetOperations_Call) Return(operations []dbmodel.Operation, err error) *CoreSpanReader_GetOperations_Call {
+	_c.Call.Return(operations, err)
+	return _c
+}
+
+func (_c *CoreSpanReader_GetOperations_Call) RunAndReturn(run func(ctx context.Context, query dbmodel.OperationQueryParameters) ([]dbmodel.Operation, error)) *CoreSpanReader_GetOperations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetServices provides a mock function for the type CoreSpanReader
+func (_mock *CoreSpanReader) GetServices(ctx context.Context) ([]string, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetServices")
+	}
+
+	var r0 []string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CoreSpanReader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
+type CoreSpanReader_GetServices_Call struct {
+	*mock.Call
+}
+
+// GetServices is a helper method to define mock.On call
+//   - ctx
+func (_e *CoreSpanReader_Expecter) GetServices(ctx interface{}) *CoreSpanReader_GetServices_Call {
+	return &CoreSpanReader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
+}
+
+func (_c *CoreSpanReader_GetServices_Call) Run(run func(ctx context.Context)) *CoreSpanReader_GetServices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *CoreSpanReader_GetServices_Call) Return(strings []string, err error) *CoreSpanReader_GetServices_Call {
+	_c.Call.Return(strings, err)
+	return _c
+}
+
+func (_c *CoreSpanReader_GetServices_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *CoreSpanReader_GetServices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTraces provides a mock function for the type CoreSpanReader
+func (_mock *CoreSpanReader) GetTraces(ctx context.Context, query []dbmodel.TraceID) ([]dbmodel.Trace, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTraces")
+	}
+
+	var r0 []dbmodel.Trace
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []dbmodel.TraceID) ([]dbmodel.Trace, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []dbmodel.TraceID) []dbmodel.Trace); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]dbmodel.Trace)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, []dbmodel.TraceID) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// CoreSpanReader_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
+type CoreSpanReader_GetTraces_Call struct {
+	*mock.Call
+}
+
+// GetTraces is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *CoreSpanReader_Expecter) GetTraces(ctx interface{}, query interface{}) *CoreSpanReader_GetTraces_Call {
+	return &CoreSpanReader_GetTraces_Call{Call: _e.mock.On("GetTraces", ctx, query)}
+}
+
+func (_c *CoreSpanReader_GetTraces_Call) Run(run func(ctx context.Context, query []dbmodel.TraceID)) *CoreSpanReader_GetTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].([]dbmodel.TraceID))
+	})
+	return _c
+}
+
+func (_c *CoreSpanReader_GetTraces_Call) Return(traces []dbmodel.Trace, err error) *CoreSpanReader_GetTraces_Call {
+	_c.Call.Return(traces, err)
+	return _c
+}
+
+func (_c *CoreSpanReader_GetTraces_Call) RunAndReturn(run func(ctx context.Context, query []dbmodel.TraceID) ([]dbmodel.Trace, error)) *CoreSpanReader_GetTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewCoreSpanWriter creates a new instance of CoreSpanWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewCoreSpanWriter(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *CoreSpanWriter {
+	mock := &CoreSpanWriter{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// CoreSpanWriter is an autogenerated mock type for the CoreSpanWriter type
+type CoreSpanWriter struct {
+	mock.Mock
+}
+
+type CoreSpanWriter_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *CoreSpanWriter) EXPECT() *CoreSpanWriter_Expecter {
+	return &CoreSpanWriter_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type CoreSpanWriter
+func (_mock *CoreSpanWriter) Close() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// CoreSpanWriter_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type CoreSpanWriter_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *CoreSpanWriter_Expecter) Close() *CoreSpanWriter_Close_Call {
+	return &CoreSpanWriter_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *CoreSpanWriter_Close_Call) Run(run func()) *CoreSpanWriter_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *CoreSpanWriter_Close_Call) Return(err error) *CoreSpanWriter_Close_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *CoreSpanWriter_Close_Call) RunAndReturn(run func() error) *CoreSpanWriter_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateTemplates provides a mock function for the type CoreSpanWriter
+func (_mock *CoreSpanWriter) CreateTemplates(spanTemplate string, serviceTemplate string, indexPrefix config.IndexPrefix) error {
+	ret := _mock.Called(spanTemplate, serviceTemplate, indexPrefix)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateTemplates")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(string, string, config.IndexPrefix) error); ok {
+		r0 = returnFunc(spanTemplate, serviceTemplate, indexPrefix)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// CoreSpanWriter_CreateTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplates'
+type CoreSpanWriter_CreateTemplates_Call struct {
+	*mock.Call
+}
+
+// CreateTemplates is a helper method to define mock.On call
+//   - spanTemplate
+//   - serviceTemplate
+//   - indexPrefix
+func (_e *CoreSpanWriter_Expecter) CreateTemplates(spanTemplate interface{}, serviceTemplate interface{}, indexPrefix interface{}) *CoreSpanWriter_CreateTemplates_Call {
+	return &CoreSpanWriter_CreateTemplates_Call{Call: _e.mock.On("CreateTemplates", spanTemplate, serviceTemplate, indexPrefix)}
+}
+
+func (_c *CoreSpanWriter_CreateTemplates_Call) Run(run func(spanTemplate string, serviceTemplate string, indexPrefix config.IndexPrefix)) *CoreSpanWriter_CreateTemplates_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(config.IndexPrefix))
+	})
+	return _c
+}
+
+func (_c *CoreSpanWriter_CreateTemplates_Call) Return(err error) *CoreSpanWriter_CreateTemplates_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *CoreSpanWriter_CreateTemplates_Call) RunAndReturn(run func(spanTemplate string, serviceTemplate string, indexPrefix config.IndexPrefix) error) *CoreSpanWriter_CreateTemplates_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WriteSpan provides a mock function for the type CoreSpanWriter
+func (_mock *CoreSpanWriter) WriteSpan(spanStartTime time.Time, span *dbmodel.Span) {
+	_mock.Called(spanStartTime, span)
+	return
+}
+
+// CoreSpanWriter_WriteSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteSpan'
+type CoreSpanWriter_WriteSpan_Call struct {
+	*mock.Call
+}
+
+// WriteSpan is a helper method to define mock.On call
+//   - spanStartTime
+//   - span
+func (_e *CoreSpanWriter_Expecter) WriteSpan(spanStartTime interface{}, span interface{}) *CoreSpanWriter_WriteSpan_Call {
+	return &CoreSpanWriter_WriteSpan_Call{Call: _e.mock.On("WriteSpan", spanStartTime, span)}
+}
+
+func (_c *CoreSpanWriter_WriteSpan_Call) Run(run func(spanStartTime time.Time, span *dbmodel.Span)) *CoreSpanWriter_WriteSpan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(time.Time), args[1].(*dbmodel.Span))
+	})
+	return _c
+}
+
+func (_c *CoreSpanWriter_WriteSpan_Call) Return() *CoreSpanWriter_WriteSpan_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *CoreSpanWriter_WriteSpan_Call) RunAndReturn(run func(spanStartTime time.Time, span *dbmodel.Span)) *CoreSpanWriter_WriteSpan_Call {
+	_c.Run(run)
+	return _c
+}
diff --git a/internal/storage/v1/grpc/shared/mocks/PluginCapabilities.go b/internal/storage/v1/grpc/shared/mocks/mocks.go
similarity index 72%
rename from internal/storage/v1/grpc/shared/mocks/PluginCapabilities.go
rename to internal/storage/v1/grpc/shared/mocks/mocks.go
index 81faac58..26392cb0 100644
--- a/internal/storage/v1/grpc/shared/mocks/PluginCapabilities.go
+++ b/internal/storage/v1/grpc/shared/mocks/mocks.go
@@ -1,17 +1,32 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 // Copyright (c) The Jaeger Authors.
 // SPDX-License-Identifier: Apache-2.0
 //
 // Run 'make generate-mocks' to regenerate.
 
-// Code generated by mockery. DO NOT EDIT.
-
 package mocks
 
 import (
-	shared "github.com/jaegertracing/jaeger/internal/storage/v1/grpc/shared"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/grpc/shared"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewPluginCapabilities creates a new instance of PluginCapabilities. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPluginCapabilities(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *PluginCapabilities {
+	mock := &PluginCapabilities{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // PluginCapabilities is an autogenerated mock type for the PluginCapabilities type
 type PluginCapabilities struct {
 	mock.Mock
@@ -25,9 +40,9 @@ func (_m *PluginCapabilities) EXPECT() *PluginCapabilities_Expecter {
 	return &PluginCapabilities_Expecter{mock: &_m.Mock}
 }
 
-// Capabilities provides a mock function with no fields
-func (_m *PluginCapabilities) Capabilities() (*shared.Capabilities, error) {
-	ret := _m.Called()
+// Capabilities provides a mock function for the type PluginCapabilities
+func (_mock *PluginCapabilities) Capabilities() (*shared.Capabilities, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Capabilities")
@@ -35,23 +50,21 @@ func (_m *PluginCapabilities) Capabilities() (*shared.Capabilities, error) {
 
 	var r0 *shared.Capabilities
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (*shared.Capabilities, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (*shared.Capabilities, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() *shared.Capabilities); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() *shared.Capabilities); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*shared.Capabilities)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -72,8 +85,8 @@ func (_c *PluginCapabilities_Capabilities_Call) Run(run func()) *PluginCapabilit
 	return _c
 }
 
-func (_c *PluginCapabilities_Capabilities_Call) Return(_a0 *shared.Capabilities, _a1 error) *PluginCapabilities_Capabilities_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *PluginCapabilities_Capabilities_Call) Return(capabilities *shared.Capabilities, err error) *PluginCapabilities_Capabilities_Call {
+	_c.Call.Return(capabilities, err)
 	return _c
 }
 
@@ -81,17 +94,3 @@ func (_c *PluginCapabilities_Capabilities_Call) RunAndReturn(run func() (*shared
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewPluginCapabilities creates a new instance of PluginCapabilities. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewPluginCapabilities(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *PluginCapabilities {
-	mock := &PluginCapabilities{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/kafka/mocks/Marshaller.go b/internal/storage/v1/kafka/mocks/Marshaller.go
deleted file mode 100644
index 938b8914..00000000
--- a/internal/storage/v1/kafka/mocks/Marshaller.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Marshaller is an autogenerated mock type for the Marshaller type
-type Marshaller struct {
-	mock.Mock
-}
-
-type Marshaller_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Marshaller) EXPECT() *Marshaller_Expecter {
-	return &Marshaller_Expecter{mock: &_m.Mock}
-}
-
-// Marshal provides a mock function with given fields: _a0
-func (_m *Marshaller) Marshal(_a0 *model.Span) ([]byte, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Marshal")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*model.Span) ([]byte, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func(*model.Span) []byte); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*model.Span) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Marshaller_Marshal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Marshal'
-type Marshaller_Marshal_Call struct {
-	*mock.Call
-}
-
-// Marshal is a helper method to define mock.On call
-//   - _a0 *model.Span
-func (_e *Marshaller_Expecter) Marshal(_a0 interface{}) *Marshaller_Marshal_Call {
-	return &Marshaller_Marshal_Call{Call: _e.mock.On("Marshal", _a0)}
-}
-
-func (_c *Marshaller_Marshal_Call) Run(run func(_a0 *model.Span)) *Marshaller_Marshal_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*model.Span))
-	})
-	return _c
-}
-
-func (_c *Marshaller_Marshal_Call) Return(_a0 []byte, _a1 error) *Marshaller_Marshal_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Marshaller_Marshal_Call) RunAndReturn(run func(*model.Span) ([]byte, error)) *Marshaller_Marshal_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewMarshaller creates a new instance of Marshaller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMarshaller(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Marshaller {
-	mock := &Marshaller{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/kafka/mocks/Unmarshaller.go b/internal/storage/v1/kafka/mocks/Unmarshaller.go
deleted file mode 100644
index dc1eda02..00000000
--- a/internal/storage/v1/kafka/mocks/Unmarshaller.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Unmarshaller is an autogenerated mock type for the Unmarshaller type
-type Unmarshaller struct {
-	mock.Mock
-}
-
-type Unmarshaller_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Unmarshaller) EXPECT() *Unmarshaller_Expecter {
-	return &Unmarshaller_Expecter{mock: &_m.Mock}
-}
-
-// Unmarshal provides a mock function with given fields: _a0
-func (_m *Unmarshaller) Unmarshal(_a0 []byte) (*model.Span, error) {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Unmarshal")
-	}
-
-	var r0 *model.Span
-	var r1 error
-	if rf, ok := ret.Get(0).(func([]byte) (*model.Span, error)); ok {
-		return rf(_a0)
-	}
-	if rf, ok := ret.Get(0).(func([]byte) *model.Span); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Span)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func([]byte) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Unmarshaller_Unmarshal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unmarshal'
-type Unmarshaller_Unmarshal_Call struct {
-	*mock.Call
-}
-
-// Unmarshal is a helper method to define mock.On call
-//   - _a0 []byte
-func (_e *Unmarshaller_Expecter) Unmarshal(_a0 interface{}) *Unmarshaller_Unmarshal_Call {
-	return &Unmarshaller_Unmarshal_Call{Call: _e.mock.On("Unmarshal", _a0)}
-}
-
-func (_c *Unmarshaller_Unmarshal_Call) Run(run func(_a0 []byte)) *Unmarshaller_Unmarshal_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]byte))
-	})
-	return _c
-}
-
-func (_c *Unmarshaller_Unmarshal_Call) Return(_a0 *model.Span, _a1 error) *Unmarshaller_Unmarshal_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Unmarshaller_Unmarshal_Call) RunAndReturn(run func([]byte) (*model.Span, error)) *Unmarshaller_Unmarshal_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewUnmarshaller creates a new instance of Unmarshaller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewUnmarshaller(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Unmarshaller {
-	mock := &Unmarshaller{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/kafka/mocks/mocks.go b/internal/storage/v1/kafka/mocks/mocks.go
new file mode 100644
index 00000000..f6575870
--- /dev/null
+++ b/internal/storage/v1/kafka/mocks/mocks.go
@@ -0,0 +1,180 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"github.com/jaegertracing/jaeger-idl/model/v1"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMarshaller creates a new instance of Marshaller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMarshaller(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Marshaller {
+	mock := &Marshaller{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Marshaller is an autogenerated mock type for the Marshaller type
+type Marshaller struct {
+	mock.Mock
+}
+
+type Marshaller_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Marshaller) EXPECT() *Marshaller_Expecter {
+	return &Marshaller_Expecter{mock: &_m.Mock}
+}
+
+// Marshal provides a mock function for the type Marshaller
+func (_mock *Marshaller) Marshal(span *model.Span) ([]byte, error) {
+	ret := _mock.Called(span)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Marshal")
+	}
+
+	var r0 []byte
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*model.Span) ([]byte, error)); ok {
+		return returnFunc(span)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*model.Span) []byte); ok {
+		r0 = returnFunc(span)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*model.Span) error); ok {
+		r1 = returnFunc(span)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Marshaller_Marshal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Marshal'
+type Marshaller_Marshal_Call struct {
+	*mock.Call
+}
+
+// Marshal is a helper method to define mock.On call
+//   - span
+func (_e *Marshaller_Expecter) Marshal(span interface{}) *Marshaller_Marshal_Call {
+	return &Marshaller_Marshal_Call{Call: _e.mock.On("Marshal", span)}
+}
+
+func (_c *Marshaller_Marshal_Call) Run(run func(span *model.Span)) *Marshaller_Marshal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*model.Span))
+	})
+	return _c
+}
+
+func (_c *Marshaller_Marshal_Call) Return(bytes []byte, err error) *Marshaller_Marshal_Call {
+	_c.Call.Return(bytes, err)
+	return _c
+}
+
+func (_c *Marshaller_Marshal_Call) RunAndReturn(run func(span *model.Span) ([]byte, error)) *Marshaller_Marshal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewUnmarshaller creates a new instance of Unmarshaller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewUnmarshaller(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Unmarshaller {
+	mock := &Unmarshaller{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Unmarshaller is an autogenerated mock type for the Unmarshaller type
+type Unmarshaller struct {
+	mock.Mock
+}
+
+type Unmarshaller_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Unmarshaller) EXPECT() *Unmarshaller_Expecter {
+	return &Unmarshaller_Expecter{mock: &_m.Mock}
+}
+
+// Unmarshal provides a mock function for the type Unmarshaller
+func (_mock *Unmarshaller) Unmarshal(bytes []byte) (*model.Span, error) {
+	ret := _mock.Called(bytes)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Unmarshal")
+	}
+
+	var r0 *model.Span
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]byte) (*model.Span, error)); ok {
+		return returnFunc(bytes)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]byte) *model.Span); ok {
+		r0 = returnFunc(bytes)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Span)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = returnFunc(bytes)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Unmarshaller_Unmarshal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unmarshal'
+type Unmarshaller_Unmarshal_Call struct {
+	*mock.Call
+}
+
+// Unmarshal is a helper method to define mock.On call
+//   - bytes
+func (_e *Unmarshaller_Expecter) Unmarshal(bytes interface{}) *Unmarshaller_Unmarshal_Call {
+	return &Unmarshaller_Unmarshal_Call{Call: _e.mock.On("Unmarshal", bytes)}
+}
+
+func (_c *Unmarshaller_Unmarshal_Call) Run(run func(bytes []byte)) *Unmarshaller_Unmarshal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]byte))
+	})
+	return _c
+}
+
+func (_c *Unmarshaller_Unmarshal_Call) Return(span *model.Span, err error) *Unmarshaller_Unmarshal_Call {
+	_c.Call.Return(span, err)
+	return _c
+}
+
+func (_c *Unmarshaller_Unmarshal_Call) RunAndReturn(run func(bytes []byte) (*model.Span, error)) *Unmarshaller_Unmarshal_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/v1/mocks/ArchiveCapable.go b/internal/storage/v1/mocks/ArchiveCapable.go
deleted file mode 100644
index c5907dc4..00000000
--- a/internal/storage/v1/mocks/ArchiveCapable.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// ArchiveCapable is an autogenerated mock type for the ArchiveCapable type
-type ArchiveCapable struct {
-	mock.Mock
-}
-
-type ArchiveCapable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *ArchiveCapable) EXPECT() *ArchiveCapable_Expecter {
-	return &ArchiveCapable_Expecter{mock: &_m.Mock}
-}
-
-// IsArchiveCapable provides a mock function with no fields
-func (_m *ArchiveCapable) IsArchiveCapable() bool {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for IsArchiveCapable")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// ArchiveCapable_IsArchiveCapable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsArchiveCapable'
-type ArchiveCapable_IsArchiveCapable_Call struct {
-	*mock.Call
-}
-
-// IsArchiveCapable is a helper method to define mock.On call
-func (_e *ArchiveCapable_Expecter) IsArchiveCapable() *ArchiveCapable_IsArchiveCapable_Call {
-	return &ArchiveCapable_IsArchiveCapable_Call{Call: _e.mock.On("IsArchiveCapable")}
-}
-
-func (_c *ArchiveCapable_IsArchiveCapable_Call) Run(run func()) *ArchiveCapable_IsArchiveCapable_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *ArchiveCapable_IsArchiveCapable_Call) Return(_a0 bool) *ArchiveCapable_IsArchiveCapable_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *ArchiveCapable_IsArchiveCapable_Call) RunAndReturn(run func() bool) *ArchiveCapable_IsArchiveCapable_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewArchiveCapable creates a new instance of ArchiveCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewArchiveCapable(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ArchiveCapable {
-	mock := &ArchiveCapable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/BaseFactory.go b/internal/storage/v1/mocks/BaseFactory.go
deleted file mode 100644
index 740925ba..00000000
--- a/internal/storage/v1/mocks/BaseFactory.go
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	dependencystore "github.com/jaegertracing/jaeger/internal/storage/v1/api/dependencystore"
-	mock "github.com/stretchr/testify/mock"
-
-	spanstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore"
-)
-
-// BaseFactory is an autogenerated mock type for the BaseFactory type
-type BaseFactory struct {
-	mock.Mock
-}
-
-type BaseFactory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *BaseFactory) EXPECT() *BaseFactory_Expecter {
-	return &BaseFactory_Expecter{mock: &_m.Mock}
-}
-
-// CreateDependencyReader provides a mock function with no fields
-func (_m *BaseFactory) CreateDependencyReader() (dependencystore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateDependencyReader")
-	}
-
-	var r0 dependencystore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (dependencystore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() dependencystore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(dependencystore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// BaseFactory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
-type BaseFactory_CreateDependencyReader_Call struct {
-	*mock.Call
-}
-
-// CreateDependencyReader is a helper method to define mock.On call
-func (_e *BaseFactory_Expecter) CreateDependencyReader() *BaseFactory_CreateDependencyReader_Call {
-	return &BaseFactory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
-}
-
-func (_c *BaseFactory_CreateDependencyReader_Call) Run(run func()) *BaseFactory_CreateDependencyReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *BaseFactory_CreateDependencyReader_Call) Return(_a0 dependencystore.Reader, _a1 error) *BaseFactory_CreateDependencyReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *BaseFactory_CreateDependencyReader_Call) RunAndReturn(run func() (dependencystore.Reader, error)) *BaseFactory_CreateDependencyReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSpanReader provides a mock function with no fields
-func (_m *BaseFactory) CreateSpanReader() (spanstore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSpanReader")
-	}
-
-	var r0 spanstore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (spanstore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() spanstore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(spanstore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// BaseFactory_CreateSpanReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanReader'
-type BaseFactory_CreateSpanReader_Call struct {
-	*mock.Call
-}
-
-// CreateSpanReader is a helper method to define mock.On call
-func (_e *BaseFactory_Expecter) CreateSpanReader() *BaseFactory_CreateSpanReader_Call {
-	return &BaseFactory_CreateSpanReader_Call{Call: _e.mock.On("CreateSpanReader")}
-}
-
-func (_c *BaseFactory_CreateSpanReader_Call) Run(run func()) *BaseFactory_CreateSpanReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *BaseFactory_CreateSpanReader_Call) Return(_a0 spanstore.Reader, _a1 error) *BaseFactory_CreateSpanReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *BaseFactory_CreateSpanReader_Call) RunAndReturn(run func() (spanstore.Reader, error)) *BaseFactory_CreateSpanReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSpanWriter provides a mock function with no fields
-func (_m *BaseFactory) CreateSpanWriter() (spanstore.Writer, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSpanWriter")
-	}
-
-	var r0 spanstore.Writer
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (spanstore.Writer, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() spanstore.Writer); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(spanstore.Writer)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// BaseFactory_CreateSpanWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanWriter'
-type BaseFactory_CreateSpanWriter_Call struct {
-	*mock.Call
-}
-
-// CreateSpanWriter is a helper method to define mock.On call
-func (_e *BaseFactory_Expecter) CreateSpanWriter() *BaseFactory_CreateSpanWriter_Call {
-	return &BaseFactory_CreateSpanWriter_Call{Call: _e.mock.On("CreateSpanWriter")}
-}
-
-func (_c *BaseFactory_CreateSpanWriter_Call) Run(run func()) *BaseFactory_CreateSpanWriter_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *BaseFactory_CreateSpanWriter_Call) Return(_a0 spanstore.Writer, _a1 error) *BaseFactory_CreateSpanWriter_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *BaseFactory_CreateSpanWriter_Call) RunAndReturn(run func() (spanstore.Writer, error)) *BaseFactory_CreateSpanWriter_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewBaseFactory creates a new instance of BaseFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewBaseFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *BaseFactory {
-	mock := &BaseFactory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/Configurable.go b/internal/storage/v1/mocks/Configurable.go
deleted file mode 100644
index ba21a993..00000000
--- a/internal/storage/v1/mocks/Configurable.go
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	flag "flag"
-
-	mock "github.com/stretchr/testify/mock"
-
-	viper "github.com/spf13/viper"
-
-	zap "go.uber.org/zap"
-)
-
-// Configurable is an autogenerated mock type for the Configurable type
-type Configurable struct {
-	mock.Mock
-}
-
-type Configurable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Configurable) EXPECT() *Configurable_Expecter {
-	return &Configurable_Expecter{mock: &_m.Mock}
-}
-
-// AddFlags provides a mock function with given fields: flagSet
-func (_m *Configurable) AddFlags(flagSet *flag.FlagSet) {
-	_m.Called(flagSet)
-}
-
-// Configurable_AddFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFlags'
-type Configurable_AddFlags_Call struct {
-	*mock.Call
-}
-
-// AddFlags is a helper method to define mock.On call
-//   - flagSet *flag.FlagSet
-func (_e *Configurable_Expecter) AddFlags(flagSet interface{}) *Configurable_AddFlags_Call {
-	return &Configurable_AddFlags_Call{Call: _e.mock.On("AddFlags", flagSet)}
-}
-
-func (_c *Configurable_AddFlags_Call) Run(run func(flagSet *flag.FlagSet)) *Configurable_AddFlags_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*flag.FlagSet))
-	})
-	return _c
-}
-
-func (_c *Configurable_AddFlags_Call) Return() *Configurable_AddFlags_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *Configurable_AddFlags_Call) RunAndReturn(run func(*flag.FlagSet)) *Configurable_AddFlags_Call {
-	_c.Run(run)
-	return _c
-}
-
-// InitFromViper provides a mock function with given fields: v, logger
-func (_m *Configurable) InitFromViper(v *viper.Viper, logger *zap.Logger) {
-	_m.Called(v, logger)
-}
-
-// Configurable_InitFromViper_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitFromViper'
-type Configurable_InitFromViper_Call struct {
-	*mock.Call
-}
-
-// InitFromViper is a helper method to define mock.On call
-//   - v *viper.Viper
-//   - logger *zap.Logger
-func (_e *Configurable_Expecter) InitFromViper(v interface{}, logger interface{}) *Configurable_InitFromViper_Call {
-	return &Configurable_InitFromViper_Call{Call: _e.mock.On("InitFromViper", v, logger)}
-}
-
-func (_c *Configurable_InitFromViper_Call) Run(run func(v *viper.Viper, logger *zap.Logger)) *Configurable_InitFromViper_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*viper.Viper), args[1].(*zap.Logger))
-	})
-	return _c
-}
-
-func (_c *Configurable_InitFromViper_Call) Return() *Configurable_InitFromViper_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *Configurable_InitFromViper_Call) RunAndReturn(run func(*viper.Viper, *zap.Logger)) *Configurable_InitFromViper_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewConfigurable creates a new instance of Configurable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewConfigurable(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Configurable {
-	mock := &Configurable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/Factory.go b/internal/storage/v1/mocks/Factory.go
deleted file mode 100644
index 378cf4fb..00000000
--- a/internal/storage/v1/mocks/Factory.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	metrics "github.com/jaegertracing/jaeger/internal/metrics"
-	dependencystore "github.com/jaegertracing/jaeger/internal/storage/v1/api/dependencystore"
-
-	mock "github.com/stretchr/testify/mock"
-
-	spanstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore"
-
-	zap "go.uber.org/zap"
-)
-
-// Factory is an autogenerated mock type for the Factory type
-type Factory struct {
-	mock.Mock
-}
-
-type Factory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Factory) EXPECT() *Factory_Expecter {
-	return &Factory_Expecter{mock: &_m.Mock}
-}
-
-// CreateDependencyReader provides a mock function with no fields
-func (_m *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateDependencyReader")
-	}
-
-	var r0 dependencystore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (dependencystore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() dependencystore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(dependencystore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
-type Factory_CreateDependencyReader_Call struct {
-	*mock.Call
-}
-
-// CreateDependencyReader is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateDependencyReader() *Factory_CreateDependencyReader_Call {
-	return &Factory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
-}
-
-func (_c *Factory_CreateDependencyReader_Call) Run(run func()) *Factory_CreateDependencyReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateDependencyReader_Call) Return(_a0 dependencystore.Reader, _a1 error) *Factory_CreateDependencyReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateDependencyReader_Call) RunAndReturn(run func() (dependencystore.Reader, error)) *Factory_CreateDependencyReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSpanReader provides a mock function with no fields
-func (_m *Factory) CreateSpanReader() (spanstore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSpanReader")
-	}
-
-	var r0 spanstore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (spanstore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() spanstore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(spanstore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateSpanReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanReader'
-type Factory_CreateSpanReader_Call struct {
-	*mock.Call
-}
-
-// CreateSpanReader is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateSpanReader() *Factory_CreateSpanReader_Call {
-	return &Factory_CreateSpanReader_Call{Call: _e.mock.On("CreateSpanReader")}
-}
-
-func (_c *Factory_CreateSpanReader_Call) Run(run func()) *Factory_CreateSpanReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateSpanReader_Call) Return(_a0 spanstore.Reader, _a1 error) *Factory_CreateSpanReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateSpanReader_Call) RunAndReturn(run func() (spanstore.Reader, error)) *Factory_CreateSpanReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSpanWriter provides a mock function with no fields
-func (_m *Factory) CreateSpanWriter() (spanstore.Writer, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSpanWriter")
-	}
-
-	var r0 spanstore.Writer
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (spanstore.Writer, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() spanstore.Writer); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(spanstore.Writer)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateSpanWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanWriter'
-type Factory_CreateSpanWriter_Call struct {
-	*mock.Call
-}
-
-// CreateSpanWriter is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateSpanWriter() *Factory_CreateSpanWriter_Call {
-	return &Factory_CreateSpanWriter_Call{Call: _e.mock.On("CreateSpanWriter")}
-}
-
-func (_c *Factory_CreateSpanWriter_Call) Run(run func()) *Factory_CreateSpanWriter_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateSpanWriter_Call) Return(_a0 spanstore.Writer, _a1 error) *Factory_CreateSpanWriter_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateSpanWriter_Call) RunAndReturn(run func() (spanstore.Writer, error)) *Factory_CreateSpanWriter_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Initialize provides a mock function with given fields: metricsFactory, logger
-func (_m *Factory) Initialize(metricsFactory metrics.Factory, logger *zap.Logger) error {
-	ret := _m.Called(metricsFactory, logger)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Initialize")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(metrics.Factory, *zap.Logger) error); ok {
-		r0 = rf(metricsFactory, logger)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Factory_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
-type Factory_Initialize_Call struct {
-	*mock.Call
-}
-
-// Initialize is a helper method to define mock.On call
-//   - metricsFactory metrics.Factory
-//   - logger *zap.Logger
-func (_e *Factory_Expecter) Initialize(metricsFactory interface{}, logger interface{}) *Factory_Initialize_Call {
-	return &Factory_Initialize_Call{Call: _e.mock.On("Initialize", metricsFactory, logger)}
-}
-
-func (_c *Factory_Initialize_Call) Run(run func(metricsFactory metrics.Factory, logger *zap.Logger)) *Factory_Initialize_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(metrics.Factory), args[1].(*zap.Logger))
-	})
-	return _c
-}
-
-func (_c *Factory_Initialize_Call) Return(_a0 error) *Factory_Initialize_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Factory_Initialize_Call) RunAndReturn(run func(metrics.Factory, *zap.Logger) error) *Factory_Initialize_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Factory {
-	mock := &Factory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/Inheritable.go b/internal/storage/v1/mocks/Inheritable.go
deleted file mode 100644
index 9c9e89c2..00000000
--- a/internal/storage/v1/mocks/Inheritable.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	storage "github.com/jaegertracing/jaeger/internal/storage/v1"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Inheritable is an autogenerated mock type for the Inheritable type
-type Inheritable struct {
-	mock.Mock
-}
-
-type Inheritable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Inheritable) EXPECT() *Inheritable_Expecter {
-	return &Inheritable_Expecter{mock: &_m.Mock}
-}
-
-// InheritSettingsFrom provides a mock function with given fields: other
-func (_m *Inheritable) InheritSettingsFrom(other storage.Factory) {
-	_m.Called(other)
-}
-
-// Inheritable_InheritSettingsFrom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InheritSettingsFrom'
-type Inheritable_InheritSettingsFrom_Call struct {
-	*mock.Call
-}
-
-// InheritSettingsFrom is a helper method to define mock.On call
-//   - other storage.Factory
-func (_e *Inheritable_Expecter) InheritSettingsFrom(other interface{}) *Inheritable_InheritSettingsFrom_Call {
-	return &Inheritable_InheritSettingsFrom_Call{Call: _e.mock.On("InheritSettingsFrom", other)}
-}
-
-func (_c *Inheritable_InheritSettingsFrom_Call) Run(run func(other storage.Factory)) *Inheritable_InheritSettingsFrom_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(storage.Factory))
-	})
-	return _c
-}
-
-func (_c *Inheritable_InheritSettingsFrom_Call) Return() *Inheritable_InheritSettingsFrom_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *Inheritable_InheritSettingsFrom_Call) RunAndReturn(run func(storage.Factory)) *Inheritable_InheritSettingsFrom_Call {
-	_c.Run(run)
-	return _c
-}
-
-// NewInheritable creates a new instance of Inheritable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewInheritable(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Inheritable {
-	mock := &Inheritable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/MetricStoreFactory.go b/internal/storage/v1/mocks/MetricStoreFactory.go
deleted file mode 100644
index a8764f59..00000000
--- a/internal/storage/v1/mocks/MetricStoreFactory.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	metricstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore"
-	mock "github.com/stretchr/testify/mock"
-
-	telemetry "github.com/jaegertracing/jaeger/internal/telemetry"
-)
-
-// MetricStoreFactory is an autogenerated mock type for the MetricStoreFactory type
-type MetricStoreFactory struct {
-	mock.Mock
-}
-
-type MetricStoreFactory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MetricStoreFactory) EXPECT() *MetricStoreFactory_Expecter {
-	return &MetricStoreFactory_Expecter{mock: &_m.Mock}
-}
-
-// CreateMetricsReader provides a mock function with no fields
-func (_m *MetricStoreFactory) CreateMetricsReader() (metricstore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateMetricsReader")
-	}
-
-	var r0 metricstore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metricstore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metricstore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metricstore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// MetricStoreFactory_CreateMetricsReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMetricsReader'
-type MetricStoreFactory_CreateMetricsReader_Call struct {
-	*mock.Call
-}
-
-// CreateMetricsReader is a helper method to define mock.On call
-func (_e *MetricStoreFactory_Expecter) CreateMetricsReader() *MetricStoreFactory_CreateMetricsReader_Call {
-	return &MetricStoreFactory_CreateMetricsReader_Call{Call: _e.mock.On("CreateMetricsReader")}
-}
-
-func (_c *MetricStoreFactory_CreateMetricsReader_Call) Run(run func()) *MetricStoreFactory_CreateMetricsReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MetricStoreFactory_CreateMetricsReader_Call) Return(_a0 metricstore.Reader, _a1 error) *MetricStoreFactory_CreateMetricsReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *MetricStoreFactory_CreateMetricsReader_Call) RunAndReturn(run func() (metricstore.Reader, error)) *MetricStoreFactory_CreateMetricsReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Initialize provides a mock function with given fields: telset
-func (_m *MetricStoreFactory) Initialize(telset telemetry.Settings) error {
-	ret := _m.Called(telset)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Initialize")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(telemetry.Settings) error); ok {
-		r0 = rf(telset)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// MetricStoreFactory_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
-type MetricStoreFactory_Initialize_Call struct {
-	*mock.Call
-}
-
-// Initialize is a helper method to define mock.On call
-//   - telset telemetry.Settings
-func (_e *MetricStoreFactory_Expecter) Initialize(telset interface{}) *MetricStoreFactory_Initialize_Call {
-	return &MetricStoreFactory_Initialize_Call{Call: _e.mock.On("Initialize", telset)}
-}
-
-func (_c *MetricStoreFactory_Initialize_Call) Run(run func(telset telemetry.Settings)) *MetricStoreFactory_Initialize_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(telemetry.Settings))
-	})
-	return _c
-}
-
-func (_c *MetricStoreFactory_Initialize_Call) Return(_a0 error) *MetricStoreFactory_Initialize_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MetricStoreFactory_Initialize_Call) RunAndReturn(run func(telemetry.Settings) error) *MetricStoreFactory_Initialize_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewMetricStoreFactory creates a new instance of MetricStoreFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMetricStoreFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MetricStoreFactory {
-	mock := &MetricStoreFactory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/Purger.go b/internal/storage/v1/mocks/Purger.go
deleted file mode 100644
index ed75f105..00000000
--- a/internal/storage/v1/mocks/Purger.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Purger is an autogenerated mock type for the Purger type
-type Purger struct {
-	mock.Mock
-}
-
-type Purger_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Purger) EXPECT() *Purger_Expecter {
-	return &Purger_Expecter{mock: &_m.Mock}
-}
-
-// Purge provides a mock function with given fields: _a0
-func (_m *Purger) Purge(_a0 context.Context) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Purge")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Purger_Purge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Purge'
-type Purger_Purge_Call struct {
-	*mock.Call
-}
-
-// Purge is a helper method to define mock.On call
-//   - _a0 context.Context
-func (_e *Purger_Expecter) Purge(_a0 interface{}) *Purger_Purge_Call {
-	return &Purger_Purge_Call{Call: _e.mock.On("Purge", _a0)}
-}
-
-func (_c *Purger_Purge_Call) Run(run func(_a0 context.Context)) *Purger_Purge_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *Purger_Purge_Call) Return(_a0 error) *Purger_Purge_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Purger_Purge_Call) RunAndReturn(run func(context.Context) error) *Purger_Purge_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewPurger creates a new instance of Purger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewPurger(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Purger {
-	mock := &Purger{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/SamplingStoreFactory.go b/internal/storage/v1/mocks/SamplingStoreFactory.go
deleted file mode 100644
index 8aa25b40..00000000
--- a/internal/storage/v1/mocks/SamplingStoreFactory.go
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	distributedlock "github.com/jaegertracing/jaeger/internal/distributedlock"
-	mock "github.com/stretchr/testify/mock"
-
-	samplingstore "github.com/jaegertracing/jaeger/internal/storage/v1/api/samplingstore"
-)
-
-// SamplingStoreFactory is an autogenerated mock type for the SamplingStoreFactory type
-type SamplingStoreFactory struct {
-	mock.Mock
-}
-
-type SamplingStoreFactory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SamplingStoreFactory) EXPECT() *SamplingStoreFactory_Expecter {
-	return &SamplingStoreFactory_Expecter{mock: &_m.Mock}
-}
-
-// CreateLock provides a mock function with no fields
-func (_m *SamplingStoreFactory) CreateLock() (distributedlock.Lock, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateLock")
-	}
-
-	var r0 distributedlock.Lock
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (distributedlock.Lock, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() distributedlock.Lock); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(distributedlock.Lock)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SamplingStoreFactory_CreateLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLock'
-type SamplingStoreFactory_CreateLock_Call struct {
-	*mock.Call
-}
-
-// CreateLock is a helper method to define mock.On call
-func (_e *SamplingStoreFactory_Expecter) CreateLock() *SamplingStoreFactory_CreateLock_Call {
-	return &SamplingStoreFactory_CreateLock_Call{Call: _e.mock.On("CreateLock")}
-}
-
-func (_c *SamplingStoreFactory_CreateLock_Call) Run(run func()) *SamplingStoreFactory_CreateLock_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SamplingStoreFactory_CreateLock_Call) Return(_a0 distributedlock.Lock, _a1 error) *SamplingStoreFactory_CreateLock_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SamplingStoreFactory_CreateLock_Call) RunAndReturn(run func() (distributedlock.Lock, error)) *SamplingStoreFactory_CreateLock_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateSamplingStore provides a mock function with given fields: maxBuckets
-func (_m *SamplingStoreFactory) CreateSamplingStore(maxBuckets int) (samplingstore.Store, error) {
-	ret := _m.Called(maxBuckets)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateSamplingStore")
-	}
-
-	var r0 samplingstore.Store
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int) (samplingstore.Store, error)); ok {
-		return rf(maxBuckets)
-	}
-	if rf, ok := ret.Get(0).(func(int) samplingstore.Store); ok {
-		r0 = rf(maxBuckets)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(samplingstore.Store)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(int) error); ok {
-		r1 = rf(maxBuckets)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SamplingStoreFactory_CreateSamplingStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSamplingStore'
-type SamplingStoreFactory_CreateSamplingStore_Call struct {
-	*mock.Call
-}
-
-// CreateSamplingStore is a helper method to define mock.On call
-//   - maxBuckets int
-func (_e *SamplingStoreFactory_Expecter) CreateSamplingStore(maxBuckets interface{}) *SamplingStoreFactory_CreateSamplingStore_Call {
-	return &SamplingStoreFactory_CreateSamplingStore_Call{Call: _e.mock.On("CreateSamplingStore", maxBuckets)}
-}
-
-func (_c *SamplingStoreFactory_CreateSamplingStore_Call) Run(run func(maxBuckets int)) *SamplingStoreFactory_CreateSamplingStore_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(int))
-	})
-	return _c
-}
-
-func (_c *SamplingStoreFactory_CreateSamplingStore_Call) Return(_a0 samplingstore.Store, _a1 error) *SamplingStoreFactory_CreateSamplingStore_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SamplingStoreFactory_CreateSamplingStore_Call) RunAndReturn(run func(int) (samplingstore.Store, error)) *SamplingStoreFactory_CreateSamplingStore_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewSamplingStoreFactory creates a new instance of SamplingStoreFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSamplingStoreFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SamplingStoreFactory {
-	mock := &SamplingStoreFactory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v1/mocks/mocks.go b/internal/storage/v1/mocks/mocks.go
new file mode 100644
index 00000000..1b298080
--- /dev/null
+++ b/internal/storage/v1/mocks/mocks.go
@@ -0,0 +1,1021 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+	"flag"
+
+	"github.com/jaegertracing/jaeger/internal/distributedlock"
+	"github.com/jaegertracing/jaeger/internal/metrics"
+	"github.com/jaegertracing/jaeger/internal/storage/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/dependencystore"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/samplingstore"
+	"github.com/jaegertracing/jaeger/internal/storage/v1/api/spanstore"
+	"github.com/jaegertracing/jaeger/internal/telemetry"
+	"github.com/spf13/viper"
+	mock "github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
+)
+
+// NewConfigurable creates a new instance of Configurable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewConfigurable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Configurable {
+	mock := &Configurable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Configurable is an autogenerated mock type for the Configurable type
+type Configurable struct {
+	mock.Mock
+}
+
+type Configurable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Configurable) EXPECT() *Configurable_Expecter {
+	return &Configurable_Expecter{mock: &_m.Mock}
+}
+
+// AddFlags provides a mock function for the type Configurable
+func (_mock *Configurable) AddFlags(flagSet *flag.FlagSet) {
+	_mock.Called(flagSet)
+	return
+}
+
+// Configurable_AddFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFlags'
+type Configurable_AddFlags_Call struct {
+	*mock.Call
+}
+
+// AddFlags is a helper method to define mock.On call
+//   - flagSet
+func (_e *Configurable_Expecter) AddFlags(flagSet interface{}) *Configurable_AddFlags_Call {
+	return &Configurable_AddFlags_Call{Call: _e.mock.On("AddFlags", flagSet)}
+}
+
+func (_c *Configurable_AddFlags_Call) Run(run func(flagSet *flag.FlagSet)) *Configurable_AddFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*flag.FlagSet))
+	})
+	return _c
+}
+
+func (_c *Configurable_AddFlags_Call) Return() *Configurable_AddFlags_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *Configurable_AddFlags_Call) RunAndReturn(run func(flagSet *flag.FlagSet)) *Configurable_AddFlags_Call {
+	_c.Run(run)
+	return _c
+}
+
+// InitFromViper provides a mock function for the type Configurable
+func (_mock *Configurable) InitFromViper(v *viper.Viper, logger *zap.Logger) {
+	_mock.Called(v, logger)
+	return
+}
+
+// Configurable_InitFromViper_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitFromViper'
+type Configurable_InitFromViper_Call struct {
+	*mock.Call
+}
+
+// InitFromViper is a helper method to define mock.On call
+//   - v
+//   - logger
+func (_e *Configurable_Expecter) InitFromViper(v interface{}, logger interface{}) *Configurable_InitFromViper_Call {
+	return &Configurable_InitFromViper_Call{Call: _e.mock.On("InitFromViper", v, logger)}
+}
+
+func (_c *Configurable_InitFromViper_Call) Run(run func(v *viper.Viper, logger *zap.Logger)) *Configurable_InitFromViper_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*viper.Viper), args[1].(*zap.Logger))
+	})
+	return _c
+}
+
+func (_c *Configurable_InitFromViper_Call) Return() *Configurable_InitFromViper_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *Configurable_InitFromViper_Call) RunAndReturn(run func(v *viper.Viper, logger *zap.Logger)) *Configurable_InitFromViper_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewBaseFactory creates a new instance of BaseFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewBaseFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *BaseFactory {
+	mock := &BaseFactory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// BaseFactory is an autogenerated mock type for the BaseFactory type
+type BaseFactory struct {
+	mock.Mock
+}
+
+type BaseFactory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *BaseFactory) EXPECT() *BaseFactory_Expecter {
+	return &BaseFactory_Expecter{mock: &_m.Mock}
+}
+
+// CreateDependencyReader provides a mock function for the type BaseFactory
+func (_mock *BaseFactory) CreateDependencyReader() (dependencystore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateDependencyReader")
+	}
+
+	var r0 dependencystore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (dependencystore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() dependencystore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(dependencystore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BaseFactory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
+type BaseFactory_CreateDependencyReader_Call struct {
+	*mock.Call
+}
+
+// CreateDependencyReader is a helper method to define mock.On call
+func (_e *BaseFactory_Expecter) CreateDependencyReader() *BaseFactory_CreateDependencyReader_Call {
+	return &BaseFactory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
+}
+
+func (_c *BaseFactory_CreateDependencyReader_Call) Run(run func()) *BaseFactory_CreateDependencyReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *BaseFactory_CreateDependencyReader_Call) Return(reader dependencystore.Reader, err error) *BaseFactory_CreateDependencyReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *BaseFactory_CreateDependencyReader_Call) RunAndReturn(run func() (dependencystore.Reader, error)) *BaseFactory_CreateDependencyReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateSpanReader provides a mock function for the type BaseFactory
+func (_mock *BaseFactory) CreateSpanReader() (spanstore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateSpanReader")
+	}
+
+	var r0 spanstore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (spanstore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() spanstore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(spanstore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BaseFactory_CreateSpanReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanReader'
+type BaseFactory_CreateSpanReader_Call struct {
+	*mock.Call
+}
+
+// CreateSpanReader is a helper method to define mock.On call
+func (_e *BaseFactory_Expecter) CreateSpanReader() *BaseFactory_CreateSpanReader_Call {
+	return &BaseFactory_CreateSpanReader_Call{Call: _e.mock.On("CreateSpanReader")}
+}
+
+func (_c *BaseFactory_CreateSpanReader_Call) Run(run func()) *BaseFactory_CreateSpanReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *BaseFactory_CreateSpanReader_Call) Return(reader spanstore.Reader, err error) *BaseFactory_CreateSpanReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *BaseFactory_CreateSpanReader_Call) RunAndReturn(run func() (spanstore.Reader, error)) *BaseFactory_CreateSpanReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateSpanWriter provides a mock function for the type BaseFactory
+func (_mock *BaseFactory) CreateSpanWriter() (spanstore.Writer, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateSpanWriter")
+	}
+
+	var r0 spanstore.Writer
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (spanstore.Writer, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() spanstore.Writer); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(spanstore.Writer)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BaseFactory_CreateSpanWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanWriter'
+type BaseFactory_CreateSpanWriter_Call struct {
+	*mock.Call
+}
+
+// CreateSpanWriter is a helper method to define mock.On call
+func (_e *BaseFactory_Expecter) CreateSpanWriter() *BaseFactory_CreateSpanWriter_Call {
+	return &BaseFactory_CreateSpanWriter_Call{Call: _e.mock.On("CreateSpanWriter")}
+}
+
+func (_c *BaseFactory_CreateSpanWriter_Call) Run(run func()) *BaseFactory_CreateSpanWriter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *BaseFactory_CreateSpanWriter_Call) Return(writer spanstore.Writer, err error) *BaseFactory_CreateSpanWriter_Call {
+	_c.Call.Return(writer, err)
+	return _c
+}
+
+func (_c *BaseFactory_CreateSpanWriter_Call) RunAndReturn(run func() (spanstore.Writer, error)) *BaseFactory_CreateSpanWriter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Factory {
+	mock := &Factory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Factory is an autogenerated mock type for the Factory type
+type Factory struct {
+	mock.Mock
+}
+
+type Factory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Factory) EXPECT() *Factory_Expecter {
+	return &Factory_Expecter{mock: &_m.Mock}
+}
+
+// CreateDependencyReader provides a mock function for the type Factory
+func (_mock *Factory) CreateDependencyReader() (dependencystore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateDependencyReader")
+	}
+
+	var r0 dependencystore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (dependencystore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() dependencystore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(dependencystore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
+type Factory_CreateDependencyReader_Call struct {
+	*mock.Call
+}
+
+// CreateDependencyReader is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateDependencyReader() *Factory_CreateDependencyReader_Call {
+	return &Factory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
+}
+
+func (_c *Factory_CreateDependencyReader_Call) Run(run func()) *Factory_CreateDependencyReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateDependencyReader_Call) Return(reader dependencystore.Reader, err error) *Factory_CreateDependencyReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *Factory_CreateDependencyReader_Call) RunAndReturn(run func() (dependencystore.Reader, error)) *Factory_CreateDependencyReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateSpanReader provides a mock function for the type Factory
+func (_mock *Factory) CreateSpanReader() (spanstore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateSpanReader")
+	}
+
+	var r0 spanstore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (spanstore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() spanstore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(spanstore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateSpanReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanReader'
+type Factory_CreateSpanReader_Call struct {
+	*mock.Call
+}
+
+// CreateSpanReader is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateSpanReader() *Factory_CreateSpanReader_Call {
+	return &Factory_CreateSpanReader_Call{Call: _e.mock.On("CreateSpanReader")}
+}
+
+func (_c *Factory_CreateSpanReader_Call) Run(run func()) *Factory_CreateSpanReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateSpanReader_Call) Return(reader spanstore.Reader, err error) *Factory_CreateSpanReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *Factory_CreateSpanReader_Call) RunAndReturn(run func() (spanstore.Reader, error)) *Factory_CreateSpanReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateSpanWriter provides a mock function for the type Factory
+func (_mock *Factory) CreateSpanWriter() (spanstore.Writer, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateSpanWriter")
+	}
+
+	var r0 spanstore.Writer
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (spanstore.Writer, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() spanstore.Writer); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(spanstore.Writer)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateSpanWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpanWriter'
+type Factory_CreateSpanWriter_Call struct {
+	*mock.Call
+}
+
+// CreateSpanWriter is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateSpanWriter() *Factory_CreateSpanWriter_Call {
+	return &Factory_CreateSpanWriter_Call{Call: _e.mock.On("CreateSpanWriter")}
+}
+
+func (_c *Factory_CreateSpanWriter_Call) Run(run func()) *Factory_CreateSpanWriter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateSpanWriter_Call) Return(writer spanstore.Writer, err error) *Factory_CreateSpanWriter_Call {
+	_c.Call.Return(writer, err)
+	return _c
+}
+
+func (_c *Factory_CreateSpanWriter_Call) RunAndReturn(run func() (spanstore.Writer, error)) *Factory_CreateSpanWriter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Initialize provides a mock function for the type Factory
+func (_mock *Factory) Initialize(metricsFactory metrics.Factory, logger *zap.Logger) error {
+	ret := _mock.Called(metricsFactory, logger)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Initialize")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(metrics.Factory, *zap.Logger) error); ok {
+		r0 = returnFunc(metricsFactory, logger)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Factory_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
+type Factory_Initialize_Call struct {
+	*mock.Call
+}
+
+// Initialize is a helper method to define mock.On call
+//   - metricsFactory
+//   - logger
+func (_e *Factory_Expecter) Initialize(metricsFactory interface{}, logger interface{}) *Factory_Initialize_Call {
+	return &Factory_Initialize_Call{Call: _e.mock.On("Initialize", metricsFactory, logger)}
+}
+
+func (_c *Factory_Initialize_Call) Run(run func(metricsFactory metrics.Factory, logger *zap.Logger)) *Factory_Initialize_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(metrics.Factory), args[1].(*zap.Logger))
+	})
+	return _c
+}
+
+func (_c *Factory_Initialize_Call) Return(err error) *Factory_Initialize_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Factory_Initialize_Call) RunAndReturn(run func(metricsFactory metrics.Factory, logger *zap.Logger) error) *Factory_Initialize_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewPurger creates a new instance of Purger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewPurger(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Purger {
+	mock := &Purger{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Purger is an autogenerated mock type for the Purger type
+type Purger struct {
+	mock.Mock
+}
+
+type Purger_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Purger) EXPECT() *Purger_Expecter {
+	return &Purger_Expecter{mock: &_m.Mock}
+}
+
+// Purge provides a mock function for the type Purger
+func (_mock *Purger) Purge(context1 context.Context) error {
+	ret := _mock.Called(context1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Purge")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = returnFunc(context1)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Purger_Purge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Purge'
+type Purger_Purge_Call struct {
+	*mock.Call
+}
+
+// Purge is a helper method to define mock.On call
+//   - context1
+func (_e *Purger_Expecter) Purge(context1 interface{}) *Purger_Purge_Call {
+	return &Purger_Purge_Call{Call: _e.mock.On("Purge", context1)}
+}
+
+func (_c *Purger_Purge_Call) Run(run func(context1 context.Context)) *Purger_Purge_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *Purger_Purge_Call) Return(err error) *Purger_Purge_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Purger_Purge_Call) RunAndReturn(run func(context1 context.Context) error) *Purger_Purge_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewSamplingStoreFactory creates a new instance of SamplingStoreFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSamplingStoreFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SamplingStoreFactory {
+	mock := &SamplingStoreFactory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// SamplingStoreFactory is an autogenerated mock type for the SamplingStoreFactory type
+type SamplingStoreFactory struct {
+	mock.Mock
+}
+
+type SamplingStoreFactory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SamplingStoreFactory) EXPECT() *SamplingStoreFactory_Expecter {
+	return &SamplingStoreFactory_Expecter{mock: &_m.Mock}
+}
+
+// CreateLock provides a mock function for the type SamplingStoreFactory
+func (_mock *SamplingStoreFactory) CreateLock() (distributedlock.Lock, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateLock")
+	}
+
+	var r0 distributedlock.Lock
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (distributedlock.Lock, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() distributedlock.Lock); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(distributedlock.Lock)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SamplingStoreFactory_CreateLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLock'
+type SamplingStoreFactory_CreateLock_Call struct {
+	*mock.Call
+}
+
+// CreateLock is a helper method to define mock.On call
+func (_e *SamplingStoreFactory_Expecter) CreateLock() *SamplingStoreFactory_CreateLock_Call {
+	return &SamplingStoreFactory_CreateLock_Call{Call: _e.mock.On("CreateLock")}
+}
+
+func (_c *SamplingStoreFactory_CreateLock_Call) Run(run func()) *SamplingStoreFactory_CreateLock_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SamplingStoreFactory_CreateLock_Call) Return(lock distributedlock.Lock, err error) *SamplingStoreFactory_CreateLock_Call {
+	_c.Call.Return(lock, err)
+	return _c
+}
+
+func (_c *SamplingStoreFactory_CreateLock_Call) RunAndReturn(run func() (distributedlock.Lock, error)) *SamplingStoreFactory_CreateLock_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateSamplingStore provides a mock function for the type SamplingStoreFactory
+func (_mock *SamplingStoreFactory) CreateSamplingStore(maxBuckets int) (samplingstore.Store, error) {
+	ret := _mock.Called(maxBuckets)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateSamplingStore")
+	}
+
+	var r0 samplingstore.Store
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(int) (samplingstore.Store, error)); ok {
+		return returnFunc(maxBuckets)
+	}
+	if returnFunc, ok := ret.Get(0).(func(int) samplingstore.Store); ok {
+		r0 = returnFunc(maxBuckets)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(samplingstore.Store)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(int) error); ok {
+		r1 = returnFunc(maxBuckets)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// SamplingStoreFactory_CreateSamplingStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSamplingStore'
+type SamplingStoreFactory_CreateSamplingStore_Call struct {
+	*mock.Call
+}
+
+// CreateSamplingStore is a helper method to define mock.On call
+//   - maxBuckets
+func (_e *SamplingStoreFactory_Expecter) CreateSamplingStore(maxBuckets interface{}) *SamplingStoreFactory_CreateSamplingStore_Call {
+	return &SamplingStoreFactory_CreateSamplingStore_Call{Call: _e.mock.On("CreateSamplingStore", maxBuckets)}
+}
+
+func (_c *SamplingStoreFactory_CreateSamplingStore_Call) Run(run func(maxBuckets int)) *SamplingStoreFactory_CreateSamplingStore_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int))
+	})
+	return _c
+}
+
+func (_c *SamplingStoreFactory_CreateSamplingStore_Call) Return(store samplingstore.Store, err error) *SamplingStoreFactory_CreateSamplingStore_Call {
+	_c.Call.Return(store, err)
+	return _c
+}
+
+func (_c *SamplingStoreFactory_CreateSamplingStore_Call) RunAndReturn(run func(maxBuckets int) (samplingstore.Store, error)) *SamplingStoreFactory_CreateSamplingStore_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMetricStoreFactory creates a new instance of MetricStoreFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMetricStoreFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MetricStoreFactory {
+	mock := &MetricStoreFactory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MetricStoreFactory is an autogenerated mock type for the MetricStoreFactory type
+type MetricStoreFactory struct {
+	mock.Mock
+}
+
+type MetricStoreFactory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MetricStoreFactory) EXPECT() *MetricStoreFactory_Expecter {
+	return &MetricStoreFactory_Expecter{mock: &_m.Mock}
+}
+
+// CreateMetricsReader provides a mock function for the type MetricStoreFactory
+func (_mock *MetricStoreFactory) CreateMetricsReader() (metricstore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateMetricsReader")
+	}
+
+	var r0 metricstore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (metricstore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() metricstore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(metricstore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MetricStoreFactory_CreateMetricsReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMetricsReader'
+type MetricStoreFactory_CreateMetricsReader_Call struct {
+	*mock.Call
+}
+
+// CreateMetricsReader is a helper method to define mock.On call
+func (_e *MetricStoreFactory_Expecter) CreateMetricsReader() *MetricStoreFactory_CreateMetricsReader_Call {
+	return &MetricStoreFactory_CreateMetricsReader_Call{Call: _e.mock.On("CreateMetricsReader")}
+}
+
+func (_c *MetricStoreFactory_CreateMetricsReader_Call) Run(run func()) *MetricStoreFactory_CreateMetricsReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MetricStoreFactory_CreateMetricsReader_Call) Return(reader metricstore.Reader, err error) *MetricStoreFactory_CreateMetricsReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *MetricStoreFactory_CreateMetricsReader_Call) RunAndReturn(run func() (metricstore.Reader, error)) *MetricStoreFactory_CreateMetricsReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Initialize provides a mock function for the type MetricStoreFactory
+func (_mock *MetricStoreFactory) Initialize(telset telemetry.Settings) error {
+	ret := _mock.Called(telset)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Initialize")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(telemetry.Settings) error); ok {
+		r0 = returnFunc(telset)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MetricStoreFactory_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
+type MetricStoreFactory_Initialize_Call struct {
+	*mock.Call
+}
+
+// Initialize is a helper method to define mock.On call
+//   - telset
+func (_e *MetricStoreFactory_Expecter) Initialize(telset interface{}) *MetricStoreFactory_Initialize_Call {
+	return &MetricStoreFactory_Initialize_Call{Call: _e.mock.On("Initialize", telset)}
+}
+
+func (_c *MetricStoreFactory_Initialize_Call) Run(run func(telset telemetry.Settings)) *MetricStoreFactory_Initialize_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(telemetry.Settings))
+	})
+	return _c
+}
+
+func (_c *MetricStoreFactory_Initialize_Call) Return(err error) *MetricStoreFactory_Initialize_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MetricStoreFactory_Initialize_Call) RunAndReturn(run func(telset telemetry.Settings) error) *MetricStoreFactory_Initialize_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewInheritable creates a new instance of Inheritable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewInheritable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Inheritable {
+	mock := &Inheritable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Inheritable is an autogenerated mock type for the Inheritable type
+type Inheritable struct {
+	mock.Mock
+}
+
+type Inheritable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Inheritable) EXPECT() *Inheritable_Expecter {
+	return &Inheritable_Expecter{mock: &_m.Mock}
+}
+
+// InheritSettingsFrom provides a mock function for the type Inheritable
+func (_mock *Inheritable) InheritSettingsFrom(other storage.Factory) {
+	_mock.Called(other)
+	return
+}
+
+// Inheritable_InheritSettingsFrom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InheritSettingsFrom'
+type Inheritable_InheritSettingsFrom_Call struct {
+	*mock.Call
+}
+
+// InheritSettingsFrom is a helper method to define mock.On call
+//   - other
+func (_e *Inheritable_Expecter) InheritSettingsFrom(other interface{}) *Inheritable_InheritSettingsFrom_Call {
+	return &Inheritable_InheritSettingsFrom_Call{Call: _e.mock.On("InheritSettingsFrom", other)}
+}
+
+func (_c *Inheritable_InheritSettingsFrom_Call) Run(run func(other storage.Factory)) *Inheritable_InheritSettingsFrom_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(storage.Factory))
+	})
+	return _c
+}
+
+func (_c *Inheritable_InheritSettingsFrom_Call) Return() *Inheritable_InheritSettingsFrom_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *Inheritable_InheritSettingsFrom_Call) RunAndReturn(run func(other storage.Factory)) *Inheritable_InheritSettingsFrom_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewArchiveCapable creates a new instance of ArchiveCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewArchiveCapable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ArchiveCapable {
+	mock := &ArchiveCapable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// ArchiveCapable is an autogenerated mock type for the ArchiveCapable type
+type ArchiveCapable struct {
+	mock.Mock
+}
+
+type ArchiveCapable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ArchiveCapable) EXPECT() *ArchiveCapable_Expecter {
+	return &ArchiveCapable_Expecter{mock: &_m.Mock}
+}
+
+// IsArchiveCapable provides a mock function for the type ArchiveCapable
+func (_mock *ArchiveCapable) IsArchiveCapable() bool {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsArchiveCapable")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// ArchiveCapable_IsArchiveCapable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsArchiveCapable'
+type ArchiveCapable_IsArchiveCapable_Call struct {
+	*mock.Call
+}
+
+// IsArchiveCapable is a helper method to define mock.On call
+func (_e *ArchiveCapable_Expecter) IsArchiveCapable() *ArchiveCapable_IsArchiveCapable_Call {
+	return &ArchiveCapable_IsArchiveCapable_Call{Call: _e.mock.On("IsArchiveCapable")}
+}
+
+func (_c *ArchiveCapable_IsArchiveCapable_Call) Run(run func()) *ArchiveCapable_IsArchiveCapable_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ArchiveCapable_IsArchiveCapable_Call) Return(b bool) *ArchiveCapable_IsArchiveCapable_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *ArchiveCapable_IsArchiveCapable_Call) RunAndReturn(run func() bool) *ArchiveCapable_IsArchiveCapable_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/v2/api/depstore/mocks/Factory.go b/internal/storage/v2/api/depstore/mocks/Factory.go
deleted file mode 100644
index ae745e05..00000000
--- a/internal/storage/v2/api/depstore/mocks/Factory.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	depstore "github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Factory is an autogenerated mock type for the Factory type
-type Factory struct {
-	mock.Mock
-}
-
-type Factory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Factory) EXPECT() *Factory_Expecter {
-	return &Factory_Expecter{mock: &_m.Mock}
-}
-
-// CreateDependencyReader provides a mock function with no fields
-func (_m *Factory) CreateDependencyReader() (depstore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateDependencyReader")
-	}
-
-	var r0 depstore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (depstore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() depstore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(depstore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
-type Factory_CreateDependencyReader_Call struct {
-	*mock.Call
-}
-
-// CreateDependencyReader is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateDependencyReader() *Factory_CreateDependencyReader_Call {
-	return &Factory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
-}
-
-func (_c *Factory_CreateDependencyReader_Call) Run(run func()) *Factory_CreateDependencyReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateDependencyReader_Call) Return(_a0 depstore.Reader, _a1 error) *Factory_CreateDependencyReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateDependencyReader_Call) RunAndReturn(run func() (depstore.Reader, error)) *Factory_CreateDependencyReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Factory {
-	mock := &Factory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/depstore/mocks/Reader.go b/internal/storage/v2/api/depstore/mocks/Reader.go
deleted file mode 100644
index 5dc30974..00000000
--- a/internal/storage/v2/api/depstore/mocks/Reader.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	depstore "github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
-	mock "github.com/stretchr/testify/mock"
-
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-)
-
-// Reader is an autogenerated mock type for the Reader type
-type Reader struct {
-	mock.Mock
-}
-
-type Reader_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Reader) EXPECT() *Reader_Expecter {
-	return &Reader_Expecter{mock: &_m.Mock}
-}
-
-// GetDependencies provides a mock function with given fields: ctx, query
-func (_m *Reader) GetDependencies(ctx context.Context, query depstore.QueryParameters) ([]model.DependencyLink, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetDependencies")
-	}
-
-	var r0 []model.DependencyLink
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, depstore.QueryParameters) ([]model.DependencyLink, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, depstore.QueryParameters) []model.DependencyLink); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]model.DependencyLink)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, depstore.QueryParameters) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
-type Reader_GetDependencies_Call struct {
-	*mock.Call
-}
-
-// GetDependencies is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query depstore.QueryParameters
-func (_e *Reader_Expecter) GetDependencies(ctx interface{}, query interface{}) *Reader_GetDependencies_Call {
-	return &Reader_GetDependencies_Call{Call: _e.mock.On("GetDependencies", ctx, query)}
-}
-
-func (_c *Reader_GetDependencies_Call) Run(run func(ctx context.Context, query depstore.QueryParameters)) *Reader_GetDependencies_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(depstore.QueryParameters))
-	})
-	return _c
-}
-
-func (_c *Reader_GetDependencies_Call) Return(_a0 []model.DependencyLink, _a1 error) *Reader_GetDependencies_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetDependencies_Call) RunAndReturn(run func(context.Context, depstore.QueryParameters) ([]model.DependencyLink, error)) *Reader_GetDependencies_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Reader {
-	mock := &Reader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/depstore/mocks/Writer.go b/internal/storage/v2/api/depstore/mocks/Writer.go
deleted file mode 100644
index 602b0703..00000000
--- a/internal/storage/v2/api/depstore/mocks/Writer.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	model "github.com/jaegertracing/jaeger-idl/model/v1"
-	mock "github.com/stretchr/testify/mock"
-
-	time "time"
-)
-
-// Writer is an autogenerated mock type for the Writer type
-type Writer struct {
-	mock.Mock
-}
-
-type Writer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Writer) EXPECT() *Writer_Expecter {
-	return &Writer_Expecter{mock: &_m.Mock}
-}
-
-// WriteDependencies provides a mock function with given fields: ts, dependencies
-func (_m *Writer) WriteDependencies(ts time.Time, dependencies []model.DependencyLink) error {
-	ret := _m.Called(ts, dependencies)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteDependencies")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(time.Time, []model.DependencyLink) error); ok {
-		r0 = rf(ts, dependencies)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Writer_WriteDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteDependencies'
-type Writer_WriteDependencies_Call struct {
-	*mock.Call
-}
-
-// WriteDependencies is a helper method to define mock.On call
-//   - ts time.Time
-//   - dependencies []model.DependencyLink
-func (_e *Writer_Expecter) WriteDependencies(ts interface{}, dependencies interface{}) *Writer_WriteDependencies_Call {
-	return &Writer_WriteDependencies_Call{Call: _e.mock.On("WriteDependencies", ts, dependencies)}
-}
-
-func (_c *Writer_WriteDependencies_Call) Run(run func(ts time.Time, dependencies []model.DependencyLink)) *Writer_WriteDependencies_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(time.Time), args[1].([]model.DependencyLink))
-	})
-	return _c
-}
-
-func (_c *Writer_WriteDependencies_Call) Return(_a0 error) *Writer_WriteDependencies_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Writer_WriteDependencies_Call) RunAndReturn(run func(time.Time, []model.DependencyLink) error) *Writer_WriteDependencies_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewWriter(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Writer {
-	mock := &Writer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/depstore/mocks/mocks.go b/internal/storage/v2/api/depstore/mocks/mocks.go
new file mode 100644
index 00000000..5903bbcb
--- /dev/null
+++ b/internal/storage/v2/api/depstore/mocks/mocks.go
@@ -0,0 +1,257 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+	"time"
+
+	"github.com/jaegertracing/jaeger-idl/model/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Factory {
+	mock := &Factory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Factory is an autogenerated mock type for the Factory type
+type Factory struct {
+	mock.Mock
+}
+
+type Factory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Factory) EXPECT() *Factory_Expecter {
+	return &Factory_Expecter{mock: &_m.Mock}
+}
+
+// CreateDependencyReader provides a mock function for the type Factory
+func (_mock *Factory) CreateDependencyReader() (depstore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateDependencyReader")
+	}
+
+	var r0 depstore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (depstore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() depstore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(depstore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateDependencyReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencyReader'
+type Factory_CreateDependencyReader_Call struct {
+	*mock.Call
+}
+
+// CreateDependencyReader is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateDependencyReader() *Factory_CreateDependencyReader_Call {
+	return &Factory_CreateDependencyReader_Call{Call: _e.mock.On("CreateDependencyReader")}
+}
+
+func (_c *Factory_CreateDependencyReader_Call) Run(run func()) *Factory_CreateDependencyReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateDependencyReader_Call) Return(reader depstore.Reader, err error) *Factory_CreateDependencyReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *Factory_CreateDependencyReader_Call) RunAndReturn(run func() (depstore.Reader, error)) *Factory_CreateDependencyReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Reader {
+	mock := &Reader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Reader is an autogenerated mock type for the Reader type
+type Reader struct {
+	mock.Mock
+}
+
+type Reader_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Reader) EXPECT() *Reader_Expecter {
+	return &Reader_Expecter{mock: &_m.Mock}
+}
+
+// GetDependencies provides a mock function for the type Reader
+func (_mock *Reader) GetDependencies(ctx context.Context, query depstore.QueryParameters) ([]model.DependencyLink, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDependencies")
+	}
+
+	var r0 []model.DependencyLink
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, depstore.QueryParameters) ([]model.DependencyLink, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, depstore.QueryParameters) []model.DependencyLink); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]model.DependencyLink)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, depstore.QueryParameters) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencies'
+type Reader_GetDependencies_Call struct {
+	*mock.Call
+}
+
+// GetDependencies is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) GetDependencies(ctx interface{}, query interface{}) *Reader_GetDependencies_Call {
+	return &Reader_GetDependencies_Call{Call: _e.mock.On("GetDependencies", ctx, query)}
+}
+
+func (_c *Reader_GetDependencies_Call) Run(run func(ctx context.Context, query depstore.QueryParameters)) *Reader_GetDependencies_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(depstore.QueryParameters))
+	})
+	return _c
+}
+
+func (_c *Reader_GetDependencies_Call) Return(dependencyLinks []model.DependencyLink, err error) *Reader_GetDependencies_Call {
+	_c.Call.Return(dependencyLinks, err)
+	return _c
+}
+
+func (_c *Reader_GetDependencies_Call) RunAndReturn(run func(ctx context.Context, query depstore.QueryParameters) ([]model.DependencyLink, error)) *Reader_GetDependencies_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewWriter(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Writer {
+	mock := &Writer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Writer is an autogenerated mock type for the Writer type
+type Writer struct {
+	mock.Mock
+}
+
+type Writer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Writer) EXPECT() *Writer_Expecter {
+	return &Writer_Expecter{mock: &_m.Mock}
+}
+
+// WriteDependencies provides a mock function for the type Writer
+func (_mock *Writer) WriteDependencies(ts time.Time, dependencies []model.DependencyLink) error {
+	ret := _mock.Called(ts, dependencies)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteDependencies")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(time.Time, []model.DependencyLink) error); ok {
+		r0 = returnFunc(ts, dependencies)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Writer_WriteDependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteDependencies'
+type Writer_WriteDependencies_Call struct {
+	*mock.Call
+}
+
+// WriteDependencies is a helper method to define mock.On call
+//   - ts
+//   - dependencies
+func (_e *Writer_Expecter) WriteDependencies(ts interface{}, dependencies interface{}) *Writer_WriteDependencies_Call {
+	return &Writer_WriteDependencies_Call{Call: _e.mock.On("WriteDependencies", ts, dependencies)}
+}
+
+func (_c *Writer_WriteDependencies_Call) Run(run func(ts time.Time, dependencies []model.DependencyLink)) *Writer_WriteDependencies_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(time.Time), args[1].([]model.DependencyLink))
+	})
+	return _c
+}
+
+func (_c *Writer_WriteDependencies_Call) Return(err error) *Writer_WriteDependencies_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Writer_WriteDependencies_Call) RunAndReturn(run func(ts time.Time, dependencies []model.DependencyLink) error) *Writer_WriteDependencies_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/v2/api/tracestore/mocks/Factory.go b/internal/storage/v2/api/tracestore/mocks/Factory.go
deleted file mode 100644
index f656a499..00000000
--- a/internal/storage/v2/api/tracestore/mocks/Factory.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	tracestore "github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Factory is an autogenerated mock type for the Factory type
-type Factory struct {
-	mock.Mock
-}
-
-type Factory_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Factory) EXPECT() *Factory_Expecter {
-	return &Factory_Expecter{mock: &_m.Mock}
-}
-
-// CreateTraceReader provides a mock function with no fields
-func (_m *Factory) CreateTraceReader() (tracestore.Reader, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateTraceReader")
-	}
-
-	var r0 tracestore.Reader
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (tracestore.Reader, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() tracestore.Reader); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(tracestore.Reader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateTraceReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTraceReader'
-type Factory_CreateTraceReader_Call struct {
-	*mock.Call
-}
-
-// CreateTraceReader is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateTraceReader() *Factory_CreateTraceReader_Call {
-	return &Factory_CreateTraceReader_Call{Call: _e.mock.On("CreateTraceReader")}
-}
-
-func (_c *Factory_CreateTraceReader_Call) Run(run func()) *Factory_CreateTraceReader_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateTraceReader_Call) Return(_a0 tracestore.Reader, _a1 error) *Factory_CreateTraceReader_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateTraceReader_Call) RunAndReturn(run func() (tracestore.Reader, error)) *Factory_CreateTraceReader_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CreateTraceWriter provides a mock function with no fields
-func (_m *Factory) CreateTraceWriter() (tracestore.Writer, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateTraceWriter")
-	}
-
-	var r0 tracestore.Writer
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (tracestore.Writer, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() tracestore.Writer); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(tracestore.Writer)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Factory_CreateTraceWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTraceWriter'
-type Factory_CreateTraceWriter_Call struct {
-	*mock.Call
-}
-
-// CreateTraceWriter is a helper method to define mock.On call
-func (_e *Factory_Expecter) CreateTraceWriter() *Factory_CreateTraceWriter_Call {
-	return &Factory_CreateTraceWriter_Call{Call: _e.mock.On("CreateTraceWriter")}
-}
-
-func (_c *Factory_CreateTraceWriter_Call) Run(run func()) *Factory_CreateTraceWriter_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *Factory_CreateTraceWriter_Call) Return(_a0 tracestore.Writer, _a1 error) *Factory_CreateTraceWriter_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Factory_CreateTraceWriter_Call) RunAndReturn(run func() (tracestore.Writer, error)) *Factory_CreateTraceWriter_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewFactory(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Factory {
-	mock := &Factory{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/tracestore/mocks/Reader.go b/internal/storage/v2/api/tracestore/mocks/Reader.go
deleted file mode 100644
index 35c86ca3..00000000
--- a/internal/storage/v2/api/tracestore/mocks/Reader.go
+++ /dev/null
@@ -1,324 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-	iter "iter"
-
-	mock "github.com/stretchr/testify/mock"
-
-	ptrace "go.opentelemetry.io/collector/pdata/ptrace"
-
-	tracestore "github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
-)
-
-// Reader is an autogenerated mock type for the Reader type
-type Reader struct {
-	mock.Mock
-}
-
-type Reader_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Reader) EXPECT() *Reader_Expecter {
-	return &Reader_Expecter{mock: &_m.Mock}
-}
-
-// FindTraceIDs provides a mock function with given fields: ctx, query
-func (_m *Reader) FindTraceIDs(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error] {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraceIDs")
-	}
-
-	var r0 iter.Seq2[[]tracestore.FoundTraceID, error]
-	if rf, ok := ret.Get(0).(func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error]); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(iter.Seq2[[]tracestore.FoundTraceID, error])
-		}
-	}
-
-	return r0
-}
-
-// Reader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
-type Reader_FindTraceIDs_Call struct {
-	*mock.Call
-}
-
-// FindTraceIDs is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query tracestore.TraceQueryParams
-func (_e *Reader_Expecter) FindTraceIDs(ctx interface{}, query interface{}) *Reader_FindTraceIDs_Call {
-	return &Reader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, query)}
-}
-
-func (_c *Reader_FindTraceIDs_Call) Run(run func(ctx context.Context, query tracestore.TraceQueryParams)) *Reader_FindTraceIDs_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(tracestore.TraceQueryParams))
-	})
-	return _c
-}
-
-func (_c *Reader_FindTraceIDs_Call) Return(_a0 iter.Seq2[[]tracestore.FoundTraceID, error]) *Reader_FindTraceIDs_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Reader_FindTraceIDs_Call) RunAndReturn(run func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error]) *Reader_FindTraceIDs_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FindTraces provides a mock function with given fields: ctx, query
-func (_m *Reader) FindTraces(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error] {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindTraces")
-	}
-
-	var r0 iter.Seq2[[]ptrace.Traces, error]
-	if rf, ok := ret.Get(0).(func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error]); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(iter.Seq2[[]ptrace.Traces, error])
-		}
-	}
-
-	return r0
-}
-
-// Reader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
-type Reader_FindTraces_Call struct {
-	*mock.Call
-}
-
-// FindTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query tracestore.TraceQueryParams
-func (_e *Reader_Expecter) FindTraces(ctx interface{}, query interface{}) *Reader_FindTraces_Call {
-	return &Reader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, query)}
-}
-
-func (_c *Reader_FindTraces_Call) Run(run func(ctx context.Context, query tracestore.TraceQueryParams)) *Reader_FindTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(tracestore.TraceQueryParams))
-	})
-	return _c
-}
-
-func (_c *Reader_FindTraces_Call) Return(_a0 iter.Seq2[[]ptrace.Traces, error]) *Reader_FindTraces_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Reader_FindTraces_Call) RunAndReturn(run func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error]) *Reader_FindTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetOperations provides a mock function with given fields: ctx, query
-func (_m *Reader) GetOperations(ctx context.Context, query tracestore.OperationQueryParams) ([]tracestore.Operation, error) {
-	ret := _m.Called(ctx, query)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetOperations")
-	}
-
-	var r0 []tracestore.Operation
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, tracestore.OperationQueryParams) ([]tracestore.Operation, error)); ok {
-		return rf(ctx, query)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, tracestore.OperationQueryParams) []tracestore.Operation); ok {
-		r0 = rf(ctx, query)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]tracestore.Operation)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, tracestore.OperationQueryParams) error); ok {
-		r1 = rf(ctx, query)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
-type Reader_GetOperations_Call struct {
-	*mock.Call
-}
-
-// GetOperations is a helper method to define mock.On call
-//   - ctx context.Context
-//   - query tracestore.OperationQueryParams
-func (_e *Reader_Expecter) GetOperations(ctx interface{}, query interface{}) *Reader_GetOperations_Call {
-	return &Reader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
-}
-
-func (_c *Reader_GetOperations_Call) Run(run func(ctx context.Context, query tracestore.OperationQueryParams)) *Reader_GetOperations_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(tracestore.OperationQueryParams))
-	})
-	return _c
-}
-
-func (_c *Reader_GetOperations_Call) Return(_a0 []tracestore.Operation, _a1 error) *Reader_GetOperations_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetOperations_Call) RunAndReturn(run func(context.Context, tracestore.OperationQueryParams) ([]tracestore.Operation, error)) *Reader_GetOperations_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetServices provides a mock function with given fields: ctx
-func (_m *Reader) GetServices(ctx context.Context) ([]string, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetServices")
-	}
-
-	var r0 []string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) []string); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]string)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Reader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
-type Reader_GetServices_Call struct {
-	*mock.Call
-}
-
-// GetServices is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *Reader_Expecter) GetServices(ctx interface{}) *Reader_GetServices_Call {
-	return &Reader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
-}
-
-func (_c *Reader_GetServices_Call) Run(run func(ctx context.Context)) *Reader_GetServices_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *Reader_GetServices_Call) Return(_a0 []string, _a1 error) *Reader_GetServices_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Reader_GetServices_Call) RunAndReturn(run func(context.Context) ([]string, error)) *Reader_GetServices_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetTraces provides a mock function with given fields: ctx, traceIDs
-func (_m *Reader) GetTraces(ctx context.Context, traceIDs ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error] {
-	_va := make([]interface{}, len(traceIDs))
-	for _i := range traceIDs {
-		_va[_i] = traceIDs[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetTraces")
-	}
-
-	var r0 iter.Seq2[[]ptrace.Traces, error]
-	if rf, ok := ret.Get(0).(func(context.Context, ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error]); ok {
-		r0 = rf(ctx, traceIDs...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(iter.Seq2[[]ptrace.Traces, error])
-		}
-	}
-
-	return r0
-}
-
-// Reader_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
-type Reader_GetTraces_Call struct {
-	*mock.Call
-}
-
-// GetTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - traceIDs ...tracestore.GetTraceParams
-func (_e *Reader_Expecter) GetTraces(ctx interface{}, traceIDs ...interface{}) *Reader_GetTraces_Call {
-	return &Reader_GetTraces_Call{Call: _e.mock.On("GetTraces",
-		append([]interface{}{ctx}, traceIDs...)...)}
-}
-
-func (_c *Reader_GetTraces_Call) Run(run func(ctx context.Context, traceIDs ...tracestore.GetTraceParams)) *Reader_GetTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]tracestore.GetTraceParams, len(args)-1)
-		for i, a := range args[1:] {
-			if a != nil {
-				variadicArgs[i] = a.(tracestore.GetTraceParams)
-			}
-		}
-		run(args[0].(context.Context), variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *Reader_GetTraces_Call) Return(_a0 iter.Seq2[[]ptrace.Traces, error]) *Reader_GetTraces_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Reader_GetTraces_Call) RunAndReturn(run func(context.Context, ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error]) *Reader_GetTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewReader(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Reader {
-	mock := &Reader{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/tracestore/mocks/Writer.go b/internal/storage/v2/api/tracestore/mocks/Writer.go
deleted file mode 100644
index feead321..00000000
--- a/internal/storage/v2/api/tracestore/mocks/Writer.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run 'make generate-mocks' to regenerate.
-
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	ptrace "go.opentelemetry.io/collector/pdata/ptrace"
-)
-
-// Writer is an autogenerated mock type for the Writer type
-type Writer struct {
-	mock.Mock
-}
-
-type Writer_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Writer) EXPECT() *Writer_Expecter {
-	return &Writer_Expecter{mock: &_m.Mock}
-}
-
-// WriteTraces provides a mock function with given fields: ctx, td
-func (_m *Writer) WriteTraces(ctx context.Context, td ptrace.Traces) error {
-	ret := _m.Called(ctx, td)
-
-	if len(ret) == 0 {
-		panic("no return value specified for WriteTraces")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, ptrace.Traces) error); ok {
-		r0 = rf(ctx, td)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Writer_WriteTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteTraces'
-type Writer_WriteTraces_Call struct {
-	*mock.Call
-}
-
-// WriteTraces is a helper method to define mock.On call
-//   - ctx context.Context
-//   - td ptrace.Traces
-func (_e *Writer_Expecter) WriteTraces(ctx interface{}, td interface{}) *Writer_WriteTraces_Call {
-	return &Writer_WriteTraces_Call{Call: _e.mock.On("WriteTraces", ctx, td)}
-}
-
-func (_c *Writer_WriteTraces_Call) Run(run func(ctx context.Context, td ptrace.Traces)) *Writer_WriteTraces_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(ptrace.Traces))
-	})
-	return _c
-}
-
-func (_c *Writer_WriteTraces_Call) Return(_a0 error) *Writer_WriteTraces_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Writer_WriteTraces_Call) RunAndReturn(run func(context.Context, ptrace.Traces) error) *Writer_WriteTraces_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewWriter(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Writer {
-	mock := &Writer{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/internal/storage/v2/api/tracestore/mocks/mocks.go b/internal/storage/v2/api/tracestore/mocks/mocks.go
new file mode 100644
index 00000000..8e36f4fb
--- /dev/null
+++ b/internal/storage/v2/api/tracestore/mocks/mocks.go
@@ -0,0 +1,525 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+// Copyright (c) The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Run 'make generate-mocks' to regenerate.
+
+package mocks
+
+import (
+	"context"
+	"iter"
+
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
+	mock "github.com/stretchr/testify/mock"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+// NewFactory creates a new instance of Factory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewFactory(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Factory {
+	mock := &Factory{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Factory is an autogenerated mock type for the Factory type
+type Factory struct {
+	mock.Mock
+}
+
+type Factory_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Factory) EXPECT() *Factory_Expecter {
+	return &Factory_Expecter{mock: &_m.Mock}
+}
+
+// CreateTraceReader provides a mock function for the type Factory
+func (_mock *Factory) CreateTraceReader() (tracestore.Reader, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateTraceReader")
+	}
+
+	var r0 tracestore.Reader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (tracestore.Reader, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() tracestore.Reader); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(tracestore.Reader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateTraceReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTraceReader'
+type Factory_CreateTraceReader_Call struct {
+	*mock.Call
+}
+
+// CreateTraceReader is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateTraceReader() *Factory_CreateTraceReader_Call {
+	return &Factory_CreateTraceReader_Call{Call: _e.mock.On("CreateTraceReader")}
+}
+
+func (_c *Factory_CreateTraceReader_Call) Run(run func()) *Factory_CreateTraceReader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateTraceReader_Call) Return(reader tracestore.Reader, err error) *Factory_CreateTraceReader_Call {
+	_c.Call.Return(reader, err)
+	return _c
+}
+
+func (_c *Factory_CreateTraceReader_Call) RunAndReturn(run func() (tracestore.Reader, error)) *Factory_CreateTraceReader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateTraceWriter provides a mock function for the type Factory
+func (_mock *Factory) CreateTraceWriter() (tracestore.Writer, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateTraceWriter")
+	}
+
+	var r0 tracestore.Writer
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (tracestore.Writer, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() tracestore.Writer); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(tracestore.Writer)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Factory_CreateTraceWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTraceWriter'
+type Factory_CreateTraceWriter_Call struct {
+	*mock.Call
+}
+
+// CreateTraceWriter is a helper method to define mock.On call
+func (_e *Factory_Expecter) CreateTraceWriter() *Factory_CreateTraceWriter_Call {
+	return &Factory_CreateTraceWriter_Call{Call: _e.mock.On("CreateTraceWriter")}
+}
+
+func (_c *Factory_CreateTraceWriter_Call) Run(run func()) *Factory_CreateTraceWriter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Factory_CreateTraceWriter_Call) Return(writer tracestore.Writer, err error) *Factory_CreateTraceWriter_Call {
+	_c.Call.Return(writer, err)
+	return _c
+}
+
+func (_c *Factory_CreateTraceWriter_Call) RunAndReturn(run func() (tracestore.Writer, error)) *Factory_CreateTraceWriter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewReader creates a new instance of Reader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Reader {
+	mock := &Reader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Reader is an autogenerated mock type for the Reader type
+type Reader struct {
+	mock.Mock
+}
+
+type Reader_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Reader) EXPECT() *Reader_Expecter {
+	return &Reader_Expecter{mock: &_m.Mock}
+}
+
+// FindTraceIDs provides a mock function for the type Reader
+func (_mock *Reader) FindTraceIDs(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error] {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraceIDs")
+	}
+
+	var r0 iter.Seq2[[]tracestore.FoundTraceID, error]
+	if returnFunc, ok := ret.Get(0).(func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error]); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(iter.Seq2[[]tracestore.FoundTraceID, error])
+		}
+	}
+	return r0
+}
+
+// Reader_FindTraceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraceIDs'
+type Reader_FindTraceIDs_Call struct {
+	*mock.Call
+}
+
+// FindTraceIDs is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) FindTraceIDs(ctx interface{}, query interface{}) *Reader_FindTraceIDs_Call {
+	return &Reader_FindTraceIDs_Call{Call: _e.mock.On("FindTraceIDs", ctx, query)}
+}
+
+func (_c *Reader_FindTraceIDs_Call) Run(run func(ctx context.Context, query tracestore.TraceQueryParams)) *Reader_FindTraceIDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(tracestore.TraceQueryParams))
+	})
+	return _c
+}
+
+func (_c *Reader_FindTraceIDs_Call) Return(seq2 iter.Seq2[[]tracestore.FoundTraceID, error]) *Reader_FindTraceIDs_Call {
+	_c.Call.Return(seq2)
+	return _c
+}
+
+func (_c *Reader_FindTraceIDs_Call) RunAndReturn(run func(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error]) *Reader_FindTraceIDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindTraces provides a mock function for the type Reader
+func (_mock *Reader) FindTraces(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error] {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindTraces")
+	}
+
+	var r0 iter.Seq2[[]ptrace.Traces, error]
+	if returnFunc, ok := ret.Get(0).(func(context.Context, tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error]); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(iter.Seq2[[]ptrace.Traces, error])
+		}
+	}
+	return r0
+}
+
+// Reader_FindTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTraces'
+type Reader_FindTraces_Call struct {
+	*mock.Call
+}
+
+// FindTraces is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) FindTraces(ctx interface{}, query interface{}) *Reader_FindTraces_Call {
+	return &Reader_FindTraces_Call{Call: _e.mock.On("FindTraces", ctx, query)}
+}
+
+func (_c *Reader_FindTraces_Call) Run(run func(ctx context.Context, query tracestore.TraceQueryParams)) *Reader_FindTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(tracestore.TraceQueryParams))
+	})
+	return _c
+}
+
+func (_c *Reader_FindTraces_Call) Return(seq2 iter.Seq2[[]ptrace.Traces, error]) *Reader_FindTraces_Call {
+	_c.Call.Return(seq2)
+	return _c
+}
+
+func (_c *Reader_FindTraces_Call) RunAndReturn(run func(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error]) *Reader_FindTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOperations provides a mock function for the type Reader
+func (_mock *Reader) GetOperations(ctx context.Context, query tracestore.OperationQueryParams) ([]tracestore.Operation, error) {
+	ret := _mock.Called(ctx, query)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOperations")
+	}
+
+	var r0 []tracestore.Operation
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, tracestore.OperationQueryParams) ([]tracestore.Operation, error)); ok {
+		return returnFunc(ctx, query)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, tracestore.OperationQueryParams) []tracestore.Operation); ok {
+		r0 = returnFunc(ctx, query)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]tracestore.Operation)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, tracestore.OperationQueryParams) error); ok {
+		r1 = returnFunc(ctx, query)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOperations'
+type Reader_GetOperations_Call struct {
+	*mock.Call
+}
+
+// GetOperations is a helper method to define mock.On call
+//   - ctx
+//   - query
+func (_e *Reader_Expecter) GetOperations(ctx interface{}, query interface{}) *Reader_GetOperations_Call {
+	return &Reader_GetOperations_Call{Call: _e.mock.On("GetOperations", ctx, query)}
+}
+
+func (_c *Reader_GetOperations_Call) Run(run func(ctx context.Context, query tracestore.OperationQueryParams)) *Reader_GetOperations_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(tracestore.OperationQueryParams))
+	})
+	return _c
+}
+
+func (_c *Reader_GetOperations_Call) Return(operations []tracestore.Operation, err error) *Reader_GetOperations_Call {
+	_c.Call.Return(operations, err)
+	return _c
+}
+
+func (_c *Reader_GetOperations_Call) RunAndReturn(run func(ctx context.Context, query tracestore.OperationQueryParams) ([]tracestore.Operation, error)) *Reader_GetOperations_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetServices provides a mock function for the type Reader
+func (_mock *Reader) GetServices(ctx context.Context) ([]string, error) {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetServices")
+	}
+
+	var r0 []string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
+		return returnFunc(ctx)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = returnFunc(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Reader_GetServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServices'
+type Reader_GetServices_Call struct {
+	*mock.Call
+}
+
+// GetServices is a helper method to define mock.On call
+//   - ctx
+func (_e *Reader_Expecter) GetServices(ctx interface{}) *Reader_GetServices_Call {
+	return &Reader_GetServices_Call{Call: _e.mock.On("GetServices", ctx)}
+}
+
+func (_c *Reader_GetServices_Call) Run(run func(ctx context.Context)) *Reader_GetServices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *Reader_GetServices_Call) Return(strings []string, err error) *Reader_GetServices_Call {
+	_c.Call.Return(strings, err)
+	return _c
+}
+
+func (_c *Reader_GetServices_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *Reader_GetServices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTraces provides a mock function for the type Reader
+func (_mock *Reader) GetTraces(ctx context.Context, traceIDs ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error] {
+	var tmpRet mock.Arguments
+	if len(traceIDs) > 0 {
+		tmpRet = _mock.Called(ctx, traceIDs)
+	} else {
+		tmpRet = _mock.Called(ctx)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTraces")
+	}
+
+	var r0 iter.Seq2[[]ptrace.Traces, error]
+	if returnFunc, ok := ret.Get(0).(func(context.Context, ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error]); ok {
+		r0 = returnFunc(ctx, traceIDs...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(iter.Seq2[[]ptrace.Traces, error])
+		}
+	}
+	return r0
+}
+
+// Reader_GetTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTraces'
+type Reader_GetTraces_Call struct {
+	*mock.Call
+}
+
+// GetTraces is a helper method to define mock.On call
+//   - ctx
+//   - traceIDs
+func (_e *Reader_Expecter) GetTraces(ctx interface{}, traceIDs ...interface{}) *Reader_GetTraces_Call {
+	return &Reader_GetTraces_Call{Call: _e.mock.On("GetTraces",
+		append([]interface{}{ctx}, traceIDs...)...)}
+}
+
+func (_c *Reader_GetTraces_Call) Run(run func(ctx context.Context, traceIDs ...tracestore.GetTraceParams)) *Reader_GetTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]tracestore.GetTraceParams, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(tracestore.GetTraceParams)
+			}
+		}
+		run(args[0].(context.Context), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *Reader_GetTraces_Call) Return(seq2 iter.Seq2[[]ptrace.Traces, error]) *Reader_GetTraces_Call {
+	_c.Call.Return(seq2)
+	return _c
+}
+
+func (_c *Reader_GetTraces_Call) RunAndReturn(run func(ctx context.Context, traceIDs ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error]) *Reader_GetTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewWriter creates a new instance of Writer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewWriter(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Writer {
+	mock := &Writer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// Writer is an autogenerated mock type for the Writer type
+type Writer struct {
+	mock.Mock
+}
+
+type Writer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Writer) EXPECT() *Writer_Expecter {
+	return &Writer_Expecter{mock: &_m.Mock}
+}
+
+// WriteTraces provides a mock function for the type Writer
+func (_mock *Writer) WriteTraces(ctx context.Context, td ptrace.Traces) error {
+	ret := _mock.Called(ctx, td)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteTraces")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, ptrace.Traces) error); ok {
+		r0 = returnFunc(ctx, td)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Writer_WriteTraces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteTraces'
+type Writer_WriteTraces_Call struct {
+	*mock.Call
+}
+
+// WriteTraces is a helper method to define mock.On call
+//   - ctx
+//   - td
+func (_e *Writer_Expecter) WriteTraces(ctx interface{}, td interface{}) *Writer_WriteTraces_Call {
+	return &Writer_WriteTraces_Call{Call: _e.mock.On("WriteTraces", ctx, td)}
+}
+
+func (_c *Writer_WriteTraces_Call) Run(run func(ctx context.Context, td ptrace.Traces)) *Writer_WriteTraces_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(ptrace.Traces))
+	})
+	return _c
+}
+
+func (_c *Writer_WriteTraces_Call) Return(err error) *Writer_WriteTraces_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Writer_WriteTraces_Call) RunAndReturn(run func(ctx context.Context, td ptrace.Traces) error) *Writer_WriteTraces_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/storage/v2/elasticsearch/tracestore/reader.go b/internal/storage/v2/elasticsearch/tracestore/reader.go
index d0503340..2df71294 100644
--- a/internal/storage/v2/elasticsearch/tracestore/reader.go
+++ b/internal/storage/v2/elasticsearch/tracestore/reader.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
 	"github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/spanstore"
-	v2api "github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
 )
 
 // TraceReader is a wrapper around spanstore.CoreSpanReader which return the output parallel to OTLP Models
@@ -26,15 +26,35 @@ func NewTraceReader(p spanstore.SpanReaderParams) *TraceReader {
 	}
 }
 
-func (*TraceReader) GetTraces(_ context.Context, _ ...v2api.GetTraceParams) iter.Seq2[[]ptrace.Traces, error] {
-	panic("not implemented")
+func (t *TraceReader) GetTraces(ctx context.Context, params ...tracestore.GetTraceParams) iter.Seq2[[]ptrace.Traces, error] {
+	return func(yield func([]ptrace.Traces, error) bool) {
+		dbTraceIds := make([]dbmodel.TraceID, 0, len(params))
+		for _, id := range params {
+			dbTraceIds = append(dbTraceIds, dbmodel.TraceID(id.TraceID.String()))
+		}
+		dbTraces, err := t.spanReader.GetTraces(ctx, dbTraceIds)
+		if err != nil {
+			yield(nil, err)
+			return
+		}
+		for _, trace := range dbTraces {
+			td, err := FromDBModel(trace.Spans)
+			if err != nil {
+				yield(nil, err)
+				return
+			}
+			if !yield([]ptrace.Traces{td}, nil) {
+				return
+			}
+		}
+	}
 }
 
 func (t *TraceReader) GetServices(ctx context.Context) ([]string, error) {
 	return t.spanReader.GetServices(ctx)
 }
 
-func (t *TraceReader) GetOperations(ctx context.Context, query v2api.OperationQueryParams) ([]v2api.Operation, error) {
+func (t *TraceReader) GetOperations(ctx context.Context, query tracestore.OperationQueryParams) ([]tracestore.Operation, error) {
 	dbOperations, err := t.spanReader.GetOperations(ctx, dbmodel.OperationQueryParameters{
 		ServiceName: query.ServiceName,
 		SpanKind:    query.SpanKind,
@@ -42,9 +62,9 @@ func (t *TraceReader) GetOperations(ctx context.Context, query v2api.OperationQu
 	if err != nil {
 		return nil, err
 	}
-	operations := make([]v2api.Operation, 0, len(dbOperations))
+	operations := make([]tracestore.Operation, 0, len(dbOperations))
 	for _, op := range dbOperations {
-		operations = append(operations, v2api.Operation{
+		operations = append(operations, tracestore.Operation{
 			Name:     op.Name,
 			SpanKind: op.SpanKind,
 		})
@@ -52,25 +72,25 @@ func (t *TraceReader) GetOperations(ctx context.Context, query v2api.OperationQu
 	return operations, nil
 }
 
-func (*TraceReader) FindTraces(_ context.Context, _ v2api.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error] {
+func (*TraceReader) FindTraces(_ context.Context, _ tracestore.TraceQueryParams) iter.Seq2[[]ptrace.Traces, error] {
 	panic("not implemented")
 }
 
-func (t *TraceReader) FindTraceIDs(ctx context.Context, query v2api.TraceQueryParams) iter.Seq2[[]v2api.FoundTraceID, error] {
-	return func(yield func([]v2api.FoundTraceID, error) bool) {
+func (t *TraceReader) FindTraceIDs(ctx context.Context, query tracestore.TraceQueryParams) iter.Seq2[[]tracestore.FoundTraceID, error] {
+	return func(yield func([]tracestore.FoundTraceID, error) bool) {
 		traceIds, err := t.spanReader.FindTraceIDs(ctx, toDBTraceQueryParams(query))
 		if err != nil {
 			yield(nil, err)
 			return
 		}
-		otelTraceIds := make([]v2api.FoundTraceID, 0, len(traceIds))
+		otelTraceIds := make([]tracestore.FoundTraceID, 0, len(traceIds))
 		for _, traceId := range traceIds {
 			dbTraceId, err := fromDbTraceId(traceId)
 			if err != nil {
 				yield(nil, err)
 				return
 			}
-			otelTraceIds = append(otelTraceIds, v2api.FoundTraceID{
+			otelTraceIds = append(otelTraceIds, tracestore.FoundTraceID{
 				TraceID: dbTraceId,
 			})
 		}
@@ -78,7 +98,7 @@ func (t *TraceReader) FindTraceIDs(ctx context.Context, query v2api.TraceQueryPa
 	}
 }
 
-func toDBTraceQueryParams(query v2api.TraceQueryParams) dbmodel.TraceQueryParameters {
+func toDBTraceQueryParams(query tracestore.TraceQueryParams) dbmodel.TraceQueryParameters {
 	tags := make(map[string]string)
 	for key, val := range query.Attributes.All() {
 		tags[key] = val.AsString()
diff --git a/internal/storage/v2/memory/fixtures/db_traces_01.json b/internal/storage/v2/memory/fixtures/db_traces_01.json
index 7ec5def5..80cee43b 100644
--- a/internal/storage/v2/memory/fixtures/db_traces_01.json
+++ b/internal/storage/v2/memory/fixtures/db_traces_01.json
@@ -23,7 +23,7 @@
               "spanId": "0000000000000002",
               "parentSpanId": "0000000000000003",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-2",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
@@ -120,7 +120,7 @@
               "spanId": "0000000000000004",
               "parentSpanId": "0000000000000011",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-4",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
diff --git a/internal/storage/v2/memory/fixtures/db_traces_02.json b/internal/storage/v2/memory/fixtures/db_traces_02.json
index d51aa779..ffa62b6e 100644
--- a/internal/storage/v2/memory/fixtures/db_traces_02.json
+++ b/internal/storage/v2/memory/fixtures/db_traces_02.json
@@ -23,7 +23,7 @@
               "spanId": "0000000000000003",
               "parentSpanId": "0000000000000010",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-3",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
@@ -120,7 +120,7 @@
               "spanId": "0000000000000005",
               "parentSpanId": "0000000000000010",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-5",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
diff --git a/internal/storage/v2/memory/fixtures/otel_traces_01.json b/internal/storage/v2/memory/fixtures/otel_traces_01.json
index 21b2ba73..664b9269 100644
--- a/internal/storage/v2/memory/fixtures/otel_traces_01.json
+++ b/internal/storage/v2/memory/fixtures/otel_traces_01.json
@@ -23,7 +23,7 @@
               "spanId": "0000000000000002",
               "parentSpanId": "0000000000000003",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-2",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
@@ -112,7 +112,7 @@
               "spanId": "0000000000000003",
               "parentSpanId": "0000000000000010",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-3",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
@@ -209,7 +209,7 @@
               "spanId": "0000000000000004",
               "parentSpanId": "0000000000000011",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-4",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
@@ -298,7 +298,7 @@
               "spanId": "0000000000000005",
               "parentSpanId": "0000000000000010",
               "flags": 1,
-              "name": "test-general-conversion",
+              "name": "test-general-conversion-5",
               "startTimeUnixNano": "1485467191639875000",
               "endTimeUnixNano": "1485467191639880000",
               "attributes": [
diff --git a/internal/storage/v2/memory/memory.go b/internal/storage/v2/memory/memory.go
index 384c6161..fb51bfc4 100644
--- a/internal/storage/v2/memory/memory.go
+++ b/internal/storage/v2/memory/memory.go
@@ -77,6 +77,34 @@ func (st *Store) WriteTraces(ctx context.Context, td ptrace.Traces) error {
 	return nil
 }
 
+// GetOperations returns operations based on the service name and span kind
+func (st *Store) GetOperations(ctx context.Context, query tracestore.OperationQueryParams) ([]tracestore.Operation, error) {
+	m := st.getTenant(tenancy.GetTenant(ctx))
+	m.RLock()
+	defer m.RUnlock()
+	var retMe []tracestore.Operation
+	if operations, ok := m.operations[query.ServiceName]; ok {
+		for operation := range operations {
+			if query.SpanKind == "" || query.SpanKind == operation.SpanKind {
+				retMe = append(retMe, operation)
+			}
+		}
+	}
+	return retMe, nil
+}
+
+// GetServices returns a list of all known services
+func (st *Store) GetServices(ctx context.Context) ([]string, error) {
+	m := st.getTenant(tenancy.GetTenant(ctx))
+	m.RLock()
+	defer m.RUnlock()
+	var retMe []string
+	for k := range m.services {
+		retMe = append(retMe, k)
+	}
+	return retMe, nil
+}
+
 // reshuffleResourceSpans reshuffles the resource spans so as to group the spans from same traces together. To understand this reshuffling
 // take an example of 2 resource spans, then these two resource spans have 2 scope spans each.
 // Every scope span consists of 2 spans with trace ids: 1 and 2. Now the final structure should look like:
diff --git a/internal/tools/go.mod b/internal/tools/go.mod
index 76c285e0..c2822302 100644
--- a/internal/tools/go.mod
+++ b/internal/tools/go.mod
@@ -5,7 +5,7 @@ go 1.24.0
 require (
 	github.com/golangci/golangci-lint/v2 v2.1.2
 	github.com/josephspurrier/goversioninfo v1.5.0
-	github.com/vektra/mockery/v2 v2.53.1
+	github.com/vektra/mockery/v3 v3.2.2
 	mvdan.cc/gofumpt v0.8.0
 )
 
@@ -39,6 +39,7 @@ require (
 	github.com/bombsimon/wsl/v4 v4.7.0 // indirect
 	github.com/breml/bidichk v0.3.3 // indirect
 	github.com/breml/errchkjson v0.4.1 // indirect
+	github.com/brunoga/deep v1.2.4 // indirect
 	github.com/butuzov/ireturn v0.4.0 // indirect
 	github.com/butuzov/mirror v1.3.0 // indirect
 	github.com/catenacyber/perfsprint v0.9.1 // indirect
@@ -61,6 +62,7 @@ require (
 	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/ettle/strcase v0.2.0 // indirect
 	github.com/fatih/color v1.18.0 // indirect
+	github.com/fatih/structs v1.1.0 // indirect
 	github.com/fatih/structtag v1.2.0 // indirect
 	github.com/firefart/nonamedreturns v1.0.6 // indirect
 	github.com/fsnotify/fsnotify v1.8.0 // indirect
@@ -96,19 +98,24 @@ require (
 	github.com/hashicorp/go-immutable-radix/v2 v2.1.0 // indirect
 	github.com/hashicorp/go-version v1.7.0 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
-	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/hexops/gotextdiff v1.0.3 // indirect
-	github.com/huandu/xstrings v1.4.0 // indirect
-	github.com/iancoleman/strcase v0.3.0 // indirect
+	github.com/huandu/xstrings v1.5.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/jedib0t/go-pretty/v6 v6.6.7 // indirect
 	github.com/jgautheron/goconst v1.8.1 // indirect
 	github.com/jingyugao/rowserrcheck v1.1.1 // indirect
-	github.com/jinzhu/copier v0.4.0 // indirect
 	github.com/jjti/go-spancheck v0.6.4 // indirect
 	github.com/julz/importas v0.2.0 // indirect
 	github.com/karamaru-alpha/copyloopvar v1.2.1 // indirect
 	github.com/kisielk/errcheck v1.9.0 // indirect
 	github.com/kkHAIKE/contextcheck v1.1.6 // indirect
+	github.com/knadh/koanf/maps v0.1.1 // indirect
+	github.com/knadh/koanf/parsers/yaml v0.1.0 // indirect
+	github.com/knadh/koanf/providers/env v1.0.0 // indirect
+	github.com/knadh/koanf/providers/file v1.1.2 // indirect
+	github.com/knadh/koanf/providers/posflag v0.1.0 // indirect
+	github.com/knadh/koanf/providers/structs v0.1.0 // indirect
+	github.com/knadh/koanf/v2 v2.1.2 // indirect
 	github.com/kulti/thelper v0.6.3 // indirect
 	github.com/kunwardeep/paralleltest v1.0.14 // indirect
 	github.com/lasiar/canonicalheader v1.1.2 // indirect
@@ -120,7 +127,6 @@ require (
 	github.com/leonklingele/grouper v1.1.2 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/macabu/inamedparam v0.2.0 // indirect
-	github.com/magiconair/properties v1.8.9 // indirect
 	github.com/manuelarte/funcorder v0.2.1 // indirect
 	github.com/maratori/testableexamples v1.0.0 // indirect
 	github.com/maratori/testpackage v1.1.1 // indirect
@@ -130,8 +136,9 @@ require (
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/mgechev/revive v1.9.0 // indirect
+	github.com/mitchellh/copystructure v1.2.0 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/moricho/tparallel v0.3.2 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/nakabonne/nestif v0.3.1 // indirect
@@ -158,7 +165,6 @@ require (
 	github.com/ryancurrah/gomodguard v1.4.1 // indirect
 	github.com/ryanrolds/sqlclosecheck v0.5.1 // indirect
 	github.com/sagikazarmark/locafero v0.7.0 // indirect
-	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/sanposhiho/wastedassign/v2 v2.1.0 // indirect
 	github.com/santhosh-tekuri/jsonschema/v6 v6.0.1 // indirect
 	github.com/sashamelentyev/interfacebloat v1.1.0 // indirect
@@ -173,7 +179,7 @@ require (
 	github.com/spf13/cast v1.7.1 // indirect
 	github.com/spf13/cobra v1.9.1 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
-	github.com/spf13/viper v1.19.0 // indirect
+	github.com/spf13/viper v1.20.0 // indirect
 	github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect
 	github.com/stbenjam/no-sprintf-host-port v0.2.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
@@ -189,6 +195,9 @@ require (
 	github.com/ultraware/whitespace v0.2.0 // indirect
 	github.com/uudashr/gocognit v1.2.0 // indirect
 	github.com/uudashr/iface v1.3.1 // indirect
+	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
+	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
+	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
 	github.com/xen0n/gosmopolitan v1.3.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yagipy/maintidx v1.0.0 // indirect
@@ -210,7 +219,6 @@ require (
 	golang.org/x/text v0.24.0 // indirect
 	golang.org/x/tools v0.32.0 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	honnef.co/go/tools v0.6.1 // indirect
diff --git a/internal/tools/go.sum b/internal/tools/go.sum
index 03e6b1e7..a23131bc 100644
--- a/internal/tools/go.sum
+++ b/internal/tools/go.sum
@@ -104,6 +104,8 @@ github.com/breml/bidichk v0.3.3 h1:WSM67ztRusf1sMoqH6/c4OBCUlRVTKq+CbSeo0R17sE=
 github.com/breml/bidichk v0.3.3/go.mod h1:ISbsut8OnjB367j5NseXEGGgO/th206dVa427kR8YTE=
 github.com/breml/errchkjson v0.4.1 h1:keFSS8D7A2T0haP9kzZTi7o26r7kE3vymjZNeNDRDwg=
 github.com/breml/errchkjson v0.4.1/go.mod h1:a23OvR6Qvcl7DG/Z4o0el6BRAjKnaReoPQFciAl9U3s=
+github.com/brunoga/deep v1.2.4 h1:Aj9E9oUbE+ccbyh35VC/NHlzzjfIVU69BXu2mt2LmL8=
+github.com/brunoga/deep v1.2.4/go.mod h1:GDV6dnXqn80ezsLSZ5Wlv1PdKAWAO4L5PnKYtv2dgaI=
 github.com/butuzov/ireturn v0.4.0 h1:+s76bF/PfeKEdbG8b54aCocxXmi0wvYdOVsWxVO7n8E=
 github.com/butuzov/ireturn v0.4.0/go.mod h1:ghI0FrCmap8pDWZwfPisFD1vEc56VKH4NpQUxDHta70=
 github.com/butuzov/mirror v1.3.0 h1:HdWCXzmwlQHdVhwvsfBb2Au0r3HyINry3bDWLYXiKoc=
@@ -166,6 +168,8 @@ github.com/ettle/strcase v0.2.0 h1:fGNiVF21fHXpX1niBgk0aROov1LagYsOwV/xqKDKR/Q=
 github.com/ettle/strcase v0.2.0/go.mod h1:DajmHElDSaX76ITe3/VHVyMin4LWSJN5Z909Wp+ED1A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
 github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
 github.com/firefart/nonamedreturns v1.0.6 h1:vmiBcKV/3EqKY3ZiPxCINmpS431OcE1S47AQUwhrg8E=
@@ -329,23 +333,19 @@ github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
-github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/huandu/xstrings v1.4.0 h1:D17IlohoQq4UcpqD7fDk80P7l+lwAmlFaBHgOipl2FU=
-github.com/huandu/xstrings v1.4.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
-github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
-github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
+github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
+github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/jedib0t/go-pretty/v6 v6.6.7 h1:m+LbHpm0aIAPLzLbMfn8dc3Ht8MW7lsSO4MPItz/Uuo=
+github.com/jedib0t/go-pretty/v6 v6.6.7/go.mod h1:YwC5CE4fJ1HFUDeivSV1r//AmANFHyqczZk+U6BDALU=
 github.com/jgautheron/goconst v1.8.1 h1:PPqCYp3K/xlOj5JmIe6O1Mj6r1DbkdbLtR3AJuZo414=
 github.com/jgautheron/goconst v1.8.1/go.mod h1:A0oxgBCHy55NQn6sYpO7UdnA9p+h7cPtoOZUmvNIako=
 github.com/jingyugao/rowserrcheck v1.1.1 h1:zibz55j/MJtLsjP1OF4bSdgXxwL1b+Vn7Tjzq7gFzUs=
 github.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c=
-github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
-github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
 github.com/jjti/go-spancheck v0.6.4 h1:Tl7gQpYf4/TMU7AT84MN83/6PutY21Nb9fuQjFTpRRc=
 github.com/jjti/go-spancheck v0.6.4/go.mod h1:yAEYdKJ2lRkDA8g7X+oKUHXOWVAXSBJRv04OhF+QUjk=
 github.com/josephspurrier/goversioninfo v1.5.0 h1:9TJtORoyf4YMoWSOo/cXFN9A/lB3PniJ91OxIH6e7Zg=
@@ -368,6 +368,20 @@ github.com/kisielk/errcheck v1.9.0/go.mod h1:kQxWMMVZgIkDq7U8xtG/n2juOjbLgZtedi0
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kkHAIKE/contextcheck v1.1.6 h1:7HIyRcnyzxL9Lz06NGhiKvenXq7Zw6Q0UQu/ttjfJCE=
 github.com/kkHAIKE/contextcheck v1.1.6/go.mod h1:3dDbMRNBFaq8HFXWC1JyvDSPm43CmE6IuHam8Wr0rkg=
+github.com/knadh/koanf/maps v0.1.1 h1:G5TjmUh2D7G2YWf5SQQqSiHRJEjaicvU0KpypqB3NIs=
+github.com/knadh/koanf/maps v0.1.1/go.mod h1:npD/QZY3V6ghQDdcQzl1W4ICNVTkohC8E73eI2xW4yI=
+github.com/knadh/koanf/parsers/yaml v0.1.0 h1:ZZ8/iGfRLvKSaMEECEBPM1HQslrZADk8fP1XFUxVI5w=
+github.com/knadh/koanf/parsers/yaml v0.1.0/go.mod h1:cvbUDC7AL23pImuQP0oRw/hPuccrNBS2bps8asS0CwY=
+github.com/knadh/koanf/providers/env v1.0.0 h1:ufePaI9BnWH+ajuxGGiJ8pdTG0uLEUWC7/HDDPGLah0=
+github.com/knadh/koanf/providers/env v1.0.0/go.mod h1:mzFyRZueYhb37oPmC1HAv/oGEEuyvJDA98r3XAa8Gak=
+github.com/knadh/koanf/providers/file v1.1.2 h1:aCC36YGOgV5lTtAFz2qkgtWdeQsgfxUkxDOe+2nQY3w=
+github.com/knadh/koanf/providers/file v1.1.2/go.mod h1:/faSBcv2mxPVjFrXck95qeoyoZ5myJ6uxN8OOVNJJCI=
+github.com/knadh/koanf/providers/posflag v0.1.0 h1:mKJlLrKPcAP7Ootf4pBZWJ6J+4wHYujwipe7Ie3qW6U=
+github.com/knadh/koanf/providers/posflag v0.1.0/go.mod h1:SYg03v/t8ISBNrMBRMlojH8OsKowbkXV7giIbBVgbz0=
+github.com/knadh/koanf/providers/structs v0.1.0 h1:wJRteCNn1qvLtE5h8KQBvLJovidSdntfdyIbbCzEyE0=
+github.com/knadh/koanf/providers/structs v0.1.0/go.mod h1:sw2YZ3txUcqA3Z27gPlmmBzWn1h8Nt9O6EP/91MkcWE=
+github.com/knadh/koanf/v2 v2.1.2 h1:I2rtLRqXRy1p01m/utEtpZSSA6dcJbgGVuE27kW2PzQ=
+github.com/knadh/koanf/v2 v2.1.2/go.mod h1:Gphfaen0q1Fc1HTgJgSTC4oRX9R2R5ErYMZJy8fLJBo=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
@@ -400,8 +414,6 @@ github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/macabu/inamedparam v0.2.0 h1:VyPYpOc10nkhI2qeNUdh3Zket4fcZjEWe35poddBCpE=
 github.com/macabu/inamedparam v0.2.0/go.mod h1:+Pee9/YfGe5LJ62pYXqB89lJ+0k5bsR8Wgz/C0Zlq3U=
-github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a8RkpQM=
-github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/manuelarte/funcorder v0.2.1 h1:7QJsw3qhljoZ5rH0xapIvjw31EcQeFbF31/7kQ/xS34=
 github.com/manuelarte/funcorder v0.2.1/go.mod h1:BQQ0yW57+PF9ZpjpeJDKOffEsQbxDFKW8F8zSMe/Zd0=
 github.com/maratori/testableexamples v1.0.0 h1:dU5alXRrD8WKSjOUnmJZuzdxWOEQ57+7s93SLMxb2vI=
@@ -426,10 +438,12 @@ github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0j
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mgechev/revive v1.9.0 h1:8LaA62XIKrb8lM6VsBSQ92slt/o92z5+hTw3CmrvSrM=
 github.com/mgechev/revive v1.9.0/go.mod h1:LAPq3+MgOf7GcL5PlWIkHb0PT7XH4NuC2LdWymhb9Mo=
+github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
+github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
+github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -525,8 +539,6 @@ github.com/ryanrolds/sqlclosecheck v0.5.1 h1:dibWW826u0P8jNLsLN+En7+RqWWTYrjCB9f
 github.com/ryanrolds/sqlclosecheck v0.5.1/go.mod h1:2g3dUjoS6AL4huFdv6wn55WpLIDjY7ZgUR4J8HOO/XQ=
 github.com/sagikazarmark/locafero v0.7.0 h1:5MqpDsTGNDhY8sGp0Aowyf0qKsPrhewaLSsFaodPcyo=
 github.com/sagikazarmark/locafero v0.7.0/go.mod h1:2za3Cg5rMaTMoG/2Ulr9AwtFaIppKXTRYnozin4aB5k=
-github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
-github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
 github.com/sanposhiho/wastedassign/v2 v2.1.0 h1:crurBF7fJKIORrV85u9UUpePDYGWnwvv3+A96WvwXT0=
 github.com/sanposhiho/wastedassign/v2 v2.1.0/go.mod h1:+oSmSC+9bQ+VUAxA66nBb0Z7N8CK7mscKTDYC6aIek4=
 github.com/santhosh-tekuri/jsonschema/v6 v6.0.1 h1:PKK9DyHxif4LZo+uQSgXNqs0jj5+xZwwfKHgph2lxBw=
@@ -563,8 +575,8 @@ github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wx
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
-github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
+github.com/spf13/viper v1.20.0 h1:zrxIyR3RQIOsarIrgL8+sAvALXul9jeEPa06Y0Ph6vY=
+github.com/spf13/viper v1.20.0/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=
 github.com/ssgreg/nlreturn/v2 v2.2.1 h1:X4XDI7jstt3ySqGU86YGAURbxw3oTDPK9sPEi6YEwQ0=
 github.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRkkxBiELzh2I=
 github.com/stbenjam/no-sprintf-host-port v0.2.0 h1:i8pxvGrt1+4G0czLr/WnmyH7zbZ8Bg8etvARQ1rpyl4=
@@ -611,8 +623,14 @@ github.com/uudashr/gocognit v1.2.0 h1:3BU9aMr1xbhPlvJLSydKwdLN3tEUUrzPSSM8S4hDYR
 github.com/uudashr/gocognit v1.2.0/go.mod h1:k/DdKPI6XBZO1q7HgoV2juESI2/Ofj9AcHPZhBBdrTU=
 github.com/uudashr/iface v1.3.1 h1:bA51vmVx1UIhiIsQFSNq6GZ6VPTk3WNMZgRiCe9R29U=
 github.com/uudashr/iface v1.3.1/go.mod h1:4QvspiRd3JLPAEXBQ9AiZpLbJlrWWgRChOKDJEuQTdg=
-github.com/vektra/mockery/v2 v2.53.1 h1:nXP4LsUbuzpR1zA1JWN4E4bGiyPBBCZkICkU4DT2BEg=
-github.com/vektra/mockery/v2 v2.53.1/go.mod h1:UJT+mgXhCcOCHXTnM5cJHCZL+d76BYB+EbY1sFztEB8=
+github.com/vektra/mockery/v3 v3.2.2 h1:WtuX8rnImYBaMe03n/LOya9aBCoTCNlaoof2qPnZETE=
+github.com/vektra/mockery/v3 v3.2.2/go.mod h1:UQwIbP5U84gbN/nkMyYVSW+tp7BFhaSym907rfS1HL4=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
+github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xen0n/gosmopolitan v1.3.0 h1:zAZI1zefvo7gcpbCOrPSHJZJYA9ZgLfJqtKzZ5pHqQM=
 github.com/xen0n/gosmopolitan v1.3.0/go.mod h1:rckfr5T6o4lBtM1ga7mLGKZmLxswUoH1zxHgNXOsEt4=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
@@ -1001,8 +1019,6 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
-gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/internal/tools/tools.go b/internal/tools/tools.go
index 268c1657..7c7d11aa 100644
--- a/internal/tools/tools.go
+++ b/internal/tools/tools.go
@@ -15,5 +15,5 @@ import (
 
 	_ "github.com/golangci/golangci-lint/v2/cmd/golangci-lint"
 	_ "github.com/josephspurrier/goversioninfo/cmd/goversioninfo"
-	_ "github.com/vektra/mockery/v2"
+	_ "github.com/vektra/mockery/v3"
 )



Test patch:
diff --git a/cmd/jaeger/internal/extension/remotestorage/config.go b/cmd/jaeger/internal/extension/remotestorage/config.go
new file mode 100644
index 00000000..b39005a3
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/config.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"github.com/asaskevich/govalidator"
+
+	"github.com/jaegertracing/jaeger/cmd/remote-storage/app"
+)
+
+type Config struct {
+	app.Options `mapstructure:",squash"`
+	Storage     string `mapstructure:"storage" valid:"required"`
+}
+
+func (cfg *Config) Validate() error {
+	_, err := govalidator.ValidateStruct(cfg)
+	return err
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/config_test.go b/cmd/jaeger/internal/extension/remotestorage/config_test.go
new file mode 100644
index 00000000..000d8862
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/config_test.go
@@ -0,0 +1,42 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestValidate(t *testing.T) {
+	tests := []struct {
+		name        string
+		config      *Config
+		expectedErr string
+	}{
+		{
+			name:        "Empty config",
+			config:      &Config{},
+			expectedErr: "Storage: non zero value required",
+		},
+		{
+			name: "Non empty-config",
+			config: &Config{
+				Storage: "some-storage",
+			},
+			expectedErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.Validate()
+			if tt.expectedErr == "" {
+				require.NoError(t, err)
+			} else {
+				require.Equal(t, tt.expectedErr, err.Error())
+			}
+		})
+	}
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/factory.go b/cmd/jaeger/internal/extension/remotestorage/factory.go
new file mode 100644
index 00000000..dcde0a3d
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/factory.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"context"
+
+	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/config/configgrpc"
+	"go.opentelemetry.io/collector/config/confignet"
+	"go.opentelemetry.io/collector/extension"
+
+	"github.com/jaegertracing/jaeger/cmd/remote-storage/app"
+	"github.com/jaegertracing/jaeger/ports"
+)
+
+// componentType is the name of this extension in configuration.
+var componentType = component.MustNewType("remote_storage")
+
+// ID is the identifier of this extension.
+var ID = component.NewID(componentType)
+
+func NewFactory() extension.Factory {
+	return extension.NewFactory(
+		componentType,
+		createDefaultConfig,
+		createExtension,
+		component.StabilityLevelDevelopment,
+	)
+}
+
+func createDefaultConfig() component.Config {
+	return &Config{
+		Options: app.Options{
+			ServerConfig: configgrpc.ServerConfig{
+				NetAddr: confignet.AddrConfig{
+					Endpoint:  ports.PortToHostPort(ports.RemoteStorageGRPC),
+					Transport: confignet.TransportTypeTCP,
+				},
+			},
+		},
+	}
+}
+
+func createExtension(
+	_ context.Context,
+	set extension.Settings,
+	cfg component.Config,
+) (extension.Extension, error) {
+	return newServer(cfg.(*Config), set.TelemetrySettings), nil
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/factory_test.go b/cmd/jaeger/internal/extension/remotestorage/factory_test.go
new file mode 100644
index 00000000..6d8dceda
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/factory_test.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/extension"
+)
+
+func TestNewFactory(t *testing.T) {
+	factory := NewFactory()
+	require.Equal(t, componentType, factory.Type())
+	require.Equal(t, factory.CreateDefaultConfig(), createDefaultConfig())
+}
+
+func TestCreateExtension(t *testing.T) {
+	set := extension.Settings{
+		ID: ID,
+	}
+	cfg := createDefaultConfig()
+	ext, err := createExtension(context.Background(), set, cfg)
+
+	require.NoError(t, err)
+	require.NotNil(t, ext)
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/package_test.go b/cmd/jaeger/internal/extension/remotestorage/package_test.go
new file mode 100644
index 00000000..2be5776d
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/package_test.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"testing"
+
+	"github.com/jaegertracing/jaeger/internal/testutils"
+)
+
+func TestMain(m *testing.M) {
+	testutils.VerifyGoLeaks(m)
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/server.go b/cmd/jaeger/internal/extension/remotestorage/server.go
new file mode 100644
index 00000000..f343dfea
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/server.go
@@ -0,0 +1,95 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"go.opentelemetry.io/collector/component"
+
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage"
+	"github.com/jaegertracing/jaeger/cmd/remote-storage/app"
+	"github.com/jaegertracing/jaeger/internal/jtracer"
+	"github.com/jaegertracing/jaeger/internal/metrics"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
+	"github.com/jaegertracing/jaeger/internal/telemetry"
+	"github.com/jaegertracing/jaeger/internal/tenancy"
+)
+
+type server struct {
+	config      *Config
+	server      *app.Server
+	telset      component.TelemetrySettings
+	closeTracer func(ctx context.Context) error
+}
+
+func newServer(config *Config, otel component.TelemetrySettings) *server {
+	return &server{
+		config: config,
+		telset: otel,
+	}
+}
+
+func (*server) Dependencies() []component.ID {
+	return []component.ID{jaegerstorage.ID}
+}
+
+func (s *server) Start(ctx context.Context, host component.Host) error {
+	// TODO OTel-collector does not initialize the tracer currently
+	// https://github.com/open-telemetry/opentelemetry-collector/issues/7532
+	//nolint
+	tracerProvider, err := jtracer.New("jaeger")
+	if err != nil {
+		return fmt.Errorf("could not initialize a tracer: %w", err)
+	}
+	// make sure to close the tracer if subsequent code exists with error
+	success := false
+	defer func(ctx context.Context) {
+		if success {
+			s.closeTracer = tracerProvider.Close
+		} else {
+			tracerProvider.Close(ctx)
+		}
+	}(ctx)
+
+	telset := telemetry.FromOtelComponent(s.telset, host)
+	telset.TracerProvider = tracerProvider.OTEL
+	telset.Metrics = telset.Metrics.
+		Namespace(metrics.NSOptions{Name: "jaeger"}).
+		Namespace(metrics.NSOptions{Name: "remote_storage"})
+	tf, err := jaegerstorage.GetTraceStoreFactory(s.config.Storage, host)
+	if err != nil {
+		return fmt.Errorf("cannot find factory for trace storage %s: %w", s.config.Storage, err)
+	}
+
+	df, ok := tf.(depstore.Factory)
+	if !ok {
+		return fmt.Errorf("cannot find factory for dependency storage %s: %w", s.config.Storage, err)
+	}
+
+	tm := tenancy.NewManager(&s.config.Tenancy)
+	s.server, err = app.NewServer(ctx, &s.config.Options, tf, df, tm, telset)
+	if err != nil {
+		return fmt.Errorf("could not create remote storage server: %w", err)
+	}
+	if err := s.server.Start(ctx); err != nil {
+		return fmt.Errorf("could not start jaeger remote storage server: %w", err)
+	}
+	success = true
+
+	return nil
+}
+
+func (s *server) Shutdown(ctx context.Context) error {
+	var errs []error
+	if s.server != nil {
+		errs = append(errs, s.server.Close())
+	}
+	if s.closeTracer != nil {
+		errs = append(errs, s.closeTracer(ctx))
+	}
+	return errors.Join(errs...)
+}
diff --git a/cmd/jaeger/internal/extension/remotestorage/server_test.go b/cmd/jaeger/internal/extension/remotestorage/server_test.go
new file mode 100644
index 00000000..a3184d31
--- /dev/null
+++ b/cmd/jaeger/internal/extension/remotestorage/server_test.go
@@ -0,0 +1,176 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package remotestorage
+
+import (
+	"context"
+	"testing"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/extension/storage/storagetest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/config/confignet"
+	noopmetric "go.opentelemetry.io/otel/metric/noop"
+	nooptrace "go.opentelemetry.io/otel/trace/noop"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
+
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage"
+	"github.com/jaegertracing/jaeger/internal/grpctest"
+	"github.com/jaegertracing/jaeger/internal/storage/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore"
+	depstoremocks "github.com/jaegertracing/jaeger/internal/storage/v2/api/depstore/mocks"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
+	tracestoremocks "github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore/mocks"
+)
+
+type fakeTraceStorageFactory struct {
+	name string
+}
+
+func (ff fakeTraceStorageFactory) CreateTraceReader() (tracestore.Reader, error) {
+	if ff.name == "need-trace-reader-error" {
+		return nil, assert.AnError
+	}
+	return &tracestoremocks.Reader{}, nil
+}
+
+func (ff fakeTraceStorageFactory) CreateTraceWriter() (tracestore.Writer, error) {
+	if ff.name == "need-span-writer-error" {
+		return nil, assert.AnError
+	}
+	return &tracestoremocks.Writer{}, nil
+}
+
+type fakeDependenciesStorageFactory struct {
+	name string
+}
+
+func (ff fakeDependenciesStorageFactory) CreateDependencyReader() (depstore.Reader, error) {
+	if ff.name == "need-dependency-reader-error" {
+		return nil, assert.AnError
+	}
+	return &depstoremocks.Reader{}, nil
+}
+
+type fakeFactory struct {
+	fakeTraceStorageFactory
+	fakeDependenciesStorageFactory
+}
+
+func newFakeFactory(name string) *fakeFactory {
+	return &fakeFactory{
+		fakeTraceStorageFactory:        fakeTraceStorageFactory{name: name},
+		fakeDependenciesStorageFactory: fakeDependenciesStorageFactory{name: name},
+	}
+}
+
+type fakeStorageExt struct{}
+
+var _ jaegerstorage.Extension = (*fakeStorageExt)(nil)
+
+func (fakeStorageExt) TraceStorageFactory(name string) (tracestore.Factory, bool) {
+	switch name {
+	case "need-factory-error":
+		return nil, false
+	case "without-dependency-storage":
+		return fakeTraceStorageFactory{name: name}, true
+	}
+
+	return newFakeFactory(name), true
+}
+
+func (fakeStorageExt) MetricStorageFactory(string) (storage.MetricStoreFactory, bool) {
+	return nil, false
+}
+
+func (fakeStorageExt) Start(context.Context, component.Host) error {
+	return nil
+}
+
+func (fakeStorageExt) Shutdown(context.Context) error {
+	return nil
+}
+
+func TestServer_Dependencies(t *testing.T) {
+	expectedDependencies := []component.ID{jaegerstorage.ID}
+	telemetrySettings := component.TelemetrySettings{
+		Logger: zaptest.NewLogger(t, zaptest.WrapOptions(zap.AddCaller())),
+	}
+
+	server := newServer(createDefaultConfig().(*Config), telemetrySettings)
+	dependencies := server.Dependencies()
+
+	require.Equal(t, expectedDependencies, dependencies)
+}
+
+func TestServer_Start(t *testing.T) {
+	host := storagetest.NewStorageHost().WithExtension(jaegerstorage.ID, fakeStorageExt{})
+	tests := []struct {
+		name        string
+		config      *Config
+		expectedErr string
+	}{
+		{
+			name: "Real server with non-empty config",
+			config: &Config{
+				Storage: "jaeger_storage",
+			},
+		},
+		{
+			name: "no trace storage factory",
+			config: &Config{
+				Storage: "need-factory-error",
+			},
+			expectedErr: "cannot find factory for trace storage",
+		},
+		{
+			name: "no dependency storage factory",
+			config: &Config{
+				Storage: "without-dependency-storage",
+			},
+			expectedErr: "cannot find factory for dependency storage",
+		},
+		{
+			name: "error creating server",
+			config: &Config{
+				Storage: "need-trace-reader-error",
+			},
+			expectedErr: "could not create remote storage server",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Despite using Noop Tracer below, query service also creates jtracer.
+			// We want to prevent that tracer from sampling anything in this test.
+			t.Setenv("OTEL_TRACES_SAMPLER", "always_off")
+			telemetrySettings := component.TelemetrySettings{
+				Logger:         zaptest.NewLogger(t, zaptest.WrapOptions(zap.AddCaller())),
+				MeterProvider:  noopmetric.NewMeterProvider(),
+				TracerProvider: nooptrace.NewTracerProvider(),
+			}
+			tt.config.NetAddr.Endpoint = "localhost:0"
+			tt.config.NetAddr.Transport = confignet.TransportTypeTCP
+			server := newServer(tt.config, telemetrySettings)
+			err := server.Start(context.Background(), host)
+			if tt.expectedErr == "" {
+				require.NoError(t, err)
+				defer server.Shutdown(context.Background())
+				grpctest.ReflectionServiceValidator{
+					HostPort: server.server.GRPCAddr(),
+					ExpectedServices: []string{
+						"jaeger.storage.v2.TraceReader",
+						"jaeger.storage.v2.DependencyReader",
+						"opentelemetry.proto.collector.trace.v1.TraceService",
+						"grpc.health.v1.Health",
+					},
+				}.Execute(t)
+			} else {
+				require.ErrorContains(t, err, tt.expectedErr)
+			}
+		})
+	}
+}
diff --git a/cmd/jaeger/internal/integration/grpc_test.go b/cmd/jaeger/internal/integration/grpc_test.go
index a47103a3..c9d3feb6 100644
--- a/cmd/jaeger/internal/integration/grpc_test.go
+++ b/cmd/jaeger/internal/integration/grpc_test.go
@@ -7,43 +7,32 @@ import (
 	"testing"
 
 	"github.com/jaegertracing/jaeger/internal/storage/integration"
-	"github.com/jaegertracing/jaeger/ports"
 )
 
-type GRPCStorageIntegration struct {
-	E2EStorageIntegration
-
-	remoteStorage        *integration.RemoteMemoryStorage
-	archiveRemoteStorage *integration.RemoteMemoryStorage
-}
-
-func (s *GRPCStorageIntegration) initializeRemoteStorages(t *testing.T) {
-	s.remoteStorage = integration.StartNewRemoteMemoryStorage(t, ports.RemoteStorageGRPC)
-	s.archiveRemoteStorage = integration.StartNewRemoteMemoryStorage(t, ports.RemoteStorageGRPC+1)
-}
-
-func (s *GRPCStorageIntegration) closeRemoteStorages(t *testing.T) {
-	s.remoteStorage.Close(t)
-	s.archiveRemoteStorage.Close(t)
-}
-
-func (s *GRPCStorageIntegration) cleanUp(t *testing.T) {
-	s.closeRemoteStorages(t)
-	s.initializeRemoteStorages(t)
-}
-
 func TestGRPCStorage(t *testing.T) {
 	integration.SkipUnlessEnv(t, "grpc")
 
-	s := &GRPCStorageIntegration{
-		E2EStorageIntegration: E2EStorageIntegration{
-			ConfigFile:         "../../config-remote-storage.yaml",
-			SkipStorageCleaner: true,
+	remoteBackend := &E2EStorageIntegration{
+		ConfigFile:      "../../config-remote-storage-backend.yaml",
+		HealthCheckPort: 12133,
+		MetricsPort:     8887,
+		EnvVarOverrides: map[string]string{
+			"JAEGER_QUERY_GRPC_ENDPOINT": "localhost:0",
+			"JAEGER_QUERY_HTTP_ENDPOINT": "localhost:0",
 		},
 	}
-	s.CleanUp = s.cleanUp
-	s.initializeRemoteStorages(t)
-	s.e2eInitialize(t, "grpc")
-	t.Cleanup(func() { s.closeRemoteStorages(t) })
-	s.RunSpanStoreTests(t)
+	remoteBackend.e2eInitialize(t, "memory")
+	t.Log("Remote backend initialized")
+
+	collector := &E2EStorageIntegration{
+		ConfigFile:         "../../config-remote-storage.yaml",
+		SkipStorageCleaner: true,
+		StorageIntegration: integration.StorageIntegration{
+			CleanUp: purge,
+		},
+	}
+	collector.e2eInitialize(t, "grpc")
+	t.Log("Collector initialized")
+
+	collector.RunSpanStoreTests(t)
 }
diff --git a/cmd/jaeger/internal/integration/query_test.go b/cmd/jaeger/internal/integration/query_test.go
index b120befc..a2bc2ce0 100644
--- a/cmd/jaeger/internal/integration/query_test.go
+++ b/cmd/jaeger/internal/integration/query_test.go
@@ -17,30 +17,24 @@ func TestJaegerQueryService(t *testing.T) {
 	query := &E2EStorageIntegration{
 		ConfigFile:         "../../config-query.yaml",
 		SkipStorageCleaner: true,
-		// referencing values in config-query.yaml
-		HealthCheckPort: 12133,
-		MetricsPort:     8887,
 	}
 	query.e2eInitialize(t, "grpc")
 	t.Log("Query initialized")
 
 	// Start another instance of Jaeger receiving traces and write traces to Remote Storage
-	collector := &GRPCStorageIntegration{
-		E2EStorageIntegration: E2EStorageIntegration{
-			ConfigFile:         "../../config-remote-storage.yaml",
-			SkipStorageCleaner: true,
-			EnvVarOverrides: map[string]string{
-				// Run jaeger_query on different ports here to avoid conflict
-				// with jaeger_query instance of Jaeger above
-				"JAEGER_QUERY_GRPC_ENDPOINT": "localhost:0",
-				"JAEGER_QUERY_HTTP_ENDPOINT": "localhost:0",
-			},
+	collector := &E2EStorageIntegration{
+		ConfigFile:      "../../config-remote-storage-backend.yaml",
+		HealthCheckPort: 12133,
+		MetricsPort:     8887,
+		EnvVarOverrides: map[string]string{
+			"JAEGER_QUERY_GRPC_ENDPOINT": "localhost:0",
+			"JAEGER_QUERY_HTTP_ENDPOINT": "localhost:0",
+		},
+		StorageIntegration: integration.StorageIntegration{
+			CleanUp: purge,
 		},
 	}
-	collector.CleanUp = collector.cleanUp
-	collector.initializeRemoteStorages(t)
-	collector.e2eInitialize(t, "grpc")
-	t.Cleanup(func() { collector.closeRemoteStorages(t) })
+	collector.e2eInitialize(t, "memory")
 	t.Log("Collector initialized")
 
 	collector.RunSpanStoreTests(t)
diff --git a/cmd/query/app/apiv3/gateway_test.go b/cmd/query/app/apiv3/gateway_test.go
index f5f3a599..f6605149 100644
--- a/cmd/query/app/apiv3/gateway_test.go
+++ b/cmd/query/app/apiv3/gateway_test.go
@@ -143,7 +143,7 @@ func (gw *testGateway) runGatewayGetOperations(t *testing.T) {
 }
 
 func (gw *testGateway) runGatewayGetTrace(t *testing.T) {
-	query := tracestore.GetTraceParams{TraceID: traceID}
+	query := []tracestore.GetTraceParams{{TraceID: traceID}}
 	gw.reader.
 		On("GetTraces", matchContext, query).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
diff --git a/cmd/query/app/apiv3/grpc_handler_test.go b/cmd/query/app/apiv3/grpc_handler_test.go
index ef9e1467..dd8e03df 100644
--- a/cmd/query/app/apiv3/grpc_handler_test.go
+++ b/cmd/query/app/apiv3/grpc_handler_test.go
@@ -108,7 +108,7 @@ func TestGetTrace(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			tsc := newTestServerClient(t)
-			tsc.reader.On("GetTraces", matchContext, tc.expectedQuery).
+			tsc.reader.On("GetTraces", matchContext, []tracestore.GetTraceParams{tc.expectedQuery}).
 				Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 					yield([]ptrace.Traces{makeTestTrace()}, nil)
 				})).Once()
@@ -127,7 +127,7 @@ func TestGetTrace(t *testing.T) {
 
 func TestGetTraceStorageError(t *testing.T) {
 	tsc := newTestServerClient(t)
-	tsc.reader.On("GetTraces", matchContext, tracestore.GetTraceParams{TraceID: traceID}).
+	tsc.reader.On("GetTraces", matchContext, []tracestore.GetTraceParams{{TraceID: traceID}}).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield(nil, assert.AnError)
 		})).Once()
diff --git a/cmd/query/app/apiv3/http_gateway_test.go b/cmd/query/app/apiv3/http_gateway_test.go
index ecddfdf9..4a75f572 100644
--- a/cmd/query/app/apiv3/http_gateway_test.go
+++ b/cmd/query/app/apiv3/http_gateway_test.go
@@ -126,9 +126,8 @@ func TestHTTPGatewayGetTrace(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			gw := setupHTTPGatewayNoServer(t, "")
-
 			gw.reader.
-				On("GetTraces", matchContext, tc.expectedQuery).
+				On("GetTraces", matchContext, []tracestore.GetTraceParams{tc.expectedQuery}).
 				Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 					yield([]ptrace.Traces{makeTestTrace()}, nil)
 				})).Once()
@@ -146,14 +145,14 @@ func TestHTTPGatewayGetTrace(t *testing.T) {
 			require.NoError(t, err)
 			w := httptest.NewRecorder()
 			gw.router.ServeHTTP(w, r)
-			gw.reader.AssertCalled(t, "GetTraces", matchContext, tc.expectedQuery)
+			gw.reader.AssertCalled(t, "GetTraces", matchContext, []tracestore.GetTraceParams{tc.expectedQuery})
 		})
 	}
 }
 
 func TestHTTPGatewayGetTraceEmptyResponse(t *testing.T) {
 	gw := setupHTTPGatewayNoServer(t, "")
-	gw.reader.On("GetTraces", matchContext, mock.AnythingOfType("tracestore.GetTraceParams")).
+	gw.reader.On("GetTraces", matchContext, mock.AnythingOfType("[]tracestore.GetTraceParams")).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield([]ptrace.Traces{}, nil)
 		})).Once()
@@ -231,7 +230,7 @@ func TestHTTPGatewayGetTraceMalformedInputErrors(t *testing.T) {
 
 func TestHTTPGatewayGetTraceInternalErrors(t *testing.T) {
 	gw := setupHTTPGatewayNoServer(t, "")
-	gw.reader.On("GetTraces", matchContext, mock.AnythingOfType("tracestore.GetTraceParams")).
+	gw.reader.On("GetTraces", matchContext, mock.AnythingOfType("[]tracestore.GetTraceParams")).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield([]ptrace.Traces{}, assert.AnError)
 		})).Once()
diff --git a/cmd/query/app/querysvc/v2/querysvc/service_test.go b/cmd/query/app/querysvc/v2/querysvc/service_test.go
index 1dc9382f..92281b14 100644
--- a/cmd/query/app/querysvc/v2/querysvc/service_test.go
+++ b/cmd/query/app/querysvc/v2/querysvc/service_test.go
@@ -97,7 +97,7 @@ func makeTestTrace() ptrace.Traces {
 
 func TestGetTraces_ErrorInReader(t *testing.T) {
 	tqs := initializeTestService()
-	tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+	tqs.traceReader.On("GetTraces", mock.Anything, []tracestore.GetTraceParams{{TraceID: testTraceID}}).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield(nil, assert.AnError)
 		})).Once()
@@ -116,16 +116,14 @@ func TestGetTraces_ErrorInReader(t *testing.T) {
 
 func TestGetTraces_Success(t *testing.T) {
 	tqs := initializeTestService()
-	tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+	params := GetTraceParams{
+		TraceIDs: []tracestore.GetTraceParams{{TraceID: testTraceID}},
+	}
+	tqs.traceReader.On("GetTraces", mock.Anything, params.TraceIDs).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield([]ptrace.Traces{makeTestTrace()}, nil)
 		})).Once()
 
-	params := GetTraceParams{
-		TraceIDs: []tracestore.GetTraceParams{
-			{TraceID: testTraceID},
-		},
-	}
 	getTracesIter := tqs.queryService.GetTraces(context.Background(), params)
 	gotTraces, err := jiter.FlattenWithErrors(getTracesIter)
 	require.NoError(t, err)
@@ -187,17 +185,13 @@ func TestGetTraces_WithRawTraces(t *testing.T) {
 			})
 
 			tqs := initializeTestService()
-			tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
-				Return(responseIter).Once()
-
 			params := GetTraceParams{
-				TraceIDs: []tracestore.GetTraceParams{
-					{
-						TraceID: testTraceID,
-					},
-				},
+				TraceIDs:  []tracestore.GetTraceParams{{TraceID: testTraceID}},
 				RawTraces: test.rawTraces,
 			}
+			tqs.traceReader.On("GetTraces", mock.Anything, params.TraceIDs).
+				Return(responseIter).Once()
+
 			getTracesIter := tqs.queryService.GetTraces(context.Background(), params)
 			gotTraces, err := jiter.FlattenWithErrors(getTracesIter)
 			require.NoError(t, err)
@@ -212,21 +206,20 @@ func TestGetTraces_WithRawTraces(t *testing.T) {
 func TestGetTraces_TraceInArchiveStorage(t *testing.T) {
 	tqs := initializeTestService(withArchiveTraceReader())
 
-	tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+	params := GetTraceParams{
+		TraceIDs: []tracestore.GetTraceParams{{TraceID: testTraceID}},
+	}
+
+	tqs.traceReader.On("GetTraces", mock.Anything, params.TraceIDs).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield([]ptrace.Traces{}, nil)
 		})).Once()
 
-	tqs.archiveTraceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+	tqs.archiveTraceReader.On("GetTraces", mock.Anything, params.TraceIDs).
 		Return(iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 			yield([]ptrace.Traces{makeTestTrace()}, nil)
 		})).Once()
 
-	params := GetTraceParams{
-		TraceIDs: []tracestore.GetTraceParams{
-			{TraceID: testTraceID},
-		},
-	}
 	getTracesIter := tqs.queryService.GetTraces(context.Background(), params)
 	gotTraces, err := jiter.FlattenWithErrors(getTracesIter)
 	require.NoError(t, err)
@@ -512,6 +505,7 @@ func TestFindTraces_WithRawTraces_PerformsAggregation(t *testing.T) {
 }
 
 func TestArchiveTrace(t *testing.T) {
+	paramsTraceIDs := []tracestore.GetTraceParams{{TraceID: testTraceID}}
 	tests := []struct {
 		name          string
 		options       []testOption
@@ -531,7 +525,7 @@ func TestArchiveTrace(t *testing.T) {
 				responseIter := iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 					yield([]ptrace.Traces{}, assert.AnError)
 				})
-				tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+				tqs.traceReader.On("GetTraces", mock.Anything, paramsTraceIDs).
 					Return(responseIter).Once()
 			},
 			expectedError: assert.AnError,
@@ -543,7 +537,7 @@ func TestArchiveTrace(t *testing.T) {
 				responseIter := iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 					yield([]ptrace.Traces{makeTestTrace()}, nil)
 				})
-				tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+				tqs.traceReader.On("GetTraces", mock.Anything, paramsTraceIDs).
 					Return(responseIter).Once()
 				tqs.archiveTraceWriter.On("WriteTraces", mock.Anything, mock.AnythingOfType("ptrace.Traces")).
 					Return(assert.AnError).Once()
@@ -557,7 +551,7 @@ func TestArchiveTrace(t *testing.T) {
 				responseIter := iter.Seq2[[]ptrace.Traces, error](func(yield func([]ptrace.Traces, error) bool) {
 					yield([]ptrace.Traces{makeTestTrace()}, nil)
 				})
-				tqs.traceReader.On("GetTraces", mock.Anything, tracestore.GetTraceParams{TraceID: testTraceID}).
+				tqs.traceReader.On("GetTraces", mock.Anything, paramsTraceIDs).
 					Return(responseIter).Once()
 				tqs.archiveTraceWriter.On("WriteTraces", mock.Anything, mock.AnythingOfType("ptrace.Traces")).
 					Return(nil).Once()
diff --git a/cmd/remote-storage/app/server_test.go b/cmd/remote-storage/app/server_test.go
index a4446b99..ea045653 100644
--- a/cmd/remote-storage/app/server_test.go
+++ b/cmd/remote-storage/app/server_test.go
@@ -41,6 +41,7 @@ var testCertKeyLocation = "../../../internal/config/tlscfg/testdata"
 func TestNewServer_CreateStorageErrors(t *testing.T) {
 	createServer := func(factory *fakeFactory) (*Server, error) {
 		return NewServer(
+			context.Background(),
 			&Options{
 				ServerConfig: configgrpc.ServerConfig{
 					NetAddr: confignet.AddrConfig{
@@ -70,8 +71,8 @@ func TestNewServer_CreateStorageErrors(t *testing.T) {
 	factory = &fakeFactory{}
 	s, err := createServer(factory)
 	require.NoError(t, err)
-	require.NoError(t, s.Start())
-	validateGRPCServer(t, s.grpcConn.Addr().String())
+	require.NoError(t, s.Start(context.Background()))
+	validateGRPCServer(t, s.GRPCAddr())
 	require.NoError(t, s.grpcConn.Close())
 }
 
@@ -85,7 +86,7 @@ func TestServerStart_BadPortErrors(t *testing.T) {
 			},
 		},
 	}
-	require.Error(t, srv.Start())
+	require.Error(t, srv.Start(context.Background()))
 }
 
 type fakeFactory struct {
@@ -137,6 +138,7 @@ func TestNewServer_TLSConfigError(t *testing.T) {
 	}
 
 	_, err := NewServer(
+		context.Background(),
 		&Options{
 			ServerConfig: configgrpc.ServerConfig{
 				NetAddr: confignet.AddrConfig{
@@ -369,6 +371,7 @@ func TestServerGRPCTLS(t *testing.T) {
 				ReportStatus: telemetry.HCAdapter(flagsSvc.HC()),
 			}
 			server, err := NewServer(
+				context.Background(),
 				serverOptions,
 				f,
 				f,
@@ -376,7 +379,7 @@ func TestServerGRPCTLS(t *testing.T) {
 				telset,
 			)
 			require.NoError(t, err)
-			require.NoError(t, server.Start())
+			require.NoError(t, server.Start(context.Background()))
 
 			var clientError error
 			var client *grpcClient
@@ -385,9 +388,9 @@ func TestServerGRPCTLS(t *testing.T) {
 				clientTLSCfg, err0 := test.clientTLS.LoadTLSConfig(context.Background())
 				require.NoError(t, err0)
 				creds := credentials.NewTLS(clientTLSCfg)
-				client = newGRPCClient(t, server.grpcConn.Addr().String(), creds, tm)
+				client = newGRPCClient(t, server.GRPCAddr(), creds, tm)
 			} else {
-				client = newGRPCClient(t, server.grpcConn.Addr().String(), nil, tm)
+				client = newGRPCClient(t, server.GRPCAddr(), nil, tm)
 			}
 
 			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
@@ -418,6 +421,7 @@ func TestServerHandlesPortZero(t *testing.T) {
 		ReportStatus: telemetry.HCAdapter(flagsSvc.HC()),
 	}
 	server, err := NewServer(
+		context.Background(),
 		&Options{ServerConfig: configgrpc.ServerConfig{
 			NetAddr: confignet.AddrConfig{Endpoint: ":0"},
 		}},
@@ -428,7 +432,7 @@ func TestServerHandlesPortZero(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	require.NoError(t, server.Start())
+	require.NoError(t, server.Start(context.Background()))
 
 	const line = "Starting GRPC server"
 	message := logs.FilterMessage(line)
diff --git a/internal/storage/v1/elasticsearch/dependencystore/storage_test.go b/internal/storage/v1/elasticsearch/dependencystore/storage_test.go
index 53d10516..a36b2fd1 100644
--- a/internal/storage/v1/elasticsearch/dependencystore/storage_test.go
+++ b/internal/storage/v1/elasticsearch/dependencystore/storage_test.go
@@ -166,7 +166,7 @@ func TestGetDependencies(t *testing.T) {
 			fixedTime := time.Date(1995, time.April, 21, 4, 21, 19, 95, time.UTC)
 
 			searchService := &mocks.SearchService{}
-			r.client.On("Search", testCase.indices...).Return(searchService)
+			r.client.On("Search", mock.AnythingOfType("[]string")).Return(searchService)
 
 			searchService.On("Size", mock.MatchedBy(func(size int) bool {
 				return size == testCase.maxDocCount
diff --git a/internal/storage/v1/elasticsearch/samplingstore/storage_test.go b/internal/storage/v1/elasticsearch/samplingstore/storage_test.go
index c10b4d41..2fe550af 100644
--- a/internal/storage/v1/elasticsearch/samplingstore/storage_test.go
+++ b/internal/storage/v1/elasticsearch/samplingstore/storage_test.go
@@ -308,7 +308,7 @@ func TestGetThroughput(t *testing.T) {
 					test.indexPrefix += "-"
 				}
 				index := test.indexPrefix.Apply(test.index)
-				w.client.On("Search", index).Return(searchService)
+				w.client.On("Search", []string{index}).Return(searchService)
 				searchService.On("Size", mock.Anything).Return(searchService)
 				searchService.On("Query", mock.Anything).Return(searchService)
 				searchService.On("IgnoreUnavailable", true).Return(searchService)
@@ -404,7 +404,7 @@ func TestGetLatestProbabilities(t *testing.T) {
 			withEsSampling(test.indexPrefix, "2006-01-02", defaultMaxDocCount, func(w *samplingStorageTest) {
 				searchService := &mocks.SearchService{}
 				index := test.indexPrefix.Apply(test.index)
-				w.client.On("Search", index).Return(searchService)
+				w.client.On("Search", []string{index}).Return(searchService)
 				searchService.On("Size", mock.Anything).Return(searchService)
 				searchService.On("IgnoreUnavailable", true).Return(searchService)
 				searchService.On("Do", mock.Anything).Return(test.searchResult, test.searchError)
diff --git a/internal/storage/v1/elasticsearch/spanstore/reader_test.go b/internal/storage/v1/elasticsearch/spanstore/reader_test.go
index 75fd75ef..b6819aaa 100644
--- a/internal/storage/v1/elasticsearch/spanstore/reader_test.go
+++ b/internal/storage/v1/elasticsearch/spanstore/reader_test.go
@@ -356,11 +356,19 @@ func TestSpanReader_multiRead_followUp_query(t *testing.T) {
 		multiSearchService := &mocks.MultiSearchService{}
 		firstMultiSearch := &mocks.MultiSearchService{}
 		secondMultiSearch := &mocks.MultiSearchService{}
-		multiSearchService.On("Add", id1Search, id2Search).Return(firstMultiSearch)
-		multiSearchService.On("Add", id1SearchSpanTime).Return(secondMultiSearch)
-
-		firstMultiSearch.On("Index", mock.AnythingOfType("string")).Return(firstMultiSearch)
-		secondMultiSearch.On("Index", mock.AnythingOfType("string")).Return(secondMultiSearch)
+		multiSearchService.On("Add", mock.MatchedBy(func(searches []*elastic.SearchRequest) bool {
+			return len(searches) == 2 &&
+				reflect.DeepEqual(searches[0], id1Search) &&
+				reflect.DeepEqual(searches[1], id2Search)
+		})).Return(firstMultiSearch).Once()
+
+		multiSearchService.On("Add", mock.MatchedBy(func(searches []*elastic.SearchRequest) bool {
+			return len(searches) == 1 &&
+				reflect.DeepEqual(searches[0], id1SearchSpanTime)
+		})).Return(secondMultiSearch).Once()
+
+		firstMultiSearch.On("Index", mock.AnythingOfType("[]string")).Return(firstMultiSearch)
+		secondMultiSearch.On("Index", mock.AnythingOfType("[]string")).Return(secondMultiSearch)
 		r.client.On("MultiSearch").Return(multiSearchService)
 
 		fistMultiSearchMock := firstMultiSearch.On("Do", mock.Anything)
@@ -930,13 +938,12 @@ func TestFindTraceIDs(t *testing.T) {
 func mockMultiSearchService(r *spanReaderTest) *mock.Call {
 	multiSearchService := &mocks.MultiSearchService{}
 	multiSearchService.On("Add", mock.Anything, mock.Anything, mock.Anything).Return(multiSearchService)
-	multiSearchService.On("Index", mock.AnythingOfType("string"), mock.AnythingOfType("string"),
-		mock.AnythingOfType("string"), mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(multiSearchService)
+	multiSearchService.On("Index", mock.AnythingOfType("[]string")).Return(multiSearchService)
 	r.client.On("MultiSearch").Return(multiSearchService)
 	return multiSearchService.On("Do", mock.Anything)
 }
 
-func mockArchiveMultiSearchService(r *spanReaderTest, indexName string) *mock.Call {
+func mockArchiveMultiSearchService(r *spanReaderTest, indexName []string) *mock.Call {
 	multiSearchService := &mocks.MultiSearchService{}
 	multiSearchService.On("Add", mock.Anything, mock.Anything, mock.Anything).Return(multiSearchService)
 	multiSearchService.On("Index", indexName).Return(multiSearchService)
@@ -962,7 +969,7 @@ func mockSearchService(r *spanReaderTest) *mock.Call {
 	searchService.On("Aggregation", stringMatcher(servicesAggregation), mock.MatchedBy(matchTermsAggregation)).Return(searchService)
 	searchService.On("Aggregation", stringMatcher(operationsAggregation), mock.MatchedBy(matchTermsAggregation)).Return(searchService)
 	searchService.On("Aggregation", stringMatcher(traceIDAggregation), mock.AnythingOfType("*elastic.TermsAggregation")).Return(searchService)
-	r.client.On("Search", mock.AnythingOfType("string"), mock.AnythingOfType("string"), mock.AnythingOfType("string"), mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(searchService)
+	r.client.On("Search", mock.AnythingOfType("[]string")).Return(searchService)
 	return searchService.On("Do", mock.Anything)
 }
 
@@ -1220,7 +1227,7 @@ func TestSpanReader_ArchiveTraces(t *testing.T) {
 			withArchiveSpanReader(t, tc.useAliases, tc.suffix, func(r *spanReaderTest) {
 				mockSearchService(r).
 					Return(&elastic.SearchResult{}, nil)
-				mockArchiveMultiSearchService(r, tc.expected).
+				mockArchiveMultiSearchService(r, []string{tc.expected}).
 					Return(&elastic.MultiSearchResult{
 						Responses: []*elastic.SearchResult{},
 					}, nil)
diff --git a/internal/storage/v2/elasticsearch/tracestore/reader_test.go b/internal/storage/v2/elasticsearch/tracestore/reader_test.go
index 3a5c7d18..89e8d5eb 100644
--- a/internal/storage/v2/elasticsearch/tracestore/reader_test.go
+++ b/internal/storage/v2/elasticsearch/tracestore/reader_test.go
@@ -5,6 +5,7 @@ package tracestore
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"testing"
 	"time"
@@ -70,12 +71,62 @@ func TestTraceReader_GetOperations_Error(t *testing.T) {
 }
 
 func TestTraceReader_GetTraces(t *testing.T) {
-	reader := NewTraceReader(spanstore.SpanReaderParams{
-		Logger: zap.NewNop(),
-	})
-	assert.Panics(t, func() {
-		reader.GetTraces(context.Background(), v2api.GetTraceParams{})
-	})
+	coreReader := &mocks.CoreSpanReader{}
+	reader := TraceReader{spanReader: coreReader}
+	tracesStr, spanStr := loadFixtures(t, 1)
+	var span dbmodel.Span
+	require.NoError(t, json.Unmarshal(spanStr, &span))
+	dbTrace := dbmodel.Trace{Spans: []dbmodel.Span{span}}
+	span.TraceID = "00000000000000020000000000000000"
+	dbTrace2 := dbmodel.Trace{Spans: []dbmodel.Span{span}}
+	coreReader.On("GetTraces", mock.Anything, mock.Anything).Return([]dbmodel.Trace{dbTrace, dbTrace2}, nil)
+	traces := reader.GetTraces(context.Background(), v2api.GetTraceParams{})
+	for td, err := range traces {
+		require.NoError(t, err)
+		assert.Len(t, td, 1)
+		testTraces(t, tracesStr, td[0])
+		break
+	}
+}
+
+func TestTraceReader_GetTraces_Errors(t *testing.T) {
+	tests := []struct {
+		name            string
+		returningErr    error
+		returningTraces []dbmodel.Trace
+		expectedErr     string
+	}{
+		{
+			name:         "some error from db GetTraces",
+			returningErr: errors.New("some error"),
+			expectedErr:  "some error",
+		},
+		{
+			name: "conversion error",
+			returningTraces: []dbmodel.Trace{
+				{
+					Spans: []dbmodel.Span{
+						{
+							TraceID: "wrong-trace-id",
+						},
+					},
+				},
+			},
+			expectedErr: "encoding/hex: invalid byte: U+0077 'w'",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			coreReader := &mocks.CoreSpanReader{}
+			reader := TraceReader{spanReader: coreReader}
+			coreReader.On("GetTraces", mock.Anything, mock.Anything).Return(tt.returningTraces, tt.returningErr)
+			traces := reader.GetTraces(context.Background(), v2api.GetTraceParams{})
+			for trace, err := range traces {
+				require.Nil(t, trace)
+				require.ErrorContains(t, err, tt.expectedErr)
+			}
+		})
+	}
 }
 
 func TestTraceReader_FindTraces(t *testing.T) {
diff --git a/internal/storage/v2/grpc/handler_test.go b/internal/storage/v2/grpc/handler_test.go
index 13d5e348..2899fb0a 100644
--- a/internal/storage/v2/grpc/handler_test.go
+++ b/internal/storage/v2/grpc/handler_test.go
@@ -47,10 +47,12 @@ func (f *testStream) Send(td *jptrace.TracesData) error {
 func TestHandler_GetTraces(t *testing.T) {
 	start := time.Now()
 	end := start.Add(time.Minute)
-	query := tracestore.GetTraceParams{
-		TraceID: pcommon.TraceID([16]byte{1}),
-		Start:   start,
-		End:     end,
+	query := []tracestore.GetTraceParams{
+		{
+			TraceID: pcommon.TraceID([16]byte{1}),
+			Start:   start,
+			End:     end,
+		},
 	}
 	trace := makeTestTrace()
 	td := jptrace.TracesData(trace)
diff --git a/internal/storage/v2/memory/memory_test.go b/internal/storage/v2/memory/memory_test.go
index 8ce90a24..94dc7ff8 100644
--- a/internal/storage/v2/memory/memory_test.go
+++ b/internal/storage/v2/memory/memory_test.go
@@ -10,14 +10,17 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"sort"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/ptrace"
+	conventions "go.opentelemetry.io/collector/semconv/v1.16.0"
 
 	v1 "github.com/jaegertracing/jaeger/internal/storage/v1/memory"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/api/tracestore"
 	"github.com/jaegertracing/jaeger/internal/tenancy"
 )
 
@@ -37,6 +40,58 @@ func TestNewStore_DefaultConfig(t *testing.T) {
 	require.True(t, ok)
 	expected2 := loadOutputTraces(t, 2)
 	testTraces(t, expected2, traces2)
+	operations, err := store.GetOperations(context.Background(), tracestore.OperationQueryParams{ServiceName: "service-x"})
+	require.NoError(t, err)
+	expectedOperations := []tracestore.Operation{
+		{
+			Name:     "test-general-conversion-2",
+			SpanKind: "Unspecified",
+		},
+		{
+			Name:     "test-general-conversion-3",
+			SpanKind: "Unspecified",
+		},
+		{
+			Name:     "test-general-conversion-4",
+			SpanKind: "Unspecified",
+		},
+		{
+			Name:     "test-general-conversion-5",
+			SpanKind: "Unspecified",
+		},
+	}
+	sort.Slice(operations, func(i, j int) bool {
+		return operations[i].Name < operations[j].Name
+	})
+	assert.Equal(t, expectedOperations, operations)
+	expectedServices := []string{"service-x"}
+	services, err := store.GetServices(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, expectedServices, services)
+}
+
+func TestGetOperationsWithKind(t *testing.T) {
+	store := NewStore(v1.Configuration{})
+	td := ptrace.NewTraces()
+	resourceSpans := td.ResourceSpans().AppendEmpty()
+	attrs := resourceSpans.Resource().Attributes()
+	attrs.PutStr(conventions.AttributeServiceName, "service-x")
+	span1 := resourceSpans.ScopeSpans().AppendEmpty().Spans().AppendEmpty()
+	span1.SetTraceID(fromString(t, "00000000000000010000000000000000"))
+	span1.SetKind(ptrace.SpanKindConsumer)
+	span1.SetName("operation-with-kind")
+	span2 := resourceSpans.ScopeSpans().AppendEmpty().Spans().AppendEmpty()
+	span2.SetTraceID(fromString(t, "00000000000000010000000000000000"))
+	err := store.WriteTraces(context.Background(), td)
+	require.NoError(t, err)
+	operations, err := store.GetOperations(context.Background(), tracestore.OperationQueryParams{
+		ServiceName: "service-x",
+		SpanKind:    ptrace.SpanKindConsumer.String(),
+	})
+	assert.Len(t, operations, 1)
+	assert.Equal(t, "operation-with-kind", operations[0].Name)
+	assert.Equal(t, operations[0].SpanKind, ptrace.SpanKindConsumer.String())
+	require.NoError(t, err)
 }
 
 func TestWriteTraces_WriteTwoBatches(t *testing.T) {