chore: tests updated

cmd/community/server.go

@@ -18,19 +18,16 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/gateway/noopgateway"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -112,9 +109,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(_ licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]] {
 			return signoz.NewAuditorProviderFactories()
 		},
-		func(_ context.Context, _ factory.ProviderSettings, _ flagger.Flagger, _ licensing.Licensing, _ telemetrystore.TelemetryStore, _ retention.Getter, _ organization.Getter, _ zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string) {
-			return signoz.NewMeterReporterProviderFactories(), "noop"
-		},
 		func(ps factory.ProviderSettings, q querier.Querier, a analytics.Analytics) querier.Handler {
 			return querier.NewHandler(ps, q, a)
 		},

cmd/enterprise/meter.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-)
-
-var meterConfigs = []metercollector.Config{
-	{
-		Provider: metercollector.ProviderStatic,
-		Static: metercollector.StaticConfig{
-			Name:        zeustypes.MeterPlatformActive,
-			Unit:        zeustypes.MeterUnitCount,
-			Aggregation: zeustypes.MeterAggregationMax,
-			Value:       1,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterLogSize,
-			Unit:                 zeustypes.MeterUnitBytes,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrylogs.DBName,
-			TableName:            telemetrylogs.LogsV2LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultLogsRetentionDays,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterSpanSize,
-			Unit:                 zeustypes.MeterUnitBytes,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrytraces.DBName,
-			TableName:            telemetrytraces.SpanIndexV3LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultTracesRetentionDays,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterDatapointCount,
-			Unit:                 zeustypes.MeterUnitCount,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrymetrics.DBName,
-			TableName:            telemetrymetrics.SamplesV4LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultMetricsRetentionDays,
-		},
-	},
-}

cmd/enterprise/server.go

@@ -18,9 +18,6 @@ import (
 	"github.com/SigNoz/signoz/ee/gateway/httpgateway"
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
-	"github.com/SigNoz/signoz/ee/metercollector/staticmetercollector"
-	"github.com/SigNoz/signoz/ee/metercollector/telemetrymetercollector"
-	"github.com/SigNoz/signoz/ee/meterreporter/httpmeterreporter"
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration/implcloudprovider"
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
@@ -39,17 +36,14 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	pkgflagger "github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	pkgcloudintegration "github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -167,20 +161,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return factories
 		},
-		func(ctx context.Context, providerSettings factory.ProviderSettings, flagger pkgflagger.Flagger, licensing licensing.Licensing, telemetryStore telemetrystore.TelemetryStore, retentionGetter retention.Getter, orgGetter organization.Getter, zeus zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string) {
-			factories := signoz.NewMeterReporterProviderFactories()
-
-			collectorFactories := factory.MustNewNamedMap(
-				staticmetercollector.NewFactory(),
-				telemetrymetercollector.NewFactory(telemetryStore, retentionGetter),
-			)
-
-			if err := factories.Add(httpmeterreporter.NewFactory(collectorFactories, meterConfigs, flagger, licensing, orgGetter, zeus)); err != nil {
-				panic(err)
-			}
-
-			return factories, "http"
-		},
 		func(ps factory.ProviderSettings, q querier.Querier, a analytics.Analytics) querier.Handler {
 			communityHandler := querier.NewHandler(ps, q, a)
 			return eequerier.NewHandler(ps, q, communityHandler)

conf/example.yaml

@@ -429,10 +429,3 @@ authz:
   openfga:
     # maximum tuples allowed per openfga write operation.
     max_tuples_per_write: 300
-
-##################### Meter Reporter #####################
-meterreporter:
-  # The interval between collection ticks. Minimum 5m.
-  interval: 6h
-  # Whether to backfill sealed days from the license creation day.
-  backfill: true

ee/metercollector/staticmetercollector/provider.go

@@ -1,61 +0,0 @@
-// Package staticmetercollector emits a fixed-value meter reading per org per window.
-package staticmetercollector
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var _ metercollector.MeterCollector = (*Provider)(nil)
-
-type Provider struct {
-	settings factory.ScopedProviderSettings
-	config   metercollector.StaticConfig
-}
-
-func NewFactory() factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(metercollector.ProviderStatic), func(ctx context.Context, providerSettings factory.ProviderSettings, config metercollector.Config) (metercollector.MeterCollector, error) {
-		return newProvider(providerSettings, config.Static), nil
-	},
-	)
-}
-
-func newProvider(providerSettings factory.ProviderSettings, config metercollector.StaticConfig) *Provider {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/metercollector/staticmetercollector")
-
-	return &Provider{
-		settings: settings,
-		config:   config,
-	}
-}
-
-func (provider *Provider) Name() zeustypes.MeterName { return provider.config.Name }
-func (provider *Provider) Unit() zeustypes.MeterUnit { return provider.config.Unit }
-func (provider *Provider) Aggregation() zeustypes.MeterAggregation {
-	return provider.config.Aggregation
-}
-
-func (provider *Provider) Origin(_ context.Context, _ valuer.UUID, license *licensetypes.License, _ time.Time) (time.Time, error) {
-	if license == nil || license.CreatedAt.IsZero() {
-		return time.Time{}, nil
-	}
-
-	createdAt := license.CreatedAt.UTC()
-	return time.Date(createdAt.Year(), createdAt.Month(), createdAt.Day(), 0, 0, 0, 0, time.UTC), nil
-}
-
-func (provider *Provider) Collect(_ context.Context, orgID valuer.UUID, license *licensetypes.License, window zeustypes.MeterWindow) ([]zeustypes.Meter, error) {
-	if license == nil || license.Key == "" {
-		return nil, nil
-	}
-
-	return []zeustypes.Meter{
-		zeustypes.NewMeter(provider.config.Name, provider.config.Value, provider.config.Unit, provider.config.Aggregation, window, zeustypes.NewDimensions(zeustypes.OrganizationID.String(orgID.StringValue()))),
-	}, nil
-}

ee/metercollector/telemetrymetercollector/provider.go

@@ -1,247 +0,0 @@
-// Package telemetrymetercollector collects telemetry meters (logs, traces, metrics)
-// by retention. One Provider materializes per TelemetryConfig.
-package telemetrymetercollector
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/huandu/go-sqlbuilder"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	labelKeyPattern   = regexp.MustCompile(`^[A-Za-z0-9_.\-]+$`)
-	labelValuePattern = regexp.MustCompile(`^[A-Za-z0-9_.\-:]+$`)
-)
-
-var _ metercollector.MeterCollector = (*Provider)(nil)
-
-type Provider struct {
-	settings        factory.ScopedProviderSettings
-	config          metercollector.TelemetryConfig
-	telemetryStore  telemetrystore.TelemetryStore
-	retentionGetter retention.Getter
-}
-
-func NewFactory(telemetryStore telemetrystore.TelemetryStore, retentionGetter retention.Getter) factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(metercollector.ProviderTelemetry), func(ctx context.Context, providerSettings factory.ProviderSettings, config metercollector.Config) (metercollector.MeterCollector, error) {
-		return newProvider(providerSettings, config.Telemetry, telemetryStore, retentionGetter), nil
-	},
-	)
-}
-
-func newProvider(
-	providerSettings factory.ProviderSettings,
-	config metercollector.TelemetryConfig,
-	telemetryStore telemetrystore.TelemetryStore,
-	retentionGetter retention.Getter,
-) *Provider {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/metercollector/telemetrymetercollector")
-
-	return &Provider{
-		settings:        settings,
-		config:          config,
-		telemetryStore:  telemetryStore,
-		retentionGetter: retentionGetter,
-	}
-}
-
-func (provider *Provider) Name() zeustypes.MeterName { return provider.config.Name }
-func (provider *Provider) Unit() zeustypes.MeterUnit { return provider.config.Unit }
-func (provider *Provider) Aggregation() zeustypes.MeterAggregation {
-	return provider.config.Aggregation
-}
-
-func (provider *Provider) Origin(ctx context.Context, _ valuer.UUID, _ *licensetypes.License, todayStart time.Time) (time.Time, error) {
-	query, args := buildOriginQuery(provider.config.Name.String())
-
-	var minMs int64
-	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(&minMs); err != nil {
-		return time.Time{}, err
-	}
-	if minMs == 0 {
-		return todayStart, nil
-	}
-
-	minDay := time.UnixMilli(minMs).UTC()
-	return time.Date(minDay.Year(), minDay.Month(), minDay.Day(), 0, 0, 0, 0, time.UTC), nil
-}
-
-func (provider *Provider) Collect(
-	ctx context.Context,
-	orgID valuer.UUID,
-	_ *licensetypes.License,
-	window zeustypes.MeterWindow,
-) ([]zeustypes.Meter, error) {
-	meterName := provider.config.Name.String()
-
-	segments, err := provider.retentionGetter.GetRetentionPolicySegments(
-		ctx,
-		orgID,
-		provider.config.DBName,
-		provider.config.TableName,
-		provider.config.DefaultRetentionDays,
-		window.StartUnixMilli,
-		window.EndUnixMilli,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	valuesByRetentionDays := make(map[int]int64)
-
-	for _, segment := range segments {
-		query, args, err := buildQuery(meterName, segment)
-		if err != nil {
-			return nil, err
-		}
-
-		rows, err := provider.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-		if err != nil {
-			return nil, err
-		}
-
-		if err := func() error {
-			defer rows.Close()
-			for rows.Next() {
-				var retentionDays int32
-				var value int64
-
-				if err := rows.Scan(&retentionDays, &value); err != nil {
-					return err
-				}
-
-				valuesByRetentionDays[int(retentionDays)] += value
-			}
-			if err := rows.Err(); err != nil {
-				return err
-			}
-			return nil
-		}(); err != nil {
-			return nil, err
-		}
-	}
-
-	meters := make([]zeustypes.Meter, 0, len(valuesByRetentionDays))
-	for retentionDays, value := range valuesByRetentionDays {
-		meters = append(meters, zeustypes.NewMeter(provider.config.Name, value, provider.config.Unit, provider.config.Aggregation, window, buildDimensions(orgID, retentionDays)))
-	}
-
-	// Empty windows still emit a sentinel so checkpoints can advance.
-	if len(meters) == 0 && len(segments) > 0 {
-		meters = append(meters, zeustypes.NewMeter(provider.config.Name, 0, provider.config.Unit, provider.config.Aggregation, window, buildDimensions(orgID, segments[len(segments)-1].DefaultDays)))
-	}
-
-	return meters, nil
-}
-
-func buildOriginQuery(meterName string) (string, []any) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("toInt64(ifNull(min(unix_milli), 0))")
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
-	sb.Where(sb.Equal("metric_name", meterName))
-	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-}
-
-func buildQuery(meterName string, segment *retentiontypes.RetentionPolicySegment) (string, []any, error) {
-	retentionExpr, err := buildRetentionMultiIfSQL(segment.Rules, segment.DefaultDays)
-	if err != nil {
-		return "", nil, err
-	}
-
-	selects := []string{
-		retentionExpr + " AS retention_days",
-		"toInt64(ifNull(sum(value), 0)) AS value",
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(selects...)
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
-	sb.Where(
-		sb.Equal("metric_name", meterName),
-		sb.GTE("unix_milli", segment.StartMs),
-		sb.LT("unix_milli", segment.EndMs),
-	)
-	sb.GroupBy("retention_days")
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return query, args, nil
-}
-
-func buildRetentionMultiIfSQL(rules []retentiontypes.CustomRetentionRule, defaultDays int) (string, error) {
-	if defaultDays <= 0 {
-		return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "non-positive default retention %d", defaultDays)
-	}
-
-	if len(rules) == 0 {
-		return "toInt32(" + strconv.Itoa(defaultDays) + ")", nil
-	}
-
-	arms := make([]string, 0, 2*len(rules)+1)
-	for ruleIndex, rule := range rules {
-		if rule.TTLDays <= 0 {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d has non-positive ttl_days %d", ruleIndex, rule.TTLDays)
-		}
-		conditionExpr, err := buildRuleConditionSQL(ruleIndex, rule)
-		if err != nil {
-			return "", err
-		}
-
-		arms = append(arms, conditionExpr)
-		arms = append(arms, strconv.Itoa(rule.TTLDays))
-	}
-	arms = append(arms, strconv.Itoa(defaultDays))
-
-	return "toInt32(multiIf(" + strings.Join(arms, ", ") + "))", nil
-}
-
-func buildRuleConditionSQL(ruleIndex int, rule retentiontypes.CustomRetentionRule) (string, error) {
-	if len(rule.Filters) == 0 {
-		return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d has no filters", ruleIndex)
-	}
-
-	filterExprs := make([]string, 0, len(rule.Filters))
-	for filterIndex, filter := range rule.Filters {
-		if !labelKeyPattern.MatchString(filter.Key) {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d has invalid key %q", ruleIndex, filterIndex, filter.Key)
-		}
-		if len(filter.Values) == 0 {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d has no values", ruleIndex, filterIndex)
-		}
-
-		quoted := make([]string, len(filter.Values))
-		for valueIndex, value := range filter.Values {
-			if !labelValuePattern.MatchString(value) {
-				return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d value %d is invalid %q", ruleIndex, filterIndex, valueIndex, value)
-			}
-			quoted[valueIndex] = "'" + value + "'"
-		}
-
-		filterExprs = append(filterExprs, fmt.Sprintf("JSONExtractString(labels, '%s') IN (%s)", filter.Key, strings.Join(quoted, ", ")))
-	}
-
-	return strings.Join(filterExprs, " AND "), nil
-}
-
-func buildDimensions(orgID valuer.UUID, retentionDays int) map[string]string {
-	retentionDurationSeconds := int64(retentionDays) * 24 * 60 * 60 // seconds
-
-	return zeustypes.NewDimensions(
-		zeustypes.OrganizationID.String(orgID.StringValue()),
-		zeustypes.RetentionDuration.String(strconv.FormatInt(retentionDurationSeconds, 10)),
-	)
-}

ee/meterreporter/httpmeterreporter/provider.go

@@ -1,318 +0,0 @@
-package httpmeterreporter
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/featuretypes"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/SigNoz/signoz/pkg/zeus"
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/trace"
-)
-
-var _ factory.ServiceWithHealthy = (*Provider)(nil)
-
-type Provider struct {
-	settings         factory.ScopedProviderSettings
-	config           meterreporter.Config
-	collectorsByName map[zeustypes.MeterName]metercollector.MeterCollector
-	flagger          flagger.Flagger
-	licensing        licensing.Licensing
-	orgGetter        organization.Getter
-	zeus             zeus.Zeus
-	healthyC         chan struct{}
-	stopC            chan struct{}
-	metrics          *reporterMetrics
-}
-
-func NewFactory(collectorFactories factory.NamedMap[factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config]], collectorConfigs []metercollector.Config, flagger flagger.Flagger, licensing licensing.Licensing, orgGetter organization.Getter, zeus zeus.Zeus) factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("http"), func(ctx context.Context, providerSettings factory.ProviderSettings, config meterreporter.Config) (meterreporter.Reporter, error) {
-		return newProvider(ctx, providerSettings, config, collectorFactories, collectorConfigs, flagger, licensing, orgGetter, zeus)
-	},
-	)
-}
-
-func newProvider(
-	ctx context.Context,
-	providerSettings factory.ProviderSettings,
-	config meterreporter.Config,
-	collectorFactories factory.NamedMap[factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config]],
-	collectorConfigs []metercollector.Config,
-	flagger flagger.Flagger,
-	licensing licensing.Licensing,
-	orgGetter organization.Getter,
-	zeus zeus.Zeus,
-) (*Provider, error) {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/meterreporter/httpmeterreporter")
-
-	collectorsByName := map[zeustypes.MeterName]metercollector.MeterCollector{}
-	for _, collectorConfig := range collectorConfigs {
-		collector, err := factory.NewProviderFromNamedMap(ctx, providerSettings, collectorConfig, collectorFactories, collectorConfig.Provider)
-		if err != nil {
-			return nil, err
-		}
-		if _, exists := collectorsByName[collector.Name()]; exists {
-			return nil, errors.Newf(errors.TypeAlreadyExists, errors.CodeAlreadyExists, "duplicate meter collector %q", collector.Name())
-		}
-		collectorsByName[collector.Name()] = collector
-	}
-
-	metrics, err := newReporterMetrics(settings.Meter())
-	if err != nil {
-		return nil, err
-	}
-
-	return &Provider{
-		settings:         settings,
-		config:           config,
-		collectorsByName: collectorsByName,
-		flagger:          flagger,
-		licensing:        licensing,
-		orgGetter:        orgGetter,
-		zeus:             zeus,
-		healthyC:         make(chan struct{}),
-		stopC:            make(chan struct{}),
-		metrics:          metrics,
-	}, nil
-}
-
-func (provider *Provider) Start(ctx context.Context) error {
-	close(provider.healthyC)
-
-	provider.collect(ctx)
-
-	ticker := time.NewTicker(provider.config.Interval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-provider.stopC:
-			return nil
-		case <-ticker.C:
-			provider.collect(ctx)
-		}
-	}
-}
-
-func (provider *Provider) collect(ctx context.Context) {
-	ctx, span := provider.settings.Tracer().Start(ctx, "meterreporter.Collect", trace.WithAttributes(attribute.String("meterreporter.provider", "http")))
-	defer span.End()
-
-	orgs, err := provider.orgGetter.ListByOwnedKeyRange(ctx)
-	if err != nil {
-		span.RecordError(err)
-		provider.settings.Logger().ErrorContext(ctx, "failed to get orgs data", errors.Attr(err))
-		return
-	}
-
-	for _, org := range orgs {
-		evalCtx := featuretypes.NewFlaggerEvaluationContext(org.ID)
-		if !provider.flagger.BooleanOrEmpty(ctx, flagger.FeatureUseMeterReporter, evalCtx) {
-			provider.settings.Logger().DebugContext(ctx, "meter reporter disabled for org, skipping reporting", slog.String("org_id", org.ID.StringValue()))
-			continue
-		}
-
-		license, err := provider.licensing.GetActive(ctx, org.ID)
-		if err != nil {
-			if errors.Ast(err, errors.TypeNotFound) {
-				provider.settings.Logger().DebugContext(ctx, "no active license found for org, skipping reporting", slog.String("org_id", org.ID.StringValue()))
-				continue
-			}
-
-			span.RecordError(err)
-			provider.settings.Logger().ErrorContext(ctx, "failed to fetch active license for org", errors.Attr(err), slog.String("org_id", org.ID.StringValue()))
-			return
-		}
-
-		if err := provider.collectOrg(ctx, org, license); err != nil {
-			span.RecordError(err)
-			provider.settings.Logger().ErrorContext(ctx, "failed to collect meters", errors.Attr(err), slog.String("org_id", org.ID.StringValue()))
-		}
-	}
-}
-
-func (provider *Provider) Stop(ctx context.Context) error {
-	close(provider.stopC)
-	return nil
-}
-
-func (provider *Provider) Healthy() <-chan struct{} {
-	return provider.healthyC
-}
-
-func (provider *Provider) collectOrg(ctx context.Context, org *types.Organization, license *licensetypes.License) error {
-	now := time.Now().UTC()
-	// Use one timestamp so a tick cannot straddle midnight.
-	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
-
-	if provider.config.Backfill {
-		checkpointsByMeter, err := provider.checkpoints(ctx, license.Key)
-		if err != nil {
-			return err
-		}
-
-		nextByCollector := provider.nextDays(license, todayStart, checkpointsByMeter)
-
-		start, end, ok := backfillRange(nextByCollector, todayStart)
-		if ok {
-			for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
-				eligible := eligibleCollectors(provider.collectorsByName, nextByCollector, day)
-				if len(eligible) == 0 {
-					continue
-				}
-
-				window, err := zeustypes.NewMeterWindow(day.UnixMilli(), day.AddDate(0, 0, 1).UnixMilli(), true)
-				if err != nil {
-					return err
-				}
-
-				if err := provider.report(ctx, org.ID, license, window, eligible); err != nil {
-					provider.settings.Logger().WarnContext(ctx, "failed to backfill for day", errors.Attr(err), slog.String("date", day.Format("2006-01-02")))
-					return err
-				}
-			}
-		}
-	}
-
-	// Today's partial window: every collector is always eligible (next <= today).
-	if now.UnixMilli() > todayStart.UnixMilli() {
-		todayWindow, err := zeustypes.NewMeterWindow(todayStart.UnixMilli(), now.UnixMilli(), false)
-		if err != nil {
-			return err
-		}
-
-		return provider.report(ctx, org.ID, license, todayWindow, provider.collectorsByName)
-	}
-
-	return nil
-}
-
-func (provider *Provider) checkpoints(ctx context.Context, licenseKey string) (map[string]time.Time, error) {
-	list, err := provider.zeus.ListMeterCheckpoints(ctx, licenseKey)
-	if err != nil {
-		provider.metrics.checkpoints.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return nil, err
-	}
-
-	provider.metrics.checkpoints.Add(ctx, 1)
-
-	checkpointsByMeter := make(map[string]time.Time, len(list))
-	for _, checkpoint := range list {
-		checkpointsByMeter[checkpoint.Name] = checkpoint.StartDate.UTC()
-	}
-
-	return checkpointsByMeter, nil
-}
-
-func (provider *Provider) nextDays(license *licensetypes.License, todayStart time.Time, checkpointsByMeter map[string]time.Time) map[zeustypes.MeterName]time.Time {
-	nextByCollector := make(map[zeustypes.MeterName]time.Time, len(provider.collectorsByName))
-	licenseCreatedAt := license.CreatedAt.UTC()
-	licenseCreatedAtDay := time.Date(licenseCreatedAt.Year(), licenseCreatedAt.Month(), licenseCreatedAt.Day(), 0, 0, 0, 0, time.UTC)
-
-	for _, collector := range provider.collectorsByName {
-		checkpoint, hasCheckpoint := checkpointsByMeter[collector.Name().String()]
-		nextByCollector[collector.Name()] = nextReportableDay(licenseCreatedAtDay, todayStart, checkpoint, hasCheckpoint)
-	}
-
-	return nextByCollector
-}
-
-func nextReportableDay(licenseCreatedAtDay time.Time, todayStart time.Time, checkpoint time.Time, hasCheckpoint bool) time.Time {
-	next := licenseCreatedAtDay
-	if next.IsZero() {
-		next = todayStart
-	}
-
-	if hasCheckpoint {
-		checkpointNext := checkpoint.AddDate(0, 0, 1)
-		if checkpointNext.After(next) {
-			next = checkpointNext
-		}
-	}
-
-	return next
-}
-
-func (provider *Provider) report(ctx context.Context, orgID valuer.UUID, license *licensetypes.License, window zeustypes.MeterWindow, collectors map[zeustypes.MeterName]metercollector.MeterCollector) error {
-	date := time.UnixMilli(window.StartUnixMilli).UTC().Format("2006-01-02")
-
-	meters := make([]zeustypes.Meter, 0, len(collectors))
-	for _, collector := range collectors {
-		meterAttr := attribute.String("signoz.meter.name", collector.Name().String())
-		collectedReadings, err := collector.Collect(ctx, orgID, license, window)
-		if err != nil {
-			provider.metrics.collections.Add(ctx, 1, metric.WithAttributes(meterAttr, errors.TypeAttr(err)))
-			continue
-		}
-
-		provider.metrics.collections.Add(ctx, 1, metric.WithAttributes(meterAttr))
-		meters = append(meters, collectedReadings...)
-	}
-
-	if len(meters) == 0 {
-		return nil
-	}
-
-	idempotencyKey := fmt.Sprintf("meterreporter:%s", date)
-
-	body, err := json.Marshal(meters)
-	if err != nil {
-		provider.metrics.reports.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return err
-	}
-
-	if err := provider.zeus.PutMetersV3(ctx, license.Key, idempotencyKey, body); err != nil {
-		provider.metrics.reports.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return err
-	}
-
-	provider.metrics.reports.Add(ctx, 1)
-	provider.metrics.meters.Add(ctx, int64(len(meters)))
-	return nil
-}
-
-// backfillRange returns the inclusive sealed-day range ending at yesterday.
-func backfillRange(nextByCollector map[zeustypes.MeterName]time.Time, todayStart time.Time) (start, end time.Time, ok bool) {
-	yesterday := todayStart.AddDate(0, 0, -1)
-
-	for _, next := range nextByCollector {
-		if !next.Before(todayStart) {
-			continue
-		}
-		if start.IsZero() || next.Before(start) {
-			start = next
-		}
-	}
-
-	if start.IsZero() || start.After(yesterday) {
-		return time.Time{}, time.Time{}, false
-	}
-
-	return start, yesterday, true
-}
-
-func eligibleCollectors(collectors map[zeustypes.MeterName]metercollector.MeterCollector, nextByCollector map[zeustypes.MeterName]time.Time, day time.Time) map[zeustypes.MeterName]metercollector.MeterCollector {
-	eligible := make(map[zeustypes.MeterName]metercollector.MeterCollector, len(collectors))
-	for name, collector := range collectors {
-		if !nextByCollector[name].After(day) {
-			eligible[name] = collector
-		}
-	}
-
-	return eligible
-}

ee/meterreporter/httpmeterreporter/telemetry.go

@@ -1,48 +0,0 @@
-package httpmeterreporter
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"go.opentelemetry.io/otel/metric"
-)
-
-type reporterMetrics struct {
-	checkpoints metric.Int64Counter
-	reports     metric.Int64Counter
-	collections metric.Int64Counter
-	meters      metric.Int64Counter
-}
-
-func newReporterMetrics(meter metric.Meter) (*reporterMetrics, error) {
-	var errs error
-
-	checkpoints, err := meter.Int64Counter("signoz.meterreporter.checkpoints", metric.WithDescription("Zeus meter checkpoint fetches."), metric.WithUnit("{checkpoint}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	reports, err := meter.Int64Counter("signoz.meterreporter.reports", metric.WithDescription("Meter reports shipped to Zeus."), metric.WithUnit("{report}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	collections, err := meter.Int64Counter("signoz.meterreporter.collections", metric.WithDescription("Per-meter collect calls."), metric.WithUnit("{collection}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	meters, err := meter.Int64Counter("signoz.meterreporter.meters", metric.WithDescription("Meter readings shipped to Zeus."), metric.WithUnit("{meter}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	if errs != nil {
-		return nil, errs
-	}
-
-	return &reporterMetrics{
-		checkpoints: checkpoints,
-		reports:     reports,
-		collections: collections,
-		meters:      meters,
-	}, nil
-}

ee/zeus/httpzeus/provider.go

@@ -150,72 +150,6 @@ func (provider *Provider) PutMetersV2(ctx context.Context, key string, data []by
 	return err
 }
 
-func (provider *Provider) PutMetersV3(ctx context.Context, key string, idempotencyKey string, data []byte) error {
-	headers := http.Header{}
-	if idempotencyKey != "" {
-		headers.Set("X-Idempotency-Key", idempotencyKey)
-	}
-
-	_, err := provider.doWithHeaders(
-		ctx,
-		provider.config.URL.JoinPath("/v2/meters"),
-		http.MethodPost,
-		key,
-		data,
-		headers,
-	)
-
-	return err
-}
-
-func (provider *Provider) ListMeterCheckpoints(ctx context.Context, key string) ([]zeustypes.MeterCheckpoint, error) {
-	response, err := provider.do(
-		ctx,
-		provider.config.URL.JoinPath("/v2/meters/checkpoints"),
-		http.MethodGet,
-		key,
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	checkpointValues := gjson.GetBytes(response, "data")
-	if !checkpointValues.Exists() || checkpointValues.Type == gjson.Null {
-		return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoints are required")
-	}
-
-	if !checkpointValues.IsArray() {
-		return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoints must be an array")
-	}
-
-	checkpointResults := checkpointValues.Array()
-	checkpoints := make([]zeustypes.MeterCheckpoint, 0, len(checkpointResults))
-	for _, checkpointValue := range checkpointResults {
-		name := checkpointValue.Get("name").String()
-		if name == "" {
-			return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoint name is required")
-		}
-
-		startDateString := checkpointValue.Get("start_date").String()
-		if startDateString == "" {
-			return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoint start_date is required for %q", name)
-		}
-
-		startDate, err := time.Parse("2006-01-02", startDateString)
-		if err != nil {
-			return nil, errors.Wrapf(err, errors.TypeInternal, zeus.ErrCodeResponseMalformed, "parse meter checkpoint start_date %q for %q", startDateString, name)
-		}
-
-		checkpoints = append(checkpoints, zeustypes.MeterCheckpoint{
-			Name:      name,
-			StartDate: startDate,
-		})
-	}
-
-	return checkpoints, nil
-}
-
 func (provider *Provider) PutProfile(ctx context.Context, key string, profile *zeustypes.PostableProfile) error {
 	body, err := json.Marshal(profile)
 	if err != nil {
@@ -251,21 +185,12 @@ func (provider *Provider) PutHost(ctx context.Context, key string, host *zeustyp
 }
 
 func (provider *Provider) do(ctx context.Context, url *url.URL, method string, key string, requestBody []byte) ([]byte, error) {
-	return provider.doWithHeaders(ctx, url, method, key, requestBody, nil)
-}
-
-func (provider *Provider) doWithHeaders(ctx context.Context, url *url.URL, method string, key string, requestBody []byte, extraHeaders http.Header) ([]byte, error) {
 	request, err := http.NewRequestWithContext(ctx, method, url.String(), bytes.NewBuffer(requestBody))
 	if err != nil {
 		return nil, err
 	}
 	request.Header.Set("X-Signoz-Cloud-Api-Key", key)
 	request.Header.Set("Content-Type", "application/json")
-	for k, vs := range extraHeaders {
-		for _, v := range vs {
-			request.Header.Add(k, v)
-		}
-	}
 
 	response, err := provider.httpClient.Do(request)
 	if err != nil {

pkg/errors/errors.go

@@ -4,8 +4,6 @@ import (
 	"errors" //nolint:depguard
 	"fmt"
 	"log/slog"
-
-	"go.opentelemetry.io/otel/attribute"
 )
 
 // base is the fundamental struct that implements the error interface.
@@ -255,10 +253,3 @@ func NewTimeoutf(code Code, format string, args ...any) *base {
 func Attr(err error) slog.Attr {
 	return slog.Any("exception", err)
 }
-
-// TypeAttr returns an OTel attribute.KeyValue with the "error.type" semconv key
-// set to the error's type string.
-func TypeAttr(err error) attribute.KeyValue {
-	t, _, _, _, _, _ := Unwrapb(err)
-	return attribute.String("error.type", t.String())
-}

pkg/flagger/registry.go

@@ -8,7 +8,6 @@ var (
 	FeatureHideRootUser      = featuretypes.MustNewName("hide_root_user")
 	FeatureGetMetersFromZeus = featuretypes.MustNewName("get_meters_from_zeus")
 	FeaturePutMetersInZeus   = featuretypes.MustNewName("put_meters_in_zeus")
-	FeatureUseMeterReporter  = featuretypes.MustNewName("use_meter_reporter")
 	FeatureUseJSONBody       = featuretypes.MustNewName("use_json_body")
 )
 
@@ -54,14 +53,6 @@ func MustNewRegistry() featuretypes.Registry {
 			DefaultVariant: featuretypes.MustNewName("disabled"),
 			Variants:       featuretypes.NewBooleanVariants(),
 		},
-		&featuretypes.Feature{
-			Name:           FeatureUseMeterReporter,
-			Kind:           featuretypes.KindBoolean,
-			Stage:          featuretypes.StageExperimental,
-			Description:    "Controls whether the enterprise meter reporter runs instead of the noop reporter",
-			DefaultVariant: featuretypes.MustNewName("disabled"),
-			Variants:       featuretypes.NewBooleanVariants(),
-		},
 		&featuretypes.Feature{
 			Name:           FeatureUseJSONBody,
 			Kind:           featuretypes.KindBoolean,

pkg/metercollector/config.go

@@ -1,68 +0,0 @@
-package metercollector
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-)
-
-const (
-	ProviderStatic    = "static"
-	ProviderTelemetry = "telemetry"
-)
-
-type Config struct {
-	Provider  string          `mapstructure:"provider"`
-	Telemetry TelemetryConfig `mapstructure:"telemetry"`
-	Static    StaticConfig    `mapstructure:"static"`
-}
-
-func (c Config) Validate() error {
-	switch c.Provider {
-	case ProviderStatic:
-		return c.Static.Validate()
-	case ProviderTelemetry:
-		return c.Telemetry.Validate()
-	default:
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidConfig, "meter collector: unknown provider %q", c.Provider)
-	}
-}
-
-type TelemetryConfig struct {
-	Name                 zeustypes.MeterName
-	Unit                 zeustypes.MeterUnit
-	Aggregation          zeustypes.MeterAggregation
-	DBName               string
-	TableName            string
-	DefaultRetentionDays int
-}
-
-type StaticConfig struct {
-	Name        zeustypes.MeterName
-	Unit        zeustypes.MeterUnit
-	Aggregation zeustypes.MeterAggregation
-	Value       int64
-}
-
-func (c StaticConfig) Validate() error {
-	if c.Name.IsZero() {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidConfig, "static meter collector: name must be set")
-	}
-
-	return nil
-}
-
-func (c TelemetryConfig) Validate() error {
-	if c.Name.IsZero() {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidConfig, "telemetry meter collector: name must be set")
-	}
-
-	if c.DBName == "" || c.TableName == "" {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidConfig, "telemetry meter collector: db_name and table_name are required")
-	}
-
-	if c.DefaultRetentionDays <= 0 {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidConfig, "telemetry meter collector: default_retention_days must be positive")
-	}
-
-	return nil
-}

pkg/metercollector/metercollector.go

@@ -1,25 +0,0 @@
-package metercollector
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMeterCollectorCollectFailed              = errors.MustNewCode("meter_collector_collect_failed")
-	ErrCodeMeterCollectorInvalidCustomRetentionRule = errors.MustNewCode("meter_collector_invalid_custom_retention_rule")
-	ErrCodeInvalidConfig                            = errors.MustNewCode("meter_collector_invalid_config")
-)
-
-type MeterCollector interface {
-	Name() zeustypes.MeterName
-	Unit() zeustypes.MeterUnit
-	Aggregation() zeustypes.MeterAggregation
-	Origin(ctx context.Context, orgID valuer.UUID, license *licensetypes.License, todayStart time.Time) (time.Time, error)
-	Collect(ctx context.Context, orgID valuer.UUID, license *licensetypes.License, window zeustypes.MeterWindow) ([]zeustypes.Meter, error)
-}

pkg/meterreporter/config.go

@@ -1,37 +0,0 @@
-package meterreporter
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-)
-
-var _ factory.Config = (*Config)(nil)
-
-type Config struct {
-	// Interval is how often the reporter collects and ships meters.
-	Interval time.Duration `mapstructure:"interval"`
-
-	// Backfill enables sealed-day catch-up from the license creation day.
-	Backfill bool `mapstructure:"backfill"`
-}
-
-func newConfig() factory.Config {
-	return Config{
-		Interval: 6 * time.Hour,
-		Backfill: true,
-	}
-}
-
-func NewConfigFactory() factory.ConfigFactory {
-	return factory.NewConfigFactory(factory.MustNewName("meterreporter"), newConfig)
-}
-
-func (c Config) Validate() error {
-	if c.Interval < 5*time.Minute || c.Interval > 24*time.Hour {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidInput, "meterreporter::interval must be between 5m and 24h")
-	}
-
-	return nil
-}

pkg/meterreporter/meterreporter.go

@@ -1,14 +0,0 @@
-package meterreporter
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-)
-
-var (
-	ErrCodeInvalidInput = errors.MustNewCode("meterreporter_invalid_input")
-)
-
-type Reporter interface {
-	factory.ServiceWithHealthy
-}

pkg/meterreporter/noopmeterreporter/provider.go

@@ -1,39 +0,0 @@
-package noopmeterreporter
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
-)
-
-type provider struct {
-	healthyC chan struct{}
-	stopC    chan struct{}
-}
-
-func NewFactory() factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("noop"), New)
-}
-
-func New(_ context.Context, _ factory.ProviderSettings, _ meterreporter.Config) (meterreporter.Reporter, error) {
-	return &provider{
-		healthyC: make(chan struct{}),
-		stopC:    make(chan struct{}),
-	}, nil
-}
-
-func (p *provider) Start(_ context.Context) error {
-	close(p.healthyC)
-	<-p.stopC
-	return nil
-}
-
-func (p *provider) Stop(_ context.Context) error {
-	close(p.stopC)
-	return nil
-}
-
-func (p *provider) Healthy() <-chan struct{} {
-	return p.healthyC
-}

pkg/modules/retention/implretention/getter.go

@@ -1,52 +0,0 @@
-package implretention
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type getter struct {
-	store retentiontypes.Store
-}
-
-// NewGetter creates a retention getter backed by the retention store.
-func NewGetter(store retentiontypes.Store) retention.Getter {
-	return &getter{
-		store: store,
-	}
-}
-
-// GetRetentionPolicySegments loads successful TTL changes and converts them into retention policy segments.
-func (getter *getter) GetRetentionPolicySegments(
-	ctx context.Context,
-	orgID valuer.UUID,
-	dbName string,
-	tableName string,
-	fallbackDefaultDays int,
-	startMs int64,
-	endMs int64,
-) ([]*retentiontypes.RetentionPolicySegment, error) {
-	if startMs >= endMs {
-		return nil, nil
-	}
-	if dbName == "" {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "dbName is empty")
-	}
-	if tableName == "" {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "tableName is empty")
-	}
-	if fallbackDefaultDays <= 0 {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "non-positive fallbackDefaultDays %d", fallbackDefaultDays)
-	}
-
-	rows, err := getter.store.ListTTLSettingsByTableNameAndBeforeCreatedAt(ctx, orgID, dbName+"."+tableName, endMs)
-	if err != nil {
-		return nil, err
-	}
-
-	return retentiontypes.BuildRetentionPolicySegmentsFromRows(rows, fallbackDefaultDays, startMs, endMs)
-}

pkg/modules/retention/implretention/store.go

@@ -1,41 +0,0 @@
-package implretention
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type store struct {
-	sqlstore sqlstore.SQLStore
-}
-
-// NewStore creates a SQL-backed retention store.
-func NewStore(sqlstore sqlstore.SQLStore) retentiontypes.Store {
-	return &store{sqlstore: sqlstore}
-}
-
-// ListTTLSettingsByTableNameAndBeforeCreatedAt returns successful TTL settings before the given timestamp.
-func (store *store) ListTTLSettingsByTableNameAndBeforeCreatedAt(ctx context.Context, orgID valuer.UUID, tableName string, beforeMs int64) ([]*retentiontypes.TTLSetting, error) {
-	rows := []*retentiontypes.TTLSetting{}
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&rows).
-		Where("table_name = ?", tableName).
-		Where("org_id = ?", orgID.StringValue()).
-		Where("status = ?", retentiontypes.TTLSettingStatusSuccess).
-		Where("created_at < ?", time.UnixMilli(beforeMs).UTC()).
-		OrderExpr("created_at ASC").
-		Scan(ctx)
-	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "load ttl_setting rows for org %q table %q", orgID.StringValue(), tableName)
-	}
-
-	return rows, nil
-}

pkg/modules/retention/retention.go

@@ -1,14 +0,0 @@
-package retention
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Getter resolves retention data and expressions for read paths.
-type Getter interface {
-	// GetRetentionPolicySegments returns retention policy segments active over a half-open meter window.
-	GetRetentionPolicySegments(ctx context.Context, orgID valuer.UUID, dbName string, tableName string, fallbackDefaultDays int, startMs int64, endMs int64) ([]*retentiontypes.RetentionPolicySegment, error)
-}

pkg/query-service/app/clickhouseReader/reader.go

@@ -1343,7 +1343,7 @@ func getLocalTableName(tableName string) string {
 
 }
 
-func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEmail string, params *retentiontypes.TTLParams) (*retentiontypes.SetTTLResponseItem, *model.ApiError) {
+func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, params *model.TTLParams) (*model.SetTTLResponseItem, *model.ApiError) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalLogs.StringValue(),
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
@@ -1378,7 +1378,7 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 		if apiErr != nil {
 			return nil, &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error in processing ttl_status check sql query")}
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusPending {
+		if statusItem.Status == constants.StatusPending {
 			return nil, &model.ApiError{Typ: model.ErrorConflict, Err: fmt.Errorf("TTL is already running")}
 		}
 	}
@@ -1434,14 +1434,10 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 					CreatedAt: time.Now(),
 					UpdatedAt: time.Now(),
 				},
-				UserAuditable: types.UserAuditable{
-					CreatedBy: userEmail,
-					UpdatedBy: userEmail,
-				},
 				TransactionID:  uuid,
 				TableName:      tableName,
 				TTL:            int(params.DelDuration),
-				Status:         retentiontypes.TTLSettingStatusPending,
+				Status:         constants.StatusPending,
 				ColdStorageTTL: coldStorageDuration,
 				OrgID:          orgID,
 			}
@@ -1467,7 +1463,7 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 						NewUpdate().
 						Model(new(retentiontypes.TTLSetting)).
 						Set("updated_at = ?", time.Now()).
-						Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+						Set("status = ?", constants.StatusFailed).
 						Where("id = ?", statusItem.ID.StringValue()).
 						Exec(ctx)
 					if dbErr != nil {
@@ -1487,7 +1483,7 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 					NewUpdate().
 					Model(new(retentiontypes.TTLSetting)).
 					Set("updated_at = ?", time.Now()).
-					Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+					Set("status = ?", constants.StatusFailed).
 					Where("id = ?", statusItem.ID.StringValue()).
 					Exec(ctx)
 				if dbErr != nil {
@@ -1502,7 +1498,7 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 				NewUpdate().
 				Model(new(retentiontypes.TTLSetting)).
 				Set("updated_at = ?", time.Now()).
-				Set("status = ?", retentiontypes.TTLSettingStatusSuccess).
+				Set("status = ?", constants.StatusSuccess).
 				Where("id = ?", statusItem.ID.StringValue()).
 				Exec(ctx)
 			if dbErr != nil {
@@ -1512,10 +1508,10 @@ func (r *ClickHouseReader) setTTLLogs(ctx context.Context, orgID string, userEma
 		}
 
 	}(ttlPayload)
-	return &retentiontypes.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
+	return &model.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
 }
 
-func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userEmail string, params *retentiontypes.TTLParams) (*retentiontypes.SetTTLResponseItem, *model.ApiError) {
+func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, params *model.TTLParams) (*model.SetTTLResponseItem, *model.ApiError) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalTraces.StringValue(),
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
@@ -1545,7 +1541,7 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 		if apiErr != nil {
 			return nil, &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error in processing ttl_status check sql query")}
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusPending {
+		if statusItem.Status == constants.StatusPending {
 			return nil, &model.ApiError{Typ: model.ErrorConflict, Err: fmt.Errorf("TTL is already running")}
 		}
 	}
@@ -1576,14 +1572,10 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 					CreatedAt: time.Now(),
 					UpdatedAt: time.Now(),
 				},
-				UserAuditable: types.UserAuditable{
-					CreatedBy: userEmail,
-					UpdatedBy: userEmail,
-				},
 				TransactionID:  uuid,
 				TableName:      tableName,
 				TTL:            int(params.DelDuration),
-				Status:         retentiontypes.TTLSettingStatusPending,
+				Status:         constants.StatusPending,
 				ColdStorageTTL: coldStorageDuration,
 				OrgID:          orgID,
 			}
@@ -1621,7 +1613,7 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 						NewUpdate().
 						Model(new(retentiontypes.TTLSetting)).
 						Set("updated_at = ?", time.Now()).
-						Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+						Set("status = ?", constants.StatusFailed).
 						Where("id = ?", statusItem.ID.StringValue()).
 						Exec(ctx)
 					if dbErr != nil {
@@ -1642,7 +1634,7 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 					NewUpdate().
 					Model(new(retentiontypes.TTLSetting)).
 					Set("updated_at = ?", time.Now()).
-					Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+					Set("status = ?", constants.StatusFailed).
 					Where("id = ?", statusItem.ID.StringValue()).
 					Exec(ctx)
 				if dbErr != nil {
@@ -1657,7 +1649,7 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 				NewUpdate().
 				Model(new(retentiontypes.TTLSetting)).
 				Set("updated_at = ?", time.Now()).
-				Set("status = ?", retentiontypes.TTLSettingStatusSuccess).
+				Set("status = ?", constants.StatusSuccess).
 				Where("id = ?", statusItem.ID.StringValue()).
 				Exec(ctx)
 			if dbErr != nil {
@@ -1666,7 +1658,7 @@ func (r *ClickHouseReader) setTTLTraces(ctx context.Context, orgID string, userE
 			}
 		}(distributedTableName)
 	}
-	return &retentiontypes.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
+	return &model.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
 }
 
 func (r *ClickHouseReader) hasCustomRetentionColumn(ctx context.Context) (bool, error) {
@@ -1695,7 +1687,7 @@ func (r *ClickHouseReader) hasCustomRetentionColumn(ctx context.Context) (bool,
 	return true, nil
 }
 
-func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail string, params *retentiontypes.CustomRetentionTTLParams) (*retentiontypes.CustomRetentionTTLResponse, error) {
+func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, params *model.CustomRetentionTTLParams) (*model.CustomRetentionTTLResponse, error) {
 
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalLogs.StringValue(),
@@ -1710,7 +1702,7 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 	if !hasCustomRetention {
 		r.logger.Info("Custom retention not supported, falling back to standard TTL method", "orgID", orgID)
 
-		ttlParams := &retentiontypes.TTLParams{
+		ttlParams := &model.TTLParams{
 			Type:        params.Type,
 			DelDuration: int64(params.DefaultTTLDays * 24 * 3600),
 		}
@@ -1726,12 +1718,12 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 			ttlParams.ToColdStorageDuration = 0
 		}
 
-		ttlResult, apiErr := r.SetTTL(ctx, orgID, userEmail, ttlParams)
+		ttlResult, apiErr := r.SetTTL(ctx, orgID, ttlParams)
 		if apiErr != nil {
 			return nil, errorsV2.Wrapf(apiErr.Err, errorsV2.TypeInternal, errorsV2.CodeInternal, "failed to set standard TTL")
 		}
 
-		return &retentiontypes.CustomRetentionTTLResponse{
+		return &model.CustomRetentionTTLResponse{
 			Message: fmt.Sprintf("Custom retention not supported, applied standard TTL of %d days. %s", params.DefaultTTLDays, ttlResult.Message),
 		}, nil
 	}
@@ -1742,7 +1734,7 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 	uuidWithHyphen := valuer.GenerateUUID()
 	uuid := strings.Replace(uuidWithHyphen.String(), "-", "", -1)
 
-	if params.Type != retentiontypes.LogsTTL {
+	if params.Type != constants.LogsTTL {
 		return nil, errorsV2.Newf(errorsV2.TypeInternal, errorsV2.CodeInternal, "custom retention TTL only supported for logs")
 	}
 
@@ -1773,7 +1765,7 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 		if apiErr != nil {
 			return nil, errorsV2.Newf(errorsV2.TypeInternal, errorsV2.CodeInternal, "error in processing custom_retention_ttl_status check sql query")
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusPending {
+		if statusItem.Status == constants.StatusPending {
 			return nil, errorsV2.Newf(errorsV2.TypeInternal, errorsV2.CodeInternal, "custom retention TTL is already running")
 		}
 	}
@@ -1855,15 +1847,11 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 				CreatedAt: time.Now(),
 				UpdatedAt: time.Now(),
 			},
-			UserAuditable: types.UserAuditable{
-				CreatedBy: userEmail,
-				UpdatedBy: userEmail,
-			},
 			TransactionID:  uuid,
 			TableName:      tableName,
 			TTL:            params.DefaultTTLDays,
 			Condition:      string(ttlConditionsJSON),
-			Status:         retentiontypes.TTLSettingStatusPending,
+			Status:         constants.StatusPending,
 			ColdStorageTTL: coldStorageDuration,
 			OrgID:          orgID,
 		}
@@ -1879,7 +1867,7 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 			err := r.setColdStorage(ctx, tableName, params.ColdStorageVolume)
 			if err != nil {
 				r.logger.Error("error in setting cold storage", errorsV2.Attr(err))
-				r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, retentiontypes.TTLSettingStatusFailed)
+				r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, constants.StatusFailed)
 				return nil, errorsV2.Wrapf(err.Err, errorsV2.TypeInternal, errorsV2.CodeInternal, "error setting cold storage for table %s", tableName)
 			}
 		}
@@ -1888,21 +1876,21 @@ func (r *ClickHouseReader) SetTTLV2(ctx context.Context, orgID string, userEmail
 			r.logger.Debug("Executing custom retention TTL request: ", "request", query, "step", i+1)
 			if err := r.db.Exec(ctx, query); err != nil {
 				r.logger.Error("error while setting custom retention ttl", errorsV2.Attr(err))
-				r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, retentiontypes.TTLSettingStatusFailed)
+				r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, constants.StatusFailed)
 				return nil, errorsV2.Wrapf(err, errorsV2.TypeInternal, errorsV2.CodeInternal, "error setting custom retention TTL for table %s, query: %s", tableName, query)
 			}
 		}
 
-		r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, retentiontypes.TTLSettingStatusSuccess)
+		r.updateCustomRetentionTTLStatus(ctx, orgID, tableName, constants.StatusSuccess)
 	}
 
-	return &retentiontypes.CustomRetentionTTLResponse{
+	return &model.CustomRetentionTTLResponse{
 		Message: "custom retention TTL has been successfully set up",
 	}, nil
 }
 
 // New method to build multiIf expressions with support for multiple AND conditions
-func (r *ClickHouseReader) buildMultiIfExpression(ttlConditions []retentiontypes.CustomRetentionRule, defaultTTLDays int, isResourceTable bool) string {
+func (r *ClickHouseReader) buildMultiIfExpression(ttlConditions []model.CustomRetentionRule, defaultTTLDays int, isResourceTable bool) string {
 	var conditions []string
 
 	for i, rule := range ttlConditions {
@@ -1974,7 +1962,7 @@ func (r *ClickHouseReader) buildMultiIfExpression(ttlConditions []retentiontypes
 	return result
 }
 
-func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID string) (*retentiontypes.GetCustomRetentionTTLResponse, error) {
+func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID string) (*model.GetCustomRetentionTTLResponse, error) {
 	// Check if V2 (custom retention) is supported
 	hasCustomRetention, err := r.hasCustomRetentionColumn(ctx)
 	if err != nil {
@@ -1983,7 +1971,7 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 		hasCustomRetention = false
 	}
 
-	response := &retentiontypes.GetCustomRetentionTTLResponse{}
+	response := &model.GetCustomRetentionTTLResponse{}
 
 	if hasCustomRetention {
 		// V2 - Custom retention is supported
@@ -2006,19 +1994,19 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 
 		if err == sql.ErrNoRows {
 			// No V2 configuration found, return defaults
-			response.DefaultTTLDays = retentiontypes.DefaultLogsRetentionDays
-			response.TTLConditions = []retentiontypes.CustomRetentionRule{}
-			response.Status = retentiontypes.TTLSettingStatusSuccess
+			response.DefaultTTLDays = 15
+			response.TTLConditions = []model.CustomRetentionRule{}
+			response.Status = constants.StatusSuccess
 			response.ColdStorageTTLDays = -1
 			return response, nil
 		}
 
 		// Parse TTL conditions from Condition
-		var ttlConditions []retentiontypes.CustomRetentionRule
+		var ttlConditions []model.CustomRetentionRule
 		if customTTL.Condition != "" {
 			if err := json.Unmarshal([]byte(customTTL.Condition), &ttlConditions); err != nil {
 				r.logger.Error("Error parsing TTL conditions", errorsV2.Attr(err))
-				ttlConditions = []retentiontypes.CustomRetentionRule{}
+				ttlConditions = []model.CustomRetentionRule{}
 			}
 		}
 
@@ -2032,8 +2020,8 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 		response.Version = "v1"
 
 		// Get V1 TTL configuration
-		ttlParams := &retentiontypes.GetTTLParams{
-			Type: retentiontypes.LogsTTL,
+		ttlParams := &model.GetTTLParams{
+			Type: constants.LogsTTL,
 		}
 
 		ttlResult, apiErr := r.GetTTL(ctx, orgID, ttlParams)
@@ -2053,7 +2041,7 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 		}
 
 		// For V1, we don't have TTL conditions
-		response.TTLConditions = []retentiontypes.CustomRetentionRule{}
+		response.TTLConditions = []model.CustomRetentionRule{}
 	}
 
 	return response, nil
@@ -2093,7 +2081,7 @@ func (r *ClickHouseReader) updateCustomRetentionTTLStatus(ctx context.Context, o
 }
 
 // Enhanced validation function with duplicate detection and efficient key validation
-func (r *ClickHouseReader) validateTTLConditions(ctx context.Context, ttlConditions []retentiontypes.CustomRetentionRule) error {
+func (r *ClickHouseReader) validateTTLConditions(ctx context.Context, ttlConditions []model.CustomRetentionRule) error {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
 		instrumentationtypes.CodeFunctionName: "validateTTLConditions",
@@ -2197,24 +2185,24 @@ func (r *ClickHouseReader) validateTTLConditions(ctx context.Context, ttlConditi
 // SetTTL sets the TTL for traces or metrics or logs tables.
 // This is an async API which creates goroutines to set TTL.
 // Status of TTL update is tracked with ttl_status table in sqlite db.
-func (r *ClickHouseReader) SetTTL(ctx context.Context, orgID string, userEmail string, params *retentiontypes.TTLParams) (*retentiontypes.SetTTLResponseItem, *model.ApiError) {
+func (r *ClickHouseReader) SetTTL(ctx context.Context, orgID string, params *model.TTLParams) (*model.SetTTLResponseItem, *model.ApiError) {
 	// Keep only latest 100 transactions/requests
 	r.deleteTtlTransactions(ctx, orgID, 100)
 
 	switch params.Type {
-	case retentiontypes.TraceTTL:
-		return r.setTTLTraces(ctx, orgID, userEmail, params)
-	case retentiontypes.MetricsTTL:
-		return r.setTTLMetrics(ctx, orgID, userEmail, params)
-	case retentiontypes.LogsTTL:
-		return r.setTTLLogs(ctx, orgID, userEmail, params)
+	case constants.TraceTTL:
+		return r.setTTLTraces(ctx, orgID, params)
+	case constants.MetricsTTL:
+		return r.setTTLMetrics(ctx, orgID, params)
+	case constants.LogsTTL:
+		return r.setTTLLogs(ctx, orgID, params)
 	default:
 		return nil, &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error while setting ttl. ttl type should be <metrics|traces>, got %v", params.Type)}
 	}
 
 }
 
-func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, userEmail string, params *retentiontypes.TTLParams) (*retentiontypes.SetTTLResponseItem, *model.ApiError) {
+func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, params *model.TTLParams) (*model.SetTTLResponseItem, *model.ApiError) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalMetrics.StringValue(),
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
@@ -2243,7 +2231,7 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 		if apiErr != nil {
 			return nil, &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error in processing ttl_status check sql query")}
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusPending {
+		if statusItem.Status == constants.StatusPending {
 			return nil, &model.ApiError{Typ: model.ErrorConflict, Err: fmt.Errorf("TTL is already running")}
 		}
 	}
@@ -2256,14 +2244,10 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 				CreatedAt: time.Now(),
 				UpdatedAt: time.Now(),
 			},
-			UserAuditable: types.UserAuditable{
-				CreatedBy: userEmail,
-				UpdatedBy: userEmail,
-			},
 			TransactionID:  uuid,
 			TableName:      tableName,
 			TTL:            int(params.DelDuration),
-			Status:         retentiontypes.TTLSettingStatusPending,
+			Status:         constants.StatusPending,
 			ColdStorageTTL: coldStorageDuration,
 			OrgID:          orgID,
 		}
@@ -2301,7 +2285,7 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 					NewUpdate().
 					Model(new(retentiontypes.TTLSetting)).
 					Set("updated_at = ?", time.Now()).
-					Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+					Set("status = ?", constants.StatusFailed).
 					Where("id = ?", statusItem.ID.StringValue()).
 					Exec(ctx)
 				if dbErr != nil {
@@ -2322,7 +2306,7 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 				NewUpdate().
 				Model(new(retentiontypes.TTLSetting)).
 				Set("updated_at = ?", time.Now()).
-				Set("status = ?", retentiontypes.TTLSettingStatusFailed).
+				Set("status = ?", constants.StatusFailed).
 				Where("id = ?", statusItem.ID.StringValue()).
 				Exec(ctx)
 			if dbErr != nil {
@@ -2337,7 +2321,7 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 			NewUpdate().
 			Model(new(retentiontypes.TTLSetting)).
 			Set("updated_at = ?", time.Now()).
-			Set("status = ?", retentiontypes.TTLSettingStatusSuccess).
+			Set("status = ?", constants.StatusSuccess).
 			Where("id = ?", statusItem.ID.StringValue()).
 			Exec(ctx)
 		if dbErr != nil {
@@ -2348,7 +2332,7 @@ func (r *ClickHouseReader) setTTLMetrics(ctx context.Context, orgID string, user
 	for _, tableName := range tableNames {
 		go metricTTL(tableName)
 	}
-	return &retentiontypes.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
+	return &model.SetTTLResponseItem{Message: "move ttl has been successfully set up"}, nil
 }
 
 func (r *ClickHouseReader) deleteTtlTransactions(ctx context.Context, orgID string, numberOfTransactionsStore int) {
@@ -2405,7 +2389,7 @@ func (r *ClickHouseReader) checkTTLStatusItem(ctx context.Context, orgID string,
 // getTTLQueryStatus fetches ttl_status table status from DB
 func (r *ClickHouseReader) getTTLQueryStatus(ctx context.Context, orgID string, tableNameArray []string) (string, *model.ApiError) {
 	failFlag := false
-	status := retentiontypes.TTLSettingStatusSuccess
+	status := constants.StatusSuccess
 	for _, tableName := range tableNameArray {
 		statusItem, apiErr := r.checkTTLStatusItem(ctx, orgID, tableName)
 		emptyStatusStruct := new(retentiontypes.TTLSetting)
@@ -2415,16 +2399,16 @@ func (r *ClickHouseReader) getTTLQueryStatus(ctx context.Context, orgID string,
 		if apiErr != nil {
 			return "", &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error in processing ttl_status check sql query")}
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusPending && statusItem.UpdatedAt.Unix()-time.Now().Unix() < 3600 {
-			status = retentiontypes.TTLSettingStatusPending
+		if statusItem.Status == constants.StatusPending && statusItem.UpdatedAt.Unix()-time.Now().Unix() < 3600 {
+			status = constants.StatusPending
 			return status, nil
 		}
-		if statusItem.Status == retentiontypes.TTLSettingStatusFailed {
+		if statusItem.Status == constants.StatusFailed {
 			failFlag = true
 		}
 	}
 	if failFlag {
-		status = retentiontypes.TTLSettingStatusFailed
+		status = constants.StatusFailed
 	}
 
 	return status, nil
@@ -2477,7 +2461,7 @@ func getLocalTableNameArray(tableNames []string) []string {
 }
 
 // GetTTL returns current ttl, expected ttl and past setTTL status for metrics/traces.
-func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *retentiontypes.GetTTLParams) (*retentiontypes.GetTTLResponseItem, *model.ApiError) {
+func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *model.GetTTLParams) (*model.GetTTLResponseItem, *model.ApiError) {
 
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
@@ -2512,8 +2496,8 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		return delTTL, moveTTL
 	}
 
-	getMetricsTTL := func() (*retentiontypes.DBResponseTTL, *model.ApiError) {
-		var dbResp []retentiontypes.DBResponseTTL
+	getMetricsTTL := func() (*model.DBResponseTTL, *model.ApiError) {
+		var dbResp []model.DBResponseTTL
 
 		query := fmt.Sprintf("SELECT engine_full FROM system.tables WHERE name='%v'", signozSampleLocalTableName)
 
@@ -2530,8 +2514,8 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		}
 	}
 
-	getTracesTTL := func() (*retentiontypes.DBResponseTTL, *model.ApiError) {
-		var dbResp []retentiontypes.DBResponseTTL
+	getTracesTTL := func() (*model.DBResponseTTL, *model.ApiError) {
+		var dbResp []model.DBResponseTTL
 
 		query := fmt.Sprintf("SELECT engine_full FROM system.tables WHERE name='%v' AND database='%v'", r.traceLocalTableName, signozTraceDBName)
 
@@ -2548,8 +2532,8 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		}
 	}
 
-	getLogsTTL := func() (*retentiontypes.DBResponseTTL, *model.ApiError) {
-		var dbResp []retentiontypes.DBResponseTTL
+	getLogsTTL := func() (*model.DBResponseTTL, *model.ApiError) {
+		var dbResp []model.DBResponseTTL
 
 		query := fmt.Sprintf("SELECT engine_full FROM system.tables WHERE name='%v' AND database='%v'", r.logsLocalTableName, r.logsDB)
 
@@ -2567,7 +2551,7 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 	}
 
 	switch ttlParams.Type {
-	case retentiontypes.TraceTTL:
+	case constants.TraceTTL:
 		tableNameArray := []string{
 			r.TraceDB + "." + r.traceTableName,
 			r.TraceDB + "." + r.traceResourceTableV3,
@@ -2595,9 +2579,9 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		}
 
 		delTTL, moveTTL := parseTTL(dbResp.EngineFull)
-		return &retentiontypes.GetTTLResponseItem{TracesTime: delTTL, TracesMoveTime: moveTTL, ExpectedTracesTime: ttlQuery.TTL, ExpectedTracesMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
+		return &model.GetTTLResponseItem{TracesTime: delTTL, TracesMoveTime: moveTTL, ExpectedTracesTime: ttlQuery.TTL, ExpectedTracesMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
 
-	case retentiontypes.MetricsTTL:
+	case constants.MetricsTTL:
 		tableNameArray := []string{signozMetricDBName + "." + signozSampleTableName}
 		tableNameArray = getLocalTableNameArray(tableNameArray)
 		status, apiErr := r.getTTLQueryStatus(ctx, orgID, tableNameArray)
@@ -2618,9 +2602,9 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		}
 
 		delTTL, moveTTL := parseTTL(dbResp.EngineFull)
-		return &retentiontypes.GetTTLResponseItem{MetricsTime: delTTL, MetricsMoveTime: moveTTL, ExpectedMetricsTime: ttlQuery.TTL, ExpectedMetricsMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
+		return &model.GetTTLResponseItem{MetricsTime: delTTL, MetricsMoveTime: moveTTL, ExpectedMetricsTime: ttlQuery.TTL, ExpectedMetricsMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
 
-	case retentiontypes.LogsTTL:
+	case constants.LogsTTL:
 		tableNameArray := []string{r.logsDB + "." + r.logsTableName}
 		tableNameArray = getLocalTableNameArray(tableNameArray)
 		status, apiErr := r.getTTLQueryStatus(ctx, orgID, tableNameArray)
@@ -2641,7 +2625,7 @@ func (r *ClickHouseReader) GetTTL(ctx context.Context, orgID string, ttlParams *
 		}
 
 		delTTL, moveTTL := parseTTL(dbResp.EngineFull)
-		return &retentiontypes.GetTTLResponseItem{LogsTime: delTTL, LogsMoveTime: moveTTL, ExpectedLogsTime: ttlQuery.TTL, ExpectedLogsMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
+		return &model.GetTTLResponseItem{LogsTime: delTTL, LogsMoveTime: moveTTL, ExpectedLogsTime: ttlQuery.TTL, ExpectedLogsMoveTime: ttlQuery.ColdStorageTTL, Status: status}, nil
 
 	default:
 		return nil, &model.ApiError{Typ: model.ErrorExec, Err: fmt.Errorf("error while getting ttl. ttl type should be metrics|traces, got %v",

pkg/query-service/app/http_handler.go

@@ -34,7 +34,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/signoz"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
 	"github.com/gorilla/mux"
@@ -1656,7 +1655,7 @@ func (aH *APIHandler) setTTL(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Context is not used here as TTL is long duration DB operation
-	result, apiErr := aH.reader.SetTTL(context.Background(), claims.OrgID, claims.Email, ttlParams)
+	result, apiErr := aH.reader.SetTTL(context.Background(), claims.OrgID, ttlParams)
 	if apiErr != nil {
 		if apiErr.Typ == model.ErrorConflict {
 			aH.HandleError(w, apiErr.Err, http.StatusConflict)
@@ -1678,14 +1677,14 @@ func (aH *APIHandler) setCustomRetentionTTL(w http.ResponseWriter, r *http.Reque
 		return
 	}
 
-	var params retentiontypes.CustomRetentionTTLParams
+	var params model.CustomRetentionTTLParams
 	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
 		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "Invalid data"))
 		return
 	}
 
 	// Context is not used here as TTL is long duration DB operation
-	result, apiErr := aH.reader.SetTTLV2(context.Background(), claims.OrgID, claims.Email, &params)
+	result, apiErr := aH.reader.SetTTLV2(context.Background(), claims.OrgID, &params)
 	if apiErr != nil {
 		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInternal, apiErr.Error()))
 		return

pkg/query-service/app/parser.go

@@ -40,7 +40,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/postprocess"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	querytemplate "github.com/SigNoz/signoz/pkg/query-service/utils/queryTemplate"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
 	chVariables "github.com/SigNoz/signoz/pkg/variables/clickhouse"
 )
 
@@ -420,7 +419,7 @@ func parseTime(param string, r *http.Request) (*time.Time, error) {
 
 }
 
-func parseTTLParams(r *http.Request) (*retentiontypes.TTLParams, error) {
+func parseTTLParams(r *http.Request) (*model.TTLParams, error) {
 
 	// make sure either of the query params are present
 	typeTTL := r.URL.Query().Get("type")
@@ -433,7 +432,7 @@ func parseTTLParams(r *http.Request) (*retentiontypes.TTLParams, error) {
 	}
 
 	// Validate the type parameter
-	if typeTTL != retentiontypes.TraceTTL && typeTTL != retentiontypes.MetricsTTL && typeTTL != retentiontypes.LogsTTL {
+	if typeTTL != baseconstants.TraceTTL && typeTTL != baseconstants.MetricsTTL && typeTTL != baseconstants.LogsTTL {
 		return nil, fmt.Errorf("type param should be metrics|traces|logs, got %v", typeTTL)
 	}
 
@@ -456,7 +455,7 @@ func parseTTLParams(r *http.Request) (*retentiontypes.TTLParams, error) {
 		}
 	}
 
-	return &retentiontypes.TTLParams{
+	return &model.TTLParams{
 		Type:                  typeTTL,
 		DelDuration:           int64(durationParsed.Seconds()),
 		ColdStorageVolume:     coldStorage,
@@ -464,7 +463,7 @@ func parseTTLParams(r *http.Request) (*retentiontypes.TTLParams, error) {
 	}, nil
 }
 
-func parseGetTTL(r *http.Request) (*retentiontypes.GetTTLParams, error) {
+func parseGetTTL(r *http.Request) (*model.GetTTLParams, error) {
 
 	typeTTL := r.URL.Query().Get("type")
 
@@ -472,12 +471,12 @@ func parseGetTTL(r *http.Request) (*retentiontypes.GetTTLParams, error) {
 		return nil, fmt.Errorf("type param cannot be empty from the query")
 	} else {
 		// Validate the type parameter
-		if typeTTL != retentiontypes.TraceTTL && typeTTL != retentiontypes.MetricsTTL && typeTTL != retentiontypes.LogsTTL {
+		if typeTTL != baseconstants.TraceTTL && typeTTL != baseconstants.MetricsTTL && typeTTL != baseconstants.LogsTTL {
 			return nil, fmt.Errorf("type param should be metrics|traces|logs, got %v", typeTTL)
 		}
 	}
 
-	return &retentiontypes.GetTTLParams{Type: typeTTL}, nil
+	return &model.GetTTLParams{Type: typeTTL}, nil
 }
 
 func parseAggregateAttributeRequest(r *http.Request) (*v3.AggregateAttributeRequest, error) {

pkg/query-service/constants/constants.go

@@ -19,6 +19,10 @@ const (
 
 const MaxAllowedPointsInTimeSeries = 300
 
+const TraceTTL = "traces"
+const MetricsTTL = "metrics"
+const LogsTTL = "logs"
+
 const SpanSearchScopeRoot = "isroot"
 const SpanSearchScopeEntryPoint = "isentrypoint"
 const OrderBySpanCount = "span_count"

pkg/query-service/interfaces/interface.go

@@ -7,7 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/querycache"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/util/stats"
@@ -24,8 +23,8 @@ type Reader interface {
 	GetServicesList(ctx context.Context) (*[]string, error)
 	GetDependencyGraph(ctx context.Context, query *model.GetServicesParams) (*[]model.ServiceMapDependencyResponseItem, error)
 
-	GetTTL(ctx context.Context, orgID string, ttlParams *retentiontypes.GetTTLParams) (*retentiontypes.GetTTLResponseItem, *model.ApiError)
-	GetCustomRetentionTTL(ctx context.Context, orgID string) (*retentiontypes.GetCustomRetentionTTLResponse, error)
+	GetTTL(ctx context.Context, orgID string, ttlParams *model.GetTTLParams) (*model.GetTTLResponseItem, *model.ApiError)
+	GetCustomRetentionTTL(ctx context.Context, orgID string) (*model.GetCustomRetentionTTLResponse, error)
 
 	// GetDisks returns a list of disks configured in the underlying DB. It is supported by
 	// clickhouse only.
@@ -47,8 +46,8 @@ type Reader interface {
 	GetFlamegraphSpansForTrace(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetFlamegraphSpansForTraceParams) (*model.GetFlamegraphSpansForTraceResponse, error)
 
 	// Setter Interfaces
-	SetTTL(ctx context.Context, orgID string, userEmail string, ttlParams *retentiontypes.TTLParams) (*retentiontypes.SetTTLResponseItem, *model.ApiError)
-	SetTTLV2(ctx context.Context, orgID string, userEmail string, params *retentiontypes.CustomRetentionTTLParams) (*retentiontypes.CustomRetentionTTLResponse, error)
+	SetTTL(ctx context.Context, orgID string, ttlParams *model.TTLParams) (*model.SetTTLResponseItem, *model.ApiError)
+	SetTTLV2(ctx context.Context, orgID string, params *model.CustomRetentionTTLParams) (*model.CustomRetentionTTLResponse, error)
 
 	FetchTemporality(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string]map[v3.Temporality]bool, error)
 	GetMetricAggregateAttributes(ctx context.Context, orgID valuer.UUID, req *v3.AggregateAttributeRequest, skipSignozMetrics bool) (*v3.AggregateAttributeResponse, error)

pkg/query-service/model/queryParams.go

@@ -404,6 +404,56 @@ type TagKey struct {
 	Type TagDataType `json:"type"`
 }
 
+type TTLParams struct {
+	Type                  string // It can be one of {traces, metrics}.
+	ColdStorageVolume     string // Name of the cold storage volume.
+	ToColdStorageDuration int64  // Seconds after which data will be moved to cold storage.
+	DelDuration           int64  // Seconds after which data will be deleted.
+}
+
+type CustomRetentionTTLParams struct {
+	Type                      string                `json:"type"`
+	DefaultTTLDays            int                   `json:"defaultTTLDays"`
+	TTLConditions             []CustomRetentionRule `json:"ttlConditions"`
+	ColdStorageVolume         string                `json:"coldStorageVolume,omitempty"`
+	ToColdStorageDurationDays int64                 `json:"coldStorageDurationDays,omitempty"`
+}
+
+type CustomRetentionRule struct {
+	Filters []FilterCondition `json:"conditions"`
+	TTLDays int               `json:"ttlDays"`
+}
+
+type FilterCondition struct {
+	Key    string   `json:"key"`
+	Values []string `json:"values"`
+}
+
+type GetCustomRetentionTTLResponse struct {
+	Version string `json:"version"`
+	Status  string `json:"status"`
+
+	// V1 fields
+	// LogsTime             int `json:"logs_ttl_duration_hrs,omitempty"`
+	// LogsMoveTime         int `json:"logs_move_ttl_duration_hrs,omitempty"`
+	ExpectedLogsTime     int `json:"expected_logs_ttl_duration_hrs,omitempty"`
+	ExpectedLogsMoveTime int `json:"expected_logs_move_ttl_duration_hrs,omitempty"`
+
+	// V2 fields
+	DefaultTTLDays     int                   `json:"default_ttl_days,omitempty"`
+	TTLConditions      []CustomRetentionRule `json:"ttl_conditions,omitempty"`
+	ColdStorageVolume  string                `json:"cold_storage_volume,omitempty"`
+	ColdStorageTTLDays int                   `json:"cold_storage_ttl_days,omitempty"`
+}
+
+type CustomRetentionTTLResponse struct {
+	Message string `json:"message"`
+}
+
+type GetTTLParams struct {
+	Type string
+}
+
 type ListErrorsParams struct {
 	StartStr      string `json:"start"`
 	EndStr        string `json:"end"`

pkg/query-service/model/response.go

@@ -150,6 +150,16 @@ type RuleResponseItem struct {
 	Data      string    `json:"data" db:"data"`
 }
 
+type TTLStatusItem struct {
+	Id             int       `json:"id" db:"id"`
+	UpdatedAt      time.Time `json:"updated_at" db:"updated_at"`
+	CreatedAt      time.Time `json:"created_at" db:"created_at"`
+	TableName      string    `json:"table_name" db:"table_name"`
+	TTL            int       `json:"ttl" db:"ttl"`
+	Status         string    `json:"status" db:"status"`
+	ColdStorageTtl int       `json:"cold_storage_ttl" db:"cold_storage_ttl"`
+}
+
 type ChannelItem struct {
 	Id        int       `json:"id" db:"id"`
 	CreatedAt time.Time `json:"created_at" db:"created_at"`
@@ -452,11 +462,35 @@ type SpanAggregatesDBResponseItem struct {
 	GroupBy      string    `ch:"groupBy"`
 }
 
+type SetTTLResponseItem struct {
+	Message string `json:"message"`
+}
+
 type DiskItem struct {
 	Name string `json:"name,omitempty" ch:"name"`
 	Type string `json:"type,omitempty" ch:"type"`
 }
 
+type DBResponseTTL struct {
+	EngineFull string `ch:"engine_full"`
+}
+
+type GetTTLResponseItem struct {
+	MetricsTime             int    `json:"metrics_ttl_duration_hrs,omitempty"`
+	MetricsMoveTime         int    `json:"metrics_move_ttl_duration_hrs,omitempty"`
+	TracesTime              int    `json:"traces_ttl_duration_hrs,omitempty"`
+	TracesMoveTime          int    `json:"traces_move_ttl_duration_hrs,omitempty"`
+	LogsTime                int    `json:"logs_ttl_duration_hrs,omitempty"`
+	LogsMoveTime            int    `json:"logs_move_ttl_duration_hrs,omitempty"`
+	ExpectedMetricsTime     int    `json:"expected_metrics_ttl_duration_hrs,omitempty"`
+	ExpectedMetricsMoveTime int    `json:"expected_metrics_move_ttl_duration_hrs,omitempty"`
+	ExpectedTracesTime      int    `json:"expected_traces_ttl_duration_hrs,omitempty"`
+	ExpectedTracesMoveTime  int    `json:"expected_traces_move_ttl_duration_hrs,omitempty"`
+	ExpectedLogsTime        int    `json:"expected_logs_ttl_duration_hrs,omitempty"`
+	ExpectedLogsMoveTime    int    `json:"expected_logs_move_ttl_duration_hrs,omitempty"`
+	Status                  string `json:"status"`
+}
+
 type DBResponseServiceName struct {
 	ServiceName string `ch:"serviceName"`
 	Count       uint64 `ch:"count"`

pkg/signoz/config.go

@@ -23,7 +23,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
@@ -136,9 +135,6 @@ type Config struct {
 	// Auditor config
 	Auditor auditor.Config `mapstructure:"auditor"`
 
-	// MeterReporter config
-	MeterReporter meterreporter.Config `mapstructure:"meterreporter"`
-
 	// CloudIntegration config
 	CloudIntegration cloudintegration.Config `mapstructure:"cloudintegration"`
 
@@ -179,7 +175,6 @@ func NewConfig(ctx context.Context, logger *slog.Logger, resolverConfig config.R
 		identn.NewConfigFactory(),
 		serviceaccount.NewConfigFactory(),
 		auditor.NewConfigFactory(),
-		meterreporter.NewConfigFactory(),
 		cloudintegration.NewConfigFactory(),
 		tracedetail.NewConfigFactory(),
 		authz.NewConfigFactory(),

pkg/signoz/handler_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
-	"github.com/SigNoz/signoz/pkg/modules/retention/implretention"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
@@ -53,8 +52,7 @@ func TestNewHandlers(t *testing.T) {
 	userRoleStore := impluser.NewUserRoleStore(sqlstore, providerSettings)
 
 	userGetter := impluser.NewGetter(impluser.NewStore(sqlstore, providerSettings), userRoleStore, flagger)
-	retentionGetter := implretention.NewGetter(implretention.NewStore(sqlstore))
-	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, nil, nil, retentionGetter, flagger)
+	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, nil, nil, flagger)
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
 	registryHandler := factory.NewHandler(nil)

pkg/signoz/module.go

@@ -29,7 +29,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter/implquickfilter"
 	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
 	"github.com/SigNoz/signoz/pkg/modules/rawdataexport/implrawdataexport"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory/implrulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/savedview"
@@ -64,7 +63,6 @@ type Modules struct {
 	Preference       preference.Module
 	UserSetter       user.Setter
 	UserGetter       user.Getter
-	RetentionGetter  retention.Getter
 	SavedView        savedview.Module
 	Apdex            apdex.Module
 	Dashboard        dashboard.Module
@@ -105,7 +103,6 @@ func NewModules(
 	userRoleStore authtypes.UserRoleStore,
 	serviceAccount serviceaccount.Module,
 	cloudIntegrationModule cloudintegration.Module,
-	retentionGetter retention.Getter,
 	fl flagger.Flagger,
 ) Modules {
 	quickfilter := implquickfilter.NewModule(implquickfilter.NewStore(sqlstore))
@@ -122,7 +119,6 @@ func NewModules(
 		Dashboard:        dashboard,
 		UserSetter:       userSetter,
 		UserGetter:       userGetter,
-		RetentionGetter:  retentionGetter,
 		QuickFilter:      quickfilter,
 		TraceFunnel:      impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
 		RawDataExport:    implrawdataexport.NewModule(querier),

pkg/signoz/module_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
-	"github.com/SigNoz/signoz/pkg/modules/retention/implretention"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
@@ -57,8 +56,7 @@ func TestNewModules(t *testing.T) {
 
 	serviceAccount := implserviceaccount.NewModule(implserviceaccount.NewStore(sqlstore), nil, nil, nil, providerSettings, serviceaccount.Config{})
 
-	retentionGetter := implretention.NewGetter(implretention.NewStore(sqlstore))
-	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, serviceAccount, implcloudintegration.NewModule(), retentionGetter, flagger)
+	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, serviceAccount, implcloudintegration.NewModule(), flagger)
 
 	reflectVal := reflect.ValueOf(modules)
 	for i := 0; i < reflectVal.NumField(); i++ {

pkg/signoz/provider.go

@@ -28,8 +28,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/identn/apikeyidentn"
 	"github.com/SigNoz/signoz/pkg/identn/impersonationidentn"
 	"github.com/SigNoz/signoz/pkg/identn/tokenizeridentn"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
-	"github.com/SigNoz/signoz/pkg/meterreporter/noopmeterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain/implauthdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
@@ -198,7 +196,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewDropUserDeletedAtFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateAWSAllRegionsFactory(sqlstore),
 		sqlmigration.NewAddServiceAccountManagedRoleTransactionsFactory(sqlstore),
-		sqlmigration.NewUpdateTTLSettingUserAuditFactory(sqlstore, sqlschema),
 	)
 }
 
@@ -322,12 +319,6 @@ func NewAuditorProviderFactories() factory.NamedMap[factory.ProviderFactory[audi
 	)
 }
 
-func NewMeterReporterProviderFactories() factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]] {
-	return factory.MustNewNamedMap(
-		noopmeterreporter.NewFactory(),
-	)
-}
-
 func NewFlaggerProviderFactories(registry featuretypes.Registry) factory.NamedMap[factory.ProviderFactory[flagger.FlaggerProvider, flagger.Config]] {
 	return factory.MustNewNamedMap(
 		configflagger.NewFactory(registry),

pkg/signoz/signoz.go

@@ -22,13 +22,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
 	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
-	"github.com/SigNoz/signoz/pkg/modules/retention/implretention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
@@ -87,7 +84,6 @@ type SigNoz struct {
 	Flagger                flagger.Flagger
 	Gateway                gateway.Gateway
 	Auditor                auditor.Auditor
-	MeterReporter          meterreporter.Reporter
 }
 
 func New(
@@ -108,7 +104,6 @@ func New(
 	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing) dashboard.Module,
 	gatewayProviderFactory func(licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config],
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
-	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
 	querierHandlerCallback func(factory.ProviderSettings, querier.Querier, analytics.Analytics) querier.Handler,
 	cloudIntegrationCallback func(sqlstore.SQLStore, global.Global, zeus.Zeus, gateway.Gateway, licensing.Licensing, serviceaccount.Module, cloudintegration.Config) (cloudintegration.Module, error),
 	rulerProviderFactories func(cache.Cache, alertmanager.Alertmanager, sqlstore.SQLStore, telemetrystore.TelemetryStore, telemetrytypes.MetadataStore, prometheus.Prometheus, organization.Getter, rulestatehistory.Module, querier.Querier, queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]],
@@ -233,8 +228,6 @@ func New(
 		return nil, err
 	}
 
-	retentionGetter := implretention.NewGetter(implretention.NewStore(sqlstore))
-
 	// Initialize prometheus from the available prometheus provider factories
 	prometheus, err := factory.NewProviderFromNamedMap(
 		ctx,
@@ -393,13 +386,6 @@ func New(
 		return nil, err
 	}
 
-	// Initialize meter reporter from the variant-specific provider factories
-	meterReporterFactories, meterReporterProvider := meterReporterProviderFactories(ctx, providerSettings, flagger, licensing, telemetrystore, retentionGetter, orgGetter, zeus)
-	meterReporter, err := factory.NewProviderFromNamedMap(ctx, providerSettings, config.MeterReporter, meterReporterFactories, meterReporterProvider)
-	if err != nil {
-		return nil, err
-	}
-
 	// Initialize authns
 	store := sqlauthnstore.NewStore(sqlstore)
 	authNs, err := authNsCallback(ctx, providerSettings, store, licensing)
@@ -455,7 +441,7 @@ func New(
 	}
 
 	// Initialize all modules
-	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, userGetter, userRoleStore, serviceAccount, cloudIntegrationModule, retentionGetter, flagger)
+	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, userGetter, userRoleStore, serviceAccount, cloudIntegrationModule, flagger)
 
 	// Initialize ruler from the variant-specific provider factories
 	rulerInstance, err := factory.NewProviderFromNamedMap(ctx, providerSettings, config.Ruler, rulerProviderFactories(cache, alertmanager, sqlstore, telemetrystore, telemetryMetadataStore, prometheus, orgGetter, modules.RuleStateHistory, querier, queryParser), "signoz")
@@ -515,7 +501,6 @@ func New(
 		factory.NewNamedService(factory.MustNewName("authz"), authz),
 		factory.NewNamedService(factory.MustNewName("user"), userService, factory.MustNewName("authz")),
 		factory.NewNamedService(factory.MustNewName("auditor"), auditor),
-		factory.NewNamedService(factory.MustNewName("meterreporter"), meterReporter, factory.MustNewName("licensing")),
 		factory.NewNamedService(factory.MustNewName("ruler"), rulerInstance),
 	)
 	if err != nil {
@@ -565,6 +550,5 @@ func New(
 		Flagger:                flagger,
 		Gateway:                gateway,
 		Auditor:                auditor,
-		MeterReporter:          meterReporter,
 	}, nil
 }

pkg/sqlmigration/079_update_ttl_setting_user_audit.go

@@ -1,84 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type updateTTLSettingUserAudit struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewUpdateTTLSettingUserAuditFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("update_ttl_setting_user_audit"), func(ctx context.Context, providerSettings factory.ProviderSettings, config Config) (SQLMigration, error) {
-		return newUpdateTTLSettingUserAudit(ctx, providerSettings, config, sqlstore, sqlschema)
-	})
-}
-
-func newUpdateTTLSettingUserAudit(_ context.Context, _ factory.ProviderSettings, _ Config, sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) (SQLMigration, error) {
-	return &updateTTLSettingUserAudit{
-		sqlstore:  sqlstore,
-		sqlschema: sqlschema,
-	}, nil
-}
-
-func (migration *updateTTLSettingUserAudit) Register(migrations *migrate.Migrations) error {
-	if err := migrations.Register(migration.Up, migration.Down); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (migration *updateTTLSettingUserAudit) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	table, uniqueConstraints, err := migration.sqlschema.GetTable(ctx, sqlschema.TableName("ttl_setting"))
-	if err != nil {
-		return err
-	}
-
-	columns := []*sqlschema.Column{
-		{
-			Name:     sqlschema.ColumnName("created_by"),
-			DataType: sqlschema.DataTypeText,
-			Nullable: true,
-		},
-		{
-			Name:     sqlschema.ColumnName("updated_by"),
-			DataType: sqlschema.DataTypeText,
-			Nullable: true,
-		},
-	}
-
-	for _, column := range columns {
-		sqls := migration.sqlschema.Operator().AddColumn(table, uniqueConstraints, column, nil)
-		for _, sql := range sqls {
-			if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-				return err
-			}
-		}
-	}
-
-	if err := tx.Commit(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (migration *updateTTLSettingUserAudit) Down(ctx context.Context, db *bun.DB) error {
-	return nil
-}

pkg/telemetrytraces/trace_operator_cte_builder.go

@@ -413,28 +413,6 @@ func (b *traceOperatorCTEBuilder) buildFinalQuery(ctx context.Context, selectFro
 }
 
 func (b *traceOperatorCTEBuilder) buildListQuery(ctx context.Context, selectFromCTE string) (*qbtypes.Statement, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-
-	// Select core fields
-	sb.Select(
-		"timestamp",
-		"trace_id",
-		"span_id",
-		"name",
-		"duration_nano",
-		"parent_span_id",
-	)
-
-	selectedFields := map[string]bool{
-		"timestamp":      true,
-		"trace_id":       true,
-		"span_id":        true,
-		"name":           true,
-		"duration_nano":  true,
-		"parent_span_id": true,
-	}
-
-	// Get keys for selectFields
 	keySelectors := b.getKeySelectors()
 	for _, field := range b.operator.SelectFields {
 		keySelectors = append(keySelectors, &telemetrytypes.FieldKeySelector{
@@ -444,13 +422,38 @@ func (b *traceOperatorCTEBuilder) buildListQuery(ctx context.Context, selectFrom
 			FieldDataType: field.FieldDataType,
 		})
 	}
-
 	keys, _, err := b.stmtBuilder.metadataStore.GetKeysMulti(ctx, keySelectors)
 	if err != nil {
 		return nil, err
 	}
 
-	// Add selectFields using ColumnExpressionFor since we now have all base table columns
+	coreFields := []string{"timestamp", "trace_id", "span_id", "name", "duration_nano", "parent_span_id"}
+	selectedFields := map[string]bool{
+		"timestamp":      true,
+		"trace_id":       true,
+		"span_id":        true,
+		"name":           true,
+		"duration_nano":  true,
+		"parent_span_id": true,
+	}
+
+	// CH 25.12.5 distributed-analyzer regression (ClickHouse/ClickHouse#103508):
+	// native columns from a Distributed-table-backed CTE get renamed col → col_0
+	// in the shard block, making them invisible to the outer SELECT/ORDER BY.
+	// Fix: rename every core field to a safe alias (_s_<col>) in the inner SELECT
+	// so the analyzer never sees the original name as an ORDER BY target. The
+	// outer SELECT re-exposes them under their original names.
+	innerCoreExprs := make([]string, len(coreFields))
+	outerCoreExprs := make([]string, len(coreFields))
+	for i, f := range coreFields {
+		innerCoreExprs[i] = fmt.Sprintf("%s AS _s_%s", f, f)
+		outerCoreExprs[i] = fmt.Sprintf("_s_%s AS %s", f, f)
+	}
+
+	innerSB := sqlbuilder.NewSelectBuilder()
+	innerSB.Select(innerCoreExprs...)
+
+	var additionalSelectedFields []string
 	for _, field := range b.operator.SelectFields {
 		if selectedFields[field.Name] {
 			continue
@@ -461,41 +464,56 @@ func (b *traceOperatorCTEBuilder) buildListQuery(ctx context.Context, selectFrom
 				slog.String("field", field.Name), errors.Attr(err))
 			continue
 		}
-		sb.SelectMore(colExpr)
+		innerSB.SelectMore(colExpr)
 		selectedFields[field.Name] = true
+		additionalSelectedFields = append(additionalSelectedFields, field.Name)
 	}
 
-	sb.From(selectFromCTE)
-
-	// Add order by support using ColumnExpressionFor
-	orderApplied := false
 	for _, orderBy := range b.operator.Order {
+		if selectedFields[orderBy.Key.Name] {
+			continue
+		}
 		colExpr, err := b.stmtBuilder.fm.ColumnExpressionFor(ctx, b.start, b.end, &orderBy.Key.TelemetryFieldKey, keys)
 		if err != nil {
 			return nil, err
 		}
-		sb.OrderBy(fmt.Sprintf("%s %s", colExpr, orderBy.Direction.StringValue()))
-		orderApplied = true
+		innerSB.SelectMore(colExpr)
+		selectedFields[orderBy.Key.Name] = true
 	}
 
-	if !orderApplied {
-		sb.OrderBy("timestamp DESC")
+	innerSB.From(selectFromCTE)
+	innerSQL, innerArgs := innerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// Outer SELECT: re-exposes core fields under their original names and acts as
+	// a projection barrier so ORDER BY-only fields do not leak into the result.
+	outerSB := sqlbuilder.NewSelectBuilder()
+	outerSB.Select(outerCoreExprs...)
+	for _, name := range additionalSelectedFields {
+		outerSB.SelectMore(fmt.Sprintf("`%s`", name))
+	}
+	outerSB.From(fmt.Sprintf("(%s) AS t", innerSQL))
+
+	if len(b.operator.Order) > 0 {
+		for _, orderBy := range b.operator.Order {
+			outerSB.OrderBy(fmt.Sprintf("`%s` %s", orderBy.Key.Name, orderBy.Direction.StringValue()))
+		}
+	} else {
+		outerSB.OrderBy("timestamp DESC")
 	}
 
 	if b.operator.Limit > 0 {
-		sb.Limit(b.operator.Limit)
+		outerSB.Limit(b.operator.Limit)
 	} else {
-		sb.Limit(100)
+		outerSB.Limit(100)
 	}
-
 	if b.operator.Offset > 0 {
-		sb.Offset(b.operator.Offset)
+		outerSB.Offset(b.operator.Offset)
 	}
 
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	outerSQL, outerArgs := outerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
 	return &qbtypes.Statement{
-		Query: sql,
-		Args:  args,
+		Query: outerSQL,
+		Args:  append(innerArgs, outerArgs...),
 	}, nil
 }
 

pkg/telemetrytraces/trace_operator_cte_builder_test.go

@@ -67,7 +67,7 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_DIR_DESC_B AS (SELECT p.* FROM A AS p INNER JOIN B AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) AS `service.name` FROM A_DIR_DESC_B ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_DIR_DESC_B AS (SELECT p.* FROM A AS p INNER JOIN B AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id, `service.name` FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) AS `service.name` FROM A_DIR_DESC_B) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10},
 			},
 			expectedErr: nil,
@@ -104,7 +104,7 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_INDIR_DESC_B AS (WITH RECURSIVE up AS (SELECT d.trace_id, d.span_id, d.parent_span_id, 0 AS depth FROM B AS d UNION ALL SELECT p.trace_id, p.span_id, p.parent_span_id, up.depth + 1 FROM all_spans AS p JOIN up ON p.trace_id = up.trace_id AND p.span_id = up.parent_span_id WHERE up.depth < 100) SELECT DISTINCT a.* FROM A AS a GLOBAL INNER JOIN (SELECT DISTINCT trace_id, span_id FROM up WHERE depth > 0 ) AS ancestors ON ancestors.trace_id = a.trace_id AND ancestors.span_id = a.span_id) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id FROM A_INDIR_DESC_B ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_INDIR_DESC_B AS (WITH RECURSIVE up AS (SELECT d.trace_id, d.span_id, d.parent_span_id, 0 AS depth FROM B AS d UNION ALL SELECT p.trace_id, p.span_id, p.parent_span_id, up.depth + 1 FROM all_spans AS p JOIN up ON p.trace_id = up.trace_id AND p.span_id = up.parent_span_id WHERE up.depth < 100) SELECT DISTINCT a.* FROM A AS a GLOBAL INNER JOIN (SELECT DISTINCT trace_id, span_id FROM up WHERE depth > 0 ) AS ancestors ON ancestors.trace_id = a.trace_id AND ancestors.span_id = a.span_id) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id FROM A_INDIR_DESC_B) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "gateway", "%service.name%", "%service.name\":\"gateway%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "database", "%service.name%", "%service.name\":\"database%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 5},
 			},
 			expectedErr: nil,
@@ -141,7 +141,7 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_AND_B AS (SELECT l.* FROM A AS l INNER JOIN B AS r ON l.trace_id = r.trace_id) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id FROM A_AND_B ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_AND_B AS (SELECT l.* FROM A AS l INNER JOIN B AS r ON l.trace_id = r.trace_id) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id FROM A_AND_B) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 15},
 			},
 			expectedErr: nil,
@@ -178,7 +178,7 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_OR_B AS (SELECT * FROM A UNION DISTINCT SELECT * FROM B) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id FROM A_OR_B ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_OR_B AS (SELECT * FROM A UNION DISTINCT SELECT * FROM B) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id FROM A_OR_B) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 20},
 			},
 			expectedErr: nil,
@@ -215,7 +215,7 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_not_B AS (SELECT l.* FROM A AS l WHERE l.trace_id GLOBAL NOT IN (SELECT DISTINCT trace_id FROM B)) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id FROM A_not_B ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_not_B AS (SELECT l.* FROM A AS l WHERE l.trace_id GLOBAL NOT IN (SELECT DISTINCT trace_id FROM B)) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id FROM A_not_B) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10},
 			},
 			expectedErr: nil,
@@ -380,11 +380,72 @@ func TestTraceOperatorStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_DIR_DESC_B AS (SELECT p.* FROM A AS p INNER JOIN B AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id), __resource_filter_C AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), C AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_C) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_D AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), D AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_D) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), C_DIR_DESC_D AS (SELECT p.* FROM C AS p INNER JOIN D AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id), A_DIR_DESC_B_AND_C_DIR_DESC_D AS (SELECT l.* FROM A_DIR_DESC_B AS l INNER JOIN C_DIR_DESC_D AS r ON l.trace_id = r.trace_id) SELECT timestamp, trace_id, span_id, name, duration_nano, parent_span_id FROM A_DIR_DESC_B_AND_C_DIR_DESC_D ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_DIR_DESC_B AS (SELECT p.* FROM A AS p INNER JOIN B AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id), __resource_filter_C AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), C AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_C) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_D AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), D AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_D) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), C_DIR_DESC_D AS (SELECT p.* FROM C AS p INNER JOIN D AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id), A_DIR_DESC_B_AND_C_DIR_DESC_D AS (SELECT l.* FROM A_DIR_DESC_B AS l INNER JOIN C_DIR_DESC_D AS r ON l.trace_id = r.trace_id) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id FROM A_DIR_DESC_B_AND_C_DIR_DESC_D) AS t ORDER BY timestamp DESC LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
 				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "auth", "%service.name%", "%service.name\":\"auth%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "database", "%service.name%", "%service.name\":\"database%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 5},
 			},
 			expectedErr: nil,
 		},
+		{
+			// order-by field (http.request.method) is not present in SelectFields;
+			// it must be included in the inner SELECT so the outer ORDER BY can
+			// reference it by alias, but must NOT appear in the outer SELECT list.
+			name:        "order by field not in select fields",
+			requestType: qbtypes.RequestTypeRaw,
+			operator: qbtypes.QueryBuilderTraceOperator{
+				Expression: "A => B",
+				SelectFields: []telemetrytypes.TelemetryFieldKey{
+					{
+						Name:          "service.name",
+						FieldContext:  telemetrytypes.FieldContextResource,
+						FieldDataType: telemetrytypes.FieldDataTypeString,
+					},
+				},
+				Order: []qbtypes.OrderBy{
+					{
+						Key: qbtypes.OrderByKey{
+							TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+								Name:          "http.request.method",
+								FieldContext:  telemetrytypes.FieldContextAttribute,
+								FieldDataType: telemetrytypes.FieldDataTypeString,
+							},
+						},
+						Direction: qbtypes.OrderDirectionDesc,
+					},
+				},
+				Limit: 10,
+			},
+			compositeQuery: &qbtypes.CompositeQuery{
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypeBuilder,
+						Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+							Name:   "A",
+							Signal: telemetrytypes.SignalTraces,
+							Filter: &qbtypes.Filter{
+								Expression: "service.name = 'frontend'",
+							},
+						},
+					},
+					{
+						Type: qbtypes.QueryTypeBuilder,
+						Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+							Name:   "B",
+							Signal: telemetrytypes.SignalTraces,
+							Filter: &qbtypes.Filter{
+								Expression: "service.name = 'backend'",
+							},
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				// http.request.method is in the inner SELECT (so ORDER BY can reach it)
+				// but is absent from the outer SELECT column list — only the ORDER BY clause references it.
+				Query: "WITH toDateTime64(1747947419000000000, 9) AS t_from, toDateTime64(1747983448000000000, 9) AS t_to, 1747945619 AS bucket_from, 1747983448 AS bucket_to, all_spans AS (SELECT *, resource_string_service$$name AS `service.name` FROM signoz_traces.distributed_signoz_index_v3 WHERE timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_A AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), A AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_A) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), __resource_filter_B AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), B AS (SELECT * FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter_B) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ?), A_DIR_DESC_B AS (SELECT p.* FROM A AS p INNER JOIN B AS c ON p.trace_id = c.trace_id AND p.span_id = c.parent_span_id) SELECT _s_timestamp AS timestamp, _s_trace_id AS trace_id, _s_span_id AS span_id, _s_name AS name, _s_duration_nano AS duration_nano, _s_parent_span_id AS parent_span_id, `service.name` FROM (SELECT timestamp AS _s_timestamp, trace_id AS _s_trace_id, span_id AS _s_span_id, name AS _s_name, duration_nano AS _s_duration_nano, parent_span_id AS _s_parent_span_id, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) AS `service.name`, attributes_string['http.request.method'] AS `http.request.method` FROM A_DIR_DESC_B) AS t ORDER BY `http.request.method` desc LIMIT ? SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000",
+				Args:  []any{"1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "frontend", "%service.name%", "%service.name\":\"frontend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), "backend", "%service.name%", "%service.name\":\"backend%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448), 10},
+			},
+			expectedErr: nil,
+		},
 	}
 
 	fm := NewFieldMapper()

pkg/types/retentiontypes/store.go

@@ -1,12 +0,0 @@
-package retentiontypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	// ListTTLSettingsByTableNameAndBeforeCreatedAt returns successful TTL settings before the given timestamp.
-	ListTTLSettingsByTableNameAndBeforeCreatedAt(ctx context.Context, orgID valuer.UUID, tableName string, beforeMs int64) ([]*TTLSetting, error)
-}

pkg/types/retentiontypes/ttl.go

@@ -1,146 +1,14 @@
 package retentiontypes
 
 import (
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/uptrace/bun"
 )
 
-const secondsPerDay = 24 * 60 * 60
-
-const (
-	DefaultLogsRetentionDays    = 15
-	DefaultMetricsRetentionDays = 30
-	DefaultTracesRetentionDays  = 15
-)
-
-const (
-	TraceTTL   = "traces"
-	MetricsTTL = "metrics"
-	LogsTTL    = "logs"
-)
-
-const (
-	TTLSettingStatusPending = "pending"
-	TTLSettingStatusFailed  = "failed"
-	TTLSettingStatusSuccess = "success"
-)
-
-// RetentionPolicySegment is a half-open time range using one retention policy.
-type RetentionPolicySegment struct {
-	StartMs     int64
-	EndMs       int64
-	Rules       []CustomRetentionRule
-	DefaultDays int
-}
-
-// NewRetentionPolicySegment creates a retention policy segment for a half-open time range.
-func NewRetentionPolicySegment(startMs int64, endMs int64, rules []CustomRetentionRule, defaultDays int) *RetentionPolicySegment {
-	return &RetentionPolicySegment{
-		StartMs:     startMs,
-		EndMs:       endMs,
-		Rules:       rules,
-		DefaultDays: defaultDays,
-	}
-}
-
-// BuildRetentionPolicySegmentsFromRows converts successful TTL settings into retention policy segments.
-func BuildRetentionPolicySegmentsFromRows(rows []*TTLSetting, fallbackDefaultDays int, startMs, endMs int64) ([]*RetentionPolicySegment, error) {
-	if startMs >= endMs {
-		return nil, nil
-	}
-
-	var activeAtStart *TTLSetting
-	inWindow := make([]*TTLSetting, 0, len(rows))
-	for _, row := range rows {
-		rowMs := row.CreatedAt.UnixMilli()
-		if rowMs <= startMs {
-			activeAtStart = row
-			continue
-		}
-		if rowMs >= endMs {
-			continue
-		}
-		inWindow = append(inWindow, row)
-	}
-
-	activeRules, activeDefault, err := parseTTLSetting(activeAtStart, fallbackDefaultDays)
-	if err != nil {
-		return nil, err
-	}
-
-	segments := make([]*RetentionPolicySegment, 0, len(inWindow)+1)
-	cursor := startMs
-	for _, row := range inWindow {
-		rowMs := row.CreatedAt.UnixMilli()
-		if rowMs <= cursor {
-			activeRules, activeDefault, err = parseTTLSetting(row, fallbackDefaultDays)
-			if err != nil {
-				return nil, err
-			}
-			continue
-		}
-		segments = append(segments, NewRetentionPolicySegment(cursor, rowMs, activeRules, activeDefault))
-		cursor = rowMs
-		activeRules, activeDefault, err = parseTTLSetting(row, fallbackDefaultDays)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if cursor < endMs {
-		segments = append(segments, NewRetentionPolicySegment(cursor, endMs, activeRules, activeDefault))
-	}
-
-	return segments, nil
-}
-
-func parseTTLSetting(row *TTLSetting, fallbackDefaultDays int) ([]CustomRetentionRule, int, error) {
-	if row == nil {
-		return nil, fallbackDefaultDays, nil
-	}
-
-	defaultDays := row.TTL
-	if row.Condition == "" {
-		defaultDays = (row.TTL + secondsPerDay - 1) / secondsPerDay
-	}
-	if defaultDays <= 0 {
-		defaultDays = fallbackDefaultDays
-	}
-
-	if row.Condition == "" {
-		return nil, defaultDays, nil
-	}
-
-	var rules []CustomRetentionRule
-	if err := json.Unmarshal([]byte(row.Condition), &rules); err != nil {
-		return nil, 0, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "parse ttl_setting condition for row %q", row.ID.StringValue())
-	}
-
-	return rules, defaultDays, nil
-}
-
-// CustomRetentionRule is one custom retention rule as stored in ttl_setting.condition.
-// Rules are evaluated in declaration order; the first matching rule wins.
-type CustomRetentionRule struct {
-	Filters []FilterCondition `json:"conditions"`
-	TTLDays int               `json:"ttlDays"`
-}
-
-// FilterCondition is one label-key, allowed-values condition inside a retention rule.
-type FilterCondition struct {
-	Key    string   `json:"key"`
-	Values []string `json:"values"`
-}
-
 type TTLSetting struct {
 	bun.BaseModel `bun:"table:ttl_setting"`
 	types.Identifiable
 	types.TimeAuditable
-	types.UserAuditable
 	TransactionID  string `bun:"transaction_id,type:text,notnull"`
 	TableName      string `bun:"table_name,type:text,notnull"`
 	TTL            int    `bun:"ttl,notnull,default:0"`
@@ -149,73 +17,3 @@ type TTLSetting struct {
 	OrgID          string `json:"-" bun:"org_id,notnull"`
 	Condition      string `bun:"condition,type:text"`
 }
-
-type TTLParams struct {
-	Type                  string
-	ColdStorageVolume     string
-	ToColdStorageDuration int64
-	DelDuration           int64
-}
-
-type CustomRetentionTTLParams struct {
-	Type                      string                `json:"type"`
-	DefaultTTLDays            int                   `json:"defaultTTLDays"`
-	TTLConditions             []CustomRetentionRule `json:"ttlConditions"`
-	ColdStorageVolume         string                `json:"coldStorageVolume,omitempty"`
-	ToColdStorageDurationDays int64                 `json:"coldStorageDurationDays,omitempty"`
-}
-
-type GetTTLParams struct {
-	Type string
-}
-
-type GetCustomRetentionTTLResponse struct {
-	Version string `json:"version"`
-	Status  string `json:"status"`
-
-	ExpectedLogsTime     int `json:"expected_logs_ttl_duration_hrs,omitempty"`
-	ExpectedLogsMoveTime int `json:"expected_logs_move_ttl_duration_hrs,omitempty"`
-
-	DefaultTTLDays     int                   `json:"default_ttl_days,omitempty"`
-	TTLConditions      []CustomRetentionRule `json:"ttl_conditions,omitempty"`
-	ColdStorageVolume  string                `json:"cold_storage_volume,omitempty"`
-	ColdStorageTTLDays int                   `json:"cold_storage_ttl_days,omitempty"`
-}
-
-type CustomRetentionTTLResponse struct {
-	Message string `json:"message"`
-}
-
-type TTLStatusItem struct {
-	Id             int       `json:"id" db:"id"`
-	UpdatedAt      time.Time `json:"updated_at" db:"updated_at"`
-	CreatedAt      time.Time `json:"created_at" db:"created_at"`
-	TableName      string    `json:"table_name" db:"table_name"`
-	TTL            int       `json:"ttl" db:"ttl"`
-	Status         string    `json:"status" db:"status"`
-	ColdStorageTtl int       `json:"cold_storage_ttl" db:"cold_storage_ttl"`
-}
-
-type SetTTLResponseItem struct {
-	Message string `json:"message"`
-}
-
-type DBResponseTTL struct {
-	EngineFull string `ch:"engine_full"`
-}
-
-type GetTTLResponseItem struct {
-	MetricsTime             int    `json:"metrics_ttl_duration_hrs,omitempty"`
-	MetricsMoveTime         int    `json:"metrics_move_ttl_duration_hrs,omitempty"`
-	TracesTime              int    `json:"traces_ttl_duration_hrs,omitempty"`
-	TracesMoveTime          int    `json:"traces_move_ttl_duration_hrs,omitempty"`
-	LogsTime                int    `json:"logs_ttl_duration_hrs,omitempty"`
-	LogsMoveTime            int    `json:"logs_move_ttl_duration_hrs,omitempty"`
-	ExpectedMetricsTime     int    `json:"expected_metrics_ttl_duration_hrs,omitempty"`
-	ExpectedMetricsMoveTime int    `json:"expected_metrics_move_ttl_duration_hrs,omitempty"`
-	ExpectedTracesTime      int    `json:"expected_traces_ttl_duration_hrs,omitempty"`
-	ExpectedTracesMoveTime  int    `json:"expected_traces_move_ttl_duration_hrs,omitempty"`
-	ExpectedLogsTime        int    `json:"expected_logs_ttl_duration_hrs,omitempty"`
-	ExpectedLogsMoveTime    int    `json:"expected_logs_move_ttl_duration_hrs,omitempty"`
-	Status                  string `json:"status"`
-}

pkg/types/retentiontypes/ttl_test.go

@@ -1,83 +0,0 @@
-package retentiontypes
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBuildRetentionPolicySegmentsFromRows(t *testing.T) {
-	start := time.Date(2026, 5, 4, 0, 0, 0, 0, time.UTC)
-	end := start.AddDate(0, 0, 1)
-
-	ruleA := CustomRetentionRule{
-		Filters: []FilterCondition{{Key: "service.name", Values: []string{"api"}}},
-		TTLDays: 7,
-	}
-	ruleB := CustomRetentionRule{
-		Filters: []FilterCondition{{Key: "env", Values: []string{"prod"}}},
-		TTLDays: 15,
-	}
-
-	t.Run("row before window is active at start", func(t *testing.T) {
-		segments, err := BuildRetentionPolicySegmentsFromRows(
-			[]*TTLSetting{
-				ttlSetting(t, start.Add(-time.Hour), 45, []CustomRetentionRule{ruleA}),
-			},
-			30,
-			start.UnixMilli(),
-			end.UnixMilli(),
-		)
-		require.NoError(t, err)
-		require.Equal(t, []*RetentionPolicySegment{
-			NewRetentionPolicySegment(start.UnixMilli(), end.UnixMilli(), []CustomRetentionRule{ruleA}, 45),
-		}, segments)
-	})
-
-	t.Run("row inside window splits segments", func(t *testing.T) {
-		firstChange := start.Add(6 * time.Hour)
-		secondChange := start.Add(18 * time.Hour)
-
-		segments, err := BuildRetentionPolicySegmentsFromRows(
-			[]*TTLSetting{
-				ttlSetting(t, firstChange, 21, []CustomRetentionRule{ruleA}),
-				ttlSetting(t, secondChange, 14, []CustomRetentionRule{ruleB}),
-			},
-			30,
-			start.UnixMilli(),
-			end.UnixMilli(),
-		)
-		require.NoError(t, err)
-		require.Equal(t, []*RetentionPolicySegment{
-			NewRetentionPolicySegment(start.UnixMilli(), firstChange.UnixMilli(), nil, 30),
-			NewRetentionPolicySegment(firstChange.UnixMilli(), secondChange.UnixMilli(), []CustomRetentionRule{ruleA}, 21),
-			NewRetentionPolicySegment(secondChange.UnixMilli(), end.UnixMilli(), []CustomRetentionRule{ruleB}, 14),
-		}, segments)
-	})
-
-	t.Run("no rows uses fallback", func(t *testing.T) {
-		segments, err := BuildRetentionPolicySegmentsFromRows(nil, 30, start.UnixMilli(), end.UnixMilli())
-		require.NoError(t, err)
-		require.Equal(t, []*RetentionPolicySegment{
-			NewRetentionPolicySegment(start.UnixMilli(), end.UnixMilli(), nil, 30),
-		}, segments)
-	})
-}
-
-func ttlSetting(t *testing.T, createdAt time.Time, ttlDays int, rules []CustomRetentionRule) *TTLSetting {
-	t.Helper()
-
-	condition, err := json.Marshal(rules)
-	require.NoError(t, err)
-
-	return &TTLSetting{
-		TimeAuditable: types.TimeAuditable{
-			CreatedAt: createdAt,
-		},
-		TTL:       ttlDays,
-		Condition: string(condition),
-	}
-}

pkg/types/zeustypes/attributes.go

@@ -1,20 +0,0 @@
-package zeustypes
-
-import "go.opentelemetry.io/otel/attribute"
-
-var (
-	// Identifies the organization.
-	OrganizationID = attribute.Key("signoz.organization.id")
-
-	// Identifies the retention bucket a meter belongs to.
-	RetentionDuration = attribute.Key("signoz.retention.duration")
-)
-
-func NewDimensions(kvs ...attribute.KeyValue) map[string]string {
-	dimensions := map[string]string{}
-	for _, kv := range kvs {
-		dimensions[string(kv.Key)] = kv.Value.AsString()
-	}
-
-	return dimensions
-}

pkg/types/zeustypes/deployment.go

@@ -1,29 +0,0 @@
-package zeustypes
-
-import (
-	"encoding/json"
-)
-
-type GettableDeployment struct {
-	ID      string `json:"id"`
-	Name    string `json:"name"`
-	Cluster struct {
-		ID     string `json:"id"`
-		Name   string `json:"name"`
-		Region struct {
-			ID   string `json:"id"`
-			Name string `json:"name"`
-			DNS  string `json:"dns"`
-		} `json:"region"`
-	} `json:"cluster"`
-}
-
-func NewGettableDeployment(data []byte) (*GettableDeployment, error) {
-	deployment := new(GettableDeployment)
-	err := json.Unmarshal(data, deployment)
-	if err != nil {
-		return nil, err
-	}
-
-	return deployment, nil
-}

pkg/types/zeustypes/host.go

@@ -1,46 +0,0 @@
-package zeustypes
-
-import (
-	"net/url"
-
-	"github.com/tidwall/gjson"
-)
-
-type Host struct {
-	Name      string `json:"name" required:"true"`
-	IsDefault bool   `json:"is_default" required:"true"`
-	URL       string `json:"url" required:"true"`
-}
-
-type GettableHost struct {
-	Name  string `json:"name" required:"true"`
-	State string `json:"state" required:"true"`
-	Tier  string `json:"tier" required:"true"`
-	Hosts []Host `json:"hosts" required:"true"`
-}
-
-type PostableHost struct {
-	Name string `json:"name" required:"true"`
-}
-
-func NewGettableHost(data []byte) *GettableHost {
-	parsed := gjson.ParseBytes(data)
-	dns := parsed.Get("cluster.region.dns").String()
-
-	hostResults := parsed.Get("hosts").Array()
-	hosts := make([]Host, len(hostResults))
-
-	for i, h := range hostResults {
-		name := h.Get("name").String()
-		hosts[i].Name = name
-		hosts[i].IsDefault = h.Get("is_default").Bool()
-		hosts[i].URL = (&url.URL{Scheme: "https", Host: name + "." + dns}).String()
-	}
-
-	return &GettableHost{
-		Name:  parsed.Get("name").String(),
-		State: parsed.Get("state").String(),
-		Tier:  parsed.Get("tier").String(),
-		Hosts: hosts,
-	}
-}

pkg/types/zeustypes/meter.go

@@ -1,54 +0,0 @@
-package zeustypes
-
-import "time"
-
-type MeterCheckpoint struct {
-	Name      string
-	StartDate time.Time
-}
-
-type Meter struct {
-	// MeterName is the fully-qualified meter identifier.
-	MeterName MeterName `json:"name"`
-
-	// Value is the aggregated integer scalar for this meter over the reporting window.
-	Value int64 `json:"value"`
-
-	// Unit is the metric unit for this meter.
-	Unit MeterUnit `json:"unit"`
-
-	// Aggregation names the aggregation applied to produce Value.
-	Aggregation MeterAggregation `json:"aggregation"`
-
-	// StartUnixMilli is the inclusive window start in epoch milliseconds.
-	StartUnixMilli int64 `json:"start_unix_milli"`
-
-	// EndUnixMilli is the exclusive window end in epoch milliseconds.
-	EndUnixMilli int64 `json:"end_unix_milli"`
-
-	// IsCompleted is false for the current day's partial value.
-	IsCompleted bool `json:"is_completed"`
-
-	// Dimensions is the per-meter label set.
-	Dimensions map[string]string `json:"dimensions"`
-}
-
-func NewMeter(
-	name MeterName,
-	value int64,
-	unit MeterUnit,
-	aggregation MeterAggregation,
-	window MeterWindow,
-	dimensions map[string]string,
-) Meter {
-	return Meter{
-		MeterName:      name,
-		Value:          value,
-		Unit:           unit,
-		Aggregation:    aggregation,
-		StartUnixMilli: window.StartUnixMilli,
-		EndUnixMilli:   window.EndUnixMilli,
-		IsCompleted:    window.IsCompleted,
-		Dimensions:     dimensions,
-	}
-}

pkg/types/zeustypes/meter_aggregation.go

@@ -1,12 +0,0 @@
-package zeustypes
-
-import "github.com/SigNoz/signoz/pkg/valuer"
-
-type MeterAggregation struct {
-	valuer.String
-}
-
-var (
-	MeterAggregationSum = MeterAggregation{valuer.NewString("sum")}
-	MeterAggregationMax = MeterAggregation{valuer.NewString("max")}
-)

pkg/types/zeustypes/meter_name.go

@@ -1,66 +0,0 @@
-package zeustypes
-
-import (
-	"encoding/json"
-	"regexp"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-var (
-	MeterSpanSize       = MustNewMeterName("signoz.meter.span.size")
-	MeterLogSize        = MustNewMeterName("signoz.meter.log.size")
-	MeterDatapointCount = MustNewMeterName("signoz.meter.metric.datapoint.count")
-	MeterPlatformActive = MustNewMeterName("signoz.meter.platform.active")
-)
-
-var meterNameRegex = regexp.MustCompile(`^[a-z][a-z0-9_.]+$`)
-
-// MeterName is a validated dotted Zeus meter name.
-type MeterName struct {
-	s string
-}
-
-func NewMeterName(s string) (MeterName, error) {
-	if !meterNameRegex.MatchString(s) {
-		return MeterName{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid meter name: %s", s)
-	}
-
-	return MeterName{s: s}, nil
-}
-
-func MustNewMeterName(s string) MeterName {
-	name, err := NewMeterName(s)
-	if err != nil {
-		panic(err)
-	}
-
-	return name
-}
-
-func (n MeterName) String() string {
-	return n.s
-}
-
-func (n MeterName) IsZero() bool {
-	return n.s == ""
-}
-
-func (n MeterName) MarshalJSON() ([]byte, error) {
-	return json.Marshal(n.s)
-}
-
-func (n *MeterName) UnmarshalJSON(data []byte) error {
-	var s string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return err
-	}
-
-	name, err := NewMeterName(s)
-	if err != nil {
-		return err
-	}
-
-	*n = name
-	return nil
-}

pkg/types/zeustypes/meter_test.go

@@ -1,30 +0,0 @@
-package zeustypes
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewMeterWindow(t *testing.T) {
-	start := time.Date(2026, 5, 4, 0, 0, 0, 0, time.UTC)
-
-	window, err := NewMeterWindow(start.UnixMilli(), start.AddDate(0, 0, 1).UnixMilli(), true)
-	require.NoError(t, err)
-	require.Equal(t, start.UnixMilli(), window.StartUnixMilli)
-	require.Equal(t, start.AddDate(0, 0, 1).UnixMilli(), window.EndUnixMilli)
-	require.True(t, window.IsCompleted)
-
-	_, err = NewMeterWindow(0, start.UnixMilli(), true)
-	require.Error(t, err)
-
-	_, err = NewMeterWindow(start.UnixMilli(), start.UnixMilli(), false)
-	require.Error(t, err)
-}
-
-func TestMustNewMeterWindowPanicsForInvalidWindow(t *testing.T) {
-	require.Panics(t, func() {
-		MustNewMeterWindow(0, 0, true)
-	})
-}

pkg/types/zeustypes/meter_unit.go

@@ -1,12 +0,0 @@
-package zeustypes
-
-import "github.com/SigNoz/signoz/pkg/valuer"
-
-type MeterUnit struct {
-	valuer.String
-}
-
-var (
-	MeterUnitCount = MeterUnit{valuer.NewString("count")}
-	MeterUnitBytes = MeterUnit{valuer.NewString("bytes")}
-)

pkg/types/zeustypes/meter_window.go

@@ -1,43 +0,0 @@
-package zeustypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-type MeterWindow struct {
-	StartUnixMilli int64
-	EndUnixMilli   int64
-	IsCompleted    bool
-}
-
-func NewMeterWindow(startUnixMilli, endUnixMilli int64, isCompleted bool) (MeterWindow, error) {
-	if startUnixMilli <= 0 {
-		return MeterWindow{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "meter window start must be positive: %d", startUnixMilli)
-	}
-
-	if endUnixMilli <= startUnixMilli {
-		return MeterWindow{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "meter window end must be after start: [%d, %d)", startUnixMilli, endUnixMilli)
-	}
-
-	return MeterWindow{
-		StartUnixMilli: startUnixMilli,
-		EndUnixMilli:   endUnixMilli,
-		IsCompleted:    isCompleted,
-	}, nil
-}
-
-func MustNewMeterWindow(startUnixMilli, endUnixMilli int64, isCompleted bool) MeterWindow {
-	window, err := NewMeterWindow(startUnixMilli, endUnixMilli, isCompleted)
-	if err != nil {
-		panic(err)
-	}
-
-	return window
-}
-
-func (w MeterWindow) Day() time.Time {
-	t := time.UnixMilli(w.StartUnixMilli).UTC()
-	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
-}

pkg/types/zeustypes/profile.go

@@ -1,13 +0,0 @@
-package zeustypes
-
-type PostableProfile struct {
-	UsesOtel                     bool     `json:"uses_otel" required:"true"`
-	HasExistingObservabilityTool bool     `json:"has_existing_observability_tool" required:"true"`
-	ExistingObservabilityTool    string   `json:"existing_observability_tool" required:"true"`
-	ReasonsForInterestInSigNoz   []string `json:"reasons_for_interest_in_signoz" required:"true"`
-	LogsScalePerDayInGB          int64    `json:"logs_scale_per_day_in_gb" required:"true"`
-	NumberOfServices             int64    `json:"number_of_services" required:"true"`
-	NumberOfHosts                int64    `json:"number_of_hosts" required:"true"`
-	WhereDidYouDiscoverSigNoz    string   `json:"where_did_you_discover_signoz" required:"true"`
-	TimelineForMigratingToSigNoz string   `json:"timeline_for_migrating_to_signoz" required:"true"`
-}

pkg/types/zeustypes/types.go

@@ -0,0 +1,87 @@
+package zeustypes
+
+import (
+	"encoding/json"
+	"net/url"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/tidwall/gjson"
+)
+
+type PostableHost struct {
+	Name string `json:"name" required:"true"`
+}
+
+type PostableProfile struct {
+	UsesOtel                     bool     `json:"uses_otel" required:"true"`
+	HasExistingObservabilityTool bool     `json:"has_existing_observability_tool" required:"true"`
+	ExistingObservabilityTool    string   `json:"existing_observability_tool" required:"true"`
+	ReasonsForInterestInSigNoz   []string `json:"reasons_for_interest_in_signoz" required:"true"`
+	LogsScalePerDayInGB          int64    `json:"logs_scale_per_day_in_gb" required:"true"`
+	NumberOfServices             int64    `json:"number_of_services" required:"true"`
+	NumberOfHosts                int64    `json:"number_of_hosts" required:"true"`
+	WhereDidYouDiscoverSigNoz    string   `json:"where_did_you_discover_signoz" required:"true"`
+	TimelineForMigratingToSigNoz string   `json:"timeline_for_migrating_to_signoz" required:"true"`
+}
+
+type GettableHost struct {
+	Name  string `json:"name" required:"true"`
+	State string `json:"state" required:"true"`
+	Tier  string `json:"tier" required:"true"`
+	Hosts []Host `json:"hosts" required:"true"`
+}
+
+type Host struct {
+	Name      string `json:"name" required:"true"`
+	IsDefault bool   `json:"is_default" required:"true"`
+	URL       string `json:"url" required:"true"`
+}
+
+func NewGettableHost(data []byte) *GettableHost {
+	parsed := gjson.ParseBytes(data)
+	dns := parsed.Get("cluster.region.dns").String()
+
+	hostResults := parsed.Get("hosts").Array()
+	hosts := make([]Host, len(hostResults))
+
+	for i, h := range hostResults {
+		name := h.Get("name").String()
+		hosts[i].Name = name
+		hosts[i].IsDefault = h.Get("is_default").Bool()
+		hosts[i].URL = (&url.URL{Scheme: "https", Host: name + "." + dns}).String()
+	}
+
+	return &GettableHost{
+		Name:  parsed.Get("name").String(),
+		State: parsed.Get("state").String(),
+		Tier:  parsed.Get("tier").String(),
+		Hosts: hosts,
+	}
+}
+
+// GettableDeployment represents the parsed deployment info from zeus.GetDeployment.
+// NOTE: this is not a full response structure, add more fields from actual response as per requirement.
+type GettableDeployment struct {
+	ID      string `json:"id"`
+	Name    string `json:"name"`
+	Cluster struct {
+		ID     string `json:"id"`
+		Name   string `json:"name"`
+		Region struct {
+			ID   string `json:"id"`
+			Name string `json:"name"`
+			DNS  string `json:"dns"`
+		} `json:"region"`
+	} `json:"cluster"`
+}
+
+// NewGettableDeployment parses raw GetDeployment bytes into a GettableDeployment.
+func NewGettableDeployment(data []byte) (*GettableDeployment, error) {
+	deployment := new(GettableDeployment)
+	err := json.Unmarshal(data, deployment)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to unmarshal deployment response")
+	}
+
+	return deployment, nil
+}

pkg/zeus/noopzeus/provider.go

@@ -49,14 +49,6 @@ func (provider *provider) PutMetersV2(_ context.Context, _ string, _ []byte) err
 	return errors.New(errors.TypeUnsupported, zeus.ErrCodeUnsupported, "putting meters v2 is not supported")
 }
 
-func (provider *provider) PutMetersV3(_ context.Context, _ string, _ string, _ []byte) error {
-	return errors.New(errors.TypeUnsupported, zeus.ErrCodeUnsupported, "putting meters v3 is not supported")
-}
-
-func (provider *provider) ListMeterCheckpoints(_ context.Context, _ string) ([]zeustypes.MeterCheckpoint, error) {
-	return nil, errors.New(errors.TypeUnsupported, zeus.ErrCodeUnsupported, "list meter checkpoints is not supported")
-}
-
 func (provider *provider) PutProfile(_ context.Context, _ string, _ *zeustypes.PostableProfile) error {
 	return errors.New(errors.TypeUnsupported, zeus.ErrCodeUnsupported, "putting profile is not supported")
 }

pkg/zeus/zeus.go

@@ -35,16 +35,6 @@ type Zeus interface {
 	// Puts the meters for the given license key using Zeus.
 	PutMetersV2(context.Context, string, []byte) error
 
-	// PutMetersV3 ships one day's raw JSON array of meter readings to the
-	// v2/meters endpoint. idempotencyKey is propagated as X-Idempotency-Key so
-	// Zeus can UPSERT on retries.
-	PutMetersV3(ctx context.Context, licenseKey string, idempotencyKey string, body []byte) error
-
-	// ListMeterCheckpoints returns the latest sealed (is_completed=true) UTC day
-	// Zeus has stored for each billing meter name. Missing meter names are
-	// treated by the cron as bootstrap cases.
-	ListMeterCheckpoints(ctx context.Context, licenseKey string) ([]zeustypes.MeterCheckpoint, error)
-
 	// Put profile for the given license key.
 	PutProfile(context.Context, string, *zeustypes.PostableProfile) error
 

tests/fixtures/querier.py

@@ -72,6 +72,7 @@ class TraceOperatorQuery:
     return_spans_from: str
     limit: int | None = None
     order: list[OrderBy] | None = None
+    select_fields: list[TelemetryFieldKey] | None = None
 
     def to_dict(self) -> dict:
         spec: dict[str, Any] = {
@@ -83,6 +84,8 @@ class TraceOperatorQuery:
             spec["limit"] = self.limit
         if self.order:
             spec["order"] = [o.to_dict() if hasattr(o, "to_dict") else o for o in self.order]
+        if self.select_fields:
+            spec["selectFields"] = [f.to_dict() for f in self.select_fields]
         return {"type": "builder_trace_operator", "spec": spec}
 
 

tests/integration/tests/querier/15_trace_operator.py

@@ -0,0 +1,487 @@
+"""
+Integration tests for TraceOperatorQuery (builder_trace_operator) through the
+/api/v5/query_range endpoint.
+
+Covers:
+1. Basic trace operator (A => B) — returns matched spans from the correct trace.
+2. Order by a field absent from selectFields — must not return a server error.
+   Guards against the ClickHouse NOT_FOUND_COLUMN_IN_BLOCK regression where
+   ordering by a column absent from an outer SELECT caused a query failure.
+3. Expression operators (=>, ->, &&, ||, A NOT B) with and without returnSpansFrom.
+"""
+
+import pytest
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.querier import (
+    OrderBy,
+    TelemetryFieldKey,
+    TraceOperatorQuery,
+    make_query_request,
+)
+from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode
+
+
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _SpanDef:
+    """Span spec relative to 'now'. parent_idx=-1 for root spans."""
+
+    name: str
+    service: str
+    op_type: str
+    duration_s: int
+    time_offset_s: int
+    parent_idx: int = -1
+    extra_attrs: dict = field(default_factory=dict)
+
+
+def _build_trace(now: datetime, trace_id: str, spans: list[_SpanDef]) -> list[Traces]:
+    span_ids = [TraceIdGenerator.span_id() for _ in spans]
+    result = []
+    for i, (defn, span_id) in enumerate(zip(spans, span_ids)):
+        parent_id = "" if defn.parent_idx < 0 else span_ids[defn.parent_idx]
+        kind = TracesKind.SPAN_KIND_SERVER if defn.parent_idx < 0 else TracesKind.SPAN_KIND_INTERNAL
+        result.append(
+            Traces(
+                timestamp=now - timedelta(seconds=defn.time_offset_s),
+                duration=timedelta(seconds=defn.duration_s),
+                trace_id=trace_id,
+                span_id=span_id,
+                parent_span_id=parent_id,
+                name=defn.name,
+                kind=kind,
+                status_code=TracesStatusCode.STATUS_CODE_OK,
+                status_message="",
+                resources={"service.name": defn.service},
+                attributes={"operation.type": defn.op_type, **defn.extra_attrs},
+            )
+        )
+    return result
+
+
+def _builder_query(name: str, filter_expr: str, limit: int = 100) -> dict:
+    return {
+        "type": "builder_query",
+        "spec": {
+            "name": name,
+            "signal": "traces",
+            "filter": {"expression": filter_expr},
+            "limit": limit,
+        },
+    }
+
+
+
+# ---------------------------------------------------------------------------
+# Order-by variants
+# ---------------------------------------------------------------------------
+# Each case uses a unique op_type prefix so spans inserted by earlier
+# parametrize runs (shared DB session) are never picked up by later ones.
+
+
+@dataclass
+class _OrderByCase:
+    id: str
+    trace1_spans: list[_SpanDef]
+    trace2_spans: list[_SpanDef]
+    filter_a: str
+    filter_b: str
+    expression: str
+    select_fields: list[TelemetryFieldKey] | None
+    order: list[OrderBy]
+    expected_rows: list[dict]  # ordered; each dict is a partial match against row data
+
+
+_ORDER_BY_CASES: list[_OrderByCase] = [
+    # Order by attribute absent from selectFields — NOT_FOUND_COLUMN_IN_BLOCK regression guard.
+    _OrderByCase(
+        id="field_not_in_select",
+        trace1_spans=[
+            _SpanDef("fnis-gp", "svc-a", "fnis-grandparent", 5, 10, extra_attrs={"http.method": "POST"}),
+            _SpanDef("fnis-mid", "svc-a", "fnis-middle", 3, 9, parent_idx=0),
+            _SpanDef("fnis-gc", "svc-a", "fnis-grandchild", 1, 8, parent_idx=1),
+        ],
+        trace2_spans=[
+            _SpanDef("fnis-gp", "svc-b", "fnis-grandparent", 5, 7, extra_attrs={"http.method": "GET"}),
+            _SpanDef("fnis-mid", "svc-b", "fnis-middle", 3, 6, parent_idx=0),
+            _SpanDef("fnis-gc", "svc-b", "fnis-grandchild", 1, 5, parent_idx=1),
+        ],
+        filter_a="operation.type = 'fnis-grandparent'",
+        filter_b="operation.type = 'fnis-grandchild'",
+        expression="A -> B",
+        select_fields=[TelemetryFieldKey(name="service.name", field_data_type="string", field_context="resource")],
+        order=[OrderBy(
+            key=TelemetryFieldKey(name="http.method", field_data_type="string", field_context="attribute"),
+            direction="desc",
+        )],
+        # POST > GET in DESC → svc-a first
+        expected_rows=[{"service.name": "svc-a"}, {"service.name": "svc-b"}],
+    ),
+    # Order by a core span field (duration_nano) with no explicit selectFields.
+    _OrderByCase(
+        id="core_span_field",
+        trace1_spans=[
+            _SpanDef("csf-parent-long", "svc-long", "csf-parent", 5, 10),
+            _SpanDef("csf-child-long", "svc-long", "csf-child", 1, 9, parent_idx=0),
+        ],
+        trace2_spans=[
+            _SpanDef("csf-parent-short", "svc-short", "csf-parent", 1, 8),
+            _SpanDef("csf-child-short", "svc-short", "csf-child", 1, 7, parent_idx=0),
+        ],
+        filter_a="operation.type = 'csf-parent'",
+        filter_b="operation.type = 'csf-child'",
+        expression="A => B",
+        select_fields=None,
+        order=[OrderBy(key=TelemetryFieldKey(name="duration_nano", field_context="span"), direction="desc")],
+        # 5 s parent first, 1 s parent second
+        expected_rows=[{"name": "csf-parent-long"}, {"name": "csf-parent-short"}],
+    ),
+    # Order by a non-core attribute that IS in selectFields — checks ordering and field presence.
+    _OrderByCase(
+        id="non_core_field_in_select",
+        trace1_spans=[
+            _SpanDef("ncis-parent-post", "svc-post", "ncis-parent", 3, 10, extra_attrs={"http.method": "POST"}),
+            _SpanDef("ncis-child-post", "svc-post", "ncis-child", 1, 9, parent_idx=0),
+        ],
+        trace2_spans=[
+            _SpanDef("ncis-parent-get", "svc-get", "ncis-parent", 3, 8, extra_attrs={"http.method": "GET"}),
+            _SpanDef("ncis-child-get", "svc-get", "ncis-child", 1, 7, parent_idx=0),
+        ],
+        filter_a="operation.type = 'ncis-parent'",
+        filter_b="operation.type = 'ncis-child'",
+        expression="A => B",
+        select_fields=[TelemetryFieldKey(name="http.method", field_data_type="string", field_context="attribute")],
+        order=[OrderBy(
+            key=TelemetryFieldKey(name="http.method", field_data_type="string", field_context="attribute"),
+            direction="desc",
+        )],
+        # POST > GET in DESC; http.method must appear in both rows (it is in selectFields)
+        expected_rows=[{"http.method": "POST"}, {"http.method": "GET"}],
+    ),
+]
+
+
+@pytest.mark.parametrize("case", [pytest.param(c, id=c.id) for c in _ORDER_BY_CASES])
+def test_trace_operator_query_order_by(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+    case: _OrderByCase,
+) -> None:
+    """
+    Verifies that trace operator queries honour the order-by clause.
+
+    Cases:
+    - field_not_in_select: order by attribute absent from selectFields
+      (NOT_FOUND_COLUMN_IN_BLOCK regression guard).
+    - core_span_field: order by duration_nano with no explicit selectFields.
+    - non_core_field_in_select: order by attribute present in selectFields.
+    """
+    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
+    trace_id_1 = TraceIdGenerator.trace_id()
+    trace_id_2 = TraceIdGenerator.trace_id()
+
+    insert_traces(
+        _build_trace(now, trace_id_1, case.trace1_spans)
+        + _build_trace(now, trace_id_2, case.trace2_spans)
+        + _build_trace(now, TraceIdGenerator.trace_id(), [_SpanDef("noise-span", "svc-noise", "noise-op", 1, 2)])
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    start_ms = int((now - timedelta(minutes=5)).timestamp() * 1000)
+    end_ms = int(now.timestamp() * 1000)
+
+    response = make_query_request(
+        signoz,
+        token,
+        start_ms=start_ms,
+        end_ms=end_ms,
+        request_type="raw",
+        queries=[
+            _builder_query("A", case.filter_a),
+            _builder_query("B", case.filter_b),
+            TraceOperatorQuery(
+                name="C",
+                expression=case.expression,
+                return_spans_from="A",
+                limit=100,
+                select_fields=case.select_fields,
+                order=case.order,
+            ).to_dict(),
+        ],
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["status"] == "success"
+
+    results = response.json()["data"]["data"]["results"]
+    assert len(results) == 1
+    rows = results[0].get("rows") or []
+    assert len(rows) == len(case.expected_rows)
+
+    for i, (row, expected) in enumerate(zip(rows, case.expected_rows)):
+        for key, value in expected.items():
+            assert row["data"].get(key) == value, (
+                f"[{case.id}] row {i}: expected {key}={value!r}, got {row['data'].get(key)!r}"
+            )
+
+
+# ---------------------------------------------------------------------------
+# Operator × returnSpansFrom matrix
+# ---------------------------------------------------------------------------
+# Each case uses a unique op_type prefix so DB rows from earlier parametrize
+# runs never contaminate later ones (the session-level ClickHouse is shared).
+#
+# Operators tested: => -> && || (A NOT B)
+# For each operator two cases:
+#   "default"  — returnSpansFrom="" → result comes from the expression's root CTE
+#   "return_A" — returnSpansFrom="A" → result comes from the A sub-query CTE
+#
+# Root-CTE semantics:
+#   =>        A spans that have a DIRECT child matching B
+#   ->        A spans that are ancestors of any B span
+#   &&        A spans from traces that also contain a B span
+#   ||        UNION of A spans and B spans
+#   A NOT B   A spans from traces that contain no B span
+
+
+@dataclass
+class _ExprCase:
+    id: str
+    traces: list[list[_SpanDef]]  # one inner list per trace
+    filter_a: str
+    filter_b: str
+    expression: str
+    return_spans_from: str          # "" → use expression root CTE
+    expected_names: set[str]        # span.name values that must appear (exact set)
+
+
+_EXPR_CASES: list[_ExprCase] = [
+    # ── A => B (direct child) ────────────────────────────────────────────────
+    # "default": root CTE = A spans that have a direct B child
+    _ExprCase(
+        id="direct_child_default",
+        traces=[
+            [
+                _SpanDef("dcd-root", "svc-dcd-a", "dcd-root", 5, 10),
+                _SpanDef("dcd-leaf", "svc-dcd-a", "dcd-leaf", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("dcd-root-only", "svc-dcd-b", "dcd-root", 2, 7)],  # A but no B child
+        ],
+        filter_a="operation.type = 'dcd-root'",
+        filter_b="operation.type = 'dcd-leaf'",
+        expression="A => B",
+        return_spans_from="",
+        expected_names={"dcd-root"},  # only the root that HAS a direct child
+    ),
+    # "return_A": returns ALL A spans, bypassing the expression filter
+    _ExprCase(
+        id="direct_child_return_A",
+        traces=[
+            [
+                _SpanDef("dca-root", "svc-dca-a", "dca-root", 5, 10),
+                _SpanDef("dca-leaf", "svc-dca-a", "dca-leaf", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("dca-root-only", "svc-dca-b", "dca-root", 2, 7)],
+        ],
+        filter_a="operation.type = 'dca-root'",
+        filter_b="operation.type = 'dca-leaf'",
+        expression="A => B",
+        return_spans_from="A",
+        expected_names={"dca-root", "dca-root-only"},
+    ),
+    # ── A -> B (indirect descendant) ─────────────────────────────────────────
+    _ExprCase(
+        id="indirect_descendant_default",
+        traces=[
+            [
+                _SpanDef("idd-gp", "svc-idd-a", "idd-gp", 5, 10),
+                _SpanDef("idd-mid", "svc-idd-a", "idd-mid", 3, 9, parent_idx=0),
+                _SpanDef("idd-gc", "svc-idd-a", "idd-gc", 1, 8, parent_idx=1),
+            ],
+            [_SpanDef("idd-gp-only", "svc-idd-b", "idd-gp", 2, 7)],  # A but no B descendant
+        ],
+        filter_a="operation.type = 'idd-gp'",
+        filter_b="operation.type = 'idd-gc'",
+        expression="A -> B",
+        return_spans_from="",
+        expected_names={"idd-gp"},
+    ),
+    _ExprCase(
+        id="indirect_descendant_return_A",
+        traces=[
+            [
+                _SpanDef("ida-gp", "svc-ida-a", "ida-gp", 5, 10),
+                _SpanDef("ida-mid", "svc-ida-a", "ida-mid", 3, 9, parent_idx=0),
+                _SpanDef("ida-gc", "svc-ida-a", "ida-gc", 1, 8, parent_idx=1),
+            ],
+            [_SpanDef("ida-gp-only", "svc-ida-b", "ida-gp", 2, 7)],
+        ],
+        filter_a="operation.type = 'ida-gp'",
+        filter_b="operation.type = 'ida-gc'",
+        expression="A -> B",
+        return_spans_from="A",
+        expected_names={"ida-gp", "ida-gp-only"},
+    ),
+    # ── A && B ────────────────────────────────────────────────────────────────
+    _ExprCase(
+        id="and_default",
+        traces=[
+            [
+                _SpanDef("and-root", "svc-and-a", "and-root", 5, 10),
+                _SpanDef("and-leaf", "svc-and-a", "and-leaf", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("and-root-only", "svc-and-b", "and-root", 2, 7)],  # A but no B in trace
+        ],
+        filter_a="operation.type = 'and-root'",
+        filter_b="operation.type = 'and-leaf'",
+        expression="A && B",
+        return_spans_from="",
+        expected_names={"and-root"},  # A from traces that also contain B
+    ),
+    _ExprCase(
+        id="and_return_A",
+        traces=[
+            [
+                _SpanDef("ana-root", "svc-ana-a", "ana-root", 5, 10),
+                _SpanDef("ana-leaf", "svc-ana-a", "ana-leaf", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("ana-root-only", "svc-ana-b", "ana-root", 2, 7)],
+        ],
+        filter_a="operation.type = 'ana-root'",
+        filter_b="operation.type = 'ana-leaf'",
+        expression="A && B",
+        return_spans_from="A",
+        expected_names={"ana-root", "ana-root-only"},
+    ),
+    # ── A || B ────────────────────────────────────────────────────────────────
+    _ExprCase(
+        id="or_default",
+        traces=[
+            [_SpanDef("ord-a-span", "svc-ord-a", "ord-a", 5, 10)],
+            [_SpanDef("ord-b-span", "svc-ord-b", "ord-b", 2, 7)],
+        ],
+        filter_a="operation.type = 'ord-a'",
+        filter_b="operation.type = 'ord-b'",
+        expression="A || B",
+        return_spans_from="",
+        expected_names={"ord-a-span", "ord-b-span"},  # UNION of both A and B
+    ),
+    _ExprCase(
+        id="or_return_A",
+        traces=[
+            [_SpanDef("ora-a-span", "svc-ora-a", "ora-a", 5, 10)],
+            [_SpanDef("ora-b-span", "svc-ora-b", "ora-b", 2, 7)],
+        ],
+        filter_a="operation.type = 'ora-a'",
+        filter_b="operation.type = 'ora-b'",
+        expression="A || B",
+        return_spans_from="A",
+        expected_names={"ora-a-span"},
+    ),
+    # ── A NOT B (binary not) ──────────────────────────────────────────────────
+    # Unary NOT A is skipped: its root CTE reads from all_spans (unbounded by
+    # filter), making row counts non-deterministic across a shared test session.
+    _ExprCase(
+        id="not_binary_default",
+        traces=[
+            [
+                _SpanDef("nbd-root-with-child", "svc-nbd-a", "nbd-root", 5, 10),
+                _SpanDef("nbd-child", "svc-nbd-a", "nbd-child", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("nbd-root-no-child", "svc-nbd-b", "nbd-root", 2, 7)],  # A, no B
+        ],
+        filter_a="operation.type = 'nbd-root'",
+        filter_b="operation.type = 'nbd-child'",
+        expression="A NOT B",
+        return_spans_from="",
+        expected_names={"nbd-root-no-child"},  # A from traces that have no B
+    ),
+    _ExprCase(
+        id="not_binary_return_A",
+        traces=[
+            [
+                _SpanDef("nba-root-with-child", "svc-nba-a", "nba-root", 5, 10),
+                _SpanDef("nba-child", "svc-nba-a", "nba-child", 2, 9, parent_idx=0),
+            ],
+            [_SpanDef("nba-root-no-child", "svc-nba-b", "nba-root", 2, 7)],
+        ],
+        filter_a="operation.type = 'nba-root'",
+        filter_b="operation.type = 'nba-child'",
+        expression="A NOT B",
+        return_spans_from="A",
+        expected_names={"nba-root-with-child", "nba-root-no-child"},  # ALL A spans
+    ),
+]
+
+
+@pytest.mark.parametrize("case", [pytest.param(c, id=c.id) for c in _EXPR_CASES])
+def test_trace_operator_expressions(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+    case: _ExprCase,
+) -> None:
+    """
+    Matrix of expression operators × returnSpansFrom settings.
+
+    For each operator (=>, ->, &&, ||, A NOT B) two cases verify:
+    - default (returnSpansFrom=""): result comes from the expression's root CTE,
+      so only spans satisfying the full structural predicate are returned.
+    - return_A (returnSpansFrom="A"): result comes from the raw A sub-query CTE,
+      bypassing the structural filter, returning ALL spans matching filter A.
+    """
+    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
+
+    all_spans: list[Traces] = []
+    for span_defs in case.traces:
+        all_spans.extend(_build_trace(now, TraceIdGenerator.trace_id(), span_defs))
+    # Noise: op_type "noise-op" matches no filter in any case; surfacing it would
+    # mean a filter regression, which the set-equality assertion below would catch.
+    all_spans.extend(_build_trace(now, TraceIdGenerator.trace_id(), [_SpanDef("noise-span", "svc-noise", "noise-op", 1, 2)]))
+    insert_traces(all_spans)
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    start_ms = int((now - timedelta(minutes=5)).timestamp() * 1000)
+    end_ms = int(now.timestamp() * 1000)
+
+    response = make_query_request(
+        signoz,
+        token,
+        start_ms=start_ms,
+        end_ms=end_ms,
+        request_type="raw",
+        queries=[
+            _builder_query("A", case.filter_a),
+            _builder_query("B", case.filter_b),
+            TraceOperatorQuery(
+                name="C",
+                expression=case.expression,
+                return_spans_from=case.return_spans_from,
+                limit=100,
+            ).to_dict(),
+        ],
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["status"] == "success"
+
+    results = response.json()["data"]["data"]["results"]
+    assert len(results) == 1
+    rows = results[0].get("rows") or []
+
+    actual_names = {row["data"]["name"] for row in rows}
+    assert actual_names == case.expected_names, (
+        f"[{case.id}] expected spans {case.expected_names}, got {actual_names}"
+    )