Remove deprecated namespace concept from Cassandra storage options (jaegertracing#7719)

## Remove namespace concept from Cassandra options

Since v1 binaries have been deprecated, the namespace concept is no
longer needed. This PR simplifies the configuration structs.

### Changes Made:
- [x] Understand current structure and usage
- [x] Simplify Options struct by removing NamespaceConfig wrapper
- [x] Replace namespace field with explicit ArchiveEnabled field
- [x] Update NewOptions to not require namespace parameter
- [x] Update IsArchiveCapable to use ArchiveEnabled field
- [x] Update all callers of NewOptions in v1 tests
- [x] Update storageconfig to use simplified Options
- [x] Update v2 cassandra factory to use Configuration.Validate()
- [x] Update v2 cassandra tests to use simplified Options
- [x] Update integration test to use simplified Options
- [x] Run fmt and fix formatting
- [x] All tests passing
- [x] Code review completed (no issues)
- [x] Lint passes
- [x] make fmt, make lint, and make test all successful

### Summary:
This PR successfully removes the deprecated namespace concept from the
Cassandra storage options:
- Removed `NamespaceConfig` struct that unnecessarily wrapped
`config.Configuration`
- Removed the unused `namespace` string field (was only used for
distinguishing archive storage)
- Replaced with explicit `ArchiveEnabled` bool field for clarity
- Simplified `NewOptions()` constructor to take no parameters
- Updated `IsArchiveCapable()` to simply check the `ArchiveEnabled`
field
- Reduced nesting and complexity in the Options struct
- Updated all test files across v1 and v2 cassandra packages and
integration tests
- Updated storageconfig to use the simplified structure

All tests pass successfully. The changes are backward compatible as they
only affect internal implementation details.

<!-- START COPILOT CODING AGENT SUFFIX -->



<!-- START COPILOT ORIGINAL PROMPT -->



<details>

<summary>Original prompt</summary>

> in internal/storage/v1/cassandra/options.go we still have the notion
of the "namespace" like NamespaceConfig etc, but since v1 binaries have
been deprecated I don't think there is any use for this concept anymore.
Please see if we can remove it and simplify the configuration structs,
reduce unnecessary nesting, and remove unnecessary functions.


</details>



<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in
our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: yurishkuro <[email protected]>

Author: Copilot

cmd/internal/storageconfig/config.go

@@ -76,16 +76,14 @@ func (cfg *TraceBackend) Unmarshal(conf *confmap.Conf) error {
 	}
 	if conf.IsSet("cassandra") {
 		cfg.Cassandra = &cassandra.Options{
-			NamespaceConfig: cassandra.NamespaceConfig{
-				Configuration: cascfg.DefaultConfiguration(),
-				Enabled:       true,
-			},
+			Configuration:          cascfg.DefaultConfiguration(),
 			SpanStoreWriteCacheTTL: 12 * time.Hour,
 			Index: cassandra.IndexConfig{
 				Tags:        true,
 				ProcessTags: true,
 				Logs:        true,
 			},
+			ArchiveEnabled: false,
 		}
 	}
 	if conf.IsSet("elasticsearch") {

internal/storage/integration/cassandra_test.go

@@ -68,13 +68,14 @@ func (s *CassandraStorageIntegration) initializeCassandra(t *testing.T) {
 	defCfg := casconfig.DefaultConfiguration()
 	cfg.ApplyDefaults(&defCfg)
 	opts := cassandrav1.Options{
-		NamespaceConfig: cassandrav1.NamespaceConfig{Configuration: cfg},
+		Configuration: cfg,
 		Index: cassandrav1.IndexConfig{
 			Logs:        true,
 			Tags:        true,
 			ProcessTags: true,
 		},
 		SpanStoreWriteCacheTTL: time.Hour * 12,
+		ArchiveEnabled:         false,
 	}
 	f, err := cassandra.NewFactory(opts, metrics.NullFactory, zaptest.NewLogger(t))
 	require.NoError(t, err)

internal/storage/v1/cassandra/factory.go

@@ -32,11 +32,6 @@ import (
 	"github.com/jaegertracing/jaeger/internal/storage/v1/cassandra/spanstore/dbmodel"
 )
 
-const (
-	primaryStorageNamespace = "cassandra"
-	archiveStorageNamespace = "cassandra-archive"
-)
-
 var ( // interface comformance checks
 	_ storage.Factory              = (*Factory)(nil)
 	_ storage.Purger               = (*Factory)(nil)
@@ -66,7 +61,7 @@ type Factory struct {
 func NewFactory() *Factory {
 	return &Factory{
 		tracer:           otel.GetTracerProvider(),
-		Options:          NewOptions(primaryStorageNamespace),
+		Options:          NewOptions(),
 		sessionBuilderFn: NewSession,
 	}
 }
@@ -231,6 +226,5 @@ func (f *Factory) InheritSettingsFrom(other storage.Factory) {
 }
 
 func (f *Factory) IsArchiveCapable() bool {
-	return f.Options.NamespaceConfig.namespace == archiveStorageNamespace &&
-		f.Options.NamespaceConfig.Enabled
+	return f.Options.ArchiveEnabled
 }

internal/storage/v1/cassandra/factory_test.go

@@ -40,7 +40,7 @@ func TestCreateSpanReaderError(t *testing.T) {
 
 func TestConfigureFromOptions(t *testing.T) {
 	f := NewFactory()
-	o := NewOptions("foo")
+	o := NewOptions()
 	f.ConfigureFromOptions(o)
 	assert.Equal(t, o, f.Options)
 	assert.Equal(t, o.GetConfig(), f.config)
@@ -99,7 +99,7 @@ func TestInheritSettingsFrom(t *testing.T) {
 	primaryFactory.config.Query.MaxRetryAttempts = 99
 
 	archiveFactory := &Factory{
-		Options: NewOptions(archiveStorageNamespace),
+		Options: NewOptions(),
 	}
 
 	archiveFactory.config.Schema.Keyspace = "bar"
@@ -112,39 +112,27 @@ func TestInheritSettingsFrom(t *testing.T) {
 
 func TestIsArchiveCapable(t *testing.T) {
 	tests := []struct {
-		name      string
-		namespace string
-		enabled   bool
-		expected  bool
+		name           string
+		archiveEnabled bool
+		expected       bool
 	}{
 		{
-			name:      "archive capable",
-			namespace: "cassandra-archive",
-			enabled:   true,
-			expected:  true,
+			name:           "archive capable",
+			archiveEnabled: true,
+			expected:       true,
 		},
 		{
-			name:      "not capable",
-			namespace: "cassandra-archive",
-			enabled:   false,
-			expected:  false,
-		},
-		{
-			name:      "capable + wrong namespace",
-			namespace: "cassandra",
-			enabled:   true,
-			expected:  false,
+			name:           "not capable",
+			archiveEnabled: false,
+			expected:       false,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			factory := &Factory{
 				Options: &Options{
-					NamespaceConfig: NamespaceConfig{
-						namespace: test.namespace,
-						Enabled:   test.enabled,
-					},
+					ArchiveEnabled: test.archiveEnabled,
 				},
 			}
 			result := factory.IsArchiveCapable()

internal/storage/v1/cassandra/options.go

@@ -15,9 +15,10 @@ import (
 // to bind them to command line flag and apply overlays, so that some configurations
 // (e.g. archive) may be underspecified and infer the rest of its parameters from primary.
 type Options struct {
-	NamespaceConfig        `mapstructure:",squash"`
+	config.Configuration   `mapstructure:",squash"`
 	SpanStoreWriteCacheTTL time.Duration `mapstructure:"span_store_write_cache_ttl"`
 	Index                  IndexConfig   `mapstructure:"index"`
+	ArchiveEnabled         bool          `mapstructure:"-"`
 }
 
 // IndexConfig configures indexing.
@@ -30,32 +31,20 @@ type IndexConfig struct {
 	TagWhiteList string `mapstructure:"tag_whitelist"`
 }
 
-// the Servers field in config.Configuration is a list, which we cannot represent with flags.
-// This struct adds a plain string field that can be bound to flags and is then parsed when
-// preparing the actual config.Configuration.
-type NamespaceConfig struct {
-	config.Configuration `mapstructure:",squash"`
-	namespace            string
-	Enabled              bool `mapstructure:"-"`
-}
-
 // NewOptions creates a new Options struct.
-func NewOptions(namespace string) *Options {
+func NewOptions() *Options {
 	// TODO all default values should be defined via cobra flags
 	options := &Options{
-		NamespaceConfig: NamespaceConfig{
-			Configuration: config.DefaultConfiguration(),
-			namespace:     namespace,
-			Enabled:       true,
-		},
+		Configuration:          config.DefaultConfiguration(),
 		SpanStoreWriteCacheTTL: time.Hour * 12,
+		ArchiveEnabled:         false,
 	}
 
 	return options
 }
 
 func (opt *Options) GetConfig() config.Configuration {
-	return opt.NamespaceConfig.Configuration
+	return opt.Configuration
 }
 
 // TagIndexBlacklist returns the list of blacklisted tags

internal/storage/v1/cassandra/options_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 func TestOptions(t *testing.T) {
-	opts := NewOptions("foo")
+	opts := NewOptions()
 	primary := opts.GetConfig()
 	assert.NotEmpty(t, primary.Schema.Keyspace)
 	assert.NotEmpty(t, primary.Connection.Servers)

internal/storage/v2/cassandra/factory.go

@@ -98,7 +98,7 @@ type withConfigBuilder struct {
 
 func (b *withConfigBuilder) build() (*cassandra.Factory, error) {
 	b.f.ConfigureFromOptions(b.opts)
-	if err := b.opts.NamespaceConfig.Validate(); err != nil {
+	if err := b.opts.Configuration.Validate(); err != nil {
 		return nil, err
 	}
 	err := b.initializer(b.metricsFactory, b.logger)

internal/storage/v2/cassandra/factory_test.go

@@ -20,9 +20,7 @@ import (
 func TestNewFactoryWithConfig(t *testing.T) {
 	t.Run("valid configuration", func(t *testing.T) {
 		opts := &cassandra.Options{
-			NamespaceConfig: cassandra.NamespaceConfig{
-				Configuration: config.DefaultConfiguration(),
-			},
+			Configuration: config.DefaultConfiguration(),
 		}
 		f := cassandra.NewFactory()
 		b := &withConfigBuilder{
@@ -38,9 +36,7 @@ func TestNewFactoryWithConfig(t *testing.T) {
 	t.Run("connection error", func(t *testing.T) {
 		expErr := errors.New("made-up error")
 		opts := &cassandra.Options{
-			NamespaceConfig: cassandra.NamespaceConfig{
-				Configuration: config.DefaultConfiguration(),
-			},
+			Configuration: config.DefaultConfiguration(),
 		}
 		f := cassandra.NewFactory()
 		b := &withConfigBuilder{
@@ -62,7 +58,7 @@ func TestNewFactoryWithConfig(t *testing.T) {
 
 func TestNewFactory(t *testing.T) {
 	v1Factory := cassandra.NewFactory()
-	v1Factory.Options = cassandra.NewOptions("primary")
+	v1Factory.Options = cassandra.NewOptions()
 	var (
 		session = &mocks.Session{}
 		query   = &mocks.Query{}
@@ -113,9 +109,7 @@ func TestCreateTraceReaderError(t *testing.T) {
 func TestCreateTraceWriterErr(t *testing.T) {
 	v1Factory := cassandra.NewFactory()
 	v1Factory.Options = &cassandra.Options{
-		NamespaceConfig: cassandra.NamespaceConfig{
-			Configuration: config.DefaultConfiguration(),
-		},
+		Configuration: config.DefaultConfiguration(),
 		Index: cassandra.IndexConfig{
 			TagBlackList: "a,b,c",
 			TagWhiteList: "a,b,c",