Add ArchiveCapable Interface To Initialize Correctly

Signed-off-by: Mahad Zaryab <mahadzaryab1@gmail.com>

plugin/configurable.go

@@ -28,3 +28,7 @@ type Configurable interface {
 type Inheritable interface {
 	InheritSettingsFrom(other storage.Factory)
 }
+
+type ArchiveCapable interface {
+	IsArchiveCapable() bool
+}

plugin/storage/cassandra/factory.go

@@ -47,6 +47,7 @@
 	_ io.Closer                    = (*Factory)(nil)
 	_ plugin.Configurable          = (*Factory)(nil)
 	_ plugin.Inheritable           = (*Factory)(nil)
+	_ plugin.ArchiveCapable        = (*Factory)(nil)
 )
 
 // Factory implements storage.Factory for Cassandra backend.
@@ -289,3 +290,7 @@
 		f.config.ApplyDefaults(&otherFactory.config)
 	}
 }
+
+func (f *Factory) IsArchiveCapable() bool {
+	return f.Options.NamespaceConfig.namespace == archiveStorageNamespace && f.Options.Enabled
+}

plugin/storage/es/factory.go

@@ -42,11 +42,12 @@
 )
 
 var ( // interface comformance checks
-	_ storage.Factory     = (*Factory)(nil)
-	_ io.Closer           = (*Factory)(nil)
-	_ plugin.Configurable = (*Factory)(nil)
-	_ plugin.Inheritable  = (*Factory)(nil)
-	_ storage.Purger      = (*Factory)(nil)
+	_ storage.Factory       = (*Factory)(nil)
+	_ io.Closer             = (*Factory)(nil)
+	_ plugin.Configurable   = (*Factory)(nil)
+	_ plugin.Inheritable    = (*Factory)(nil)
+	_ storage.Purger        = (*Factory)(nil)
+	_ plugin.ArchiveCapable = (*Factory)(nil)
 )
 
 // Factory implements storage.Factory for Elasticsearch backend.
@@ -138,7 +139,7 @@
 	if f.config.Authentication.BasicAuthentication.PasswordFilePath != "" {
 		watcher, err := fswatcher.New([]string{f.config.Authentication.BasicAuthentication.PasswordFilePath}, f.onPasswordChange, f.logger)
 		if err != nil {
 			return fmt.Errorf("failed to create watcher for ES client's password: %w", err)
 		}
 		f.pwdFileWatcher = watcher
 	}
@@ -369,3 +370,7 @@
 		f.config.ApplyDefaults(otherFactory.config)
 	}
 }
+
+func (f *Factory) IsArchiveCapable() bool {
+	return f.Options.Config.namespace == archiveNamespace && f.config.Enabled
+}

plugin/storage/es/options.go

@@ -275,7 +275,7 @@ func addFlags(flagSet *flag.FlagSet, nsConfig *namespaceConfig) {
 	if nsConfig.namespace == archiveNamespace {
 		flagSet.Bool(
 			nsConfig.namespace+suffixEnabled,
-			nsConfig.Enabled,
+			false,
 			"Enable extra storage")
 	} else {
 		// MaxSpanAge is only relevant when searching for unarchived traces.

plugin/storage/factory.go

@@ -146,37 +146,46 @@
 		return cassandra.NewArchiveFactory(), nil
 	case elasticsearchStorageType, opensearchStorageType:
 		return es.NewArchiveFactory(), nil
 	case grpcStorageType:
 		return grpc.NewArchiveFactory(), nil
 	default:
 		return nil, fmt.Errorf("archive storage factory not available for %s", factoryType)
 	}
 }
 
-// Initialize implements storage.Factory.
 func (f *Factory) Initialize(metricsFactory metrics.Factory, logger *zap.Logger) error {
 	f.metricsFactory = metricsFactory
-	initializeFactories := func(factories map[string]storage.Factory, role string) error {
-		for kind, factory := range factories {
-			mf := metricsFactory.Namespace(metrics.NSOptions{
-				Name: "storage",
-				Tags: map[string]string{
-					"kind": kind,
-					"role": role,
-				},
-			})
-			if err := factory.Initialize(mf, logger); err != nil {
-				return err
-			}
+
+	initializeFactory := func(kind string, factory storage.Factory, role string) error {
+		mf := metricsFactory.Namespace(metrics.NSOptions{
+			Name: "storage",
+			Tags: map[string]string{
+				"kind": kind,
+				"role": role,
+			},
+		})
+		return factory.Initialize(mf, logger)
+	}
+
+	for kind, factory := range f.factories {
+		if err := initializeFactory(kind, factory, "primary"); err != nil {
+			return err
 		}
-		return nil
 	}
-	if err := initializeFactories(f.factories, "primary"); err != nil {
-		return err
+
+	uninitializedArchiveFactories := make(map[string]struct{})
+	for kind, factory := range f.archiveFactories {
+		if archivable, ok := factory.(plugin.ArchiveCapable); ok && archivable.IsArchiveCapable() {
+			if err := initializeFactory(kind, factory, "primary"); err != nil {
+				uninitializedArchiveFactories[kind] = struct{}{}
+			}
+		}
 	}
-	if err := initializeFactories(f.archiveFactories, "archive"); err != nil {
-		return err
+
+	for kind := range uninitializedArchiveFactories {
+		delete(f.archiveFactories, kind)
 	}
+
 	f.publishOpts()
 	return nil
 }