fix(ai-assistant): map apply_filter requestType to explorer panel type

"Open in Explorer" chips opened the Logs/Traces Explorer in the default raw
List view even when the agent's query was a grouped aggregation
(requestType=scalar with groupBy): applyFilter never set a panelTypes URL
param, so the explorer fell back to PANEL_TYPES.LIST.

Derive the panel type from the query's requestType (scalar/distribution ->
table, time_series -> graph, raw/other -> list) and set panelTypes on both the
on-page (redirectWithQueryBuilderData) and off-page (buildExplorerNavigationUrl)
navigation paths, mirroring the saved-view path that already worked. Removes
leftover [apply_filter] debug logs.

.vscode/settings.json

@@ -19,8 +19,5 @@
     "editor.defaultFormatter": "vscode.html-language-features"
   },
   "python-envs.defaultEnvManager": "ms-python.python:system",
-  "python-envs.pythonProjects": [],
-  "[json]": {
-    "editor.defaultFormatter": "vscode.json-language-features"
-  }
+  "python-envs.pythonProjects": []
 }

cmd/community/server.go

@@ -29,8 +29,6 @@ import (
 	"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/metricreductionrule"
-	pkgimplmetricreductionrule "github.com/SigNoz/signoz/pkg/modules/metricreductionrule/implmetricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
@@ -121,9 +119,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(_ sqlstore.SQLStore, _ dashboard.Module, _ global.Global, _ zeus.Zeus, _ gateway.Gateway, _ licensing.Licensing, _ serviceaccount.Module, _ cloudintegration.Config) (cloudintegration.Module, error) {
 			return implcloudintegration.NewModule(), nil
 		},
-		func(_ sqlstore.SQLStore, _ telemetrystore.TelemetryStore, _ dashboard.Module, _ queryparser.QueryParser, _ licensing.Licensing, _ factory.ProviderSettings, _ int) metricreductionrule.Module {
-			return pkgimplmetricreductionrule.NewModule()
-		},
 		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
 			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, nil, nil))
 		},

cmd/enterprise/server.go

@@ -24,7 +24,6 @@ import (
 	"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"
-	eeimplmetricreductionrule "github.com/SigNoz/signoz/ee/modules/metricreductionrule/implmetricreductionrule"
 	eequerier "github.com/SigNoz/signoz/ee/querier"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
 	eerules "github.com/SigNoz/signoz/ee/query-service/rules"
@@ -47,7 +46,6 @@ import (
 	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/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
@@ -184,9 +182,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return implcloudintegration.NewModule(pkgcloudintegration.NewStore(sqlStore), dashboardModule, global, zeus, gateway, licensing, serviceAccount, cloudProvidersMap, config)
 		},
-		func(sqlStore sqlstore.SQLStore, ts telemetrystore.TelemetryStore, dashboardModule dashboard.Module, queryParser queryparser.QueryParser, licensing licensing.Licensing, ps factory.ProviderSettings, threads int) metricreductionrule.Module {
-			return eeimplmetricreductionrule.NewModule(sqlStore, ts, dashboardModule, queryParser, licensing, ps, threads)
-		},
 		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
 			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, eerules.PrepareTaskFunc, eerules.TestNotification))
 		},

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.129.0
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.129.0
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.129.0}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.129.0}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

docs/contributing/go/handler.md

@@ -109,20 +109,6 @@ func (h *handler) CreateThing(rw http.ResponseWriter, req *http.Request) {
 }
 ```
 
-When you need an ID from `claims` as a `valuer.UUID` (for example to pass it to a module), derive it with the `Must*` constructor instead of `NewUUID` plus an error check. Claims are validated by the auth middleware, so the conversion cannot fail and the error branch would be dead code:
-
-```go
-// Good — claims are pre-validated, the conversion cannot fail.
-orgID := valuer.MustNewUUID(claims.OrgID)
-
-// Avoid — the error path is unreachable.
-orgID, err := valuer.NewUUID(claims.OrgID)
-if err != nil {
-    render.Error(rw, err)
-    return
-}
-```
-
 ### 3. Register the handler in `signozapiserver`
 
 In `pkg/apiserver/signozapiserver`, add a route in the appropriate `add*Routes` function (`addUserRoutes`, `addSessionRoutes`, `addOrgRoutes`, etc.). The pattern is:
@@ -401,4 +387,3 @@ Note the discriminator property lives in the variants, not on the parent — the
 - **Add `nullable:"true"`** on fields that can be `null`. Pay special attention to slices and maps -- in Go these default to `nil` which serializes to `null`. If the field should always be an array, initialize it and do not mark it nullable.
 - **Implement `Enum()`** on every type that has a fixed set of acceptable values so the JSON schema generates proper `enum` constraints.
 - **Add request examples** via `RequestExamples` in `OpenAPIDef` for any non-trivial endpoint. See `pkg/apiserver/signozapiserver/querier.go` for reference.
-- **Derive IDs from `claims` with `valuer.MustNewUUID`** (e.g. `claims.OrgID`, `claims.UserID`). Claims are pre-validated by the auth middleware, so use the `Must*` constructor — don't write `NewUUID` followed by an `if err != nil { render.Error(...); return }` block.

ee/modules/dashboard/impldashboard/module.go

@@ -217,10 +217,6 @@ func (module *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy
 	return module.pkgDashboardModule.CreateV2(ctx, orgID, createdBy, creator, source, postable)
 }
 
-func (module *module) CloneV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.CloneV2(ctx, orgID, createdBy, creator, id)
-}
-
 func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
 	return module.pkgDashboardModule.GetV2(ctx, orgID, id)
 }
@@ -266,22 +262,6 @@ func (module *module) DeletePreferencesForUser(ctx context.Context, orgID valuer
 	return module.pkgDashboardModule.DeletePreferencesForUser(ctx, orgID, userID)
 }
 
-func (module *module) CreateView(ctx context.Context, orgID valuer.UUID, postable dashboardtypes.PostableDashboardView) (*dashboardtypes.DashboardView, error) {
-	return module.pkgDashboardModule.CreateView(ctx, orgID, postable)
-}
-
-func (module *module) ListViews(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.ListableDashboardView, error) {
-	return module.pkgDashboardModule.ListViews(ctx, orgID)
-}
-
-func (module *module) UpdateView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updateable dashboardtypes.UpdatableDashboardView) (*dashboardtypes.DashboardView, error) {
-	return module.pkgDashboardModule.UpdateView(ctx, orgID, id, updateable)
-}
-
-func (module *module) DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.DeleteView(ctx, orgID, id)
-}
-
 func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.Get(ctx, orgID, id)
 }

ee/modules/metricreductionrule/implmetricreductionrule/clickhouse.go

@@ -1,332 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-	"time"
-
-	sqlbuilder "github.com/huandu/go-sqlbuilder"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-)
-
-var (
-	reductionRulesTable = telemetrymetrics.DBName + "." + telemetrymetrics.ReductionRulesTableName
-	metadataTable       = telemetrymetrics.DBName + "." + telemetrymetrics.AttributesMetadataTableName
-	timeseriesTable     = telemetrymetrics.DBName + "." + telemetrymetrics.TimeseriesV4TableName
-)
-
-type clickhouse struct {
-	telemetryStore telemetrystore.TelemetryStore
-	threads        int
-}
-
-func newClickhouse(telemetryStore telemetrystore.TelemetryStore, threads int) *clickhouse {
-	return &clickhouse{telemetryStore: telemetryStore, threads: threads}
-}
-
-func (c *clickhouse) withThreads(ctx context.Context) context.Context {
-	return ctxtypes.SetClickhouseMaxThreads(ctx, c.threads)
-}
-
-const timeSeriesBucketMilli = int64(time.Hour / time.Millisecond)
-
-// floorToTimeSeriesBucket rounds the start down to the hour, since unix_milli is hour-bucketed.
-func floorToTimeSeriesBucket(ms int64) int64 {
-	return ms - (ms % timeSeriesBucketMilli)
-}
-
-func (c *clickhouse) Sync(ctx context.Context, metricName string, labels []string, matchType string, effectiveFromMs int64, deleted bool, updatedAt time.Time) error {
-	ctx = c.withThreads(ctx)
-
-	ib := sqlbuilder.NewInsertBuilder()
-	ib.InsertInto(reductionRulesTable)
-	ib.Cols("metric_name", "labels", "match_type", "effective_from_unix_milli", "deleted", "updated_at")
-	ib.Values(metricName, labels, matchType, effectiveFromMs, deleted, updatedAt)
-
-	query, args := ib.BuildWithFlavor(sqlbuilder.ClickHouse)
-	if err := c.telemetryStore.ClickhouseDB().Exec(ctx, query, args...); err != nil {
-		return errors.WrapInternalf(err, errors.CodeInternal, "failed to sync reduction rule to clickhouse")
-	}
-	return nil
-}
-
-func (c *clickhouse) MetricExists(ctx context.Context, metricName string) (bool, error) {
-	ctx = c.withThreads(ctx)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("count(*) > 0")
-	sb.From(metadataTable)
-	sb.Where(sb.E("metric_name", metricName))
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	var exists bool
-	if err := c.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(&exists); err != nil {
-		return false, errors.WrapInternalf(err, errors.CodeInternal, "failed to check metric existence")
-	}
-	return exists, nil
-}
-
-func (c *clickhouse) IsExponentialHistogram(ctx context.Context, metricName string) (bool, error) {
-	ctx = c.withThreads(ctx)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("count(*) > 0")
-	sb.From(timeseriesTable)
-	sb.Where(sb.E("metric_name", metricName), sb.E("type", metrictypes.ExpHistogramType.StringValue()))
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	var isExpHist bool
-	if err := c.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(&isExpHist); err != nil {
-		return false, errors.WrapInternalf(err, errors.CodeInternal, "failed to check metric type")
-	}
-	return isExpHist, nil
-}
-
-func (c *clickhouse) AttributeKeys(ctx context.Context, metricName string, startMs, endMs int64) ([]string, error) {
-	ctx = c.withThreads(ctx)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("attr_name")
-	sb.Distinct()
-	sb.From(metadataTable)
-	sb.Where(
-		sb.E("metric_name", metricName),
-		"NOT startsWith(attr_name, '__')",
-		sb.GE("last_reported_unix_milli", startMs),
-		sb.LE("first_reported_unix_milli", endMs),
-	)
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := c.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to fetch metric attribute keys")
-	}
-	defer rows.Close()
-
-	keys := make([]string, 0)
-	for rows.Next() {
-		var key string
-		if err := rows.Scan(&key); err != nil {
-			return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan attribute key")
-		}
-		keys = append(keys, key)
-	}
-	return keys, rows.Err()
-}
-
-func (c *clickhouse) tableExists(ctx context.Context, distributedTableName string) bool {
-	var exists bool
-	query := "SELECT count() > 0 FROM system.tables WHERE database = ? AND name = ?"
-	if err := c.telemetryStore.ClickhouseDB().QueryRow(ctx, query, telemetrymetrics.DBName, distributedTableName).Scan(&exists); err != nil {
-		return false
-	}
-	return exists
-}
-
-func (c *clickhouse) originalSeriesSource(ctx context.Context) (table string, originalOnly bool) {
-	if c.tableExists(ctx, telemetrymetrics.TimeseriesV4BufferTableName) {
-		return telemetrymetrics.DBName + "." + telemetrymetrics.TimeseriesV4BufferTableName, true
-	}
-	return telemetrymetrics.DBName + "." + telemetrymetrics.TimeseriesV4TableName, false
-}
-
-func (c *clickhouse) EstimateCardinality(ctx context.Context, metricName string, keptLabels []string, startMs, endMs int64) (uint64, uint64, error) {
-	ctx = c.withThreads(ctx)
-	table, originalOnly := c.originalSeriesSource(ctx)
-	startMs = floorToTimeSeriesBucket(startMs)
-
-	sb := sqlbuilder.NewSelectBuilder()
-
-	reducedExpr := "1"
-	if len(keptLabels) > 0 {
-		reducedExpr = "countDistinct(("
-		for i, label := range keptLabels {
-			if i > 0 {
-				reducedExpr += ", "
-			}
-			reducedExpr += "JSONExtractString(labels, " + sb.Var(label) + ")"
-		}
-		reducedExpr += "))"
-	}
-
-	sb.Select("countDistinct(fingerprint)", reducedExpr)
-	sb.From(table)
-	conds := []string{
-		sb.E("metric_name", metricName),
-		sb.GE("unix_milli", startMs),
-		sb.LT("unix_milli", endMs),
-	}
-	if originalOnly {
-		conds = append(conds, sb.E("is_reduced", false))
-	}
-	sb.Where(conds...)
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	var current, reduced uint64
-	if err := c.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(&current, &reduced); err != nil {
-		return 0, 0, errors.WrapInternalf(err, errors.CodeInternal, "failed to estimate reduction impact")
-	}
-	if len(keptLabels) == 0 && current == 0 {
-		reduced = 0
-	}
-	if reduced > current {
-		reduced = current
-	}
-	return current, reduced, nil
-}
-
-type volumeRow struct {
-	MetricName string
-	Ingested   uint64
-	Reduced    uint64
-}
-
-func (c *clickhouse) VolumeByMetric(ctx context.Context, metricNames []string, startMs, endMs int64) (map[string]volumeRow, error) {
-	if len(metricNames) == 0 {
-		return map[string]volumeRow{}, nil
-	}
-	ctx = c.withThreads(ctx)
-
-	ingestedTable, originalOnly := c.originalSeriesSource(ctx)
-	ingested, err := c.countSeries(ctx, ingestedTable, originalOnly, metricNames, startMs, endMs)
-	if err != nil {
-		return nil, err
-	}
-
-	reduced := ingested
-	if c.tableExists(ctx, telemetrymetrics.TimeseriesV4ReducedTableName) {
-		reduced, err = c.countSeries(ctx, telemetrymetrics.DBName+"."+telemetrymetrics.TimeseriesV4ReducedTableName, false, metricNames, startMs, endMs)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	out := make(map[string]volumeRow, len(metricNames))
-	for metricName, count := range ingested {
-		out[metricName] = volumeRow{MetricName: metricName, Ingested: count, Reduced: out[metricName].Reduced}
-	}
-	for metricName, count := range reduced {
-		row := out[metricName]
-		row.MetricName = metricName
-		row.Reduced = count
-		out[metricName] = row
-	}
-	return out, nil
-}
-
-func (c *clickhouse) countSeries(ctx context.Context, table string, originalOnly bool, metricNames []string, startMs, endMs int64) (map[string]uint64, error) {
-	startMs = floorToTimeSeriesBucket(startMs)
-	names := make([]any, len(metricNames))
-	for i, name := range metricNames {
-		names[i] = name
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("metric_name", "countDistinct(fingerprint)")
-	sb.From(table)
-	conds := []string{
-		sb.In("metric_name", names...),
-		sb.GE("unix_milli", startMs),
-		sb.LT("unix_milli", endMs),
-	}
-	if originalOnly {
-		conds = append(conds, sb.E("is_reduced", false))
-	}
-	sb.Where(conds...)
-	sb.GroupBy("metric_name")
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := c.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to count metric series")
-	}
-	defer rows.Close()
-
-	out := make(map[string]uint64, len(metricNames))
-	for rows.Next() {
-		var (
-			metricName string
-			count      uint64
-		)
-		if err := rows.Scan(&metricName, &count); err != nil {
-			return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan series count")
-		}
-		out[metricName] = count
-	}
-	return out, rows.Err()
-}
-
-func (c *clickhouse) RankByVolume(ctx context.Context, metricNames []string, orderBy metricreductionruletypes.ReductionRuleOrderBy, order metricreductionruletypes.Order, startMs, endMs int64, offset, limit int) ([]volumeRow, error) {
-	if len(metricNames) == 0 {
-		return []volumeRow{}, nil
-	}
-	ctx = c.withThreads(ctx)
-
-	ingestedTable, originalOnly := c.originalSeriesSource(ctx)
-	reducedPresent := c.tableExists(ctx, telemetrymetrics.TimeseriesV4ReducedTableName)
-	startMs = floorToTimeSeriesBucket(startMs)
-
-	orderExpr := "ingested"
-	switch orderBy {
-	case metricreductionruletypes.OrderByReducedVolume:
-		orderExpr = "reduced"
-	case metricreductionruletypes.OrderByReduction:
-		orderExpr = "if(ingested = 0, 0, (toFloat64(ingested) - toFloat64(reduced)) / toFloat64(ingested))"
-	}
-	direction := "ASC"
-	if order == metricreductionruletypes.OrderDesc {
-		direction = "DESC"
-	}
-
-	ingestedFilter := ""
-	if originalOnly {
-		ingestedFilter = "is_reduced = false AND "
-	}
-	reducedSelect := "ifNull(i.cnt, 0) AS reduced"
-	if reducedPresent {
-		reducedSelect = "ifNull(d.cnt, 0) AS reduced"
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("base.metric_name AS metric_name", "ifNull(i.cnt, 0) AS ingested", reducedSelect)
-	sb.From("(SELECT arrayJoin(" + sb.Var(metricNames) + ") AS metric_name) AS base")
-	sb.JoinWithOption(
-		sqlbuilder.LeftJoin,
-		"(SELECT metric_name, countDistinct(fingerprint) AS cnt FROM "+ingestedTable+" WHERE has("+sb.Var(metricNames)+", metric_name) AND "+ingestedFilter+"unix_milli >= "+sb.Var(startMs)+" AND unix_milli < "+sb.Var(endMs)+" GROUP BY metric_name) AS i",
-		"base.metric_name = i.metric_name",
-	)
-	if reducedPresent {
-		reducedTable := telemetrymetrics.DBName + "." + telemetrymetrics.TimeseriesV4ReducedTableName
-		sb.JoinWithOption(
-			sqlbuilder.LeftJoin,
-			"(SELECT metric_name, countDistinct(fingerprint) AS cnt FROM "+reducedTable+" WHERE has("+sb.Var(metricNames)+", metric_name) AND unix_milli >= "+sb.Var(startMs)+" AND unix_milli < "+sb.Var(endMs)+" GROUP BY metric_name) AS d",
-			"base.metric_name = d.metric_name",
-		)
-	}
-	sb.OrderBy(orderExpr + " " + direction)
-	if limit > 0 {
-		sb.Limit(limit).Offset(offset)
-	}
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := c.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to rank reduction rules by volume")
-	}
-	defer rows.Close()
-
-	out := make([]volumeRow, 0, len(metricNames))
-	for rows.Next() {
-		var row volumeRow
-		if err := rows.Scan(&row.MetricName, &row.Ingested, &row.Reduced); err != nil {
-			return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan volume row")
-		}
-		out = append(out, row)
-	}
-	return out, rows.Err()
-}

ee/modules/metricreductionrule/implmetricreductionrule/module.go

@@ -1,390 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-	"log/slog"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-const (
-	effectiveFromMargin    = 5 * time.Minute
-	defaultPreviewLookback = 24 * time.Hour
-)
-
-var protectedLabels = map[string]struct{}{
-	"le":                     {},
-	"quantile":               {},
-	"__name__":               {},
-	"__temporality__":        {},
-	"deployment.environment": {},
-}
-
-func isProtected(label string) bool {
-	_, ok := protectedLabels[label]
-	return ok
-}
-
-type module struct {
-	store     metricreductionruletypes.Store
-	ch        *clickhouse
-	dashboard dashboard.Module
-	ruleStore ruletypes.RuleStore
-	licensing licensing.Licensing
-	logger    *slog.Logger
-}
-
-func NewModule(sqlStore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, dashboardModule dashboard.Module, queryParser queryparser.QueryParser, licensing licensing.Licensing, providerSettings factory.ProviderSettings, threads int) metricreductionrule.Module {
-	scoped := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/modules/metricreductionrule/implmetricreductionrule")
-	return &module{
-		store:     NewStore(sqlStore),
-		ch:        newClickhouse(telemetryStore, threads),
-		dashboard: dashboardModule,
-		ruleStore: sqlrulestore.NewRuleStore(sqlStore, queryParser, providerSettings),
-		licensing: licensing,
-		logger:    scoped.Logger(),
-	}
-}
-
-func (m *module) checkLicense(ctx context.Context, orgID valuer.UUID) error {
-	if _, err := m.licensing.GetActive(ctx, orgID); err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "metric volume control requires a valid license").WithAdditional(err.Error())
-	}
-	return nil
-}
-
-func (m *module) List(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error) {
-	if err := m.checkLicense(ctx, orgID); err != nil {
-		return nil, err
-	}
-	if err := params.Validate(); err != nil {
-		return nil, err
-	}
-
-	now := time.Now()
-	startMs := now.Add(-defaultPreviewLookback).UnixMilli()
-	endMs := now.UnixMilli()
-
-	switch params.OrderBy {
-	case metricreductionruletypes.OrderByMetricName, metricreductionruletypes.OrderByLastUpdated:
-		return m.listSortedByColumn(ctx, orgID, params, startMs, endMs)
-	default:
-		return m.listSortedByVolume(ctx, orgID, params, startMs, endMs)
-	}
-}
-
-func (m *module) listSortedByColumn(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams, startMs, endMs int64) (*metricreductionruletypes.GettableReductionRules, error) {
-	domainRules, total, err := m.store.List(ctx, orgID, params)
-	if err != nil {
-		return nil, err
-	}
-
-	metricNames := make([]string, len(domainRules))
-	for i, rule := range domainRules {
-		metricNames[i] = rule.MetricName
-	}
-	volumes, err := m.ch.VolumeByMetric(ctx, metricNames, startMs, endMs)
-	if err != nil {
-		return nil, err
-	}
-
-	rules := make([]metricreductionruletypes.GettableReductionRule, 0, len(domainRules))
-	for _, rule := range domainRules {
-		rules = append(rules, withVolume(toGettableReductionRule(rule), volumes[rule.MetricName]))
-	}
-
-	return &metricreductionruletypes.GettableReductionRules{Rules: rules, Total: total}, nil
-}
-
-func (m *module) listSortedByVolume(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams, startMs, endMs int64) (*metricreductionruletypes.GettableReductionRules, error) {
-	allRules, total, err := m.store.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{})
-	if err != nil {
-		return nil, err
-	}
-	if total == 0 {
-		return &metricreductionruletypes.GettableReductionRules{Rules: []metricreductionruletypes.GettableReductionRule{}, Total: 0}, nil
-	}
-
-	metricNames := make([]string, len(allRules))
-	ruleByMetric := make(map[string]*metricreductionruletypes.StorableReductionRule, len(allRules))
-	for i, rule := range allRules {
-		metricNames[i] = rule.MetricName
-		ruleByMetric[rule.MetricName] = rule
-	}
-
-	ranked, err := m.ch.RankByVolume(ctx, metricNames, params.OrderBy, params.Order, startMs, endMs, params.Offset, params.Limit)
-	if err != nil {
-		return nil, err
-	}
-
-	rules := make([]metricreductionruletypes.GettableReductionRule, 0, len(ranked))
-	for _, row := range ranked {
-		rule, ok := ruleByMetric[row.MetricName]
-		if !ok {
-			continue
-		}
-		rules = append(rules, withVolume(toGettableReductionRule(rule), row))
-	}
-
-	return &metricreductionruletypes.GettableReductionRules{Rules: rules, Total: total}, nil
-}
-
-func (m *module) Get(ctx context.Context, orgID valuer.UUID, metricName string) (*metricreductionruletypes.GettableReductionRule, error) {
-	if err := m.checkLicense(ctx, orgID); err != nil {
-		return nil, err
-	}
-	if metricName == "" {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-
-	rule, err := m.store.Get(ctx, orgID, metricName)
-	if err != nil {
-		return nil, err
-	}
-
-	now := time.Now()
-	current, reduced, reductionPercent, _, err := m.estimateVolume(ctx, rule.MetricName, rule.MatchType, rule.Labels, now.Add(-defaultPreviewLookback).UnixMilli(), now.UnixMilli())
-	if err != nil {
-		return nil, err
-	}
-	gettable := toGettableReductionRule(rule)
-	gettable.IngestedSeries = current
-	gettable.ReducedSeries = reduced
-	gettable.ReductionPercent = reductionPercent
-	return &gettable, nil
-}
-
-func (m *module) Upsert(ctx context.Context, orgID valuer.UUID, userEmail string, req *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	if err := m.checkLicense(ctx, orgID); err != nil {
-		return nil, err
-	}
-	if err := req.Validate(); err != nil {
-		return nil, err
-	}
-	if err := m.validateMetricForReduction(ctx, req.MetricName); err != nil {
-		return nil, err
-	}
-
-	if req.MatchType == metricreductionruletypes.MatchTypeDrop {
-		for _, label := range req.Labels {
-			if isProtected(label) {
-				return nil, errors.Newf(errors.TypeInvalidInput, metricreductionruletypes.ErrCodeMetricReductionRuleProtectedLabel,
-					"label %q is protected and cannot be dropped", label)
-			}
-		}
-	}
-
-	now := time.Now()
-	rule := metricreductionruletypes.NewReductionRule(orgID, req.MetricName, req.MatchType, req.Labels, now.Add(effectiveFromMargin), userEmail)
-
-	if err := m.store.RunInTx(ctx, func(ctx context.Context) error {
-		if err := m.store.Upsert(ctx, rule); err != nil {
-			return err
-		}
-		return m.ch.Sync(ctx, rule.MetricName, rule.Labels, rule.MatchType.StringValue(), rule.EffectiveFrom.UnixMilli(), false, rule.UpdatedAt)
-	}); err != nil {
-		return nil, err
-	}
-
-	gettable := toGettableReductionRule(rule)
-	return &gettable, nil
-}
-
-func (m *module) Delete(ctx context.Context, orgID valuer.UUID, metricName string) error {
-	if err := m.checkLicense(ctx, orgID); err != nil {
-		return err
-	}
-	if metricName == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-
-	now := time.Now()
-	effectiveFromMs := now.Add(effectiveFromMargin).UnixMilli()
-	return m.store.RunInTx(ctx, func(ctx context.Context) error {
-		if err := m.store.Delete(ctx, orgID, metricName); err != nil {
-			return err
-		}
-		return m.ch.Sync(ctx, metricName, []string{}, metricreductionruletypes.MatchTypeDrop.StringValue(), effectiveFromMs, true, now)
-	})
-}
-
-func (m *module) Preview(ctx context.Context, orgID valuer.UUID, req *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error) {
-	if err := m.checkLicense(ctx, orgID); err != nil {
-		return nil, err
-	}
-	if err := req.Validate(); err != nil {
-		return nil, err
-	}
-	if err := m.validateMetricForReduction(ctx, req.MetricName); err != nil {
-		return nil, err
-	}
-
-	lookback := time.Duration(req.LookbackMs) * time.Millisecond
-	if lookback <= 0 {
-		lookback = defaultPreviewLookback
-	}
-	now := time.Now()
-	current, reduced, reductionPercent, dropped, err := m.estimateVolume(ctx, req.MetricName, req.MatchType, req.Labels, now.Add(-lookback).UnixMilli(), now.UnixMilli())
-	if err != nil {
-		return nil, err
-	}
-
-	return &metricreductionruletypes.GettableReductionRulePreview{
-		IngestedSeries:   current,
-		ReducedSeries:    reduced,
-		ReductionPercent: reductionPercent,
-		DroppedLabels:    dropped,
-		AffectedAssets:   m.relatedAssetImpact(ctx, orgID, req.MetricName, dropped),
-		EffectiveFrom:    now.Add(effectiveFromMargin),
-	}, nil
-}
-
-func (m *module) validateMetricForReduction(ctx context.Context, metricName string) error {
-	exists, err := m.ch.MetricExists(ctx, metricName)
-	if err != nil {
-		return err
-	}
-	if !exists {
-		return errors.NewNotFoundf(errors.CodeNotFound, "metric not found: %q", metricName)
-	}
-
-	isExpHist, err := m.ch.IsExponentialHistogram(ctx, metricName)
-	if err != nil {
-		return err
-	}
-	if isExpHist {
-		return errors.Newf(errors.TypeInvalidInput, metricreductionruletypes.ErrCodeMetricReductionRuleUnsupportedMetricType,
-			"exponential histogram metrics cannot be reduced in v1")
-	}
-	return nil
-}
-
-func (m *module) relatedAssetImpact(ctx context.Context, orgID valuer.UUID, metricName string, dropped []string) []metricreductionruletypes.AffectedAsset {
-	affected := make([]metricreductionruletypes.AffectedAsset, 0)
-	droppedSet := make(map[string]struct{}, len(dropped))
-	for _, label := range dropped {
-		droppedSet[label] = struct{}{}
-	}
-
-	if dashboards, err := m.dashboard.GetByMetricNames(ctx, orgID, []string{metricName}); err != nil {
-		m.logger.WarnContext(ctx, "failed to fetch related dashboards for reduction preview", slog.String("metric_name", metricName), errors.Attr(err))
-	} else {
-		for _, item := range dashboards[metricName] {
-			var groupBy []string
-			if gb := item["group_by"]; gb != "" {
-				groupBy = strings.Split(gb, ",")
-			}
-			affected = append(affected, metricreductionruletypes.AffectedAsset{
-				Type:           metricreductionruletypes.AssetTypeDashboard,
-				ID:             item["dashboard_id"],
-				Name:           item["dashboard_name"],
-				Widget:         item["widget_name"],
-				ImpactedLabels: intersectLabels(groupBy, droppedSet),
-			})
-		}
-	}
-
-	if alerts, err := m.ruleStore.GetStoredRulesByMetricName(ctx, orgID.String(), metricName); err != nil {
-		m.logger.WarnContext(ctx, "failed to fetch related alerts for reduction preview", slog.String("metric_name", metricName), errors.Attr(err))
-	} else {
-		for _, a := range alerts {
-			affected = append(affected, metricreductionruletypes.AffectedAsset{
-				Type: metricreductionruletypes.AssetTypeAlert,
-				ID:   a.AlertID,
-				Name: a.AlertName,
-			})
-		}
-	}
-
-	return affected
-}
-
-func toGettableReductionRule(rule *metricreductionruletypes.StorableReductionRule) metricreductionruletypes.GettableReductionRule {
-	return metricreductionruletypes.GettableReductionRule{
-		MetricName:    rule.MetricName,
-		MatchType:     rule.MatchType,
-		Labels:        rule.Labels,
-		EffectiveFrom: rule.EffectiveFrom,
-		UpdatedAt:     rule.UpdatedAt,
-		UpdatedBy:     rule.UpdatedBy,
-		Active:        !rule.EffectiveFrom.After(time.Now()),
-	}
-}
-
-func withVolume(rule metricreductionruletypes.GettableReductionRule, volume volumeRow) metricreductionruletypes.GettableReductionRule {
-	rule.IngestedSeries = volume.Ingested
-	rule.ReducedSeries = volume.Reduced
-	if volume.Ingested > 0 && volume.Reduced <= volume.Ingested {
-		rule.ReductionPercent = (1 - float64(volume.Reduced)/float64(volume.Ingested)) * 100
-	}
-	return rule
-}
-
-func intersectLabels(keys []string, droppedSet map[string]struct{}) []string {
-	var out []string
-	for _, key := range keys {
-		if _, ok := droppedSet[key]; ok {
-			out = append(out, key)
-		}
-	}
-	return out
-}
-
-func resolveDroppedKept(matchType metricreductionruletypes.MatchType, ruleLabels, keys []string) (dropped, kept []string) {
-	ruleSet := make(map[string]struct{}, len(ruleLabels))
-	for _, l := range ruleLabels {
-		ruleSet[l] = struct{}{}
-	}
-
-	for _, k := range keys {
-		if isProtected(k) {
-			kept = append(kept, k)
-			continue
-		}
-		_, listed := ruleSet[k]
-		drop := listed
-		if matchType == metricreductionruletypes.MatchTypeKeep {
-			drop = !listed
-		}
-		if drop {
-			dropped = append(dropped, k)
-		} else {
-			kept = append(kept, k)
-		}
-	}
-
-	sort.Strings(dropped)
-	sort.Strings(kept)
-	return dropped, kept
-}
-
-func (m *module) estimateVolume(ctx context.Context, metricName string, matchType metricreductionruletypes.MatchType, labels []string, startMs, endMs int64) (current uint64, reduced uint64, reductionPercent float64, dropped []string, err error) {
-	keys, err := m.ch.AttributeKeys(ctx, metricName, startMs, endMs)
-	if err != nil {
-		return 0, 0, 0, nil, err
-	}
-	dropped, kept := resolveDroppedKept(matchType, labels, keys)
-
-	current, reduced, err = m.ch.EstimateCardinality(ctx, metricName, kept, startMs, endMs)
-	if err != nil {
-		return 0, 0, 0, nil, err
-	}
-	if current > 0 && reduced <= current {
-		reductionPercent = (1 - float64(reduced)/float64(current)) * 100
-	}
-	return current, reduced, reductionPercent, dropped, nil
-}

ee/modules/metricreductionrule/implmetricreductionrule/store.go

@@ -1,102 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type store struct {
-	sqlstore sqlstore.SQLStore
-}
-
-func NewStore(sqlstore sqlstore.SQLStore) metricreductionruletypes.Store {
-	return &store{sqlstore: sqlstore}
-}
-
-func (s *store) List(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams) ([]*metricreductionruletypes.StorableReductionRule, int, error) {
-	column := "metric_name"
-	if params.OrderBy == metricreductionruletypes.OrderByLastUpdated {
-		column = "updated_at"
-	}
-	direction := "ASC"
-	if params.Order == metricreductionruletypes.OrderDesc {
-		direction = "DESC"
-	}
-
-	rules := make([]*metricreductionruletypes.StorableReductionRule, 0)
-	query := s.sqlstore.
-		BunDBCtx(ctx).
-		NewSelect().
-		Model(&rules).
-		Where("org_id = ?", orgID).
-		Order(column + " " + direction)
-	if params.Limit > 0 {
-		query = query.Limit(params.Limit).Offset(params.Offset)
-	}
-
-	total, err := query.ScanAndCount(ctx)
-	if err != nil {
-		return nil, 0, err
-	}
-	return rules, total, nil
-}
-
-func (s *store) Get(ctx context.Context, orgID valuer.UUID, metricName string) (*metricreductionruletypes.StorableReductionRule, error) {
-	rule := new(metricreductionruletypes.StorableReductionRule)
-	err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewSelect().
-		Model(rule).
-		Where("org_id = ?", orgID).
-		Where("metric_name = ?", metricName).
-		Scan(ctx)
-	if err != nil {
-		return nil, s.sqlstore.WrapNotFoundErrf(err, metricreductionruletypes.ErrCodeMetricReductionRuleNotFound, "no reduction rule found for metric %q", metricName)
-	}
-	return rule, nil
-}
-
-func (s *store) Upsert(ctx context.Context, rule *metricreductionruletypes.StorableReductionRule) error {
-	_, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewInsert().
-		Model(rule).
-		On("CONFLICT (org_id, metric_name) DO UPDATE").
-		Set("match_type = EXCLUDED.match_type").
-		Set("labels = EXCLUDED.labels").
-		Set("effective_from = EXCLUDED.effective_from").
-		Set("updated_at = EXCLUDED.updated_at").
-		Set("updated_by = EXCLUDED.updated_by").
-		Exec(ctx)
-	return err
-}
-
-func (s *store) Delete(ctx context.Context, orgID valuer.UUID, metricName string) error {
-	res, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewDelete().
-		Model((*metricreductionruletypes.StorableReductionRule)(nil)).
-		Where("org_id = ?", orgID).
-		Where("metric_name = ?", metricName).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rowsAffected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rowsAffected == 0 {
-		return errors.Newf(errors.TypeNotFound, metricreductionruletypes.ErrCodeMetricReductionRuleNotFound, "no reduction rule found for metric %q", metricName)
-	}
-	return nil
-}
-
-func (s *store) RunInTx(ctx context.Context, cb func(ctx context.Context) error) error {
-	return s.sqlstore.RunInTxCtx(ctx, nil, cb)
-}

ee/modules/metricreductionrule/implmetricreductionrule/store_test.go

@@ -1,170 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory/factorytest"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlitesqlstore"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func newTestStore(t *testing.T) sqlstore.SQLStore {
-	t.Helper()
-	dbPath := filepath.Join(t.TempDir(), "test.db")
-	store, err := sqlitesqlstore.New(context.Background(), factorytest.NewSettings(), sqlstore.Config{
-		Provider: "sqlite",
-		Connection: sqlstore.ConnectionConfig{
-			MaxOpenConns:    1,
-			MaxConnLifetime: 0,
-		},
-		Sqlite: sqlstore.SqliteConfig{
-			Path:            dbPath,
-			Mode:            "wal",
-			BusyTimeout:     5 * time.Second,
-			TransactionMode: "deferred",
-		},
-	})
-	require.NoError(t, err)
-
-	_, err = store.BunDB().NewCreateTable().
-		Model((*metricreductionruletypes.StorableReductionRule)(nil)).
-		IfNotExists().
-		Exec(context.Background())
-	require.NoError(t, err)
-
-	_, err = store.BunDB().Exec(`CREATE UNIQUE INDEX IF NOT EXISTS uq_metric_reduction_rule_org_metric ON metric_reduction_rule (org_id, metric_name)`)
-	require.NoError(t, err)
-	return store
-}
-
-func newRule(orgID valuer.UUID, metricName string, matchType metricreductionruletypes.MatchType, labels []string, by string) *metricreductionruletypes.StorableReductionRule {
-	return metricreductionruletypes.NewReductionRule(orgID, metricName, matchType, labels, time.Now(), by)
-}
-
-func TestStore_UpsertGetListDelete(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgID := valuer.GenerateUUID()
-
-	empty, _, err := s.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{})
-	require.NoError(t, err)
-	assert.Empty(t, empty)
-
-	require.NoError(t, s.Upsert(ctx, newRule(orgID, "http_requests_total", metricreductionruletypes.MatchTypeDrop, []string{"pod", "container"}, "creator@x.com")))
-
-	got, err := s.Get(ctx, orgID, "http_requests_total")
-	require.NoError(t, err)
-	assert.Equal(t, metricreductionruletypes.MatchTypeDrop, got.MatchType)
-	assert.Equal(t, []string{"pod", "container"}, []string(got.Labels))
-	assert.Equal(t, "creator@x.com", got.CreatedBy)
-
-	list, _, err := s.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{})
-	require.NoError(t, err)
-	require.Len(t, list, 1)
-}
-
-func TestStore_UpsertReplacesAndPreservesCreator(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgID := valuer.GenerateUUID()
-
-	require.NoError(t, s.Upsert(ctx, newRule(orgID, "cpu_usage", metricreductionruletypes.MatchTypeDrop, []string{"pod"}, "creator@x.com")))
-	require.NoError(t, s.Upsert(ctx, newRule(orgID, "cpu_usage", metricreductionruletypes.MatchTypeKeep, []string{"le"}, "editor@x.com")))
-
-	list, _, err := s.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{})
-	require.NoError(t, err)
-	require.Len(t, list, 1, "upsert on the same (org, metric) replaces, it does not duplicate")
-
-	got, err := s.Get(ctx, orgID, "cpu_usage")
-	require.NoError(t, err)
-	assert.Equal(t, metricreductionruletypes.MatchTypeKeep, got.MatchType)
-	assert.Equal(t, []string{"le"}, []string(got.Labels))
-	assert.Equal(t, "creator@x.com", got.CreatedBy, "created_by is preserved on update")
-	assert.Equal(t, "editor@x.com", got.UpdatedBy, "updated_by reflects the latest editor")
-}
-
-func TestStore_DeleteMissingRuleErrors(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgID := valuer.GenerateUUID()
-
-	require.NoError(t, s.Upsert(ctx, newRule(orgID, "mem_usage", metricreductionruletypes.MatchTypeDrop, []string{"pod"}, "creator@x.com")))
-	require.NoError(t, s.Delete(ctx, orgID, "mem_usage"))
-
-	_, err := s.Get(ctx, orgID, "mem_usage")
-	require.Error(t, err)
-
-	require.Error(t, s.Delete(ctx, orgID, "mem_usage"), "deleting a non-existent rule returns an error")
-}
-
-func TestStore_ScopedByOrg(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgA := valuer.GenerateUUID()
-	orgB := valuer.GenerateUUID()
-
-	require.NoError(t, s.Upsert(ctx, newRule(orgA, "shared_metric", metricreductionruletypes.MatchTypeDrop, []string{"pod"}, "a@x.com")))
-
-	_, err := s.Get(ctx, orgB, "shared_metric")
-	require.Error(t, err, "a rule in org A must not be visible to org B")
-
-	list, _, err := s.List(ctx, orgB, &metricreductionruletypes.ListReductionRulesParams{})
-	require.NoError(t, err)
-	assert.Empty(t, list)
-}
-
-func TestStore_ListSortsAndPaginates(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgID := valuer.GenerateUUID()
-
-	for _, name := range []string{"c_metric", "a_metric", "b_metric"} {
-		require.NoError(t, s.Upsert(ctx, newRule(orgID, name, metricreductionruletypes.MatchTypeDrop, []string{"pod"}, "x@x.com")))
-	}
-
-	page, total, err := s.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{
-		OrderBy: metricreductionruletypes.OrderByMetricName,
-		Order:   metricreductionruletypes.OrderAsc,
-		Offset:  0,
-		Limit:   2,
-	})
-	require.NoError(t, err)
-	assert.Equal(t, 3, total, "total reflects all rows, not the page size")
-	require.Len(t, page, 2)
-	assert.Equal(t, "a_metric", page[0].MetricName)
-	assert.Equal(t, "b_metric", page[1].MetricName)
-
-	page, _, err = s.List(ctx, orgID, &metricreductionruletypes.ListReductionRulesParams{
-		OrderBy: metricreductionruletypes.OrderByMetricName,
-		Order:   metricreductionruletypes.OrderDesc,
-		Offset:  2,
-		Limit:   2,
-	})
-	require.NoError(t, err)
-	require.Len(t, page, 1)
-	assert.Equal(t, "a_metric", page[0].MetricName, "desc order with offset 2 lands on the smallest name")
-}
-
-func TestStore_RunInTxRollsBackOnError(t *testing.T) {
-	ctx := context.Background()
-	s := NewStore(newTestStore(t))
-	orgID := valuer.GenerateUUID()
-
-	err := s.RunInTx(ctx, func(ctx context.Context) error {
-		if err := s.Upsert(ctx, newRule(orgID, "rolled_back", metricreductionruletypes.MatchTypeDrop, []string{"pod"}, "creator@x.com")); err != nil {
-			return err
-		}
-		return assert.AnError
-	})
-	require.ErrorIs(t, err, assert.AnError)
-
-	_, err = s.Get(ctx, orgID, "rolled_back")
-	require.Error(t, err, "the upsert must not persist when the transaction callback fails")
-}

ee/querier/handler.go

@@ -3,13 +3,13 @@ package querier
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"io"
 	"net/http"
 
 	anomalyV2 "github.com/SigNoz/signoz/ee/anomaly"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
@@ -48,8 +48,8 @@ func (h *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 	}
 
 	var queryRangeRequest qbtypes.QueryRangeRequest
-	if err := binding.JSON.BindBody(req.Body, &queryRangeRequest); err != nil {
-		render.Error(rw, err)
+	if err := json.NewDecoder(req.Body).Decode(&queryRangeRequest); err != nil {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to decode request body: %v", err))
 		return
 	}
 

ee/query-service/app/server.go

@@ -10,6 +10,7 @@ import (
 	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
 	"go.opentelemetry.io/otel/propagation"
 
+	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
 
 	"github.com/gorilla/handlers"
@@ -19,6 +20,7 @@ import (
 
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
+	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/web"
@@ -57,12 +59,25 @@ type Server struct {
 
 // NewServer creates and initializes Server
 func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
+	cacheForTraceDetail, err := memorycache.New(context.TODO(), signoz.Instrumentation.ToProviderSettings(), cache.Config{
+		Provider: "memory",
+		Memory: cache.Memory{
+			NumCounters: 10 * 10000,
+			MaxCost:     1 << 27, // 128 MB
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+
 	reader := clickhouseReader.NewReader(
 		signoz.Instrumentation.Logger(),
 		signoz.SQLStore,
 		signoz.TelemetryStore,
 		signoz.Prometheus,
 		signoz.TelemetryStore.Cluster(),
+		config.Querier.FluxInterval,
+		cacheForTraceDetail,
 		signoz.Cache,
 		nil,
 	)

frontend/.oxlintrc.json

@@ -291,8 +291,6 @@
     // Prevents the usage of specific antd components in favor of our lib
     "signoz/no-signozhq-ui-barrel": "error",
     // Forces subpath imports (@signozhq/ui/<component>) instead of the eagerly-loaded barrel
-    "signoz/no-css-module-bracket-access": "warn",
-    // Prevents bracket access on CSS modules (styles['kebab-case']) which fails with camelCaseOnly config
     "no-restricted-globals": [
       "error",
       {

frontend/.stylelintrc.cjs

@@ -2,33 +2,9 @@
 const path = require('path');
 
 module.exports = {
-	plugins: [
-		path.join(__dirname, 'stylelint-rules/no-unsupported-asset-url.js'),
-		path.join(__dirname, 'stylelint-rules/css-modules/no-deep-nesting.js'),
-		path.join(__dirname, 'stylelint-rules/css-modules/no-id-selectors.js'),
-		path.join(
-			__dirname,
-			'stylelint-rules/css-modules/no-bare-element-selectors.js',
-		),
-		path.join(__dirname, 'stylelint-rules/css-modules/prefer-css-variables.js'),
-		path.join(__dirname, 'stylelint-rules/css-modules/class-name-pattern.js'),
-	],
+	plugins: [path.join(__dirname, 'stylelint-rules/no-unsupported-asset-url.js')],
 	customSyntax: 'postcss-scss',
 	rules: {
-		// Applies to all SCSS files
 		'local/no-unsupported-asset-url': true,
 	},
-	overrides: [
-		{
-			// CSS module-specific rules
-			files: ['**/*.module.scss'],
-			rules: {
-				'local/no-deep-nesting': [true, { severity: 'warning' }],
-				'local/no-id-selectors': true,
-				'local/no-bare-element-selectors': true,
-				'local/prefer-css-variables': [true, { severity: 'warning' }],
-				'local/class-name-pattern': [true, { severity: 'warning' }],
-			},
-		},
-	],
 };

frontend/AGENTS.md

@@ -23,8 +23,6 @@ You are operating within a constrained context window and strict system prompts.
 - Always add data-testid or testId (if supported) to critical/behavioral components like inputs, buttons, etc...
   - When creating test, these IDs should be used instead of finding by role.
 - Never create barrel files.
-- When writing new css, prefer CSS Modules
-  - Use ./docs/css-modules-guide.md as reference on how to write good CSS Modules.
 
 3. FORCED VERIFICATION: Your internal tools mark file writes as successful even if the code does not compile. You are FORBIDDEN from reporting a task as complete until you have:
 - Run `pnpm tsgo --noEmit`

frontend/docs/css-modules-guide.md

@@ -1,513 +0,0 @@
-# CSS Modules Guide
-
-## Checklist Before Committing
-
-- [ ] All class names use camelCase in CSS
-- [ ] State classes use `is-`/`has-` prefix (e.g., `isActive`, `hasError`)
-- [ ] No bracket access (`styles['...']`) in JS unless verified
-- [ ] No dynamic class lookup - use explicit variant maps instead
-- [ ] No deep class nesting (max 3 class levels; pseudo-classes/elements and parent-reference selectors like `&.active`, `&#bar` are not counted)
-- [ ] No hardcoded colors - use `--l1/l2/l3-*` semantic tokens (not `--bg-*` primitives)
-- [ ] No magic numbers - use `--spacing-*` tokens
-- [ ] Typography uses `--periscope-font-size-*` or `--font-size-*` tokens
-- [ ] @signozhq/ui overrides use CSS variables, not direct class overrides
-- [ ] Global escapes only for third-party overrides
-- [ ] No ID selectors
-- [ ] No bare element selectors
-- [ ] Keyframes use `:local(@keyframes name)` to avoid global collisions
-
-## Config (vite.config.ts)
-
-```ts
-css: {
-  modules: {
-    localsConvention: 'camelCaseOnly',
-  },
-}
-```
-
-**Critical:** `camelCaseOnly` exports ONLY camelCase keys. Original kebab-case NOT accessible.
-
-## Quick Reference
-
-| CSS Class | JS Access | Works? | Preferred?                 |
-|-----------|-----------|--------|----------------------------|
-| `.alertHistory` | `styles.alertHistory` | Yes | Yes                        |
-| `.alert-history` | `styles.alertHistory` | Yes | No, use `.alertHistory`    |
-| `.alert-history` | `styles['alert-history']` | NO - undefined | Never, use `.alertHistory` |
-
-## Bad Patterns
-
-### Class Naming
-
-```scss
-// BAD: Bracket access won't work
-.my-class { }
-// Then in JS: styles['my-class'] -> undefined
-
-// BAD: Collision - both become same key
-.alertHistory { }
-.alert-history { }  // -> styles.alertHistory (conflicts)
-
-// BAD: Underscore inconsistency
-.my_class { }  // -> styles.myClass (confusing)
-
-// GOOD: Direct camelCase
-.alertHistory { }
-.statsCard { }
-
-// GOOD: State classes with is-/has- prefix
-.isDisabled { }
-.isActive { }
-.hasError { }
-.isLoading { }
-```
-
-### Nesting
-
-```scss
-// BAD: Deep nesting - specificity wars, hard to override
-.container {
-  .wrapper {
-    .inner {
-      .content { }
-    }
-  }
-}
-
-// BAD: Nesting creates separate classes you might not expect
-.button {
-  .icon { }  // -> styles.icon (separate class, not scoped under .button)
-}
-
-// GOOD: Flat structure
-.container { }
-.containerWrapper { }
-.containerContent { }
-
-// GOOD: Nesting only for pseudo/states
-.button {
-  &:hover { }
-  &:disabled { }
-  &::before { }
-}
-```
-
-### Global Escapes
-
-```scss
-// BAD: Overusing global
-:global {
-  .everything { }
-  .in-here { }
-  .is-global { }
-}
-
-// BAD: Global without necessity
-:global(.myComponent) { }  // defeats purpose of modules
-
-// GOOD: Targeted global for third-party overrides
-.container {
-  :global(.ant-modal-content) {
-    padding: 0;
-  }
-}
-```
-
-### Selectors
-
-```scss
-// BAD: ID selectors - not reusable
-#myComponent { }
-
-// BAD: Element selectors without scope
-div { }  // affects ALL divs in component
-
-// BAD: Complex selectors
-.container > div + span ~ p { }
-
-// GOOD: Class-only selectors
-.container { }
-.title { }
-```
-
-### Variables & Values
-
-```scss
-// BAD: Hardcoded colors
-.button {
-  background: #1890ff;
-  color: white;
-}
-
-// BAD: Magic numbers
-.container {
-  padding: 17px;
-  margin-left: 43px;
-}
-
-// GOOD: Semantic tokens (theme-aware)
-.button {
-  background: var(--primary-background);
-  color: var(--primary-foreground);
-}
-
-.card {
-  background: var(--l2-background);
-  color: var(--l2-foreground);
-}
-
-// GOOD: Spacing system
-.container {
-  padding: var(--spacing-4);
-  margin-left: var(--spacing-5);
-}
-```
-
-## Design Tokens (@signozhq/design-tokens)
-
-Prefer semantic tokens over hardcoded values.
-
-You can read the ./node_modules/@signozhq/design-tokens/dist/style.css to find complete list of available tokens.
-
-### Spacing
-
-```scss
-// Spacing scale (index -> px):
-// --spacing-0=0    --spacing-1=2    --spacing-2=4    --spacing-3=6    --spacing-4=8
-// --spacing-5=10   --spacing-6=12   --spacing-7=14   --spacing-8=16   --spacing-10=20
-// --spacing-12=24  --spacing-16=32  --spacing-20=40  --spacing-24=48  --spacing-32=64
-// --spacing-40=80  --spacing-48=96  --spacing-56=112 --spacing-64=128
-// (index != px; --spacing-2 is 4px, not 2px)
-.container {
-  padding: var(--spacing-4);      // 8px
-  gap: var(--spacing-6);          // 12px
-  margin-bottom: var(--spacing-8); // 16px
-}
-
-// Also available: --padding-* and --margin-* (rem-based)
-// --padding-1 = 0.25rem, --padding-4 = 1rem, etc.
-```
-
-### Typography
-
-```scss
-// Font sizes (preferred)
-.title {
-  font-size: var(--periscope-font-size-large);   // 18px
-  font-size: var(--periscope-font-size-medium);  // 16px
-  font-size: var(--periscope-font-size-base);    // 13px
-  font-size: var(--periscope-font-size-small);   // 11px
-}
-
-// Alternative scale (rem-based)
-.heading {
-  font-size: var(--font-size-xl);  // 1.25rem
-  font-size: var(--font-size-lg);  // 1.125rem
-  font-size: var(--font-size-base); // 1rem
-  font-size: var(--font-size-sm);  // 0.875rem
-}
-
-// Font weights
-.bold {
-  font-weight: var(--font-weight-semibold); // 600
-  font-weight: var(--font-weight-medium);   // 500
-  font-weight: var(--font-weight-normal);   // 400
-}
-
-// Line heights
-.text {
-  line-height: var(--line-height-20); // 20px
-  line-height: var(--line-height-24); // 24px
-}
-```
-
-### Colors (Prefer Semantic Tokens)
-
-Use L1/L2/L3 semantic tokens - they handle light/dark theme automatically.
-
-```scss
-// BAD: Primitive tokens (fixed value across themes, won't swap on theme change)
-.card {
-  background: var(--bg-ink-400);
-  color: var(--text-vanilla-100);
-}
-
-// GOOD: L1/L2/L3 tokens (theme-aware - swap automatically light/dark)
-.card {
-  background: var(--l1-background);  // base layer
-  color: var(--l1-foreground);       // primary text
-}
-
-.panel {
-  background: var(--l2-background);  // elevated surface
-  color: var(--l2-foreground);       // secondary text
-  border-color: var(--l2-border);
-}
-
-.nested {
-  background: var(--l3-background);  // nested/inset
-  color: var(--l3-foreground);       // tertiary text
-}
-
-// Hover states
-.card:hover {
-  background: var(--l1-background-hover);
-  color: var(--l1-foreground-hover);
-}
-
-// Semantic action colors (also theme-aware)
-.primary {
-  background: var(--primary-background);
-  color: var(--primary-foreground);
-}
-
-.danger {
-  background: var(--danger-background);
-  color: var(--danger-foreground);
-}
-
-.success {
-  background: var(--success-background);
-  color: var(--success-foreground);
-}
-
-.warning {
-  background: var(--warning-background);
-  color: var(--warning-foreground);
-}
-
-// Accent colors (for highlights, badges, etc.)
-.accent {
-  background: var(--accent-primary);        // robin blue
-  background: var(--accent-forest);         // green
-  background: var(--accent-cherry);         // red
-  background: var(--accent-amber);          // yellow
-}
-```
-
-**Token hierarchy:**
-- Primitive tokens (`--bg-*`, `--text-*`, etc.) have fixed values across themes.
-- Semantic tokens (L1/L2/L3, `--primary-*`, `--danger-*`, etc.) automatically swap based on theme.
-- L1 = base/root layer
-- L2 = elevated surfaces (cards, panels)
-- L3 = nested/inset elements
-
-## Overriding @signozhq/ui Components
-
-Components expose CSS variables for customization.
-
-You can ensure they exist by looking at ./node_modules/@signozhq/ui/dist.
-Never write a override without confirm it exists.
-
-Override via:
-
-### Method 1: CSS Variables (Preferred)
-
-Each component exposes `--<component>-<property>` variables:
-
-```scss
-// Override Button
-.customButton {
-  --button-background: var(--success-background);
-  --button-border-radius: var(--radius-2);
-  --button-padding: var(--spacing-4) var(--spacing-8);
-  --button-font-size: var(--periscope-font-size-base);
-}
-
-// Override Input
-.customInput {
-  --input-height: 2.5rem;
-  --input-border-color: var(--l2-border);
-  --input-padding: var(--spacing-2) var(--spacing-6);
-  --input-placeholder-color: var(--l3-foreground);
-}
-
-// Override nested parts
-.customInput {
-  --input-prefix-padding: 0 var(--spacing-4) 0 var(--spacing-6);
-  --input-suffix-color: var(--accent-primary);
-}
-```
-
-### Method 2: Data Attributes
-
-Components use data attributes for variants/states. Target them for state-specific overrides:
-
-```scss
-// Target variant
-.wrapper :global([data-variant="outlined"]) {
-  --button-border-color: var(--accent-primary);
-}
-
-// Target size
-.wrapper :global([data-size="sm"]) {
-  --button-font-size: var(--periscope-font-size-small);
-}
-
-// Target color
-.wrapper :global([data-color="destructive"]) {
-  --button-background: var(--danger-background);
-}
-
-// Target state (Radix patterns)
-.popover :global([data-state="open"]) {
-  opacity: 1;
-}
-
-.tooltip :global([data-side="top"]) {
-  margin-bottom: var(--spacing-2);
-}
-```
-
-### Common Component CSS Variables
-
-**Button:**
-- `--button-background`, `--button-border-radius`, `--button-padding`
-- `--button-font-size`, `--button-height`, `--button-gap`
-- `--button-hover-background`, `--button-disabled-opacity`
-
-**Input:**
-- `--input-height`, `--input-border-color`, `--input-background`
-- `--input-padding`, `--input-font-size`, `--input-placeholder-color`
-- `--input-focus-outline-color`, `--input-hover-border-color`
-- `--input-prefix-*`, `--input-suffix-*` for adornments
-
-**General pattern:** `--<component>-<property>` or `--<component>-<state>-<property>`
-
-## Good Patterns
-
-### Structure
-
-```scss
-// Flat, descriptive, component-scoped
-.alertHistory { }
-.alertHistoryHeader { }
-.alertHistoryContent { }
-.alertHistoryFooter { }
-
-// State modifiers as separate classes
-.alertHistory { }
-.alertHistoryLoading { }
-.alertHistoryEmpty { }
-.alertHistoryError { }
-```
-
-### Composition
-
-```scss
-// GOOD: Composing styles
-.baseButton {
-  padding: var(--spacing-2) var(--spacing-4);
-  border-radius: var(--radius-2);
-}
-
-.primaryButton {
-  composes: baseButton;
-  background: var(--primary-background);
-}
-```
-
-### Pseudo Elements
-
-```scss
-.button {
-  // States
-  &:hover { opacity: 0.9; }
-  &:focus { outline: 2px solid var(--ring); outline-offset: 2px; }
-  &:disabled { opacity: 0.5; cursor: not-allowed; }
-
-  // Pseudo elements
-  &::before { content: ''; }
-  &::after { content: ''; }
-}
-```
-
-### Media Queries
-
-```scss
-.container {
-  display: flex;
-  flex-direction: column;
-  
-  @media (min-width: 768px) {
-    flex-direction: row;
-  }
-}
-```
-
-### Keyframes (Local Scoping)
-
-Without `:local()`, keyframe names are global and can clash across modules:
-
-```scss
-// BAD: Global keyframe - can conflict with other modules
-@keyframes fadeIn {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
-// GOOD: Locally scoped keyframe
-:local(@keyframes fadeIn) {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
-.modal {
-  animation: fadeIn 200ms ease;
-}
-```
-
-## JS Import Patterns
-
-```tsx
-// GOOD
-import styles from './Component.module.scss';
-
-<div className={styles.container}>
-  <span className={styles.title}>Title</span>
-</div>
-
-// GOOD: Conditional classes
-<div className={`${styles.button} ${isActive ? styles.buttonActive : ''}`}>
-
-// GOOD: With clsx/classnames
-<div className={clsx(styles.button, { [styles.buttonActive]: isActive })}>
-
-// BAD: Bracket access (may be undefined)
-<div className={styles['button-active']}>  // undefined if CSS has .button-active
-
-// BAD: String interpolation for class names
-<div className={`${styles.button}-active`}>  // won't work
-
-// BAD: Dynamic class lookup - can't be statically analyzed
-const cls = styles[`variant${props.type}`];  // Vite can't tree-shake or type-check
-
-// GOOD: Explicit map for dynamic variants
-const variantMap = {
-  primary: styles.variantPrimary,
-  secondary: styles.variantSecondary,
-  ghost: styles.variantGhost,
-};
-const cls = variantMap[props.type];
-```
-
-## Lint Rules
-
-### JS/TS (oxlint)
-
-| Rule | Severity | Catches |
-|------|----------|---------|
-| `signoz/no-css-module-bracket-access` | warn | `styles['kebab-case']`, dynamic access |
-
-### CSS/SCSS (stylelint)
-
-| Rule | Severity | Catches |
-|------|----------|---------|
-| `local/no-deep-nesting` | warning | class nesting >3 levels (pseudo-classes/elements and parent-reference selectors `&.foo`, `&#bar` not counted; configurable via `maxDepth` secondary option) |
-| `local/no-id-selectors` | error | `#id` selectors |
-| `local/no-bare-element-selectors` | error | root-level `div`, `span` etc |
-| `local/prefer-css-variables` | warning | hardcoded colors |
-| `local/class-name-pattern` | warning | kebab-case, snake_case, PascalCase |
-
-Run: `pnpm lint:styles` to check CSS modules.

frontend/package.json

@@ -45,8 +45,8 @@
     "@dnd-kit/utilities": "3.2.2",
     "@grafana/data": "^11.6.14",
     "@monaco-editor/react": "^4.7.0",
-    "@sentry/react": "10.57.0",
-    "@sentry/vite-plugin": "5.3.0",
+    "@sentry/react": "8.41.0",
+    "@sentry/vite-plugin": "2.22.6",
     "@signozhq/design-tokens": "2.1.4",
     "@signozhq/icons": "0.4.0",
     "@signozhq/resizable": "0.0.2",
@@ -192,9 +192,9 @@
     "lint-staged": "^17.0.4",
     "msw": "1.3.2",
     "orval": "8.9.1",
-    "oxfmt": "0.54.0",
-    "oxlint": "1.69.0",
-    "oxlint-tsgolint": "0.23.0",
+    "oxfmt": "0.47.0",
+    "oxlint": "1.62.0",
+    "oxlint-tsgolint": "0.22.1",
     "postcss": "8.5.14",
     "postcss-scss": "4.0.9",
     "react-resizable": "3.0.4",

frontend/plugins/rules/no-css-module-bracket-access.mjs

@@ -1,144 +0,0 @@
-/**
- * Rule: no-css-module-bracket-access
- *
- * Prevents bracket access on CSS module imports that may fail with camelCaseOnly config.
- *
- * With Vite's `localsConvention: 'camelCaseOnly'`, kebab-case class names are
- * converted to camelCase and the original key is NOT exported.
- *
- * This rule catches patterns like:
- *   styles['my-class']     // BAD - undefined if CSS has .my-class
- *   styles['myClass']      // OK but prefer dot notation
- *   styles.myClass         // GOOD
- *
- * Catches:
- * - Bracket access with kebab-case strings (always fails)
- * - Bracket access with any string literal (warn - prefer dot notation)
- * - Dynamic bracket access (warn - risky)
- */
-
-const CSS_MODULE_IMPORT_NAMES = new Set([
-	'styles',
-	'classes',
-	'css',
-	'classNames',
-]);
-
-function looksLikeCssModuleImport(name) {
-	// Common patterns: styles, componentStyles, alertHistoryStyles
-	return (
-		CSS_MODULE_IMPORT_NAMES.has(name) ||
-		name.endsWith('Styles') ||
-		name.endsWith('Classes') ||
-		name.endsWith('Css')
-	);
-}
-
-function isKebabCase(str) {
-	return str.includes('-');
-}
-
-function isSnakeCase(str) {
-	return str.includes('_');
-}
-
-export default {
-	create(context) {
-		return {
-			MemberExpression(node) {
-				// Only check bracket notation: styles['...']
-				if (!node.computed) {
-					return;
-				}
-
-				const object = node.object;
-				if (object.type !== 'Identifier') {
-					return;
-				}
-
-				// Check if this looks like a CSS module import
-				if (!looksLikeCssModuleImport(object.name)) {
-					return;
-				}
-
-				const property = node.property;
-
-				// Dynamic access: styles[variable]
-				if (property.type === 'Identifier') {
-					context.report({
-						node,
-						message: `Dynamic CSS module access '${object.name}[${property.name}]' is risky. With 'camelCaseOnly' config, kebab-case keys don't exist. Use dot notation or verify the key exists.`,
-					});
-					return;
-				}
-
-				// Template literal: styles[\`...\`]
-				if (property.type === 'TemplateLiteral') {
-					context.report({
-						node,
-						message: `Template literal CSS module access is risky. With 'camelCaseOnly' config, kebab-case keys don't exist. Prefer dot notation.`,
-					});
-					return;
-				}
-
-				// Numeric / boolean / null literal: styles[0]. Not a class lookup; ignore.
-				if (property.type === 'Literal' && typeof property.value !== 'string') {
-					return;
-				}
-
-				// String literal: styles['...']
-				if (property.type === 'Literal' && typeof property.value === 'string') {
-					const className = property.value;
-
-					// Kebab-case will definitely fail
-					if (isKebabCase(className)) {
-						context.report({
-							node,
-							message: `CSS module class '${className}' uses kebab-case which won't work with 'camelCaseOnly' config. Use '${object.name}.${toCamelCase(className)}' instead.`,
-						});
-						return;
-					}
-
-					// Snake_case is suspicious
-					if (isSnakeCase(className)) {
-						context.report({
-							node,
-							message: `CSS module class '${className}' uses snake_case which may not work as expected. Prefer camelCase: '${object.name}.${toCamelCase(className)}'.`,
-						});
-						return;
-					}
-
-					// Valid camelCase but using bracket notation - prefer dot
-					if (/^[a-z][a-zA-Z0-9]*$/.test(className)) {
-						context.report({
-							node,
-							message: `Prefer dot notation: '${object.name}.${className}' instead of '${object.name}['${className}']'.`,
-						});
-					}
-					return;
-				}
-
-				// Catch-all for other dynamic expressions:
-				//   styles['prefix' + suffix]   (BinaryExpression)
-				//   styles[isActive && 'foo']   (LogicalExpression)
-				//   styles[isActive ? 'a' : 'b'] (ConditionalExpression)
-				//   styles[fn()]                (CallExpression)
-				context.report({
-					node,
-					message: `Dynamic CSS module access on '${object.name}' is risky. With 'camelCaseOnly' config, kebab-case keys don't exist. Use dot notation or verify each key resolves to an exported camelCase class.`,
-				});
-			},
-		};
-	},
-};
-
-function toCamelCase(str) {
-	return str
-		.split(/[-_]/)
-		.map((part, i) =>
-			i === 0
-				? part.toLowerCase()
-				: part.charAt(0).toUpperCase() + part.slice(1).toLowerCase(),
-		)
-		.join('');
-}

frontend/plugins/signoz.mjs

@@ -11,7 +11,6 @@ import noUnsupportedAssetPattern from './rules/no-unsupported-asset-pattern.mjs'
 import noRawAbsolutePath from './rules/no-raw-absolute-path.mjs';
 import noAntdComponents from './rules/no-antd-components.mjs';
 import noSignozhqUiBarrel from './rules/no-signozhq-ui-barrel.mjs';
-import noCssModuleBracketAccess from './rules/no-css-module-bracket-access.mjs';
 
 export default {
 	meta: {
@@ -24,6 +23,5 @@ export default {
 		'no-raw-absolute-path': noRawAbsolutePath,
 		'no-antd-components': noAntdComponents,
 		'no-signozhq-ui-barrel': noSignozhqUiBarrel,
-		'no-css-module-bracket-access': noCssModuleBracketAccess,
 	},
 };

frontend/src/AppRoutes/pageComponents.ts

@@ -64,17 +64,10 @@ export const TraceDetail = Loadable(
 		),
 );
 
-export const TraceDetailOldRedirect = Loadable(
-	() =>
-		import(
-			/* webpackChunkName: "TraceDetailOldRedirect" */ 'pages/TraceDetailOldRedirect/index'
-		),
-);
-
 export const TraceDetailV3 = Loadable(
 	() =>
 		import(
-			/* webpackChunkName: "TraceDetailV3 Page" */ 'pages/TraceDetailsV3/index'
+			/* webpackChunkName: "TraceDetailV3 Page" */ 'pages/TraceDetailV3Page/index'
 		),
 );
 

frontend/src/AppRoutes/routes.ts

@@ -47,7 +47,7 @@ import {
 	SomethingWentWrong,
 	StatusPage,
 	SupportPage,
-	TraceDetailOldRedirect,
+	TraceDetail,
 	TraceDetailV3,
 	TraceFilter,
 	TracesExplorer,
@@ -139,11 +139,13 @@ const routes: AppRoutes[] = [
 		exact: true,
 		key: 'LOGS_SAVE_VIEWS',
 	},
-	// Legacy /trace-old/:id redirects to the current /trace/:id view.
+	// V3 trace details is gated until release: /trace serves V2 (public),
+	// /trace-old serves V3 (URL-only access). Flip the two `component`
+	// values back to release V3.
 	{
 		path: ROUTES.TRACE_DETAIL_OLD,
 		exact: true,
-		component: TraceDetailOldRedirect,
+		component: TraceDetail,
 		isPrivate: true,
 		key: 'TRACE_DETAIL_OLD',
 	},
@@ -469,13 +471,6 @@ const routes: AppRoutes[] = [
 		key: 'METRICS_EXPLORER_VIEWS',
 		isPrivate: true,
 	},
-	{
-		path: ROUTES.METRICS_EXPLORER_VOLUME_CONTROL,
-		exact: true,
-		component: MetricsExplorer,
-		key: 'METRICS_EXPLORER_VOLUME_CONTROL',
-		isPrivate: true,
-	},
 
 	{
 		path: ROUTES.METER,

frontend/src/api/ai-assistant/chat.ts

@@ -55,9 +55,6 @@ import type {
 	ThreadDetailResponseDTO,
 	ThreadListResponseDTO,
 	ThreadSummaryDTO,
-	ChipDTO,
-	ChipsResponseDTO,
-	PageTypeDTO,
 	ToolCallEventDTO,
 	ToolResultEventDTO,
 } from './sigNozAIAssistantAPI.schemas';
@@ -544,19 +541,3 @@ export async function submitFeedback(
 		comment: comment ?? null,
 	});
 }
-
-// ---------------------------------------------------------------------------
-// Contextual empty-state chips
-// GET /api/v1/assistant/empty-state/chips?page_type=… → { chips }
-// ---------------------------------------------------------------------------
-
-export async function getEmptyStateChips(
-	pageType: PageTypeDTO,
-	signal?: AbortSignal,
-): Promise<ChipDTO[]> {
-	const response = await AIAssistantInstance.get<ChipsResponseDTO>(
-		'/empty-state/chips',
-		{ params: { page_type: pageType }, signal },
-	);
-	return response.data.chips;
-}

frontend/src/api/ai-assistant/index.ts

@@ -26,7 +26,6 @@ import type {
 	CancelApiV1AssistantCancelPostHeaders,
 	CancelRequestDTO,
 	CancelResponseDTO,
-	ChipsResponseDTO,
 	ClarifyApiV1AssistantClarifyPostHeaders,
 	ClarifyRequestDTO,
 	ClarifyResponseDTO,
@@ -40,11 +39,8 @@ import type {
 	ErrorResponseDTO,
 	FeedbackRequestDTO,
 	FeedbackResponseDTO,
-	GetChipsApiV1AssistantEmptyStateChipsGetHeaders,
-	GetChipsApiV1AssistantEmptyStateChipsGetParams,
 	GetThreadApiV1AssistantThreadsThreadIdGetHeaders,
 	GetThreadApiV1AssistantThreadsThreadIdGetPathParameters,
-	GetUsageApiV1AssistantUsageGetHeaders,
 	HTTPValidationErrorDTO,
 	HealthResponseDTO,
 	ListThreadsApiV1AssistantThreadsGetHeaders,
@@ -69,89 +65,93 @@ import type {
 	UpdateThreadApiV1AssistantThreadsThreadIdPatchHeaders,
 	UpdateThreadApiV1AssistantThreadsThreadIdPatchPathParameters,
 	UpdateThreadRequestDTO,
-	UsageResponseDTO,
 } from './sigNozAIAssistantAPI.schemas';
 
-import { GeneratedAPIInstance } from '../generatedAPIInstance';
+import {
+	GeneratedAPIInstance,
+	getGeneratedAPIQueryKeyHeaders,
+} from '../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../generatedAPIInstance';
 
 /**
- * @summary Healthz
+ * @summary Health
  */
-export const healthzHealthzGet = (signal?: AbortSignal) => {
+export const healthHealthGet = (signal?: AbortSignal) => {
 	return GeneratedAPIInstance<HealthResponseDTO>({
-		url: `/healthz`,
+		url: `/health`,
 		method: 'GET',
 		signal,
 	});
 };
 
-export const getHealthzHealthzGetQueryKey = () => {
-	return [`/healthz`] as const;
+export const getHealthHealthGetQueryKey = () => {
+	return [`/health`] as const;
 };
 
-export const getHealthzHealthzGetQueryOptions = <
-	TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+export const getHealthHealthGetQueryOptions = <
+	TData = Awaited<ReturnType<typeof healthHealthGet>>,
 	TError = ErrorType<unknown>,
 >(options?: {
 	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof healthzHealthzGet>>,
+		Awaited<ReturnType<typeof healthHealthGet>>,
 		TError,
 		TData
 	>;
 }) => {
 	const { query: queryOptions } = options ?? {};
 
-	const queryKey = queryOptions?.queryKey ?? getHealthzHealthzGetQueryKey();
+	const queryKey = queryOptions?.queryKey ?? getHealthHealthGetQueryKey();
 
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof healthzHealthzGet>>
-	> = ({ signal }) => healthzHealthzGet(signal);
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof healthHealthGet>>> = ({
+		signal,
+	}) => healthHealthGet(signal);
 
 	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof healthzHealthzGet>>,
+		Awaited<ReturnType<typeof healthHealthGet>>,
 		TError,
 		TData
 	> & { queryKey: QueryKey };
 };
 
-export type HealthzHealthzGetQueryResult = NonNullable<
-	Awaited<ReturnType<typeof healthzHealthzGet>>
+export type HealthHealthGetQueryResult = NonNullable<
+	Awaited<ReturnType<typeof healthHealthGet>>
 >;
-export type HealthzHealthzGetQueryError = ErrorType<unknown>;
+export type HealthHealthGetQueryError = ErrorType<unknown>;
 
 /**
- * @summary Healthz
+ * @summary Health
  */
 
-export function useHealthzHealthzGet<
-	TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+export function useHealthHealthGet<
+	TData = Awaited<ReturnType<typeof healthHealthGet>>,
 	TError = ErrorType<unknown>,
 >(options?: {
 	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof healthzHealthzGet>>,
+		Awaited<ReturnType<typeof healthHealthGet>>,
 		TError,
 		TData
 	>;
 }): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getHealthzHealthzGetQueryOptions(options);
+	const queryOptions = getHealthHealthGetQueryOptions(options);
 
 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
- * @summary Healthz
+ * @summary Health
  */
-export const invalidateHealthzHealthzGet = async (
+export const invalidateHealthHealthGet = async (
 	queryClient: QueryClient,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getHealthzHealthzGetQueryKey() },
+		{ queryKey: getHealthHealthGetQueryKey() },
 		options,
 	);
 
@@ -159,82 +159,84 @@ export const invalidateHealthzHealthzGet = async (
 };
 
 /**
- * @summary Readyz
+ * @summary Ready
  */
-export const readyzReadyzGet = (signal?: AbortSignal) => {
+export const readyReadyGet = (signal?: AbortSignal) => {
 	return GeneratedAPIInstance<ReadinessResponseDTO>({
-		url: `/readyz`,
+		url: `/ready`,
 		method: 'GET',
 		signal,
 	});
 };
 
-export const getReadyzReadyzGetQueryKey = () => {
-	return [`/readyz`] as const;
+export const getReadyReadyGetQueryKey = () => {
+	return [`/ready`] as const;
 };
 
-export const getReadyzReadyzGetQueryOptions = <
-	TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+export const getReadyReadyGetQueryOptions = <
+	TData = Awaited<ReturnType<typeof readyReadyGet>>,
 	TError = ErrorType<ReadinessResponseDTO>,
 >(options?: {
 	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof readyzReadyzGet>>,
+		Awaited<ReturnType<typeof readyReadyGet>>,
 		TError,
 		TData
 	>;
 }) => {
 	const { query: queryOptions } = options ?? {};
 
-	const queryKey = queryOptions?.queryKey ?? getReadyzReadyzGetQueryKey();
+	const queryKey = queryOptions?.queryKey ?? getReadyReadyGetQueryKey();
 
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof readyzReadyzGet>>> = ({
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof readyReadyGet>>> = ({
 		signal,
-	}) => readyzReadyzGet(signal);
+	}) => readyReadyGet(signal);
 
 	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof readyzReadyzGet>>,
+		Awaited<ReturnType<typeof readyReadyGet>>,
 		TError,
 		TData
 	> & { queryKey: QueryKey };
 };
 
-export type ReadyzReadyzGetQueryResult = NonNullable<
-	Awaited<ReturnType<typeof readyzReadyzGet>>
+export type ReadyReadyGetQueryResult = NonNullable<
+	Awaited<ReturnType<typeof readyReadyGet>>
 >;
-export type ReadyzReadyzGetQueryError = ErrorType<ReadinessResponseDTO>;
+export type ReadyReadyGetQueryError = ErrorType<ReadinessResponseDTO>;
 
 /**
- * @summary Readyz
+ * @summary Ready
  */
 
-export function useReadyzReadyzGet<
-	TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+export function useReadyReadyGet<
+	TData = Awaited<ReturnType<typeof readyReadyGet>>,
 	TError = ErrorType<ReadinessResponseDTO>,
 >(options?: {
 	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof readyzReadyzGet>>,
+		Awaited<ReturnType<typeof readyReadyGet>>,
 		TError,
 		TData
 	>;
 }): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getReadyzReadyzGetQueryOptions(options);
+	const queryOptions = getReadyReadyGetQueryOptions(options);
 
 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
- * @summary Readyz
+ * @summary Ready
  */
-export const invalidateReadyzReadyzGet = async (
+export const invalidateReadyReadyGet = async (
 	queryClient: QueryClient,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getReadyzReadyzGetQueryKey() },
+		{ queryKey: getReadyReadyGetQueryKey() },
 		options,
 	);
 
@@ -245,7 +247,7 @@ export const invalidateReadyzReadyzGet = async (
  * @summary Create a new thread
  */
 export const createThreadApiV1AssistantThreadsPost = (
-	createThreadApiV1AssistantThreadsPostBody?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>,
+	createThreadApiV1AssistantThreadsPostBody: BodyType<CreateThreadApiV1AssistantThreadsPostBody>,
 	headers?: CreateThreadApiV1AssistantThreadsPostHeaders,
 	signal?: AbortSignal,
 ) => {
@@ -266,7 +268,7 @@ export const getCreateThreadApiV1AssistantThreadsPostMutationOptions = <
 		Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>,
 		TError,
 		{
-			data?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
+			data: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 			headers?: CreateThreadApiV1AssistantThreadsPostHeaders;
 		},
 		TContext
@@ -275,7 +277,7 @@ export const getCreateThreadApiV1AssistantThreadsPostMutationOptions = <
 	Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>,
 	TError,
 	{
-		data?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
+		data: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 		headers?: CreateThreadApiV1AssistantThreadsPostHeaders;
 	},
 	TContext
@@ -292,7 +294,7 @@ export const getCreateThreadApiV1AssistantThreadsPostMutationOptions = <
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>,
 		{
-			data?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
+			data: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 			headers?: CreateThreadApiV1AssistantThreadsPostHeaders;
 		}
 	> = (props) => {
@@ -308,8 +310,7 @@ export type CreateThreadApiV1AssistantThreadsPostMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>
 >;
 export type CreateThreadApiV1AssistantThreadsPostMutationBody =
-	| BodyType<CreateThreadApiV1AssistantThreadsPostBody>
-	| undefined;
+	BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 export type CreateThreadApiV1AssistantThreadsPostMutationError = ErrorType<
 	ErrorResponseDTO | HTTPValidationErrorDTO
 >;
@@ -325,7 +326,7 @@ export const useCreateThreadApiV1AssistantThreadsPost = <
 		Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>,
 		TError,
 		{
-			data?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
+			data: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 			headers?: CreateThreadApiV1AssistantThreadsPostHeaders;
 		},
 		TContext
@@ -334,14 +335,15 @@ export const useCreateThreadApiV1AssistantThreadsPost = <
 	Awaited<ReturnType<typeof createThreadApiV1AssistantThreadsPost>>,
 	TError,
 	{
-		data?: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
+		data: BodyType<CreateThreadApiV1AssistantThreadsPostBody>;
 		headers?: CreateThreadApiV1AssistantThreadsPostHeaders;
 	},
 	TContext
 > => {
-	return useMutation(
-		getCreateThreadApiV1AssistantThreadsPostMutationOptions(options),
-	);
+	const mutationOptions =
+		getCreateThreadApiV1AssistantThreadsPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Cursor-based pagination, sorted by updatedAt desc. Use `archived=true|false|all` to filter.
@@ -363,8 +365,13 @@ export const listThreadsApiV1AssistantThreadsGet = (
 
 export const getListThreadsApiV1AssistantThreadsGetQueryKey = (
 	params?: ListThreadsApiV1AssistantThreadsGetParams,
+	headers?: ListThreadsApiV1AssistantThreadsGetHeaders,
 ) => {
-	return [`/api/v1/assistant/threads`, ...(params ? [params] : [])] as const;
+	return [
+		`/api/v1/assistant/threads`,
+		...(params ? [params] : []),
+		...getGeneratedAPIQueryKeyHeaders(headers),
+	] as const;
 };
 
 export const getListThreadsApiV1AssistantThreadsGetQueryOptions = <
@@ -385,7 +392,7 @@ export const getListThreadsApiV1AssistantThreadsGetQueryOptions = <
 
 	const queryKey =
 		queryOptions?.queryKey ??
-		getListThreadsApiV1AssistantThreadsGetQueryKey(params);
+		getListThreadsApiV1AssistantThreadsGetQueryKey(params, headers);
 
 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof listThreadsApiV1AssistantThreadsGet>>
@@ -434,7 +441,9 @@ export function useListThreadsApiV1AssistantThreadsGet<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -447,7 +456,7 @@ export const invalidateListThreadsApiV1AssistantThreadsGet = async (
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getListThreadsApiV1AssistantThreadsGetQueryKey(params) },
+		{ queryKey: getListThreadsApiV1AssistantThreadsGetQueryKey(params, headers) },
 		options,
 	);
 
@@ -471,10 +480,14 @@ export const getThreadApiV1AssistantThreadsThreadIdGet = (
 	});
 };
 
-export const getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey = ({
-	threadId,
-}: GetThreadApiV1AssistantThreadsThreadIdGetPathParameters) => {
-	return [`/api/v1/assistant/threads/${threadId}`] as const;
+export const getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey = (
+	{ threadId }: GetThreadApiV1AssistantThreadsThreadIdGetPathParameters,
+	headers?: GetThreadApiV1AssistantThreadsThreadIdGetHeaders,
+) => {
+	return [
+		`/api/v1/assistant/threads/${threadId}`,
+		...getGeneratedAPIQueryKeyHeaders(headers),
+	] as const;
 };
 
 export const getGetThreadApiV1AssistantThreadsThreadIdGetQueryOptions = <
@@ -495,7 +508,7 @@ export const getGetThreadApiV1AssistantThreadsThreadIdGetQueryOptions = <
 
 	const queryKey =
 		queryOptions?.queryKey ??
-		getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey({ threadId });
+		getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey({ threadId }, headers);
 
 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof getThreadApiV1AssistantThreadsThreadIdGet>>
@@ -549,7 +562,9 @@ export function useGetThreadApiV1AssistantThreadsThreadIdGet<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -563,7 +578,10 @@ export const invalidateGetThreadApiV1AssistantThreadsThreadIdGet = async (
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
 		{
-			queryKey: getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey({ threadId }),
+			queryKey: getGetThreadApiV1AssistantThreadsThreadIdGetQueryKey(
+				{ threadId },
+				headers,
+			),
 		},
 		options,
 	);
@@ -578,14 +596,12 @@ export const updateThreadApiV1AssistantThreadsThreadIdPatch = (
 	{ threadId }: UpdateThreadApiV1AssistantThreadsThreadIdPatchPathParameters,
 	updateThreadRequestDTO: BodyType<UpdateThreadRequestDTO>,
 	headers?: UpdateThreadApiV1AssistantThreadsThreadIdPatchHeaders,
-	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ThreadSummaryDTO>({
 		url: `/api/v1/assistant/threads/${threadId}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json', ...headers },
 		data: updateThreadRequestDTO,
-		signal,
 	});
 };
 
@@ -679,9 +695,10 @@ export const useUpdateThreadApiV1AssistantThreadsThreadIdPatch = <
 	},
 	TContext
 > => {
-	return useMutation(
-		getUpdateThreadApiV1AssistantThreadsThreadIdPatchMutationOptions(options),
-	);
+	const mutationOptions =
+		getUpdateThreadApiV1AssistantThreadsThreadIdPatchMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Persists the user message, creates an execution (state: queued), kicks off the agent loop asynchronously, and returns immediately. Open `GET /executions/{executionId}/events` for the SSE stream.
@@ -808,11 +825,12 @@ export const useCreateMessageApiV1AssistantThreadsThreadIdMessagesPost = <
 	},
 	TContext
 > => {
-	return useMutation(
+	const mutationOptions =
 		getCreateMessageApiV1AssistantThreadsThreadIdMessagesPostMutationOptions(
 			options,
-		),
-	);
+		);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Clean-slate regeneration. Starts a fresh execution with conversation history up to (excluding) the original assistant response.
@@ -943,11 +961,12 @@ export const useRegenerateMessageApiV1AssistantMessagesMessageIdRegeneratePost =
 		},
 		TContext
 	> => {
-		return useMutation(
+		const mutationOptions =
 			getRegenerateMessageApiV1AssistantMessagesMessageIdRegeneratePostMutationOptions(
 				options,
-			),
-		);
+			);
+
+		return useMutation(mutationOptions);
 	};
 /**
  * Triggers a replay execution that runs the stored tool call with exact params. Returns a new executionId — open SSE for that execution.
@@ -1047,9 +1066,10 @@ export const useApproveApiV1AssistantApprovePost = <
 	},
 	TContext
 > => {
-	return useMutation(
-		getApproveApiV1AssistantApprovePostMutationOptions(options),
-	);
+	const mutationOptions =
+		getApproveApiV1AssistantApprovePostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Marks the approval as rejected. The execution completes with no tool execution.
@@ -1149,7 +1169,10 @@ export const useRejectApiV1AssistantRejectPost = <
 	},
 	TContext
 > => {
-	return useMutation(getRejectApiV1AssistantRejectPostMutationOptions(options));
+	const mutationOptions =
+		getRejectApiV1AssistantRejectPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Provides structured answers to a clarification request. Persists the answers as a user transcript message, emits `user_message` as the first replayable event on the new execution stream, and resumes the agent with the answers as tool results.
@@ -1249,9 +1272,10 @@ export const useClarifyApiV1AssistantClarifyPost = <
 	},
 	TContext
 > => {
-	return useMutation(
-		getClarifyApiV1AssistantClarifyPostMutationOptions(options),
-	);
+	const mutationOptions =
+		getClarifyApiV1AssistantClarifyPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Cooperative cancel. The agent loop finishes its current step, emits a truncated message if streaming, and transitions to canceled.
@@ -1351,7 +1375,10 @@ export const useCancelApiV1AssistantCancelPost = <
 	},
 	TContext
 > => {
-	return useMutation(getCancelApiV1AssistantCancelPostMutationOptions(options));
+	const mutationOptions =
+		getCancelApiV1AssistantCancelPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Deletes the resource that was created by the assistant.
@@ -1450,7 +1477,9 @@ export const useUndoApiV1AssistantUndoPost = <
 	},
 	TContext
 > => {
-	return useMutation(getUndoApiV1AssistantUndoPostMutationOptions(options));
+	const mutationOptions = getUndoApiV1AssistantUndoPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Rolls back the resource to its pre-change snapshot.
@@ -1550,7 +1579,10 @@ export const useRevertApiV1AssistantRevertPost = <
 	},
 	TContext
 > => {
-	return useMutation(getRevertApiV1AssistantRevertPostMutationOptions(options));
+	const mutationOptions =
+		getRevertApiV1AssistantRevertPostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Recreates the resource from its pre-delete snapshot.
@@ -1650,9 +1682,10 @@ export const useRestoreApiV1AssistantRestorePost = <
 	},
 	TContext
 > => {
-	return useMutation(
-		getRestoreApiV1AssistantRestorePostMutationOptions(options),
-	);
+	const mutationOptions =
+		getRestoreApiV1AssistantRestorePostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * @summary Submit feedback on an assistant message
@@ -1778,221 +1811,10 @@ export const useSubmitFeedbackApiV1AssistantMessagesMessageIdFeedbackPost = <
 	},
 	TContext
 > => {
-	return useMutation(
+	const mutationOptions =
 		getSubmitFeedbackApiV1AssistantMessagesMessageIdFeedbackPostMutationOptions(
 			options,
-		),
-	);
-};
-/**
- * @summary Current rate-limit usage for the authenticated user + org
- */
-export const getUsageApiV1AssistantUsageGet = (
-	headers?: GetUsageApiV1AssistantUsageGetHeaders,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UsageResponseDTO>({
-		url: `/api/v1/assistant/usage`,
-		method: 'GET',
-		headers,
-		signal,
-	});
-};
-
-export const getGetUsageApiV1AssistantUsageGetQueryKey = () => {
-	return [`/api/v1/assistant/usage`] as const;
-};
-
-export const getGetUsageApiV1AssistantUsageGetQueryOptions = <
-	TData = Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>,
-	TError = ErrorType<ErrorResponseDTO | HTTPValidationErrorDTO>,
->(
-	headers?: GetUsageApiV1AssistantUsageGetHeaders,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetUsageApiV1AssistantUsageGetQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>
-	> = ({ signal }) => getUsageApiV1AssistantUsageGet(headers, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetUsageApiV1AssistantUsageGetQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>
->;
-export type GetUsageApiV1AssistantUsageGetQueryError = ErrorType<
-	ErrorResponseDTO | HTTPValidationErrorDTO
->;
-
-/**
- * @summary Current rate-limit usage for the authenticated user + org
- */
-
-export function useGetUsageApiV1AssistantUsageGet<
-	TData = Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>,
-	TError = ErrorType<ErrorResponseDTO | HTTPValidationErrorDTO>,
->(
-	headers?: GetUsageApiV1AssistantUsageGetHeaders,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getUsageApiV1AssistantUsageGet>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetUsageApiV1AssistantUsageGetQueryOptions(
-		headers,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Current rate-limit usage for the authenticated user + org
- */
-export const invalidateGetUsageApiV1AssistantUsageGet = async (
-	queryClient: QueryClient,
-	headers?: GetUsageApiV1AssistantUsageGetHeaders,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetUsageApiV1AssistantUsageGetQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * @summary Contextual empty-state chips
- */
-export const getChipsApiV1AssistantEmptyStateChipsGet = (
-	params: GetChipsApiV1AssistantEmptyStateChipsGetParams,
-	headers?: GetChipsApiV1AssistantEmptyStateChipsGetHeaders,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ChipsResponseDTO>({
-		url: `/api/v1/assistant/empty-state/chips`,
-		method: 'GET',
-		headers,
-		params,
-		signal,
-	});
-};
-
-export const getGetChipsApiV1AssistantEmptyStateChipsGetQueryKey = (
-	params?: GetChipsApiV1AssistantEmptyStateChipsGetParams,
-) => {
-	return [
-		`/api/v1/assistant/empty-state/chips`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetChipsApiV1AssistantEmptyStateChipsGetQueryOptions = <
-	TData = Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>,
-	TError = ErrorType<ErrorResponseDTO | HTTPValidationErrorDTO>,
->(
-	params: GetChipsApiV1AssistantEmptyStateChipsGetParams,
-	headers?: GetChipsApiV1AssistantEmptyStateChipsGetHeaders,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ??
-		getGetChipsApiV1AssistantEmptyStateChipsGetQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>
-	> = ({ signal }) =>
-		getChipsApiV1AssistantEmptyStateChipsGet(params, headers, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetChipsApiV1AssistantEmptyStateChipsGetQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>
->;
-export type GetChipsApiV1AssistantEmptyStateChipsGetQueryError = ErrorType<
-	ErrorResponseDTO | HTTPValidationErrorDTO
->;
-
-/**
- * @summary Contextual empty-state chips
- */
-
-export function useGetChipsApiV1AssistantEmptyStateChipsGet<
-	TData = Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>,
-	TError = ErrorType<ErrorResponseDTO | HTTPValidationErrorDTO>,
->(
-	params: GetChipsApiV1AssistantEmptyStateChipsGetParams,
-	headers?: GetChipsApiV1AssistantEmptyStateChipsGetHeaders,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getChipsApiV1AssistantEmptyStateChipsGet>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetChipsApiV1AssistantEmptyStateChipsGetQueryOptions(
-		params,
-		headers,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Contextual empty-state chips
- */
-export const invalidateGetChipsApiV1AssistantEmptyStateChipsGet = async (
-	queryClient: QueryClient,
-	params: GetChipsApiV1AssistantEmptyStateChipsGetParams,
-	headers?: GetChipsApiV1AssistantEmptyStateChipsGetHeaders,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetChipsApiV1AssistantEmptyStateChipsGetQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
+		);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/dashboard/index.ts

@@ -18,20 +18,15 @@ import type {
 } from 'react-query';
 
 import type {
-	CloneDashboardV2201,
-	CloneDashboardV2PathParameters,
 	CreateDashboardV2201,
-	CreateDashboardView201,
 	CreatePublicDashboard201,
 	CreatePublicDashboardPathParameters,
 	DashboardtypesPatchableDashboardV2DTO,
 	DashboardtypesPostableDashboardV2DTO,
-	DashboardtypesPostableDashboardViewDTO,
 	DashboardtypesPostablePublicDashboardDTO,
 	DashboardtypesUpdatableDashboardV2DTO,
 	DashboardtypesUpdatablePublicDashboardDTO,
 	DeleteDashboardV2PathParameters,
-	DeleteDashboardViewPathParameters,
 	DeletePublicDashboardPathParameters,
 	GetDashboardV2200,
 	GetDashboardV2PathParameters,
@@ -41,7 +36,6 @@ import type {
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	ListDashboardViews200,
 	ListDashboardsForUserV2200,
 	ListDashboardsForUserV2Params,
 	ListDashboardsV2200,
@@ -55,8 +49,6 @@ import type {
 	UnpinDashboardV2PathParameters,
 	UpdateDashboardV2200,
 	UpdateDashboardV2PathParameters,
-	UpdateDashboardView200,
-	UpdateDashboardViewPathParameters,
 	UpdatePublicDashboardPathParameters,
 } from '../sigNoz.schemas';
 
@@ -71,7 +63,7 @@ export const deletePublicDashboard = (
 	{ id }: DeletePublicDashboardPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'DELETE',
 		signal,
@@ -354,7 +346,7 @@ export const updatePublicDashboard = (
 	dashboardtypesUpdatablePublicDashboardDTO?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -656,354 +648,6 @@ export const invalidateGetPublicDashboardWidgetQueryRange = async (
 	return queryClient;
 };
 
-/**
- * Returns every saved view in the calling user's org. Saved views are shared org-wide.
- * @summary List dashboard saved views
- */
-export const listDashboardViews = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListDashboardViews200>({
-		url: `/api/v2/dashboard_views`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListDashboardViewsQueryKey = () => {
-	return [`/api/v2/dashboard_views`] as const;
-};
-
-export const getListDashboardViewsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listDashboardViews>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardViews>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListDashboardViewsQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listDashboardViews>>
-	> = ({ signal }) => listDashboardViews(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardViews>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDashboardViewsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDashboardViews>>
->;
-export type ListDashboardViewsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List dashboard saved views
- */
-
-export function useListDashboardViews<
-	TData = Awaited<ReturnType<typeof listDashboardViews>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardViews>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDashboardViewsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List dashboard saved views
- */
-export const invalidateListDashboardViews = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDashboardViewsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Persists the calling user's dashboard listing state (query, sort, order) as a named, reusable view shared across the org.
- * @summary Create dashboard saved view
- */
-export const createDashboardView = (
-	dashboardtypesPostableDashboardViewDTO?: BodyType<DashboardtypesPostableDashboardViewDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateDashboardView201>({
-		url: `/api/v2/dashboard_views`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardViewDTO,
-		signal,
-	});
-};
-
-export const getCreateDashboardViewMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardView>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardViewDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createDashboardView>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardViewDTO> },
-	TContext
-> => {
-	const mutationKey = ['createDashboardView'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createDashboardView>>,
-		{ data?: BodyType<DashboardtypesPostableDashboardViewDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createDashboardView(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateDashboardViewMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createDashboardView>>
->;
-export type CreateDashboardViewMutationBody =
-	| BodyType<DashboardtypesPostableDashboardViewDTO>
-	| undefined;
-export type CreateDashboardViewMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create dashboard saved view
- */
-export const useCreateDashboardView = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardView>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardViewDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createDashboardView>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardViewDTO> },
-	TContext
-> => {
-	return useMutation(getCreateDashboardViewMutationOptions(options));
-};
-/**
- * Removes a saved view. Saved views are shared org-wide. Deleting a non-existent view returns 404.
- * @summary Delete dashboard saved view
- */
-export const deleteDashboardView = (
-	{ id }: DeleteDashboardViewPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v2/dashboard_views/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteDashboardViewMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardView>>,
-		TError,
-		{ pathParams: DeleteDashboardViewPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteDashboardView>>,
-	TError,
-	{ pathParams: DeleteDashboardViewPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteDashboardView'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteDashboardView>>,
-		{ pathParams: DeleteDashboardViewPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteDashboardView(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteDashboardViewMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteDashboardView>>
->;
-
-export type DeleteDashboardViewMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete dashboard saved view
- */
-export const useDeleteDashboardView = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardView>>,
-		TError,
-		{ pathParams: DeleteDashboardViewPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteDashboardView>>,
-	TError,
-	{ pathParams: DeleteDashboardViewPathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteDashboardViewMutationOptions(options));
-};
-/**
- * Replaces a saved view's name and data. Saved views are shared org-wide.
- * @summary Update dashboard saved view
- */
-export const updateDashboardView = (
-	{ id }: UpdateDashboardViewPathParameters,
-	dashboardtypesPostableDashboardViewDTO?: BodyType<DashboardtypesPostableDashboardViewDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UpdateDashboardView200>({
-		url: `/api/v2/dashboard_views/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardViewDTO,
-		signal,
-	});
-};
-
-export const getUpdateDashboardViewMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardView>>,
-		TError,
-		{
-			pathParams: UpdateDashboardViewPathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardViewDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateDashboardView>>,
-	TError,
-	{
-		pathParams: UpdateDashboardViewPathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardViewDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateDashboardView'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updateDashboardView>>,
-		{
-			pathParams: UpdateDashboardViewPathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardViewDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateDashboardView(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateDashboardViewMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateDashboardView>>
->;
-export type UpdateDashboardViewMutationBody =
-	| BodyType<DashboardtypesPostableDashboardViewDTO>
-	| undefined;
-export type UpdateDashboardViewMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update dashboard saved view
- */
-export const useUpdateDashboardView = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardView>>,
-		TError,
-		{
-			pathParams: UpdateDashboardViewPathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardViewDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateDashboardView>>,
-	TError,
-	{
-		pathParams: UpdateDashboardViewPathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardViewDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpdateDashboardViewMutationOptions(options));
-};
 /**
  * Returns a page of v2-shape dashboards for the org. This is the pure, user-independent list — it carries no pin state. Use ListDashboardsForUserV2 for the personalized, pin-aware list. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`name`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`).
  * @summary List dashboards (v2)
@@ -1192,7 +836,7 @@ export const deleteDashboardV2 = (
 	{ id }: DeleteDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}`,
 		method: 'DELETE',
 		signal,
@@ -1562,85 +1206,6 @@ export const useUpdateDashboardV2 = <
 > => {
 	return useMutation(getUpdateDashboardV2MutationOptions(options));
 };
-/**
- * This endpoint clones an existing v2-shape dashboard. User and integration dashboards can be cloned; system dashboards are rejected. The clone keeps the source's display name, panels, and tags, but gets a freshly generated unique internal name and is always created as an unlocked user dashboard owned by the caller.
- * @summary Clone dashboard (v2)
- */
-export const cloneDashboardV2 = (
-	{ id }: CloneDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CloneDashboardV2201>({
-		url: `/api/v2/dashboards/${id}/clone`,
-		method: 'POST',
-		signal,
-	});
-};
-
-export const getCloneDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof cloneDashboardV2>>,
-		TError,
-		{ pathParams: CloneDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof cloneDashboardV2>>,
-	TError,
-	{ pathParams: CloneDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['cloneDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof cloneDashboardV2>>,
-		{ pathParams: CloneDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return cloneDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CloneDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof cloneDashboardV2>>
->;
-
-export type CloneDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Clone dashboard (v2)
- */
-export const useCloneDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof cloneDashboardV2>>,
-		TError,
-		{ pathParams: CloneDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof cloneDashboardV2>>,
-	TError,
-	{ pathParams: CloneDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getCloneDashboardV2MutationOptions(options));
-};
 /**
  * This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
  * @summary Unlock dashboard (v2)
@@ -1649,7 +1214,7 @@ export const unlockDashboardV2 = (
 	{ id }: UnlockDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}/lock`,
 		method: 'DELETE',
 		signal,
@@ -1728,7 +1293,7 @@ export const lockDashboardV2 = (
 	{ id }: LockDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}/lock`,
 		method: 'PUT',
 		signal,
@@ -1906,7 +1471,7 @@ export const unpinDashboardV2 = (
 	{ id }: UnpinDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/users/me/dashboards/${id}/pins`,
 		method: 'DELETE',
 		signal,
@@ -1985,7 +1550,7 @@ export const pinDashboardV2 = (
 	{ id }: PinDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/users/me/dashboards/${id}/pins`,
 		method: 'PUT',
 		signal,

frontend/src/api/generated/services/logs/index.ts

@@ -37,7 +37,7 @@ export const handleExportRawDataPOST = (
 	params?: HandleExportRawDataPOSTParams,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/export_raw_data`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/metrics/index.ts

@@ -18,7 +18,6 @@ import type {
 } from 'react-query';
 
 import type {
-	DeleteMetricReductionRulePathParameters,
 	GetMetricAlerts200,
 	GetMetricAlertsPathParameters,
 	GetMetricAttributes200,
@@ -30,27 +29,18 @@ import type {
 	GetMetricHighlightsPathParameters,
 	GetMetricMetadata200,
 	GetMetricMetadataPathParameters,
-	GetMetricReductionRule200,
-	GetMetricReductionRulePathParameters,
 	GetMetricsOnboardingStatus200,
 	GetMetricsStats200,
 	GetMetricsTreemap200,
 	InspectMetrics200,
-	ListMetricReductionRules200,
-	ListMetricReductionRulesParams,
 	ListMetrics200,
 	ListMetricsParams,
-	MetricreductionruletypesPostableReductionRuleDTO,
-	MetricreductionruletypesPostableReductionRulePreviewDTO,
 	MetricsexplorertypesInspectMetricsRequestDTO,
 	MetricsexplorertypesStatsRequestDTO,
 	MetricsexplorertypesTreemapRequestDTO,
 	MetricsexplorertypesUpdateMetricMetadataRequestDTO,
-	PreviewMetricReductionRule200,
 	RenderErrorResponseDTO,
 	UpdateMetricMetadataPathParameters,
-	UpsertMetricReductionRule200,
-	UpsertMetricReductionRulePathParameters,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
@@ -690,7 +680,7 @@ export const updateMetricMetadata = (
 	metricsexplorertypesUpdateMetricMetadataRequestDTO?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/metrics/${metricName}/metadata`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
@@ -781,292 +771,6 @@ export const useUpdateMetricMetadata = <
 > => {
 	return useMutation(getUpdateMetricMetadataMutationOptions(options));
 };
-/**
- * Removes the volume-control (label reduction) rule for a specified metric, reverting it to full fidelity. Admin only; enterprise feature.
- * @summary Delete a metric reduction rule
- */
-export const deleteMetricReductionRule = (
-	{ metricName }: DeleteMetricReductionRulePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v2/metrics/${metricName}/reduction_rule`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteMetricReductionRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMetricReductionRule>>,
-		TError,
-		{ pathParams: DeleteMetricReductionRulePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMetricReductionRule>>,
-	TError,
-	{ pathParams: DeleteMetricReductionRulePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMetricReductionRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteMetricReductionRule>>,
-		{ pathParams: DeleteMetricReductionRulePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMetricReductionRule(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMetricReductionRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMetricReductionRule>>
->;
-
-export type DeleteMetricReductionRuleMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a metric reduction rule
- */
-export const useDeleteMetricReductionRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMetricReductionRule>>,
-		TError,
-		{ pathParams: DeleteMetricReductionRulePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMetricReductionRule>>,
-	TError,
-	{ pathParams: DeleteMetricReductionRulePathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteMetricReductionRuleMutationOptions(options));
-};
-/**
- * Returns the active volume-control (label reduction) rule for a specified metric. Enterprise feature.
- * @summary Get a metric reduction rule
- */
-export const getMetricReductionRule = (
-	{ metricName }: GetMetricReductionRulePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetMetricReductionRule200>({
-		url: `/api/v2/metrics/${metricName}/reduction_rule`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricReductionRuleQueryKey = ({
-	metricName,
-}: GetMetricReductionRulePathParameters) => {
-	return [`/api/v2/metrics/${metricName}/reduction_rule`] as const;
-};
-
-export const getGetMetricReductionRuleQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricReductionRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ metricName }: GetMetricReductionRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricReductionRule>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricReductionRuleQueryKey({ metricName });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricReductionRule>>
-	> = ({ signal }) => getMetricReductionRule({ metricName }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRule>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricReductionRuleQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricReductionRule>>
->;
-export type GetMetricReductionRuleQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a metric reduction rule
- */
-
-export function useGetMetricReductionRule<
-	TData = Awaited<ReturnType<typeof getMetricReductionRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ metricName }: GetMetricReductionRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricReductionRule>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricReductionRuleQueryOptions(
-		{ metricName },
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get a metric reduction rule
- */
-export const invalidateGetMetricReductionRule = async (
-	queryClient: QueryClient,
-	{ metricName }: GetMetricReductionRulePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricReductionRuleQueryKey({ metricName }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates or updates the volume-control (label reduction) rule for a specified metric. The rule takes effect after a short activation delay. Admin only; enterprise feature.
- * @summary Create or update a metric reduction rule
- */
-export const upsertMetricReductionRule = (
-	{ metricName }: UpsertMetricReductionRulePathParameters,
-	metricreductionruletypesPostableReductionRuleDTO?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UpsertMetricReductionRule200>({
-		url: `/api/v2/metrics/${metricName}/reduction_rule`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: metricreductionruletypesPostableReductionRuleDTO,
-		signal,
-	});
-};
-
-export const getUpsertMetricReductionRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof upsertMetricReductionRule>>,
-		TError,
-		{
-			pathParams: UpsertMetricReductionRulePathParameters;
-			data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof upsertMetricReductionRule>>,
-	TError,
-	{
-		pathParams: UpsertMetricReductionRulePathParameters;
-		data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['upsertMetricReductionRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof upsertMetricReductionRule>>,
-		{
-			pathParams: UpsertMetricReductionRulePathParameters;
-			data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return upsertMetricReductionRule(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpsertMetricReductionRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof upsertMetricReductionRule>>
->;
-export type UpsertMetricReductionRuleMutationBody =
-	| BodyType<MetricreductionruletypesPostableReductionRuleDTO>
-	| undefined;
-export type UpsertMetricReductionRuleMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create or update a metric reduction rule
- */
-export const useUpsertMetricReductionRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof upsertMetricReductionRule>>,
-		TError,
-		{
-			pathParams: UpsertMetricReductionRulePathParameters;
-			data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof upsertMetricReductionRule>>,
-	TError,
-	{
-		pathParams: UpsertMetricReductionRulePathParameters;
-		data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpsertMetricReductionRuleMutationOptions(options));
-};
 /**
  * Returns raw time series data points for a metric within a time range (max 30 minutes). Each series includes labels and timestamp/value pairs.
  * @summary Inspect raw metric data points
@@ -1236,192 +940,6 @@ export const invalidateGetMetricsOnboardingStatus = async (
 	return queryClient;
 };
 
-/**
- * Returns active metric volume-control (label reduction) rules, sorted and paginated server-side. Enterprise feature.
- * @summary List metric reduction rules
- */
-export const listMetricReductionRules = (
-	params?: ListMetricReductionRulesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListMetricReductionRules200>({
-		url: `/api/v2/metrics/reduction_rules`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListMetricReductionRulesQueryKey = (
-	params?: ListMetricReductionRulesParams,
-) => {
-	return [
-		`/api/v2/metrics/reduction_rules`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getListMetricReductionRulesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listMetricReductionRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListMetricReductionRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMetricReductionRules>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListMetricReductionRulesQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listMetricReductionRules>>
-	> = ({ signal }) => listMetricReductionRules(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listMetricReductionRules>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListMetricReductionRulesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listMetricReductionRules>>
->;
-export type ListMetricReductionRulesQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List metric reduction rules
- */
-
-export function useListMetricReductionRules<
-	TData = Awaited<ReturnType<typeof listMetricReductionRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListMetricReductionRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMetricReductionRules>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListMetricReductionRulesQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List metric reduction rules
- */
-export const invalidateListMetricReductionRules = async (
-	queryClient: QueryClient,
-	params?: ListMetricReductionRulesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListMetricReductionRulesQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Estimates the series reduction and related-asset impact of a candidate volume-control rule without persisting it. Enterprise feature.
- * @summary Preview a metric reduction rule
- */
-export const previewMetricReductionRule = (
-	metricreductionruletypesPostableReductionRulePreviewDTO?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PreviewMetricReductionRule200>({
-		url: `/api/v2/metrics/reduction_rules/preview`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: metricreductionruletypesPostableReductionRulePreviewDTO,
-		signal,
-	});
-};
-
-export const getPreviewMetricReductionRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof previewMetricReductionRule>>,
-		TError,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof previewMetricReductionRule>>,
-	TError,
-	{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
-	TContext
-> => {
-	const mutationKey = ['previewMetricReductionRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof previewMetricReductionRule>>,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return previewMetricReductionRule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PreviewMetricReductionRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof previewMetricReductionRule>>
->;
-export type PreviewMetricReductionRuleMutationBody =
-	| BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO>
-	| undefined;
-export type PreviewMetricReductionRuleMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Preview a metric reduction rule
- */
-export const usePreviewMetricReductionRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof previewMetricReductionRule>>,
-		TError,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof previewMetricReductionRule>>,
-	TError,
-	{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
-	TContext
-> => {
-	return useMutation(getPreviewMetricReductionRuleMutationOptions(options));
-};
 /**
  * This endpoint provides list of metrics with their number of samples and timeseries for the given time range
  * @summary Get metrics statistics

frontend/src/api/generated/services/role/index.ts

@@ -203,7 +203,7 @@ export const deleteRole = (
 	{ id }: DeleteRolePathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'DELETE',
 		signal,
@@ -372,7 +372,7 @@ export const patchRole = (
 	authtypesPatchableRoleDTO?: BodyType<AuthtypesPatchableRoleDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
@@ -572,7 +572,7 @@ export const patchObjects = (
 	coretypesPatchableObjectsDTO?: BodyType<CoretypesPatchableObjectsDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}/relations/${relation}/objects`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/serviceaccount/index.ts

@@ -222,7 +222,7 @@ export const deleteServiceAccount = (
 	{ id }: DeleteServiceAccountPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'DELETE',
 		signal,
@@ -405,7 +405,7 @@ export const updateServiceAccount = (
 	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -707,7 +707,7 @@ export const revokeServiceAccountKey = (
 	{ id, fid }: RevokeServiceAccountKeyPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'DELETE',
 		signal,
@@ -788,7 +788,7 @@ export const updateServiceAccountKey = (
 	serviceaccounttypesUpdatableFactorAPIKeyDTO?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -1090,7 +1090,7 @@ export const deleteServiceAccountRole = (
 	{ id, rid }: DeleteServiceAccountRolePathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/roles/${rid}`,
 		method: 'DELETE',
 		signal,
@@ -1254,7 +1254,7 @@ export const updateMyServiceAccount = (
 	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/me`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -2143,10 +2143,6 @@ export interface ErrorsResponseerroradditionalDTO {
 	 * @type string
 	 */
 	message?: string;
-	/**
-	 * @type array
-	 */
-	suggestions?: string[];
 }
 
 export interface ErrorsResponseretryjsonDTO {
@@ -2162,6 +2158,10 @@ export interface ErrorsJSONDTO {
 	 * @type array
 	 */
 	errors?: ErrorsResponseerroradditionalDTO[];
+	/**
+	 * @type array
+	 */
+	invalidReferences?: string[];
 	/**
 	 * @type string
 	 */
@@ -2645,14 +2645,6 @@ export enum CloudintegrationtypesServiceIDDTO {
 	appservice = 'appservice',
 	containerapp = 'containerapp',
 	aks = 'aks',
-	sqldatabase = 'sqldatabase',
-	sqldatabasemi = 'sqldatabasemi',
-	mysqlflexibleserver = 'mysqlflexibleserver',
-	postgresqlflexibleserver = 'postgresqlflexibleserver',
-	mongodb = 'mongodb',
-	cosmosdb = 'cosmosdb',
-	cassandradb = 'cassandradb',
-	redis = 'redis',
 }
 export type CloudintegrationtypesCloudIntegrationServiceDTOAnyOf = {
 	/**
@@ -4633,54 +4625,6 @@ export interface DashboardtypesDashboardSpecDTO {
 	variables: DashboardtypesVariableDTO[];
 }
 
-export enum DashboardtypesListOrderDTO {
-	asc = 'asc',
-	desc = 'desc',
-}
-export enum DashboardtypesListSortDTO {
-	updated_at = 'updated_at',
-	created_at = 'created_at',
-	name = 'name',
-}
-export interface DashboardtypesDashboardViewDataDTO {
-	order?: DashboardtypesListOrderDTO;
-	/**
-	 * @type string
-	 */
-	query?: string;
-	sort?: DashboardtypesListSortDTO;
-	/**
-	 * @type string
-	 */
-	version: string;
-}
-
-export interface DashboardtypesDashboardViewDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	data: DashboardtypesDashboardViewDataDTO;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-}
-
 export enum DashboardtypesDatasourcePluginKindDTO {
 	'signoz/Datasource' = 'signoz/Datasource',
 }
@@ -4792,6 +4736,15 @@ export interface DashboardtypesJSONPatchOperationDTO {
 	value?: unknown;
 }
 
+export enum DashboardtypesListOrderDTO {
+	asc = 'asc',
+	desc = 'desc',
+}
+export enum DashboardtypesListSortDTO {
+	updated_at = 'updated_at',
+	created_at = 'created_at',
+	name = 'name',
+}
 export interface DashboardtypesListedDashboardV2SpecDTO {
 	display?: DashboardtypesDisplayDTO;
 }
@@ -4934,13 +4887,6 @@ export interface DashboardtypesListableDashboardV2DTO {
 	total: number;
 }
 
-export interface DashboardtypesListableDashboardViewDTO {
-	/**
-	 * @type array
-	 */
-	views: DashboardtypesDashboardViewDTO[];
-}
-
 export enum DashboardtypesPanelPluginKindDTO {
 	'signoz/TimeSeriesPanel' = 'signoz/TimeSeriesPanel',
 	'signoz/BarChartPanel' = 'signoz/BarChartPanel',
@@ -4992,14 +4938,6 @@ export interface DashboardtypesPostableDashboardV2DTO {
 	tags: TagtypesPostableTagDTO[] | null;
 }
 
-export interface DashboardtypesPostableDashboardViewDTO {
-	data: DashboardtypesDashboardViewDataDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
 export interface DashboardtypesPostablePublicDashboardDTO {
 	/**
 	 * @type string
@@ -6577,157 +6515,6 @@ export interface LlmpricingruletypesUpdatableLLMPricingRulesDTO {
 	rules: LlmpricingruletypesUpdatableLLMPricingRuleDTO[] | null;
 }
 
-export enum MetricreductionruletypesAssetTypeDTO {
-	dashboard = 'dashboard',
-	alert_rule = 'alert_rule',
-}
-export interface MetricreductionruletypesAffectedAssetDTO {
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type array,null
-	 */
-	impactedLabels: string[] | null;
-	/**
-	 * @type string
-	 */
-	name: string;
-	type: MetricreductionruletypesAssetTypeDTO;
-	/**
-	 * @type string
-	 */
-	widget?: string;
-}
-
-export enum MetricreductionruletypesMatchTypeDTO {
-	drop = 'drop',
-	keep = 'keep',
-}
-export interface MetricreductionruletypesGettableReductionRuleDTO {
-	/**
-	 * @type boolean
-	 */
-	active: boolean;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	effectiveFrom: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	ingestedSeries: number;
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	reducedSeries: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	reductionPercent: number;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-	/**
-	 * @type string
-	 */
-	updatedBy: string;
-}
-
-export interface MetricreductionruletypesGettableReductionRulePreviewDTO {
-	/**
-	 * @type array,null
-	 */
-	affectedAssets: MetricreductionruletypesAffectedAssetDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	droppedLabels: string[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	effectiveFrom: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	ingestedSeries: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	reducedSeries: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	reductionPercent: number;
-}
-
-export interface MetricreductionruletypesGettableReductionRulesDTO {
-	/**
-	 * @type array,null
-	 */
-	rules: MetricreductionruletypesGettableReductionRuleDTO[] | null;
-	/**
-	 * @type integer
-	 */
-	total: number;
-}
-
-export enum MetricreductionruletypesOrderDTO {
-	asc = 'asc',
-	desc = 'desc',
-}
-export interface MetricreductionruletypesPostableReductionRuleDTO {
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-}
-
-export interface MetricreductionruletypesPostableReductionRulePreviewDTO {
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	lookbackMs?: number;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-}
-
-export enum MetricreductionruletypesReductionRuleOrderByDTO {
-	metricname = 'metricname',
-	ingestedvolume = 'ingestedvolume',
-	reducedvolume = 'reducedvolume',
-	reduction = 'reduction',
-	lastupdated = 'lastupdated',
-}
 export interface MetricsexplorertypesInspectMetricsRequestDTO {
 	/**
 	 * @type integer
@@ -6889,10 +6676,6 @@ export interface MetricsexplorertypesMetricDashboardDTO {
 	 * @type string
 	 */
 	dashboardName: string;
-	/**
-	 * @type array
-	 */
-	groupBy?: string[];
 	/**
 	 * @type string
 	 */
@@ -9953,19 +9736,6 @@ export type UpdateSpanMapperPathParameters = {
 	groupId: string;
 	mapperId: string;
 };
-export type GetStats200Data = { [key: string]: unknown };
-
-export type GetStats200 = {
-	/**
-	 * @type object
-	 */
-	data: GetStats200Data;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetTraceAggregationsPathParameters = {
 	traceID: string;
 };
@@ -10046,36 +9816,6 @@ export type GetUserPreference200 = {
 export type UpdateUserPreferencePathParameters = {
 	name: string;
 };
-export type ListDashboardViews200 = {
-	data: DashboardtypesListableDashboardViewDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateDashboardView201 = {
-	data: DashboardtypesDashboardViewDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteDashboardViewPathParameters = {
-	id: string;
-};
-export type UpdateDashboardViewPathParameters = {
-	id: string;
-};
-export type UpdateDashboardView200 = {
-	data: DashboardtypesDashboardViewDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListDashboardsV2Params = {
 	/**
 	 * @type string
@@ -10154,17 +9894,6 @@ export type UpdateDashboardV2200 = {
 	status: string;
 };
 
-export type CloneDashboardV2PathParameters = {
-	id: string;
-};
-export type CloneDashboardV2201 = {
-	data: DashboardtypesGettableDashboardV2DTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type UnlockDashboardV2PathParameters = {
 	id: string;
 };
@@ -10471,31 +10200,6 @@ export type GetMetricMetadata200 = {
 export type UpdateMetricMetadataPathParameters = {
 	metricName: string;
 };
-export type DeleteMetricReductionRulePathParameters = {
-	metricName: string;
-};
-export type GetMetricReductionRulePathParameters = {
-	metricName: string;
-};
-export type GetMetricReductionRule200 = {
-	data: MetricreductionruletypesGettableReductionRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type UpsertMetricReductionRulePathParameters = {
-	metricName: string;
-};
-export type UpsertMetricReductionRule200 = {
-	data: MetricreductionruletypesGettableReductionRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type InspectMetrics200 = {
 	data: MetricsexplorertypesInspectMetricsResponseDTO;
 	/**
@@ -10512,43 +10216,6 @@ export type GetMetricsOnboardingStatus200 = {
 	status: string;
 };
 
-export type ListMetricReductionRulesParams = {
-	/**
-	 * @description undefined
-	 */
-	orderBy?: MetricreductionruletypesReductionRuleOrderByDTO;
-	/**
-	 * @description undefined
-	 */
-	order?: MetricreductionruletypesOrderDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-};
-
-export type ListMetricReductionRules200 = {
-	data: MetricreductionruletypesGettableReductionRulesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type PreviewMetricReductionRule200 = {
-	data: MetricreductionruletypesGettableReductionRulePreviewDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetMetricsStats200 = {
 	data: MetricsexplorertypesStatsResponseDTO;
 	/**

frontend/src/api/generated/services/stats/index.ts

@@ -1,96 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
- * SigNoz
- */
-import { useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type { GetStats200, RenderErrorResponseDTO } from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType } from '../../../generatedAPIInstance';
-
-/**
- * This endpoint returns the collected stats for the organization
- * @summary Get stats
- */
-export const getStats = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetStats200>({
-		url: `/api/v1/stats`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetStatsQueryKey = () => {
-	return [`/api/v1/stats`] as const;
-};
-
-export const getGetStatsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getStats>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetStatsQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getStats>>> = ({
-		signal,
-	}) => getStats(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getStats>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetStatsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getStats>>
->;
-export type GetStatsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get stats
- */
-
-export function useGetStats<
-	TData = Awaited<ReturnType<typeof getStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getStats>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetStatsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get stats
- */
-export const invalidateGetStats = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetStatsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.tsx

@@ -1,29 +1,67 @@
 /* eslint-disable sonarjs/no-identical-functions */
 import { Fragment, useMemo, useState } from 'react';
 import { Input } from '@signozhq/ui/input';
-import { Skeleton } from 'antd';
+import { Button, Skeleton } from 'antd';
+import { Checkbox } from '@signozhq/ui/checkbox';
 import { Typography } from '@signozhq/ui/typography';
+import cx from 'classnames';
+import { removeKeysFromExpression } from 'components/QueryBuilderV2/utils';
 import {
 	IQuickFiltersConfig,
 	QuickFiltersSource,
 } from 'components/QuickFilters/types';
+import { OPERATORS } from 'constants/antlrQueryConstants';
+import {
+	DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY,
+	PANEL_TYPES,
+} from 'constants/queryBuilder';
 import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
+import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
+import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useGetQueryKeyValueSuggestions } from 'hooks/querySuggestions/useGetQueryKeyValueSuggestions';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { cloneDeep, isArray, isFunction } from 'lodash-es';
+import { ChevronDown, ChevronRight } from '@signozhq/icons';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+import { v4 as uuid } from 'uuid';
 
-import CheckboxFilterHeader from './CheckboxFilterHeader';
-import CheckboxValueRow from './CheckboxValueRow';
 import LogsQuickFilterEmptyState from './LogsQuickFilterEmptyState';
-import useActiveQueryIndex from './useActiveQueryIndex';
-import useCheckboxDisclosure from './useCheckboxDisclosure';
-import useCheckboxFilterActions from './useCheckboxFilterActions';
-import useCheckboxFilterState from './useCheckboxFilterState';
-import useCheckboxFilterValues from './useCheckboxFilterValues';
+import { isKeyMatch } from './utils';
 
 import './Checkbox.styles.scss';
 
+const SELECTED_OPERATORS = [OPERATORS['='], 'in'];
+const NON_SELECTED_OPERATORS = [OPERATORS['!='], 'not in', 'nin'];
+
 const SOURCES_WITH_EMPTY_STATE_ENABLED = [QuickFiltersSource.LOGS_EXPLORER];
 
+// Sources that use backend APIs expecting short operator format (e.g., 'nin' instead of 'not in')
+const SOURCES_WITH_SHORT_OPERATORS = [QuickFiltersSource.INFRA_MONITORING];
+
+/**
+ * Returns the correct NOT_IN operator value based on source.
+ * InfraMonitoring backend expects 'nin', others expect 'not in'.
+ */
+function getNotInOperator(source: QuickFiltersSource): string {
+	if (SOURCES_WITH_SHORT_OPERATORS.includes(source)) {
+		return 'nin';
+	}
+	return getOperatorValue('NOT_IN');
+}
+
+function setDefaultValues(
+	values: string[],
+	trueOrFalse: boolean,
+): Record<string, boolean> {
+	const defaultState: Record<string, boolean> = {};
+	values.forEach((val) => {
+		defaultState[val] = trueOrFalse;
+	});
+	return defaultState;
+}
 interface ICheckboxProps {
 	filter: IQuickFiltersConfig;
 	source: QuickFiltersSource;
@@ -34,39 +72,194 @@ interface ICheckboxProps {
 export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 	const { source, filter, onFilterChange } = props;
 	const [searchText, setSearchText] = useState<string>('');
-
-	const activeQueryIndex = useActiveQueryIndex(source);
+	// null = no user action, true = user opened, false = user closed
+	const [userToggleState, setUserToggleState] = useState<boolean | null>(null);
+	const [visibleItemsCount, setVisibleItemsCount] = useState<number>(10);
 
 	const {
-		isOpen,
+		lastUsedQuery,
+		currentQuery,
+		redirectWithQueryBuilderData,
+		panelType,
+	} = useQueryBuilder();
+
+	// Determine if we're in ListView mode
+	const isListView = panelType === PANEL_TYPES.LIST;
+	// In ListView mode, use index 0 for most sources; for TRACES_EXPLORER, use lastUsedQuery
+	// Otherwise use lastUsedQuery for non-ListView modes
+	const activeQueryIndex = useMemo(() => {
+		if (isListView) {
+			return source === QuickFiltersSource.TRACES_EXPLORER
+				? lastUsedQuery || 0
+				: 0;
+		}
+		return lastUsedQuery || 0;
+	}, [isListView, source, lastUsedQuery]);
+
+	// Check if this filter has active filters in the query
+	const isSomeFilterPresentForCurrentAttribute = useMemo(
+		() =>
+			currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items?.some(
+				(item) => isKeyMatch(item.key?.key, filter.attributeKey.key),
+			),
+		[currentQuery.builder.queryData, activeQueryIndex, filter.attributeKey.key],
+	);
+
+	// Derive isOpen from filter state + user action
+	const isOpen = useMemo(() => {
+		// If user explicitly toggled, respect that
+		if (userToggleState !== null) {
+			return userToggleState;
+		}
+
+		// Auto-open if this filter has active filters in the query
+		if (isSomeFilterPresentForCurrentAttribute) {
+			return true;
+		}
+
+		// Otherwise use default behavior (first 2 filters open)
+		return filter.defaultOpen;
+	}, [
+		userToggleState,
 		isSomeFilterPresentForCurrentAttribute,
-		visibleItemsCount,
-		onToggleOpen,
-		onShowMore,
-	} = useCheckboxDisclosure({ filter, activeQueryIndex });
+		filter.defaultOpen,
+	]);
 
-	const { attributeValues, isLoading } = useCheckboxFilterValues({
-		filter,
-		source,
-		searchText,
-		isOpen,
-	});
+	const { data, isLoading } = useGetAggregateValues(
+		{
+			aggregateOperator: filter.aggregateOperator || 'noop',
+			dataSource: filter.dataSource || DataSource.LOGS,
+			aggregateAttribute: filter.aggregateAttribute || '',
+			attributeKey: filter.attributeKey.key,
+			filterAttributeKeyDataType: filter.attributeKey.dataType || DataTypes.EMPTY,
+			tagType: filter.attributeKey.type || '',
+			searchText: searchText ?? '',
+		},
+		{
+			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
+			keepPreviousData: true,
+		},
+	);
 
-	const { currentFilterState, isFilterDisabled, isMultipleValuesTrueForTheKey } =
-		useCheckboxFilterState({ filter, attributeValues, activeQueryIndex });
+	const { data: keyValueSuggestions, isLoading: isLoadingKeyValueSuggestions } =
+		useGetQueryKeyValueSuggestions({
+			key: filter.attributeKey.key,
+			signal: filter.dataSource || DataSource.LOGS,
+			signalSource: 'meter',
+			options: {
+				enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
+				keepPreviousData: true,
+			},
+		});
 
-	const { onChange, onClear } = useCheckboxFilterActions({
-		filter,
-		source,
-		attributeValues,
-		activeQueryIndex,
-		onFilterChange,
-	});
+	const attributeValues: string[] = useMemo(() => {
+		const dataType = filter.attributeKey.dataType || DataTypes.String;
+
+		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
+			// Process the response data
+			const responseData = keyValueSuggestions?.data as any;
+			const values = responseData.data?.values || {};
+			const stringValues = values.stringValues || [];
+			const numberValues = values.numberValues || [];
+
+			// Generate options from string values - explicitly handle empty strings
+			const stringOptions = stringValues
+				// Strict filtering for empty string - we'll handle it as a special case if needed
+				.filter(
+					(value: string | null | undefined): value is string =>
+						value !== null && value !== undefined && value !== '',
+				);
+
+			// Generate options from number values
+			const numberOptions = numberValues
+				.filter(
+					(value: number | null | undefined): value is number =>
+						value !== null && value !== undefined,
+				)
+				.map((value: number) => value.toString());
+
+			// Combine all options and make sure we don't have duplicate labels
+			return [...stringOptions, ...numberOptions];
+		}
+
+		const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
+		return (data?.payload?.[key] || []).filter(
+			(val) => val !== undefined && val !== null,
+		);
+	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
 
 	const setSearchTextDebounced = useDebouncedFn((...args) => {
 		setSearchText(args[0] as string);
 	}, DEBOUNCE_DELAY);
 
+	// derive the state of each filter key here in the renderer itself and keep it in sync with current query
+	// also we need to keep a note of last focussed query.
+	// eslint-disable-next-line sonarjs/cognitive-complexity
+	const currentFilterState = useMemo(() => {
+		let filterState: Record<string, boolean> = setDefaultValues(
+			attributeValues,
+			false,
+		);
+		const filterSync = currentQuery?.builder.queryData?.[
+			activeQueryIndex
+		]?.filters?.items.find((item) =>
+			isKeyMatch(item.key?.key, filter.attributeKey.key),
+		);
+
+		if (filterSync) {
+			if (SELECTED_OPERATORS.includes(filterSync.op)) {
+				if (isArray(filterSync.value)) {
+					filterSync.value.forEach((val) => {
+						filterState[String(val)] = true;
+					});
+				} else if (typeof filterSync.value === 'string') {
+					filterState[filterSync.value] = true;
+				} else if (typeof filterSync.value === 'boolean') {
+					filterState[String(filterSync.value)] = true;
+				} else if (typeof filterSync.value === 'number') {
+					filterState[String(filterSync.value)] = true;
+				}
+			} else if (NON_SELECTED_OPERATORS.includes(filterSync.op)) {
+				filterState = setDefaultValues(attributeValues, true);
+				if (isArray(filterSync.value)) {
+					filterSync.value.forEach((val) => {
+						filterState[String(val)] = false;
+					});
+				} else if (typeof filterSync.value === 'string') {
+					filterState[filterSync.value] = false;
+				} else if (typeof filterSync.value === 'boolean') {
+					filterState[String(filterSync.value)] = false;
+				} else if (typeof filterSync.value === 'number') {
+					filterState[String(filterSync.value)] = false;
+				}
+			}
+		} else {
+			filterState = setDefaultValues(attributeValues, true);
+		}
+		return filterState;
+	}, [
+		attributeValues,
+		currentQuery?.builder.queryData,
+		filter.attributeKey,
+		activeQueryIndex,
+	]);
+
+	// disable the filter when there are multiple entries of the same attribute key present in the filter bar
+	const isFilterDisabled = useMemo(
+		() =>
+			(currentQuery?.builder?.queryData?.[
+				activeQueryIndex
+			]?.filters?.items?.filter((item) =>
+				isKeyMatch(item.key?.key, filter.attributeKey.key),
+			)?.length || 0) > 1,
+
+		[currentQuery?.builder?.queryData, activeQueryIndex, filter.attributeKey],
+	);
+
+	// variable to check if the current filter has multiple values to its name in the key op value section
+	const isMultipleValuesTrueForTheKey =
+		Object.values(currentFilterState).filter((val) => val).length > 1;
+
 	// Sort checked items to the top, then unchecked items
 	const currentAttributeKeys = useMemo(() => {
 		const checkedValues = attributeValues.filter(
@@ -84,6 +277,293 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 		[currentAttributeKeys, currentFilterState],
 	);
 
+	const handleClearFilterAttribute = (): void => {
+		const preparedQuery: Query = {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: currentQuery.builder.queryData.map((item, idx) => ({
+					...item,
+					filter: {
+						expression: removeKeysFromExpression(item.filter?.expression ?? '', [
+							filter.attributeKey.key,
+						]),
+					},
+					filters: {
+						...item.filters,
+						items:
+							idx === activeQueryIndex
+								? item.filters?.items?.filter(
+										(fil) => !isKeyMatch(fil.key?.key, filter.attributeKey.key),
+									) || []
+								: [...(item.filters?.items || [])],
+						op: item.filters?.op || 'AND',
+					},
+				})),
+			},
+		};
+
+		if (onFilterChange && isFunction(onFilterChange)) {
+			onFilterChange(preparedQuery);
+		} else {
+			redirectWithQueryBuilderData(preparedQuery);
+		}
+	};
+
+	const onChange = (
+		value: string,
+		checked: boolean,
+		isOnlyOrAllClicked: boolean,
+		// eslint-disable-next-line sonarjs/cognitive-complexity
+	): void => {
+		const query = cloneDeep(currentQuery.builder.queryData?.[activeQueryIndex]);
+
+		// if only or all are clicked we do not need to worry about anything just override whatever we have
+		// by either adding a new IN operator value clause in case of ONLY or remove everything we have for ALL.
+		if (isOnlyOrAllClicked && query?.filters?.items) {
+			const isOnlyOrAll = isSomeFilterPresentForCurrentAttribute
+				? currentFilterState[value] && !isMultipleValuesTrueForTheKey
+					? 'All'
+					: 'Only'
+				: 'Only';
+			query.filters.items = query.filters.items.filter(
+				(q) => !isKeyMatch(q.key?.key, filter.attributeKey.key),
+			);
+
+			if (query.filter?.expression) {
+				query.filter.expression = removeKeysFromExpression(
+					query.filter.expression,
+					[filter.attributeKey.key],
+				);
+			}
+
+			if (isOnlyOrAll === 'Only') {
+				const newFilterItem: TagFilterItem = {
+					id: uuid(),
+					op: getOperatorValue(OPERATORS.IN),
+					key: filter.attributeKey,
+					value,
+				};
+				query.filters.items = [...query.filters.items, newFilterItem];
+			}
+		} else if (query?.filters?.items) {
+			if (
+				query.filters?.items?.some((item) =>
+					isKeyMatch(item.key?.key, filter.attributeKey.key),
+				)
+			) {
+				// if there is already a running filter for the current attribute key then
+				// we split the cases by which particular operator is present right now!
+				const currentFilter = query.filters?.items?.find((q) =>
+					isKeyMatch(q.key?.key, filter.attributeKey.key),
+				);
+				if (currentFilter) {
+					const runningOperator = currentFilter?.op;
+					switch (runningOperator) {
+						case 'in':
+							if (checked) {
+								// if it's an IN operator then if we are checking another value it get's added to the
+								// filter clause. example -  key IN [value1, currentSelectedValue]
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: [...currentFilter.value, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								} else {
+									// if the current state wasn't an array we make it one and add our value
+									const newFilter = {
+										...currentFilter,
+										value: [currentFilter.value as string, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								}
+							} else if (!checked) {
+								// if we are removing some value when the running operator is IN we filter.
+								// example - key IN [value1,currentSelectedValue] becomes key IN [value1] in case of array
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value.filter((val) => val !== value),
+									};
+
+									if (newFilter.value.length === 0) {
+										query.filters.items = query.filters.items.filter(
+											(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+										);
+									} else {
+										query.filters.items = query.filters.items.map((item) => {
+											if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+												return newFilter;
+											}
+											return item;
+										});
+									}
+								} else {
+									// if not an array remove the whole thing altogether!
+									query.filters.items = query.filters.items.filter(
+										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+									);
+								}
+							}
+							break;
+						case 'nin':
+						case 'not in':
+							// if the current running operator is NIN then when unchecking the value it gets
+							// added to the clause like key NIN [value1 , currentUnselectedValue]
+							if (!checked) {
+								// in case of array add the currentUnselectedValue to the list.
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: [...currentFilter.value, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								} else {
+									// in case of not an array make it one!
+									const newFilter = {
+										...currentFilter,
+										value: [currentFilter.value as string, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								}
+							} else if (checked) {
+								// opposite of above!
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value.filter((val) => val !== value),
+									};
+									if (newFilter.value.length === 0) {
+										query.filters.items = query.filters.items.filter(
+											(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+										);
+										if (query.filter?.expression) {
+											query.filter.expression = removeKeysFromExpression(
+												query.filter.expression,
+												[filter.attributeKey.key],
+											);
+										}
+									} else {
+										query.filters.items = query.filters.items.map((item) => {
+											if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+												return newFilter;
+											}
+											return item;
+										});
+									}
+								} else {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value === value ? null : currentFilter.value,
+									};
+									if (newFilter.value === null && query.filter?.expression) {
+										query.filter.expression = removeKeysFromExpression(
+											query.filter.expression,
+											[filter.attributeKey.key],
+										);
+									}
+									query.filters.items = query.filters.items.filter(
+										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+									);
+								}
+							}
+							break;
+						case '=':
+							if (checked) {
+								const newFilter = {
+									...currentFilter,
+									op: getOperatorValue(OPERATORS.IN),
+									value: [currentFilter.value as string, value],
+								};
+								query.filters.items = query.filters.items.map((item) => {
+									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+										return newFilter;
+									}
+									return item;
+								});
+							} else if (!checked) {
+								query.filters.items = query.filters.items.filter(
+									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+								);
+							}
+							break;
+						case '!=':
+							if (!checked) {
+								const newFilter = {
+									...currentFilter,
+									op: getNotInOperator(source),
+									value: [currentFilter.value as string, value],
+								};
+								query.filters.items = query.filters.items.map((item) => {
+									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+										return newFilter;
+									}
+									return item;
+								});
+							} else if (checked) {
+								query.filters.items = query.filters.items.filter(
+									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+								);
+							}
+							break;
+						default:
+							break;
+					}
+				}
+			} else {
+				// case  - when there is no filter for the current key that means all are selected right now.
+				const newFilterItem: TagFilterItem = {
+					id: uuid(),
+					op: getNotInOperator(source),
+					key: filter.attributeKey,
+					value,
+				};
+				query.filters.items = [...query.filters.items, newFilterItem];
+			}
+		}
+		const finalQuery = {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: [
+					...currentQuery.builder.queryData.map((q, idx) => {
+						if (idx === activeQueryIndex) {
+							return query;
+						}
+						return q;
+					}),
+				],
+			},
+		};
+
+		if (onFilterChange && isFunction(onFilterChange)) {
+			onFilterChange(finalQuery);
+		} else {
+			redirectWithQueryBuilderData(finalQuery);
+		}
+	};
+
 	const isEmptyStateWithDocsEnabled =
 		SOURCES_WITH_EMPTY_STATE_ENABLED.includes(source) &&
 		!searchText &&
@@ -91,19 +571,48 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 
 	return (
 		<div className="checkbox-filter">
-			<CheckboxFilterHeader
-				title={filter.title}
-				isOpen={isOpen}
-				showClearAll={!!attributeValues.length}
-				onToggleOpen={onToggleOpen}
-				onClear={onClear}
-			/>
-			{isOpen && isLoading && !attributeValues.length && (
-				<section className="loading">
-					<Skeleton paragraph={{ rows: 4 }} />
+			<section
+				className="filter-header-checkbox"
+				onClick={(): void => {
+					if (isOpen) {
+						setUserToggleState(false);
+						setVisibleItemsCount(10);
+					} else {
+						setUserToggleState(true);
+					}
+				}}
+			>
+				<section className="left-action">
+					{isOpen ? (
+						<ChevronDown size={13} cursor="pointer" />
+					) : (
+						<ChevronRight size={13} cursor="pointer" />
+					)}
+					<Typography.Text className="title">{filter.title}</Typography.Text>
 				</section>
-			)}
-			{isOpen && !isLoading && (
+				<section className="right-action">
+					{isOpen && !!attributeValues.length && (
+						<Typography.Text
+							className="clear-all"
+							onClick={(e): void => {
+								e.stopPropagation();
+								e.preventDefault();
+								handleClearFilterAttribute();
+							}}
+						>
+							Clear All
+						</Typography.Text>
+					)}
+				</section>
+			</section>
+			{isOpen &&
+				(isLoading || isLoadingKeyValueSuggestions) &&
+				!attributeValues.length && (
+					<section className="loading">
+						<Skeleton paragraph={{ rows: 4 }} />
+					</section>
+				)}
+			{isOpen && !isLoading && !isLoadingKeyValueSuggestions && (
 				<>
 					{!isEmptyStateWithDocsEnabled && (
 						<section className="search">
@@ -125,24 +634,48 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 											data-testid="filter-separator"
 										/>
 									)}
-									<CheckboxValueRow
-										value={value}
-										checked={currentFilterState[value]}
-										disabled={isFilterDisabled}
-										title={filter.title}
-										onlyButtonLabel={
-											isSomeFilterPresentForCurrentAttribute
-												? currentFilterState[value] && !isMultipleValuesTrueForTheKey
-													? 'All'
-													: 'Only'
-												: 'Only'
-										}
-										customRendererForValue={filter.customRendererForValue}
-										onCheckboxChange={(checked): void => onChange(value, checked, false)}
-										onOnlyOrAllClick={(): void =>
-											onChange(value, currentFilterState[value], true)
-										}
-									/>
+									<div className="value">
+										<Checkbox
+											onChange={(checked): void =>
+												onChange(value, checked === true, false)
+											}
+											value={currentFilterState[value]}
+											disabled={isFilterDisabled}
+											className="check-box"
+										/>
+
+										<div
+											className={cx(
+												'checkbox-value-section',
+												isFilterDisabled ? 'filter-disabled' : '',
+											)}
+											onClick={(): void => {
+												if (isFilterDisabled) {
+													return;
+												}
+												onChange(value, currentFilterState[value], true);
+											}}
+										>
+											<div className={`${filter.title} label-${value}`} />
+											{filter.customRendererForValue ? (
+												filter.customRendererForValue(value)
+											) : (
+												<Typography.Text className="value-string" truncate={1}>
+													{String(value)}
+												</Typography.Text>
+											)}
+											<Button type="text" className="only-btn">
+												{isSomeFilterPresentForCurrentAttribute
+													? currentFilterState[value] && !isMultipleValuesTrueForTheKey
+														? 'All'
+														: 'Only'
+													: 'Only'}
+											</Button>
+											<Button type="text" className="toggle-btn">
+												Toggle
+											</Button>
+										</div>
+									</div>
 								</Fragment>
 							))}
 						</section>
@@ -155,7 +688,10 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 					)}
 					{visibleItemsCount < attributeValues?.length && (
 						<section className="show-more">
-							<Typography.Text className="show-more-text" onClick={onShowMore}>
+							<Typography.Text
+								className="show-more-text"
+								onClick={(): void => setVisibleItemsCount((prev) => prev + 10)}
+							>
 								Show More...
 							</Typography.Text>
 						</section>

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/CheckboxFilterHeader.tsx

@@ -1,47 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import { ChevronDown, ChevronRight } from '@signozhq/icons';
-
-interface CheckboxFilterHeaderProps {
-	title: string;
-	isOpen: boolean;
-	showClearAll: boolean;
-	onToggleOpen: () => void;
-	onClear: () => void;
-}
-
-function CheckboxFilterHeader({
-	title,
-	isOpen,
-	showClearAll,
-	onToggleOpen,
-	onClear,
-}: CheckboxFilterHeaderProps): JSX.Element {
-	return (
-		<section className="filter-header-checkbox" onClick={onToggleOpen}>
-			<section className="left-action">
-				{isOpen ? (
-					<ChevronDown size={13} cursor="pointer" />
-				) : (
-					<ChevronRight size={13} cursor="pointer" />
-				)}
-				<Typography.Text className="title">{title}</Typography.Text>
-			</section>
-			<section className="right-action">
-				{isOpen && showClearAll && (
-					<Typography.Text
-						className="clear-all"
-						onClick={(e): void => {
-							e.stopPropagation();
-							e.preventDefault();
-							onClear();
-						}}
-					>
-						Clear All
-					</Typography.Text>
-				)}
-			</section>
-		</section>
-	);
-}
-
-export default CheckboxFilterHeader;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/CheckboxValueRow.tsx

@@ -1,68 +0,0 @@
-import { Button } from 'antd';
-import { Checkbox } from '@signozhq/ui/checkbox';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-
-interface CheckboxValueRowProps {
-	value: string;
-	checked: boolean;
-	disabled: boolean;
-	title: string;
-	onlyButtonLabel: string;
-	customRendererForValue?: (value: string) => JSX.Element;
-	onCheckboxChange: (checked: boolean) => void;
-	onOnlyOrAllClick: () => void;
-}
-
-function CheckboxValueRow({
-	value,
-	checked,
-	disabled,
-	title,
-	onlyButtonLabel,
-	customRendererForValue,
-	onCheckboxChange,
-	onOnlyOrAllClick,
-}: CheckboxValueRowProps): JSX.Element {
-	return (
-		<div className="value">
-			<Checkbox
-				onChange={(isChecked): void => onCheckboxChange(isChecked === true)}
-				value={checked}
-				disabled={disabled}
-				className="check-box"
-			/>
-
-			<div
-				className={cx('checkbox-value-section', disabled ? 'filter-disabled' : '')}
-				onClick={(): void => {
-					if (disabled) {
-						return;
-					}
-					onOnlyOrAllClick();
-				}}
-			>
-				<div className={`${title} label-${value}`} />
-				{customRendererForValue ? (
-					customRendererForValue(value)
-				) : (
-					<Typography.Text className="value-string" truncate={1}>
-						{String(value)}
-					</Typography.Text>
-				)}
-				<Button type="text" className="only-btn">
-					{onlyButtonLabel}
-				</Button>
-				<Button type="text" className="toggle-btn">
-					Toggle
-				</Button>
-			</div>
-		</div>
-	);
-}
-
-CheckboxValueRow.defaultProps = {
-	customRendererForValue: undefined,
-};
-
-export default CheckboxValueRow;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.ts

@@ -1,417 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { removeKeysFromExpression } from 'components/QueryBuilderV2/utils';
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { OPERATORS } from 'constants/antlrQueryConstants';
-import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
-import { cloneDeep, isArray } from 'lodash-es';
-import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
-import { v4 as uuid } from 'uuid';
-
-import { isKeyMatch } from './utils';
-
-export const SELECTED_OPERATORS = [OPERATORS['='], 'in'];
-export const NON_SELECTED_OPERATORS = [OPERATORS['!='], 'not in', 'nin'];
-
-// Sources that use backend APIs expecting short operator format (e.g., 'nin' instead of 'not in')
-const SOURCES_WITH_SHORT_OPERATORS = [QuickFiltersSource.INFRA_MONITORING];
-
-/**
- * Returns the correct NOT_IN operator value based on source.
- * InfraMonitoring backend expects 'nin', others expect 'not in'.
- */
-export function getNotInOperator(source: QuickFiltersSource): string {
-	if (SOURCES_WITH_SHORT_OPERATORS.includes(source)) {
-		return 'nin';
-	}
-	return getOperatorValue('NOT_IN');
-}
-
-function setDefaultValues(
-	values: string[],
-	trueOrFalse: boolean,
-): Record<string, boolean> {
-	const defaultState: Record<string, boolean> = {};
-	values.forEach((val) => {
-		defaultState[val] = trueOrFalse;
-	});
-	return defaultState;
-}
-
-/**
- * Derives the checked/unchecked state for each attribute value by reading the
- * active filter clause for this attribute key out of the query.
- *
- * - No matching clause -> every value is checked (all selected).
- * - IN / `=` clause     -> only the listed values are checked.
- * - NOT IN / `!=` clause -> every value is checked except the excluded ones.
- */
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function deriveCheckboxState({
-	attributeValues,
-	filterItems,
-	filterKey,
-}: {
-	attributeValues: string[];
-	filterItems: TagFilterItem[] | undefined;
-	filterKey: string;
-}): Record<string, boolean> {
-	let filterState: Record<string, boolean> = setDefaultValues(
-		attributeValues,
-		false,
-	);
-	const filterSync = filterItems?.find((item) =>
-		isKeyMatch(item.key?.key, filterKey),
-	);
-
-	if (filterSync) {
-		if (SELECTED_OPERATORS.includes(filterSync.op)) {
-			if (isArray(filterSync.value)) {
-				filterSync.value.forEach((val) => {
-					filterState[String(val)] = true;
-				});
-			} else if (typeof filterSync.value === 'string') {
-				filterState[filterSync.value] = true;
-			} else if (typeof filterSync.value === 'boolean') {
-				filterState[String(filterSync.value)] = true;
-			} else if (typeof filterSync.value === 'number') {
-				filterState[String(filterSync.value)] = true;
-			}
-		} else if (NON_SELECTED_OPERATORS.includes(filterSync.op)) {
-			filterState = setDefaultValues(attributeValues, true);
-			if (isArray(filterSync.value)) {
-				filterSync.value.forEach((val) => {
-					filterState[String(val)] = false;
-				});
-			} else if (typeof filterSync.value === 'string') {
-				filterState[filterSync.value] = false;
-			} else if (typeof filterSync.value === 'boolean') {
-				filterState[String(filterSync.value)] = false;
-			} else if (typeof filterSync.value === 'number') {
-				filterState[String(filterSync.value)] = false;
-			}
-		}
-	} else {
-		filterState = setDefaultValues(attributeValues, true);
-	}
-	return filterState;
-}
-
-/**
- * Returns a new query with every clause for this attribute key removed, both
- * from the structured filter items and the raw filter expression.
- */
-export function clearFilterFromQuery({
-	currentQuery,
-	filter,
-	activeQueryIndex,
-}: {
-	currentQuery: Query;
-	filter: IQuickFiltersConfig;
-	activeQueryIndex: number;
-}): Query {
-	return {
-		...currentQuery,
-		builder: {
-			...currentQuery.builder,
-			queryData: currentQuery.builder.queryData.map((item, idx) => ({
-				...item,
-				filter: {
-					expression: removeKeysFromExpression(item.filter?.expression ?? '', [
-						filter.attributeKey.key,
-					]),
-				},
-				filters: {
-					...item.filters,
-					items:
-						idx === activeQueryIndex
-							? item.filters?.items?.filter(
-									(fil) => !isKeyMatch(fil.key?.key, filter.attributeKey.key),
-								) || []
-							: [...(item.filters?.items || [])],
-					op: item.filters?.op || 'AND',
-				},
-			})),
-		},
-	};
-}
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function applyCheckboxToggle({
-	currentQuery,
-	activeQueryIndex,
-	filter,
-	source,
-	attributeValues,
-	value,
-	checked,
-	isOnlyOrAllClicked,
-}: {
-	currentQuery: Query;
-	activeQueryIndex: number;
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	attributeValues: string[];
-	value: string;
-	checked: boolean;
-	isOnlyOrAllClicked: boolean;
-}): Query {
-	const activeItems =
-		currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items;
-
-	const isSomeFilterPresentForCurrentAttribute = !!activeItems?.some((item) =>
-		isKeyMatch(item.key?.key, filter.attributeKey.key),
-	);
-
-	const currentFilterState = deriveCheckboxState({
-		attributeValues,
-		filterItems: activeItems,
-		filterKey: filter.attributeKey.key,
-	});
-
-	const isMultipleValuesTrueForTheKey =
-		Object.values(currentFilterState).filter((val) => val).length > 1;
-
-	const query = cloneDeep(currentQuery.builder.queryData?.[activeQueryIndex]);
-
-	// if only or all are clicked we do not need to worry about anything just override whatever we have
-	// by either adding a new IN operator value clause in case of ONLY or remove everything we have for ALL.
-	if (isOnlyOrAllClicked && query?.filters?.items) {
-		const isOnlyOrAll = isSomeFilterPresentForCurrentAttribute
-			? currentFilterState[value] && !isMultipleValuesTrueForTheKey
-				? 'All'
-				: 'Only'
-			: 'Only';
-		query.filters.items = query.filters.items.filter(
-			(q) => !isKeyMatch(q.key?.key, filter.attributeKey.key),
-		);
-
-		if (query.filter?.expression) {
-			query.filter.expression = removeKeysFromExpression(query.filter.expression, [
-				filter.attributeKey.key,
-			]);
-		}
-
-		if (isOnlyOrAll === 'Only') {
-			const newFilterItem: TagFilterItem = {
-				id: uuid(),
-				op: getOperatorValue(OPERATORS.IN),
-				key: filter.attributeKey,
-				value,
-			};
-			query.filters.items = [...query.filters.items, newFilterItem];
-		}
-	} else if (query?.filters?.items) {
-		if (
-			query.filters?.items?.some((item) =>
-				isKeyMatch(item.key?.key, filter.attributeKey.key),
-			)
-		) {
-			// if there is already a running filter for the current attribute key then
-			// we split the cases by which particular operator is present right now!
-			const currentFilter = query.filters?.items?.find((q) =>
-				isKeyMatch(q.key?.key, filter.attributeKey.key),
-			);
-			if (currentFilter) {
-				const runningOperator = currentFilter?.op;
-				switch (runningOperator) {
-					case 'in':
-						if (checked) {
-							// if it's an IN operator then if we are checking another value it get's added to the
-							// filter clause. example -  key IN [value1, currentSelectedValue]
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: [...currentFilter.value, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							} else {
-								// if the current state wasn't an array we make it one and add our value
-								const newFilter = {
-									...currentFilter,
-									value: [currentFilter.value as string, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							}
-						} else if (!checked) {
-							// if we are removing some value when the running operator is IN we filter.
-							// example - key IN [value1,currentSelectedValue] becomes key IN [value1] in case of array
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value.filter((val) => val !== value),
-								};
-
-								if (newFilter.value.length === 0) {
-									query.filters.items = query.filters.items.filter(
-										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-									);
-								} else {
-									query.filters.items = query.filters.items.map((item) => {
-										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-											return newFilter;
-										}
-										return item;
-									});
-								}
-							} else {
-								// if not an array remove the whole thing altogether!
-								query.filters.items = query.filters.items.filter(
-									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-								);
-							}
-						}
-						break;
-					case 'nin':
-					case 'not in':
-						// if the current running operator is NIN then when unchecking the value it gets
-						// added to the clause like key NIN [value1 , currentUnselectedValue]
-						if (!checked) {
-							// in case of array add the currentUnselectedValue to the list.
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: [...currentFilter.value, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							} else {
-								// in case of not an array make it one!
-								const newFilter = {
-									...currentFilter,
-									value: [currentFilter.value as string, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							}
-						} else if (checked) {
-							// opposite of above!
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value.filter((val) => val !== value),
-								};
-								if (newFilter.value.length === 0) {
-									query.filters.items = query.filters.items.filter(
-										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-									);
-									if (query.filter?.expression) {
-										query.filter.expression = removeKeysFromExpression(
-											query.filter.expression,
-											[filter.attributeKey.key],
-										);
-									}
-								} else {
-									query.filters.items = query.filters.items.map((item) => {
-										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-											return newFilter;
-										}
-										return item;
-									});
-								}
-							} else {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value === value ? null : currentFilter.value,
-								};
-								if (newFilter.value === null && query.filter?.expression) {
-									query.filter.expression = removeKeysFromExpression(
-										query.filter.expression,
-										[filter.attributeKey.key],
-									);
-								}
-								query.filters.items = query.filters.items.filter(
-									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-								);
-							}
-						}
-						break;
-					case '=':
-						if (checked) {
-							const newFilter = {
-								...currentFilter,
-								op: getOperatorValue(OPERATORS.IN),
-								value: [currentFilter.value as string, value],
-							};
-							query.filters.items = query.filters.items.map((item) => {
-								if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-									return newFilter;
-								}
-								return item;
-							});
-						} else if (!checked) {
-							query.filters.items = query.filters.items.filter(
-								(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-							);
-						}
-						break;
-					case '!=':
-						if (!checked) {
-							const newFilter = {
-								...currentFilter,
-								op: getNotInOperator(source),
-								value: [currentFilter.value as string, value],
-							};
-							query.filters.items = query.filters.items.map((item) => {
-								if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-									return newFilter;
-								}
-								return item;
-							});
-						} else if (checked) {
-							query.filters.items = query.filters.items.filter(
-								(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-							);
-						}
-						break;
-					default:
-						break;
-				}
-			}
-		} else {
-			// case  - when there is no filter for the current key that means all are selected right now.
-			const newFilterItem: TagFilterItem = {
-				id: uuid(),
-				op: getNotInOperator(source),
-				key: filter.attributeKey,
-				value,
-			};
-			query.filters.items = [...query.filters.items, newFilterItem];
-		}
-	}
-
-	return {
-		...currentQuery,
-		builder: {
-			...currentQuery.builder,
-			queryData: [
-				...currentQuery.builder.queryData.map((q, idx) => {
-					if (idx === activeQueryIndex) {
-						return query;
-					}
-					return q;
-				}),
-			],
-		},
-	};
-}

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useActiveQueryIndex.ts

@@ -1,27 +0,0 @@
-import { useMemo } from 'react';
-import { QuickFiltersSource } from 'components/QuickFilters/types';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-/**
- * Resolves which query-builder query index the checkbox filter reads from and
- * writes to.
- *
- * In ListView most sources use index 0; TRACES_EXPLORER and every non-ListView
- * mode track the last focused query.
- */
-function useActiveQueryIndex(source: QuickFiltersSource): number {
-	const { lastUsedQuery, panelType } = useQueryBuilder();
-	const isListView = panelType === PANEL_TYPES.LIST;
-
-	return useMemo(() => {
-		if (isListView) {
-			return source === QuickFiltersSource.TRACES_EXPLORER
-				? lastUsedQuery || 0
-				: 0;
-		}
-		return lastUsedQuery || 0;
-	}, [isListView, source, lastUsedQuery]);
-}
-
-export default useActiveQueryIndex;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxDisclosure.ts

@@ -1,90 +0,0 @@
-import { useMemo, useState } from 'react';
-import { IQuickFiltersConfig } from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-import { isKeyMatch } from './utils';
-
-const DEFAULT_VISIBLE_ITEMS_COUNT = 10;
-
-interface UseCheckboxDisclosureProps {
-	filter: IQuickFiltersConfig;
-	activeQueryIndex: number;
-}
-
-interface UseCheckboxDisclosureReturn {
-	isOpen: boolean;
-	isSomeFilterPresentForCurrentAttribute: boolean;
-	visibleItemsCount: number;
-	onToggleOpen: () => void;
-	onShowMore: () => void;
-}
-
-/**
- * Owns the open/collapsed state of a checkbox filter section and how many
- * values are visible.
- *
- * Auto-opens when the query already has a clause for this attribute, otherwise
- * falls back to `filter.defaultOpen`. An explicit user toggle always wins.
- * Collapsing resets the visible count.
- */
-function useCheckboxDisclosure({
-	filter,
-	activeQueryIndex,
-}: UseCheckboxDisclosureProps): UseCheckboxDisclosureReturn {
-	const { currentQuery } = useQueryBuilder();
-	// null = no user action, true = user opened, false = user closed
-	const [userToggleState, setUserToggleState] = useState<boolean | null>(null);
-	const [visibleItemsCount, setVisibleItemsCount] = useState<number>(
-		DEFAULT_VISIBLE_ITEMS_COUNT,
-	);
-
-	const isSomeFilterPresentForCurrentAttribute = useMemo(
-		() =>
-			!!currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items?.some(
-				(item) => isKeyMatch(item.key?.key, filter.attributeKey.key),
-			),
-		[currentQuery.builder.queryData, activeQueryIndex, filter.attributeKey.key],
-	);
-
-	const isOpen = useMemo(() => {
-		// If user explicitly toggled, respect that
-		if (userToggleState !== null) {
-			return userToggleState;
-		}
-
-		// Auto-open if this filter has active filters in the query
-		if (isSomeFilterPresentForCurrentAttribute) {
-			return true;
-		}
-
-		// Otherwise use default behavior (first 2 filters open)
-		return filter.defaultOpen;
-	}, [
-		userToggleState,
-		isSomeFilterPresentForCurrentAttribute,
-		filter.defaultOpen,
-	]);
-
-	const onToggleOpen = (): void => {
-		if (isOpen) {
-			setUserToggleState(false);
-			setVisibleItemsCount(DEFAULT_VISIBLE_ITEMS_COUNT);
-		} else {
-			setUserToggleState(true);
-		}
-	};
-
-	const onShowMore = (): void => {
-		setVisibleItemsCount((prev) => prev + DEFAULT_VISIBLE_ITEMS_COUNT);
-	};
-
-	return {
-		isOpen,
-		isSomeFilterPresentForCurrentAttribute,
-		visibleItemsCount,
-		onToggleOpen,
-		onShowMore,
-	};
-}
-
-export default useCheckboxDisclosure;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterActions.ts

@@ -1,78 +0,0 @@
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { isFunction } from 'lodash-es';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	applyCheckboxToggle,
-	clearFilterFromQuery,
-} from './checkboxFilterQuery';
-
-interface UseCheckboxFilterActionsProps {
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	attributeValues: string[];
-	activeQueryIndex: number;
-	onFilterChange?: ((query: Query) => void) | null;
-}
-
-interface UseCheckboxFilterActionsReturn {
-	onChange: (
-		value: string,
-		checked: boolean,
-		isOnlyOrAllClicked: boolean,
-	) => void;
-	onClear: () => void;
-}
-
-/**
- * Wires the pure checkbox query algebra to query-builder dispatch: the
- * caller-provided `onFilterChange` when present, otherwise a URL redirect.
- */
-function useCheckboxFilterActions({
-	filter,
-	source,
-	attributeValues,
-	activeQueryIndex,
-	onFilterChange,
-}: UseCheckboxFilterActionsProps): UseCheckboxFilterActionsReturn {
-	const { currentQuery, redirectWithQueryBuilderData } = useQueryBuilder();
-
-	const dispatch = (query: Query): void => {
-		if (onFilterChange && isFunction(onFilterChange)) {
-			onFilterChange(query);
-		} else {
-			redirectWithQueryBuilderData(query);
-		}
-	};
-
-	const onChange = (
-		value: string,
-		checked: boolean,
-		isOnlyOrAllClicked: boolean,
-	): void => {
-		dispatch(
-			applyCheckboxToggle({
-				currentQuery,
-				activeQueryIndex,
-				filter,
-				source,
-				attributeValues,
-				value,
-				checked,
-				isOnlyOrAllClicked,
-			}),
-		);
-	};
-
-	const onClear = (): void => {
-		dispatch(clearFilterFromQuery({ currentQuery, filter, activeQueryIndex }));
-	};
-
-	return { onChange, onClear };
-}
-
-export default useCheckboxFilterActions;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterState.ts

@@ -1,71 +0,0 @@
-import { useMemo } from 'react';
-import { IQuickFiltersConfig } from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-import { deriveCheckboxState } from './checkboxFilterQuery';
-import { isKeyMatch } from './utils';
-
-interface UseCheckboxFilterStateProps {
-	filter: IQuickFiltersConfig;
-	attributeValues: string[];
-	activeQueryIndex: number;
-}
-
-interface UseCheckboxFilterStateReturn {
-	currentFilterState: Record<string, boolean>;
-	isFilterDisabled: boolean;
-	isMultipleValuesTrueForTheKey: boolean;
-}
-
-/**
- * Reads the active query and derives the per-value checked state for this
- * attribute, whether the filter is disabled (same key used more than once in
- * the filter bar), and whether more than one value is currently selected.
- */
-function useCheckboxFilterState({
-	filter,
-	attributeValues,
-	activeQueryIndex,
-}: UseCheckboxFilterStateProps): UseCheckboxFilterStateReturn {
-	const { currentQuery } = useQueryBuilder();
-
-	// derive the state of each filter key here and keep it in sync with current query
-	const currentFilterState = useMemo(
-		() =>
-			deriveCheckboxState({
-				attributeValues,
-				filterItems:
-					currentQuery?.builder.queryData?.[activeQueryIndex]?.filters?.items,
-				filterKey: filter.attributeKey.key,
-			}),
-		[
-			attributeValues,
-			currentQuery?.builder.queryData,
-			filter.attributeKey,
-			activeQueryIndex,
-		],
-	);
-
-	// disable the filter when there are multiple entries of the same attribute key present in the filter bar
-	const isFilterDisabled = useMemo(
-		() =>
-			(currentQuery?.builder?.queryData?.[
-				activeQueryIndex
-			]?.filters?.items?.filter((item) =>
-				isKeyMatch(item.key?.key, filter.attributeKey.key),
-			)?.length || 0) > 1,
-		[currentQuery?.builder?.queryData, activeQueryIndex, filter.attributeKey],
-	);
-
-	// whether the current filter has multiple values to its name in the key op value section
-	const isMultipleValuesTrueForTheKey =
-		Object.values(currentFilterState).filter((val) => val).length > 1;
-
-	return {
-		currentFilterState,
-		isFilterDisabled,
-		isMultipleValuesTrueForTheKey,
-	};
-}
-
-export default useCheckboxFilterState;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterValues.tsx

@@ -1,99 +0,0 @@
-import { useMemo } from 'react';
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY } from 'constants/queryBuilder';
-import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
-import { useGetQueryKeyValueSuggestions } from 'hooks/querySuggestions/useGetQueryKeyValueSuggestions';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { DataSource } from 'types/common/queryBuilder';
-
-interface UseCheckboxFilterValuesProps {
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	searchText: string;
-	isOpen: boolean;
-}
-
-interface UseCheckboxFilterValuesReturn {
-	attributeValues: string[];
-	isLoading: boolean;
-}
-
-function useCheckboxFilterValues({
-	filter,
-	source,
-	searchText,
-	isOpen,
-}: UseCheckboxFilterValuesProps): UseCheckboxFilterValuesReturn {
-	const { data, isLoading } = useGetAggregateValues(
-		{
-			aggregateOperator: filter.aggregateOperator || 'noop',
-			dataSource: filter.dataSource || DataSource.LOGS,
-			aggregateAttribute: filter.aggregateAttribute || '',
-			attributeKey: filter.attributeKey.key,
-			filterAttributeKeyDataType: filter.attributeKey.dataType || DataTypes.EMPTY,
-			tagType: filter.attributeKey.type || '',
-			searchText: searchText ?? '',
-		},
-		{
-			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
-			keepPreviousData: true,
-		},
-	);
-
-	const { data: keyValueSuggestions, isLoading: isLoadingKeyValueSuggestions } =
-		useGetQueryKeyValueSuggestions({
-			key: filter.attributeKey.key,
-			signal: filter.dataSource || DataSource.LOGS,
-			signalSource: 'meter',
-			options: {
-				enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
-				keepPreviousData: true,
-			},
-		});
-
-	const attributeValues: string[] = useMemo(() => {
-		const dataType = filter.attributeKey.dataType || DataTypes.String;
-
-		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
-			// Process the response data
-			const responseData = keyValueSuggestions?.data as any;
-			const values = responseData.data?.values || {};
-			const stringValues = values.stringValues || [];
-			const numberValues = values.numberValues || [];
-
-			// Generate options from string values - explicitly handle empty strings
-			const stringOptions = stringValues
-				// Strict filtering for empty string - we'll handle it as a special case if needed
-				.filter(
-					(value: string | null | undefined): value is string =>
-						value !== null && value !== undefined && value !== '',
-				);
-
-			// Generate options from number values
-			const numberOptions = numberValues
-				.filter(
-					(value: number | null | undefined): value is number =>
-						value !== null && value !== undefined,
-				)
-				.map((value: number) => value.toString());
-
-			// Combine all options and make sure we don't have duplicate labels
-			return [...stringOptions, ...numberOptions];
-		}
-
-		const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
-		return (data?.payload?.[key] || []).filter(
-			(val) => val !== undefined && val !== null,
-		);
-	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
-
-	return {
-		attributeValues,
-		isLoading: isLoading || isLoadingKeyValueSuggestions,
-	};
-}
-
-export default useCheckboxFilterValues;

frontend/src/constants/localStorage.ts

@@ -38,8 +38,8 @@ export enum LOCALSTORAGE {
 	DISSMISSED_COST_METER_INFO = 'DISMISSED_COST_METER_INFO',
 	DISMISSED_API_KEYS_DEPRECATION_BANNER = 'DISMISSED_API_KEYS_DEPRECATION_BANNER',
 	TRACE_DETAILS_SPAN_DETAILS_POSITION = 'TRACE_DETAILS_SPAN_DETAILS_POSITION',
-	LICENSE_KEY_CALLOUT_DISMISSED = 'LICENSE_KEY_CALLOUT_DISMISSED',
 	TRACE_DETAILS_PREFER_OLD_VIEW = 'TRACE_DETAILS_PREFER_OLD_VIEW',
+	LICENSE_KEY_CALLOUT_DISMISSED = 'LICENSE_KEY_CALLOUT_DISMISSED',
 	DASHBOARD_PREFERENCES = 'DASHBOARD_PREFERENCES',
 	ACTIVE_SIGNOZ_INSTANCE_URL = 'ACTIVE_SIGNOZ_INSTANCE_URL',
 	DASHBOARDS_LIST_VISIBLE_COLUMNS = 'DASHBOARDS_LIST_VISIBLE_COLUMNS',

frontend/src/constants/reactQueryKeys.ts

@@ -113,7 +113,4 @@ export const REACT_QUERY_KEY = {
 
 	// Fields Selector Query Keys
 	GET_FIELDS_SELECTOR_SUGGESTIONS: 'GET_FIELDS_SELECTOR_SUGGESTIONS',
-
-	// AI Assistant Query Keys
-	AI_ASSISTANT_EMPTY_STATE_CHIPS: 'AI_ASSISTANT_EMPTY_STATE_CHIPS',
 } as const;

frontend/src/constants/routes.ts

@@ -77,7 +77,6 @@ const ROUTES = {
 	METRICS_EXPLORER: '/metrics-explorer/summary',
 	METRICS_EXPLORER_EXPLORER: '/metrics-explorer/explorer',
 	METRICS_EXPLORER_VIEWS: '/metrics-explorer/views',
-	METRICS_EXPLORER_VOLUME_CONTROL: '/metrics-explorer/volume-control',
 	API_MONITORING_BASE: '/api-monitoring',
 	API_MONITORING: '/api-monitoring/explorer',
 	METRICS_EXPLORER_BASE: '/metrics-explorer',

frontend/src/container/AIAssistant/__tests__/getAutoContexts.test.ts

@@ -63,50 +63,6 @@ describe('getAutoContexts', () => {
 		]);
 	});
 
-	it('resolves alert list tabs on /alerts', () => {
-		expect(getAutoContexts(ROUTES.LIST_ALL_ALERT, '')).toStrictEqual([
-			{
-				source: 'auto',
-				type: 'alert',
-				resourceId: null,
-				metadata: { page: 'alert_list' },
-			},
-		]);
-
-		expect(
-			getAutoContexts(ROUTES.LIST_ALL_ALERT, '?tab=AlertRules'),
-		).toStrictEqual([
-			{
-				source: 'auto',
-				type: 'alert',
-				resourceId: null,
-				metadata: { page: 'alert_list' },
-			},
-		]);
-
-		expect(
-			getAutoContexts(ROUTES.LIST_ALL_ALERT, '?tab=TriggeredAlerts'),
-		).toStrictEqual([
-			{
-				source: 'auto',
-				type: 'alert',
-				resourceId: null,
-				metadata: { page: 'alerts_triggered' },
-			},
-		]);
-
-		expect(
-			getAutoContexts(ROUTES.LIST_ALL_ALERT, '?tab=Configuration'),
-		).toStrictEqual([
-			{
-				source: 'auto',
-				type: 'alert',
-				resourceId: null,
-				metadata: { page: 'alert_list' },
-			},
-		]);
-	});
-
 	it('returns dashboard detail context on dashboard page', () => {
 		const dashboardId = 'dash-123';
 		const pathname = ROUTES.DASHBOARD.replace(':dashboardId', dashboardId);
@@ -130,21 +86,4 @@ describe('getAutoContexts', () => {
 
 		expect(contexts).toStrictEqual([]);
 	});
-
-	it('emits no auto-context on /home (no attachable resource)', () => {
-		expect(getAutoContexts(ROUTES.HOME, '')).toStrictEqual([]);
-	});
-
-	it('emits no auto-context on infrastructure monitoring routes', () => {
-		expect(
-			getAutoContexts(ROUTES.INFRASTRUCTURE_MONITORING_BASE, ''),
-		).toStrictEqual([]);
-
-		expect(
-			getAutoContexts(
-				ROUTES.INFRASTRUCTURE_MONITORING_HOSTS,
-				'?selectedItem=host-1',
-			),
-		).toStrictEqual([]);
-	});
 });

frontend/src/container/AIAssistant/__tests__/resolvePageType.test.ts

@@ -1,87 +0,0 @@
-import { PageTypeDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { QueryParams } from 'constants/query';
-import ROUTES from 'constants/routes';
-
-import { resolvePageType } from '../resolvePageType';
-
-describe('resolvePageType', () => {
-	it('returns other for the standalone assistant surface', () => {
-		expect(
-			resolvePageType('/services', '', { isStandaloneAssistant: true }),
-		).toBe(PageTypeDTO.other);
-	});
-
-	it('returns dashboard_detail on a dashboard page', () => {
-		const pathname = ROUTES.DASHBOARD.replace(':dashboardId', 'dash-123');
-
-		expect(resolvePageType(pathname, '')).toBe(PageTypeDTO.dashboard_detail);
-	});
-
-	it('returns alerts_triggered on alert history without ruleId', () => {
-		expect(resolvePageType(ROUTES.ALERT_HISTORY, '')).toBe(
-			PageTypeDTO.alerts_triggered,
-		);
-	});
-
-	it('resolves alert list tabs on /alerts', () => {
-		expect(resolvePageType(ROUTES.LIST_ALL_ALERT, '')).toBe(
-			PageTypeDTO.alert_list,
-		);
-		expect(resolvePageType(ROUTES.LIST_ALL_ALERT, '?tab=AlertRules')).toBe(
-			PageTypeDTO.alert_list,
-		);
-		expect(resolvePageType(ROUTES.LIST_ALL_ALERT, '?tab=TriggeredAlerts')).toBe(
-			PageTypeDTO.alerts_triggered,
-		);
-		expect(resolvePageType(ROUTES.LIST_ALL_ALERT, '?tab=Configuration')).toBe(
-			PageTypeDTO.alert_list,
-		);
-	});
-
-	it('returns log_detail when logs explorer has activeLogId', () => {
-		const search = `?${QueryParams.activeLogId}=log-1`;
-
-		expect(resolvePageType(ROUTES.LOGS_EXPLORER, search)).toBe(
-			PageTypeDTO.log_detail,
-		);
-	});
-
-	it('returns other for unmapped routes', () => {
-		expect(resolvePageType(ROUTES.ALERT_OVERVIEW, '')).toBe(PageTypeDTO.other);
-	});
-
-	it('returns other for the app root route (no contextual mapping)', () => {
-		expect(resolvePageType(ROUTES.HOME_PAGE, '')).toBe(PageTypeDTO.other);
-	});
-
-	it('returns homepage on /home', () => {
-		expect(resolvePageType(ROUTES.HOME, '')).toBe(PageTypeDTO.homepage);
-	});
-
-	it('returns infra_entity_detail on infrastructure monitoring routes', () => {
-		expect(resolvePageType(ROUTES.INFRASTRUCTURE_MONITORING_BASE, '')).toBe(
-			PageTypeDTO.infra_entity_detail,
-		);
-		expect(resolvePageType(ROUTES.INFRASTRUCTURE_MONITORING_HOSTS, '')).toBe(
-			PageTypeDTO.infra_entity_detail,
-		);
-		expect(resolvePageType(ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES, '')).toBe(
-			PageTypeDTO.infra_entity_detail,
-		);
-	});
-
-	it('returns metrics_explorer on all metrics explorer routes', () => {
-		expect(resolvePageType(ROUTES.METRICS_EXPLORER_BASE, '')).toBe(
-			PageTypeDTO.metrics_explorer,
-		);
-		expect(resolvePageType(ROUTES.METRICS_EXPLORER, '')).toBe(
-			PageTypeDTO.metrics_explorer,
-		);
-		expect(resolvePageType(ROUTES.METRICS_EXPLORER_EXPLORER, '')).toBe(
-			PageTypeDTO.metrics_explorer,
-		);
-		expect(resolvePageType(ROUTES.METRICS_EXPLORER_VIEWS, '')).toBe(
-			PageTypeDTO.metrics_explorer,
-		);
-	});
-});

frontend/src/container/AIAssistant/components/ActionsSection/ActionsSection.tsx

@@ -47,7 +47,14 @@ import { AIAssistantEvents, SuggestedPromptCategory } from '../../events';
 import { useAIAssistantAnalyticsContext } from '../../hooks/useAIAssistantAnalyticsContext';
 import { useAIAssistantStore } from '../../store/useAIAssistantStore';
 
-import { openSavedViewByKey } from './utils/openSavedView';
+import {
+	getPanelTypeForRequestType,
+	requestTypeFromActionQuery,
+} from './utils/applyFilterPanelType';
+import {
+	buildExplorerNavigationUrl,
+	openSavedViewByKey,
+} from './utils/openSavedView';
 import {
 	isSavedViewOpenAction,
 	resolveOpenResourceType,
@@ -323,48 +330,41 @@ function withDerivedFilterExpressions(query: Query): Query {
  *     the new URL on mount.
  */
 function applyFilter(action: MessageActionDTO, deps: ApplyFilterDeps): void {
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] enter', {
-		signal: action.signal,
-		query: action.query,
-		pathname: deps.pathname,
-	});
 	if (!action.signal || !action.query) {
-		// eslint-disable-next-line no-console
-		console.warn('[apply_filter] bail: missing signal or query', action);
 		return;
 	}
 	const urlQuery = toUrlCompositeQuery(action.query as Record<string, unknown>);
 	if (!urlQuery) {
-		// eslint-disable-next-line no-console
-		console.warn(
-			'[apply_filter] bail: toUrlCompositeQuery returned null — agent payload shape unrecognized',
-			action.query,
-		);
 		return;
 	}
+	// `requestType` lives on the request envelope, which `toUrlCompositeQuery`
+	// drops — read it off the raw action query and translate it into the
+	// explorer panel type so a grouped/aggregated query opens as a table/graph
+	// instead of the default raw-log List view.
+	const panelType = getPanelTypeForRequestType(
+		requestTypeFromActionQuery(action.query as Record<string, unknown>),
+	);
 	const normalized = withDerivedFilterExpressions(urlQuery as unknown as Query);
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] normalized', normalized);
 	if (signalMatchesPathname(action.signal, deps.pathname)) {
-		// eslint-disable-next-line no-console
-		console.log('[apply_filter] on-page → handleSetQueryData + redirect');
 		normalized.builder.queryData.forEach((q, i) => {
 			deps.handleSetQueryData(i, q);
 		});
-		deps.redirectWithQueryBuilderData(normalized);
+		deps.redirectWithQueryBuilderData(normalized, {
+			[QueryParams.panelTypes]: panelType,
+		});
 		return;
 	}
 	const base = explorerRouteForSignal(action.signal);
 	if (!base) {
-		// eslint-disable-next-line no-console
-		console.warn('[apply_filter] bail: no route for signal', action.signal);
 		return;
 	}
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] off-page → history.push', base);
-	const encoded = encodeURIComponent(JSON.stringify(normalized));
-	deps.history.push(`${base}?${QueryParams.compositeQuery}=${encoded}`);
+	// Reuse the saved-view URL builder so the encoding (double-encoded
+	// compositeQuery + JSON-stringified panelTypes) matches what the explorer's
+	// URL parser expects — see useGetCompositeQueryParam / useGetPanelTypesQueryParam.
+	const url = buildExplorerNavigationUrl(base, normalized, {
+		[QueryParams.panelTypes]: panelType,
+	});
+	deps.history.push(url);
 }
 
 /** Picks the right rollback API call for a given action kind. */

frontend/src/container/AIAssistant/components/ActionsSection/utils/__tests__/applyFilterPanelType.test.ts

@@ -0,0 +1,75 @@
+import { PANEL_TYPES } from 'constants/queryBuilder';
+
+import {
+	getPanelTypeForRequestType,
+	requestTypeFromActionQuery,
+} from '../applyFilterPanelType';
+
+describe('getPanelTypeForRequestType', () => {
+	it('maps scalar (grouped aggregation) to the Table view', () => {
+		expect(getPanelTypeForRequestType('scalar')).toBe(PANEL_TYPES.TABLE);
+	});
+
+	it('maps time_series to the Time Series (graph) view', () => {
+		expect(getPanelTypeForRequestType('time_series')).toBe(
+			PANEL_TYPES.TIME_SERIES,
+		);
+	});
+
+	it('maps distribution (aggregation) to the Table view', () => {
+		expect(getPanelTypeForRequestType('distribution')).toBe(PANEL_TYPES.TABLE);
+	});
+
+	it('maps raw to the List view', () => {
+		expect(getPanelTypeForRequestType('raw')).toBe(PANEL_TYPES.LIST);
+	});
+
+	it.each([undefined, null, '', 'trace', 'nonsense', 42, {}])(
+		'defaults to the List view for raw/unknown/missing requestType (%p)',
+		(value) => {
+			expect(getPanelTypeForRequestType(value)).toBe(PANEL_TYPES.LIST);
+		},
+	);
+});
+
+describe('requestTypeFromActionQuery', () => {
+	it('reads the top-level requestType envelope field', () => {
+		expect(
+			requestTypeFromActionQuery({
+				requestType: 'scalar',
+				schemaVersion: 'v5',
+				compositeQuery: { queries: [] },
+			}),
+		).toBe('scalar');
+	});
+
+	it('returns undefined when the field or query is absent', () => {
+		expect(requestTypeFromActionQuery({})).toBeUndefined();
+		expect(requestTypeFromActionQuery(null)).toBeUndefined();
+		expect(requestTypeFromActionQuery(undefined)).toBeUndefined();
+	});
+
+	it('composes with getPanelTypeForRequestType for the reported bug payload', () => {
+		// The "log count by service" apply_filter payload from issue #304 follow-up:
+		// scalar + groupBy(service.name) must open the Table view, not List.
+		const query = {
+			requestType: 'scalar',
+			schemaVersion: 'v5',
+			compositeQuery: {
+				queries: [
+					{
+						type: 'builder_query',
+						spec: {
+							signal: 'logs',
+							aggregations: [{ expression: 'count()' }],
+							groupBy: [{ name: 'service.name' }],
+						},
+					},
+				],
+			},
+		};
+		expect(getPanelTypeForRequestType(requestTypeFromActionQuery(query))).toBe(
+			PANEL_TYPES.TABLE,
+		);
+	});
+});

frontend/src/container/AIAssistant/components/ActionsSection/utils/__tests__/openSavedView.test.ts

@@ -221,6 +221,20 @@ describe('buildExplorerNavigationUrl', () => {
 		expect(url).toContain(`${QueryParams.compositeQuery}=`);
 		expect(url).toContain(`${QueryParams.viewKey}=`);
 	});
+
+	// Regression guard for the apply_filter view bug: the panel type must land
+	// on the URL JSON-encoded the way `useGetPanelTypesQueryParam` reads it
+	// (`JSON.parse` of the param), i.e. as the quoted string `"table"` ->
+	// `panelTypes=%22table%22`. Without this the explorer falls back to LIST.
+	it('JSON-encodes panelTypes so the explorer opens the right view', () => {
+		const url = buildExplorerNavigationUrl(
+			ROUTES.LOGS_EXPLORER,
+			{ queryType: 'builder' } as never,
+			{ [QueryParams.panelTypes]: PANEL_TYPES.TABLE },
+		);
+
+		expect(url).toContain(`${QueryParams.panelTypes}=%22table%22`);
+	});
 });
 
 describe('openSavedView', () => {

frontend/src/container/AIAssistant/components/ActionsSection/utils/applyFilterPanelType.ts

@@ -0,0 +1,46 @@
+import { REQUEST_TYPES } from 'api/v5/queryRange/constants';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { RequestType } from 'types/api/v5/queryRange';
+
+/**
+ * Maps an apply_filter `query.requestType` to the explorer panel type so the
+ * Explorer opens in the view the query implies:
+ *
+ *   - `scalar`       -> Table        (grouped aggregation, e.g. "count by service")
+ *   - `distribution` -> Table        (aggregation; Logs/Traces have no histogram view)
+ *   - `time_series`  -> Time Series  (graph)
+ *   - `raw` / other  -> List         (raw rows) [default]
+ *
+ * `trace` and the empty request type fall through to the List default on
+ * purpose — they are raw, ungrouped result sets.
+ *
+ * The agent emits `requestType` on the request envelope of `action.query`. It
+ * must be read off the raw action query *before* `toUrlCompositeQuery` maps the
+ * inner `compositeQuery` (that mapper keeps only the builder queries and drops
+ * the envelope). Without an explicit `panelTypes` URL param the Explorer falls
+ * back to `PANEL_TYPES.LIST` (see `useGetPanelTypesQueryParam`), so a grouped
+ * "count by service" query renders as a raw log list instead of a table.
+ */
+const REQUEST_TYPE_TO_PANEL_TYPE: Partial<Record<RequestType, PANEL_TYPES>> = {
+	[REQUEST_TYPES.SCALAR]: PANEL_TYPES.TABLE,
+	[REQUEST_TYPES.DISTRIBUTION]: PANEL_TYPES.TABLE,
+	[REQUEST_TYPES.TIME_SERIES]: PANEL_TYPES.TIME_SERIES,
+	[REQUEST_TYPES.RAW]: PANEL_TYPES.LIST,
+};
+
+export function getPanelTypeForRequestType(requestType: unknown): PANEL_TYPES {
+	if (typeof requestType === 'string') {
+		const mapped = REQUEST_TYPE_TO_PANEL_TYPE[requestType as RequestType];
+		if (mapped) {
+			return mapped;
+		}
+	}
+	return PANEL_TYPES.LIST;
+}
+
+/** Reads the `requestType` envelope field off a raw apply_filter query payload. */
+export function requestTypeFromActionQuery(
+	query: Record<string, unknown> | null | undefined,
+): unknown {
+	return query?.requestType;
+}

frontend/src/container/AIAssistant/components/VirtualizedMessages/VirtualizedMessages.module.scss

@@ -45,7 +45,7 @@
 	line-height: 1.45;
 }
 
-.suggestions {
+.emptySuggestions {
 	display: flex;
 	flex-direction: column;
 	gap: 6px;
@@ -53,8 +53,11 @@
 	max-width: 360px;
 }
 
-.suggestion {
-	width: 100%;
+.emptyChip {
+	display: flex;
+	align-items: center;
+	justify-content: flex-start !important;
+	gap: 8px;
 	padding: 10px 14px;
 	border: 1px solid var(--l2-border);
 	border-radius: var(--radius-2);
@@ -63,16 +66,21 @@
 	font-size: 12.5px;
 	text-align: left;
 	cursor: pointer;
-	transition:
-		background 0.15s ease,
-		border-color 0.15s ease,
-		color 0.15s ease;
+	transition: all 0.15s ease;
 	line-height: 1.35;
-	overflow-wrap: anywhere;
 
 	&:hover {
 		background: var(--l2-background);
 		border-color: var(--l3-border);
 		color: var(--l1-foreground);
 	}
+
+	svg {
+		flex-shrink: 0;
+		color: var(--l3-foreground);
+	}
+
+	&:hover svg {
+		color: var(--accent-primary);
+	}
 }

frontend/src/container/AIAssistant/components/VirtualizedMessages/VirtualizedMessages.tsx

@@ -1,5 +1,13 @@
 import { useCallback, useEffect, useRef } from 'react';
+import { Button } from '@signozhq/ui/button';
 import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
+import {
+	Activity,
+	TriangleAlert,
+	ChartBar,
+	Search,
+	Zap,
+} from '@signozhq/icons';
 import Noz from 'components/Noz/Noz';
 
 import logEvent from 'api/common/logEvent';
@@ -12,7 +20,29 @@ import MessageBubble from '../MessageBubble';
 import StreamingMessage from '../StreamingMessage';
 
 import styles from './VirtualizedMessages.module.scss';
-import { useEmptyStateChips } from './useEmptyStateChips';
+
+const SUGGESTIONS = [
+	{
+		icon: TriangleAlert,
+		text: 'Show me the top errors in the last hour',
+	},
+	{
+		icon: Activity,
+		text: 'What services have the highest latency?',
+	},
+	{
+		icon: ChartBar,
+		text: 'Give me an overview of system health',
+	},
+	{
+		icon: Search,
+		text: 'Find slow database queries',
+	},
+	{
+		icon: Zap,
+		text: 'Which endpoints have the most 5xx errors?',
+	},
+];
 
 const EMPTY_EVENTS: StreamingEventItem[] = [];
 
@@ -143,10 +173,8 @@ export default function VirtualizedMessages({
 
 	const showStreamingSlot =
 		isStreaming || Boolean(pendingApproval) || Boolean(pendingClarification);
-	const isEmptyState = messages.length === 0 && !showStreamingSlot;
-	const { chips: emptyStateChips } = useEmptyStateChips(isEmptyState);
 
-	if (isEmptyState) {
+	if (messages.length === 0 && !showStreamingSlot) {
 		return (
 			<div className={styles.empty}>
 				<div className={`${styles.emptyIcon} noz-wave`}>
@@ -156,22 +184,24 @@ export default function VirtualizedMessages({
 				<p className={styles.emptySubtitle}>
 					Ask questions about your traces, logs, metrics, and infrastructure.
 				</p>
-				<div className={styles.suggestions}>
-					{emptyStateChips.map((chip) => (
-						<div
-							key={chip.id}
-							className={styles.suggestion}
+				<div className={styles.emptySuggestions}>
+					{SUGGESTIONS.map((s) => (
+						<Button
+							key={s.text}
+							variant="outlined"
+							color="secondary"
+							className={styles.emptyChip}
 							onClick={(): void => {
 								void logEvent(AIAssistantEvents.SuggestedPromptClicked, {
-									promptId: chip.id,
+									promptId: s.text,
 									category: SuggestedPromptCategory.EmptyState,
 								});
-								onSendSuggestedPrompt(chip.text);
+								onSendSuggestedPrompt(s.text);
 							}}
-							data-testid={`empty-state-chip-${chip.id}`}
+							prefix={<s.icon size={14} />}
 						>
-							{chip.text}
-						</div>
+							{s.text}
+						</Button>
 					))}
 				</div>
 			</div>

frontend/src/container/AIAssistant/components/VirtualizedMessages/emptyStateChipsFallback.ts

@@ -1,25 +0,0 @@
-import type { ChipDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-
-/** Static empty-state chips used when the contextual chips API is unavailable. */
-export const EMPTY_STATE_CHIPS_FALLBACK: ChipDTO[] = [
-	{
-		id: 'top_errors_last_hour',
-		text: 'Show me the top errors in the last hour',
-	},
-	{
-		id: 'highest_latency_services',
-		text: 'What services have the highest latency?',
-	},
-	{
-		id: 'system_health_overview',
-		text: 'Give me an overview of system health',
-	},
-	{
-		id: 'slow_database_queries',
-		text: 'Find slow database queries',
-	},
-	{
-		id: 'endpoints_5xx_errors',
-		text: 'Which endpoints have the most 5xx errors?',
-	},
-];

frontend/src/container/AIAssistant/components/VirtualizedMessages/useEmptyStateChips.ts

@@ -1,33 +0,0 @@
-import { useMemo } from 'react';
-import { useQuery } from 'react-query';
-
-import { getEmptyStateChips } from 'api/ai-assistant/chat';
-import type { ChipDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
-import { useResolvePageType } from 'hooks/aiAssistant/useResolvePageType';
-
-import { EMPTY_STATE_CHIPS_FALLBACK } from './emptyStateChipsFallback';
-
-interface UseEmptyStateChipsResult {
-	chips: ChipDTO[];
-}
-
-export function useEmptyStateChips(enabled: boolean): UseEmptyStateChipsResult {
-	const pageType = useResolvePageType();
-
-	const { data, isError } = useQuery(
-		[REACT_QUERY_KEY.AI_ASSISTANT_EMPTY_STATE_CHIPS, pageType],
-		({ signal }) => getEmptyStateChips(pageType, signal),
-		{ enabled },
-	);
-
-	const chips = useMemo(() => {
-		if (isError) {
-			return EMPTY_STATE_CHIPS_FALLBACK;
-		}
-		return data ?? [];
-	}, [data, isError]);
-
-	return { chips };
-}

frontend/src/container/AIAssistant/getAutoContexts.ts

@@ -1,7 +1,6 @@
 import type { MessageContext } from 'api/ai-assistant/chat';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
-import { AlertListTabs } from 'pages/AlertList/types';
 import { matchPath } from 'react-router-dom';
 
 /**
@@ -165,18 +164,13 @@ export function getAutoContexts(
 		];
 	}
 
-	// Alerts index — `/alerts` with tab query param (defaults to Alert Rules).
 	if (matchPath(pathname, { path: ROUTES.LIST_ALL_ALERT, exact: true })) {
-		const page = resolveAlertsIndexPage(params.get(QueryParams.tab));
 		return [
 			{
 				source: 'auto',
 				type: 'alert',
 				resourceId: null,
-				metadata: {
-					page,
-					...(page === 'alerts_triggered' ? sharedMetadata : {}),
-				},
+				metadata: { page: 'alert_list' },
 			},
 		];
 	}
@@ -282,9 +276,8 @@ export function getAutoContexts(
 
 	// ── Metrics ───────────────────────────────────────────────────────────────
 
-	// Metrics explorer — `/metrics-explorer` and sub-routes (summary, explorer, views).
 	if (
-		matchPath(pathname, { path: ROUTES.METRICS_EXPLORER_BASE, exact: false })
+		matchPath(pathname, { path: ROUTES.METRICS_EXPLORER_EXPLORER, exact: false })
 	) {
 		return [
 			{
@@ -299,25 +292,9 @@ export function getAutoContexts(
 		];
 	}
 
-	// NOTE: Homepage (`/home`) and infrastructure monitoring
-	// (`/infrastructure-monitoring/*`) intentionally emit no auto-context here.
-	// They have no resource that maps to `MessageContextDTOType`, so attaching
-	// a chip would misrepresent the page (e.g. a bogus "metrics_explorer"
-	// context). Their `page_type` for empty-state chips is resolved directly
-	// from the route in `resolvePageType`.
-
 	return [];
 }
 
-type AlertsIndexPage = 'alert_list' | 'alerts_triggered';
-
-function resolveAlertsIndexPage(tab: string | null): AlertsIndexPage {
-	if (tab === AlertListTabs.TRIGGERED_ALERTS) {
-		return 'alerts_triggered';
-	}
-	return 'alert_list';
-}
-
 /**
  * Pulls metadata fields that any page may carry in its query string —
  * `timeRange`, `query`, saved-view selectors, dashboard variables. Each

frontend/src/container/AIAssistant/resolvePageType.ts

@@ -1,74 +0,0 @@
-import { PageTypeDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { QueryParams } from 'constants/query';
-import ROUTES from 'constants/routes';
-import { matchPath } from 'react-router-dom';
-
-import { getAutoContexts } from './getAutoContexts';
-
-const PAGE_METADATA_TO_DTO: Record<string, PageTypeDTO> = {
-	dashboard_detail: PageTypeDTO.dashboard_detail,
-	dashboard_list: PageTypeDTO.dashboard_list,
-	panel_edit: PageTypeDTO.panel_edit,
-	panel_fullscreen: PageTypeDTO.panel_fullscreen,
-	logs_explorer: PageTypeDTO.logs_explorer,
-	trace_detail: PageTypeDTO.trace_detail,
-	traces_explorer: PageTypeDTO.traces_explorer,
-	metrics_explorer: PageTypeDTO.metrics_explorer,
-	service_detail: PageTypeDTO.service_detail,
-	services_list: PageTypeDTO.services_list,
-	alert_edit: PageTypeDTO.alert_edit,
-	alert_list: PageTypeDTO.alert_list,
-	alert_new: PageTypeDTO.alert_new,
-	alerts_triggered: PageTypeDTO.alerts_triggered,
-};
-
-interface ResolvePageTypeOptions {
-	/** Standalone `/ai-assistant` surface — no underlying observability page. */
-	isStandaloneAssistant?: boolean;
-}
-
-/**
- * Maps the current URL (and assistant surface) to the backend `page_type`
- * enum used by contextual empty-state chips.
- */
-export function resolvePageType(
-	pathname: string,
-	search: string,
-	options?: ResolvePageTypeOptions,
-): PageTypeDTO {
-	if (options?.isStandaloneAssistant) {
-		return PageTypeDTO.other;
-	}
-
-	// Pseudo-pages with no attachable resource: resolved straight from the
-	// route. They deliberately emit no auto-context chip (see `getAutoContexts`),
-	// so they can't be derived from `metadata.page` like the pages below.
-	if (matchPath(pathname, { path: ROUTES.HOME, exact: true })) {
-		return PageTypeDTO.homepage;
-	}
-	if (
-		matchPath(pathname, {
-			path: ROUTES.INFRASTRUCTURE_MONITORING_BASE,
-			exact: false,
-		})
-	) {
-		return PageTypeDTO.infra_entity_detail;
-	}
-
-	const contexts = getAutoContexts(pathname, search);
-	const page = contexts[0]?.metadata?.page;
-	if (typeof page === 'string') {
-		if (page === 'logs_explorer') {
-			const activeLogId = new URLSearchParams(search).get(QueryParams.activeLogId);
-			if (activeLogId) {
-				return PageTypeDTO.log_detail;
-			}
-		}
-		const mapped = PAGE_METADATA_TO_DTO[page];
-		if (mapped) {
-			return mapped;
-		}
-	}
-
-	return PageTypeDTO.other;
-}

frontend/src/container/DashboardContainer/visualization/charts/Pie/Pie.module.scss

@@ -63,6 +63,5 @@
 	flex: 0 0 auto;
 	min-height: 0;
 	min-width: 0;
-	padding-left: 12px;
-	padding-bottom: 12px;
+	padding: 8px;
 }

frontend/src/container/DashboardContainer/visualization/charts/Pie/Pie.tsx

@@ -16,7 +16,7 @@ import PieArc from './PieArc';
 import PieCenterLabel from './PieCenterLabel';
 import styles from './Pie.module.scss';
 import { PieTooltipData } from './types';
-import { getDonutGeometry, getFillColor } from './utils';
+import { getFillColor } from './utils';
 
 /**
  * Donut chart rendered with @visx. Splits its area into chart + legend with the
@@ -78,12 +78,16 @@ export default function Pie({
 			[containerWidth, containerHeight, position, data],
 		);
 
-	// Donut geometry derived from the allocated chart box, sized to leave room
-	// for the external leader labels (see getDonutGeometry).
-	const { size, radius, innerRadius } = useMemo(
-		() => getDonutGeometry(width, height),
-		[width, height],
-	);
+	// Donut geometry derived from the allocated chart box.
+	const { size, radius, innerRadius } = useMemo(() => {
+		const nextSize = Math.min(width, height);
+		const nextRadius = nextSize * 0.35;
+		return {
+			size: nextSize,
+			radius: nextRadius,
+			innerRadius: nextRadius * 0.6,
+		};
+	}, [width, height]);
 
 	const totalValue = useMemo(
 		() => visibleData.reduce((sum, slice) => sum + slice.value, 0),

frontend/src/container/DashboardContainer/visualization/charts/Pie/__tests__/utils.test.ts

@@ -1,40 +1,11 @@
 import {
 	getArcGeometry,
-	getDonutGeometry,
 	getFillColor,
 	getScaledFontSize,
 	lightenColor,
 } from '../utils';
 
 describe('Pie utils', () => {
-	describe('getDonutGeometry', () => {
-		it('keeps the label anchor inside the box (reserves room for leader labels)', () => {
-			const { radius } = getDonutGeometry(400, 300);
-			const half = Math.min(400, 300) / 2; // 150
-			// The label anchor sits at radius * 1.3 and must stay within the box
-			// half-extent so labels are not clipped.
-			expect(radius * 1.3).toBeLessThanOrEqual(half);
-			// And it should use the available room (anchor = half - 22 allowance).
-			expect(radius * 1.3).toBeCloseTo(half - 22);
-		});
-
-		it('derives size and inner radius from the outer radius', () => {
-			const { size, radius, innerRadius } = getDonutGeometry(300, 300);
-			expect(size).toBeCloseTo(radius * 2);
-			expect(innerRadius).toBeCloseTo(radius * 0.6);
-		});
-
-		it('sizes off the smaller dimension so it fits both axes', () => {
-			expect(getDonutGeometry(1000, 200)).toStrictEqual(
-				getDonutGeometry(200, 1000),
-			);
-		});
-
-		it('never returns a negative radius for a box too small for labels', () => {
-			expect(getDonutGeometry(20, 20).radius).toBe(0);
-		});
-	});
-
 	describe('getScaledFontSize', () => {
 		it('returns the base size for empty text', () => {
 			expect(getScaledFontSize({ text: '', baseSize: 30, innerRadius: 100 })).toBe(

frontend/src/container/DashboardContainer/visualization/charts/Pie/types.ts

@@ -10,16 +10,6 @@ export interface ScaledFontSizeArgs {
 	innerRadius: number;
 }
 
-/** Donut sizing for a given chart box: the outer/inner radii and the square it spans. */
-export interface DonutGeometry {
-	/** Outer diameter — feeds the visx Pie width/height and the render guard. */
-	size: number;
-	/** Outer radius of the donut ring. */
-	radius: number;
-	/** Inner radius (the hole) — also bounds the centre-total font. */
-	innerRadius: number;
-}
-
 export interface ArcGeometry {
 	/** Outer point where the leader label sits. */
 	labelX: number;

frontend/src/container/DashboardContainer/visualization/charts/Pie/utils.ts

@@ -3,37 +3,7 @@
  * so the renderer stays declarative (per the one-component-per-file rule).
  */
 
-import {
-	ArcGeometry,
-	DonutGeometry,
-	ParsedRgb,
-	ScaledFontSizeArgs,
-} from './types';
-
-// Leader-line + two-line label/value drawn outside the donut. `getArcGeometry`
-// anchors the label at `radius * LABEL_RADIUS_RATIO`; `LABEL_TEXT_ALLOWANCE` is
-// the px reserved beyond that anchor for the (10px, two-line) text so it never
-// clips against the SVG edge.
-const LABEL_RADIUS_RATIO = 1.3;
-const LABEL_TEXT_ALLOWANCE = 22;
-const INNER_RADIUS_RATIO = 0.6;
-
-/**
- * Sizes the donut to fit inside a `width × height` box *with room for the
- * external leader labels*. The label anchor sits at `radius * 1.3`, so we solve
- * the outer radius back from the box's half-extent minus the text allowance —
- * guaranteeing the labels stay inside the SVG instead of being clipped (V1 used
- * a flat `0.35 * min(w,h)`, which left too little margin on small panels).
- */
-export function getDonutGeometry(width: number, height: number): DonutGeometry {
-	const half = Math.min(width, height) / 2;
-	const radius = Math.max(0, (half - LABEL_TEXT_ALLOWANCE) / LABEL_RADIUS_RATIO);
-	return {
-		size: radius * 2,
-		radius,
-		innerRadius: radius * INNER_RADIUS_RATIO,
-	};
-}
+import { ArcGeometry, ParsedRgb, ScaledFontSizeArgs } from './types';
 
 /**
  * Shrinks the centre-total font as the text gets longer so it never overflows
@@ -67,7 +37,7 @@ export function getArcGeometry(
 	radius: number,
 ): ArcGeometry {
 	const angle = (startAngle + endAngle) / 2;
-	const labelRadius = radius * LABEL_RADIUS_RATIO;
+	const labelRadius = radius * 1.3;
 	const lineEndRadius = radius * 1.1;
 	return {
 		labelX: Math.sin(angle) * labelRadius,

frontend/src/container/DashboardContainer/visualization/charts/__tests__/utils.test.ts

@@ -1,79 +0,0 @@
-import { LegendPosition } from 'lib/uPlotV2/components/types';
-
-import { calculateChartDimensions } from '../utils';
-
-const labels = (count: number, length = 20): string[] =>
-	Array.from({ length: count }, (_, i) =>
-		`label-${i}`.padEnd(length, 'x').slice(0, length),
-	);
-
-describe('calculateChartDimensions', () => {
-	it('returns all zeros when the container has no space', () => {
-		expect(
-			calculateChartDimensions({
-				containerWidth: 0,
-				containerHeight: 300,
-				legendConfig: { position: LegendPosition.BOTTOM },
-				seriesLabels: labels(3),
-			}),
-		).toStrictEqual({
-			width: 0,
-			height: 0,
-			legendWidth: 0,
-			legendHeight: 0,
-			averageLegendWidth: 0,
-		});
-	});
-
-	it('RIGHT: reserves a side column capped at 30% of the width and keeps full height', () => {
-		const dims = calculateChartDimensions({
-			containerWidth: 1000,
-			containerHeight: 400,
-			legendConfig: { position: LegendPosition.RIGHT },
-			seriesLabels: labels(10, 40),
-		});
-		// 40-char labels approximate to 336px, capped at min(240, 30% of 1000).
-		expect(dims.legendWidth).toBe(240);
-		expect(dims.width).toBe(760);
-		expect(dims.height).toBe(400);
-		expect(dims.legendHeight).toBe(400);
-	});
-
-	it('BOTTOM: a single row of items reserves one legend row', () => {
-		const dims = calculateChartDimensions({
-			containerWidth: 1000,
-			containerHeight: 500,
-			legendConfig: { position: LegendPosition.BOTTOM },
-			seriesLabels: labels(3),
-		});
-		// One row = line height (28) + padding (12).
-		expect(dims.legendHeight).toBe(40);
-		expect(dims.height).toBe(460);
-		expect(dims.legendWidth).toBe(1000);
-	});
-
-	it('BOTTOM: many items cap at two rows on a tall container', () => {
-		const dims = calculateChartDimensions({
-			containerWidth: 1000,
-			containerHeight: 500,
-			legendConfig: { position: LegendPosition.BOTTOM },
-			seriesLabels: labels(40),
-		});
-		// Two rows = 2 * 40 - 12 (no trailing padding) = 68, under the 80px cap.
-		expect(dims.legendHeight).toBe(68);
-		expect(dims.height).toBe(432);
-	});
-
-	it('BOTTOM: on a short container the legend never takes more than 30% of the height', () => {
-		const dims = calculateChartDimensions({
-			containerWidth: 1000,
-			containerHeight: 160,
-			legendConfig: { position: LegendPosition.BOTTOM },
-			seriesLabels: labels(40),
-		});
-		// Without the height-relative cap the legend would take 68px of a 160px
-		// panel and the chart (pie especially) collapses to a sliver.
-		expect(dims.legendHeight).toBe(48); // 30% of 160
-		expect(dims.height).toBe(112);
-	});
-});

frontend/src/container/DashboardContainer/visualization/charts/utils.ts

@@ -116,15 +116,7 @@ export function calculateChartDimensions({
 			? legendRowCount * legendRowHeight - LEGEND_PADDING
 			: legendRowHeight;
 
-	// Cap at two rows / 80px, and never more than 30% of the container height
-	// (the doc above always promised the %-cap; without it, short grid panels
-	// hand most of their area to the legend and the chart — the pie donut
-	// especially — collapses to a sliver). 30% mirrors the RIGHT-legend width cap.
-	const maxAllowedLegendHeight = Math.min(
-		2 * legendRowHeight,
-		80,
-		Math.floor(containerHeight * 0.3),
-	);
+	const maxAllowedLegendHeight = Math.min(2 * legendRowHeight, 80);
 
 	const bottomLegendHeight = Math.min(
 		idealBottomLegendHeight,

frontend/src/container/MetricsApplication/Tabs/Overview/ServiceOverview.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from 'react';
 import { useParams } from 'react-router-dom';
+import { Skeleton } from 'antd';
 import { ENTITY_VERSION_V4 } from 'constants/app';
 import { FeatureKeys } from 'constants/features';
 import { PANEL_TYPES } from 'constants/queryBuilder';
@@ -123,14 +124,24 @@ function ServiceOverview({
 			/>
 			<Card data-testid="service_latency">
 				<GraphContainer>
-					<Graph
-						onDragSelect={onDragSelect}
-						widget={latencyWidget}
-						onClickHandler={handleGraphClick('Service')}
-						isQueryEnabled={isQueryEnabled}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							onDragSelect={onDragSelect}
+							widget={latencyWidget}
+							onClickHandler={handleGraphClick('Service')}
+							isQueryEnabled={isQueryEnabled}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			</Card>
 		</>

frontend/src/container/MetricsApplication/Tabs/Overview/TopLevelOperations.tsx

@@ -1,3 +1,4 @@
+import { Skeleton } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import axios from 'axios';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
@@ -28,14 +29,24 @@ function TopLevelOperation({
 				</Typography>
 			) : (
 				<GraphContainer>
-					<Graph
-						widget={widget}
-						onClickHandler={handleGraphClick(opName)}
-						onDragSelect={onDragSelect}
-						isQueryEnabled={!topLevelOperationsIsLoading}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							widget={widget}
+							onClickHandler={handleGraphClick(opName)}
+							onDragSelect={onDragSelect}
+							isQueryEnabled={!topLevelOperationsIsLoading}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			)}
 		</Card>

frontend/src/container/MetricsExplorer/MetricDetails/MetricDetails.styles.scss

@@ -516,11 +516,6 @@
 	--tooltip-z-index: 1000;
 }
 
-// Lift the volume-control config drawer above the MetricDetails drawer (z-index 1000).
-.volume-control-config-drawer {
-	z-index: 1100 !important;
-}
-
 @keyframes fade-in-out {
 	0% {
 		opacity: 0;

frontend/src/container/MetricsExplorer/MetricDetails/MetricDetails.tsx

@@ -21,7 +21,6 @@ import AllAttributes from './AllAttributes';
 import DashboardsAndAlertsPopover from './DashboardsAndAlertsPopover';
 import Highlights from './Highlights';
 import Metadata from './Metadata';
-import VolumeControlSection from './VolumeControl/VolumeControlSection';
 import { MetricDetailsProps } from './types';
 import { getMetricDetailsQuery } from './utils';
 
@@ -191,7 +190,6 @@ function MetricDetails({
 					isLoadingMetricMetadata={isLoadingMetricMetadata}
 					refetchMetricMetadata={refetchMetricMetadata}
 				/>
-				<VolumeControlSection metricName={metricName} />
 				<AllAttributes
 					metricName={metricName}
 					metricType={metadata?.type}

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/ImpactPanel.tsx

@@ -1,64 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import { Spin } from 'antd';
-import { MetricreductionruletypesGettableReductionRulePreviewDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { formatCompact } from './configUtils';
-import { RuleMode } from './types';
-import styles from './VolumeControlConfig.module.scss';
-
-interface ImpactPanelProps {
-	mode: RuleMode;
-	preview?: MetricreductionruletypesGettableReductionRulePreviewDTO;
-	isLoading: boolean;
-}
-
-function ImpactPanel({
-	mode,
-	preview,
-	isLoading,
-}: ImpactPanelProps): JSX.Element {
-	if (mode === 'all') {
-		return (
-			<div className={styles.impact} data-testid="volume-control-impact">
-				<Typography.Text className={styles.impactNote}>
-					All attributes remain queryable, no reduction.
-				</Typography.Text>
-			</div>
-		);
-	}
-
-	return (
-		<div className={styles.impact} data-testid="volume-control-impact">
-			{isLoading && <Spin size="small" />}
-			{!isLoading && preview && (
-				<div className={styles.meters}>
-					<div className={styles.meter}>
-						<span className={styles.meterLabel}>Ingested series</span>
-						<span className={styles.meterValue}>
-							{formatCompact(preview.ingestedSeries)}
-						</span>
-					</div>
-					<div className={styles.meter}>
-						<span className={styles.meterLabel}>Reduced series</span>
-						<span className={styles.meterValue}>
-							{formatCompact(preview.reducedSeries)}
-						</span>
-					</div>
-					<div className={styles.meter}>
-						<span className={styles.meterLabel}>Reduction</span>
-						<span className={`${styles.meterValue} ${styles.meterValueGood}`}>
-							−{Math.round(preview.reductionPercent)}%
-						</span>
-					</div>
-				</div>
-			)}
-			{!isLoading && !preview && (
-				<Typography.Text className={styles.impactNote}>
-					Select attributes to preview the impact.
-				</Typography.Text>
-			)}
-		</div>
-	);
-}
-
-export default ImpactPanel;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/LabelSelector.tsx

@@ -1,47 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import { Select } from 'antd';
-import { popupContainer } from 'utils/selectPopupContainer';
-
-import { RuleMode } from './types';
-import styles from './VolumeControlConfig.module.scss';
-
-interface LabelSelectorProps {
-	mode: RuleMode;
-	options: string[];
-	value: string[];
-	onChange: (labels: string[]) => void;
-	loading?: boolean;
-}
-
-function LabelSelector({
-	mode,
-	options,
-	value,
-	onChange,
-	loading,
-}: LabelSelectorProps): JSX.Element {
-	const helpText =
-		mode === 'include'
-			? 'Only the selected attributes will remain queryable.'
-			: 'The selected attributes will be aggregated away; all others stay queryable.';
-
-	return (
-		<div className={styles.field} data-testid="volume-control-label-selector">
-			<Typography.Text className={styles.fieldLabel}>Attributes</Typography.Text>
-			<Typography.Text className={styles.fieldHint}>{helpText}</Typography.Text>
-			<Select
-				mode="multiple"
-				className={styles.labelSelect}
-				placeholder="Select attributes"
-				value={value}
-				onChange={onChange}
-				loading={loading}
-				options={options.map((key) => ({ label: key, value: key }))}
-				getPopupContainer={popupContainer}
-				data-testid="volume-control-label-select"
-			/>
-		</div>
-	);
-}
-
-export default LabelSelector;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/ModeSelector.tsx

@@ -1,60 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-
-import { RuleMode } from './types';
-import styles from './VolumeControlConfig.module.scss';
-
-interface ModeOption {
-	mode: RuleMode;
-	title: string;
-	description: string;
-}
-
-const MODE_OPTIONS: ModeOption[] = [
-	{
-		mode: 'all',
-		title: 'Allow all attributes',
-		description: 'All attributes stay queryable. Removes any existing rule.',
-	},
-	{
-		mode: 'include',
-		title: 'Include attributes',
-		description: 'Allowlist: only the selected attributes stay queryable.',
-	},
-	{
-		mode: 'exclude',
-		title: 'Exclude attributes',
-		description: 'Blocklist: the selected attributes are aggregated away.',
-	},
-];
-
-interface ModeSelectorProps {
-	mode: RuleMode;
-	onChange: (mode: RuleMode) => void;
-}
-
-function ModeSelector({ mode, onChange }: ModeSelectorProps): JSX.Element {
-	return (
-		<div className={styles.modeCards} data-testid="volume-control-mode-selector">
-			{MODE_OPTIONS.map((option) => (
-				<button
-					type="button"
-					key={option.mode}
-					className={`${styles.modeCard} ${
-						mode === option.mode ? styles.modeCardActive : ''
-					}`}
-					onClick={(): void => onChange(option.mode)}
-					data-testid={`volume-control-mode-${option.mode}`}
-				>
-					<Typography.Text className={styles.modeTitle}>
-						{option.title}
-					</Typography.Text>
-					<Typography.Text className={styles.modeDesc}>
-						{option.description}
-					</Typography.Text>
-				</button>
-			))}
-		</div>
-	);
-}
-
-export default ModeSelector;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/RelatedAssetsWarning.tsx

@@ -1,51 +0,0 @@
-import { Info } from '@signozhq/icons';
-import { MetricreductionruletypesAffectedAssetDTO } from 'api/generated/services/sigNoz.schemas';
-
-import styles from './VolumeControlConfig.module.scss';
-
-interface RelatedAssetsWarningProps {
-	affectedAssets?: MetricreductionruletypesAffectedAssetDTO[] | null;
-}
-
-function RelatedAssetsWarning({
-	affectedAssets,
-}: RelatedAssetsWarningProps): JSX.Element | null {
-	const impacted = (affectedAssets ?? []).filter(
-		(asset) => (asset.impactedLabels ?? []).length > 0,
-	);
-	if (impacted.length === 0) {
-		return null;
-	}
-
-	const impactedLabels = Array.from(
-		new Set(impacted.flatMap((asset) => asset.impactedLabels ?? [])),
-	);
-
-	return (
-		<div className={styles.warning} data-testid="volume-control-warning">
-			<Info size={14} />
-			<div>
-				<div className={styles.warningTitle}>
-					This rule affects {impacted.length} related asset
-					{impacted.length > 1 ? 's' : ''}.
-				</div>
-				{impactedLabels.length > 0 && (
-					<div className={styles.warningDetail}>
-						{impactedLabels.join(', ')} will no longer be queryable; affected panels
-						fall back to aggregated data once the rule applies.
-					</div>
-				)}
-				<ul className={styles.assetList}>
-					{impacted.map((asset) => (
-						<li key={`${asset.type}-${asset.id}`}>
-							{asset.name}
-							{asset.widget ? ` · ${asset.widget}` : ''}
-						</li>
-					))}
-				</ul>
-			</div>
-		</div>
-	);
-}
-
-export default RelatedAssetsWarning;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/VolumeControlConfig.module.scss

@@ -1,172 +0,0 @@
-.body {
-	display: flex;
-	flex-direction: column;
-	gap: 20px;
-	padding: 4px 2px;
-}
-
-.title {
-	display: flex;
-	align-items: center;
-	gap: 10px;
-}
-
-.admin-tag {
-	font-size: 10px;
-	font-weight: 600;
-	letter-spacing: 0.03em;
-	color: var(--bg-amber-400, #ffd778);
-	border: 1px solid var(--bg-amber-500, #ffcc56);
-	border-radius: 99px;
-	padding: 1px 8px;
-}
-
-/* mode cards */
-.mode-cards {
-	display: grid;
-	grid-template-columns: repeat(3, 1fr);
-	gap: 10px;
-}
-
-.mode-card {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-	text-align: left;
-	border: 1px solid var(--bg-slate-400, #1d212d);
-	border-radius: 6px;
-	background: var(--bg-ink-300, #16181d);
-	padding: 12px;
-	cursor: pointer;
-	transition:
-		border-color 0.12s ease,
-		background 0.12s ease;
-}
-
-.mode-card:hover {
-	border-color: var(--bg-slate-200, #2c3140);
-}
-
-.mode-card-active {
-	border-color: var(--bg-robin-500, #4e74f8);
-	background: rgba(78, 116, 248, 0.08);
-}
-
-.mode-title {
-	font-size: 12.5px;
-	font-weight: 600;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.mode-desc {
-	font-size: 11px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-	line-height: 1.45;
-}
-
-/* label selector */
-.field {
-	display: flex;
-	flex-direction: column;
-	gap: 6px;
-}
-
-.field-label {
-	font-size: 12.5px;
-	font-weight: 600;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.field-hint {
-	font-size: 11px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.label-select {
-	width: 100%;
-	margin-top: 4px;
-}
-
-/* impact panel */
-.impact {
-	border: 1px solid var(--bg-slate-400, #1d212d);
-	border-radius: 6px;
-	background: var(--bg-ink-300, #16181d);
-	padding: 14px;
-}
-
-.impact-note {
-	font-size: 12px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.meters {
-	display: grid;
-	grid-template-columns: repeat(3, 1fr);
-	gap: 12px;
-}
-
-.meter {
-	display: flex;
-	flex-direction: column;
-	gap: 5px;
-}
-
-.meter-label {
-	font-size: 10px;
-	text-transform: uppercase;
-	letter-spacing: 0.04em;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.meter-value {
-	font-family: 'Geist Mono', monospace;
-	font-size: 18px;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.meter-value-good {
-	color: var(--bg-forest-400, #50e7a7);
-}
-
-/* related-asset warning */
-.warning {
-	display: flex;
-	gap: 10px;
-	padding: 11px 13px;
-	border-radius: 6px;
-	background: rgba(255, 204, 86, 0.07);
-	border: 1px solid rgba(255, 204, 86, 0.3);
-	color: var(--bg-amber-400, #ffd778);
-}
-
-.warning-title {
-	font-size: 12px;
-	font-weight: 600;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.warning-detail {
-	font-size: 11.5px;
-	color: var(--bg-vanilla-300, #e9e9e9);
-	margin-top: 4px;
-}
-
-.asset-list {
-	margin: 6px 0 0;
-	padding-left: 16px;
-	font-size: 11.5px;
-	color: var(--bg-vanilla-300, #e9e9e9);
-}
-
-/* footer */
-.footer {
-	display: flex;
-	align-items: center;
-	gap: 10px;
-	width: 100%;
-}
-
-.footer-spacer {
-	flex: 1;
-}

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/VolumeControlConfigDrawer.tsx

@@ -1,115 +0,0 @@
-import { Button } from '@signozhq/ui/button';
-import { DrawerWrapper } from '@signozhq/ui/drawer';
-import { MetricreductionruletypesGettableReductionRuleDTO } from 'api/generated/services/sigNoz.schemas';
-
-import ImpactPanel from './ImpactPanel';
-import LabelSelector from './LabelSelector';
-import ModeSelector from './ModeSelector';
-import RelatedAssetsWarning from './RelatedAssetsWarning';
-import { useVolumeControlConfig } from './useVolumeControlConfig';
-import styles from './VolumeControlConfig.module.scss';
-
-interface VolumeControlConfigDrawerProps {
-	metricName: string;
-	existingRule: MetricreductionruletypesGettableReductionRuleDTO | null;
-	open: boolean;
-	onClose: () => void;
-}
-
-function VolumeControlConfigDrawer({
-	metricName,
-	existingRule,
-	open,
-	onClose,
-}: VolumeControlConfigDrawerProps): JSX.Element {
-	const {
-		mode,
-		setMode,
-		labels,
-		setLabels,
-		attributeKeys,
-		isLoadingAttributes,
-		preview,
-		isPreviewLoading,
-		save,
-		remove,
-		isSaving,
-		isRemoving,
-		hasExistingRule,
-		isSaveDisabled,
-	} = useVolumeControlConfig({ metricName, existingRule, open, onClose });
-
-	const footer = (
-		<div className={styles.footer}>
-			<Button
-				variant="outlined"
-				color="secondary"
-				onClick={onClose}
-				data-testid="volume-control-cancel"
-			>
-				Cancel
-			</Button>
-			<div className={styles.footerSpacer} />
-			{hasExistingRule && (
-				<Button
-					variant="ghost"
-					color="destructive"
-					onClick={remove}
-					loading={isRemoving}
-					data-testid="volume-control-remove"
-				>
-					Remove rule
-				</Button>
-			)}
-			<Button
-				variant="solid"
-				color="primary"
-				onClick={save}
-				disabled={isSaveDisabled}
-				loading={isSaving}
-				data-testid="volume-control-save"
-			>
-				Save rule
-			</Button>
-		</div>
-	);
-
-	return (
-		<DrawerWrapper
-			open={open}
-			onOpenChange={(next: boolean): void => {
-				if (!next) {
-					onClose();
-				}
-			}}
-			title={`Manage attributes · ${metricName}`}
-			direction="right"
-			showCloseButton
-			width="wide"
-			footer={footer}
-			showOverlay={false}
-			className="volume-control-config-drawer"
-			style={{ zIndex: 1100 }}
-		>
-			<div className={styles.body} data-testid="volume-control-config-drawer">
-				<div className={styles.title}>
-					<span className={styles.adminTag}>Admin only</span>
-				</div>
-				<ModeSelector mode={mode} onChange={setMode} />
-				{mode !== 'all' && (
-					<LabelSelector
-						mode={mode}
-						options={attributeKeys}
-						value={labels}
-						onChange={setLabels}
-						loading={isLoadingAttributes}
-					/>
-				)}
-				<ImpactPanel mode={mode} preview={preview} isLoading={isPreviewLoading} />
-				<RelatedAssetsWarning affectedAssets={preview?.affectedAssets} />
-			</div>
-		</DrawerWrapper>
-	);
-}
-
-export default VolumeControlConfigDrawer;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/VolumeControlSection.module.scss

@@ -1,114 +0,0 @@
-.section {
-	margin-top: 16px;
-}
-
-.header {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	margin-bottom: 10px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.title {
-	font-size: 11px;
-	font-weight: 600;
-	text-transform: uppercase;
-	letter-spacing: 0.05em;
-}
-
-.card {
-	border: 1px solid var(--bg-slate-400, #1d212d);
-	border-radius: 6px;
-	padding: 12px 14px;
-	background: var(--bg-ink-300, #16181d);
-}
-
-.card-row {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	margin-bottom: 8px;
-}
-
-.status-dot {
-	width: 7px;
-	height: 7px;
-	border-radius: 50%;
-	flex: 0 0 auto;
-}
-
-.status-active {
-	background: var(--bg-forest-500, #25e192);
-}
-
-.status-pending {
-	background: var(--bg-amber-500, #ffcc56);
-}
-
-.card-title {
-	font-weight: 600;
-}
-
-.mode {
-	display: block;
-	font-size: 12px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-	margin-bottom: 8px;
-}
-
-.chips {
-	display: flex;
-	flex-wrap: wrap;
-	gap: 6px;
-}
-
-.chip {
-	font-family: 'Geist Mono', monospace;
-	font-size: 11px;
-	padding: 2px 8px;
-	border-radius: 4px;
-	background: var(--bg-ink-200, #23262e);
-	border: 1px solid var(--bg-slate-400, #1d212d);
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.empty {
-	display: flex;
-	flex-direction: column;
-	align-items: flex-start;
-	border: 1px dashed var(--bg-slate-300, #242834);
-	border-radius: 6px;
-	padding: 14px;
-}
-
-.empty-text {
-	font-size: 12px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.setup-button {
-	margin-top: 12px;
-}
-
-.edit-button {
-	margin-left: auto;
-}
-
-.pending-banner {
-	display: flex;
-	align-items: flex-start;
-	gap: 8px;
-	padding: 9px 12px;
-	margin-bottom: 10px;
-	border-radius: 6px;
-	background: rgba(35, 196, 248, 0.07);
-	border: 1px solid rgba(35, 196, 248, 0.25);
-	color: var(--bg-aqua-400, #4bcff9);
-}
-
-.pending-text {
-	font-size: 11.5px;
-	color: var(--bg-vanilla-300, #e9e9e9);
-	line-height: 1.45;
-}

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/VolumeControlSection.tsx

@@ -1,136 +0,0 @@
-import { Gauge, Info } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-import { Skeleton } from 'antd';
-import { useGetMetricReductionRule } from 'api/generated/services/metrics';
-import { useVolumeControlFeatureGate } from 'hooks/metricsExplorer/useVolumeControlFeatureGate';
-import { useState } from 'react';
-
-import { getLabelVerb, getMatchTypeLabel } from './utils';
-import VolumeControlConfigDrawer from './VolumeControlConfigDrawer';
-import styles from './VolumeControlSection.module.scss';
-
-interface VolumeControlSectionProps {
-	metricName: string;
-}
-
-function VolumeControlSection({
-	metricName,
-}: VolumeControlSectionProps): JSX.Element | null {
-	const { isVolumeControlEnabled, canManageVolumeControl } =
-		useVolumeControlFeatureGate();
-	const [isConfigOpen, setIsConfigOpen] = useState(false);
-
-	const { data, isLoading, error } = useGetMetricReductionRule(
-		{ metricName },
-		{
-			query: {
-				enabled: isVolumeControlEnabled && !!metricName,
-				retry: false,
-			},
-		},
-	);
-
-	if (!isVolumeControlEnabled) {
-		return null;
-	}
-
-	const rule = data?.data;
-	const hasRule = !!rule && !error;
-
-	const openConfig = (): void => setIsConfigOpen(true);
-	const closeConfig = (): void => setIsConfigOpen(false);
-
-	return (
-		<div className={styles.section} data-testid="volume-control-section">
-			<div className={styles.header}>
-				<Gauge size={14} />
-				<Typography.Text className={styles.title}>Volume control</Typography.Text>
-			</div>
-
-			{isLoading && <Skeleton active title={false} paragraph={{ rows: 2 }} />}
-
-			{!isLoading && hasRule && rule && !rule.active && (
-				<div
-					className={styles.pendingBanner}
-					data-testid="volume-control-pending-banner"
-				>
-					<Info size={13} />
-					<Typography.Text className={styles.pendingText}>
-						This metric&apos;s configuration was recently updated. Reduced volumes
-						will take effect within a few minutes.
-					</Typography.Text>
-				</div>
-			)}
-
-			{!isLoading && hasRule && rule && (
-				<div className={styles.card} data-testid="volume-control-active">
-					<div className={styles.cardRow}>
-						<span
-							className={`${styles.statusDot} ${
-								rule.active ? styles.statusActive : styles.statusPending
-							}`}
-						/>
-						<Typography.Text className={styles.cardTitle}>
-							{rule.active
-								? 'Aggregation rule active'
-								: 'Aggregation rule pending activation'}
-						</Typography.Text>
-						{canManageVolumeControl && (
-							<Button
-								variant="ghost"
-								color="secondary"
-								className={styles.editButton}
-								onClick={openConfig}
-								data-testid="volume-control-edit"
-							>
-								Edit
-							</Button>
-						)}
-					</div>
-					<Typography.Text className={styles.mode}>
-						{getMatchTypeLabel(rule.matchType)}
-					</Typography.Text>
-					<div className={styles.chips}>
-						{(rule.labels ?? []).map((label) => (
-							<span className={styles.chip} key={label}>
-								{getLabelVerb(rule.matchType)} {label}
-							</span>
-						))}
-					</div>
-				</div>
-			)}
-
-			{!isLoading && !hasRule && (
-				<div className={styles.empty} data-testid="volume-control-empty">
-					<Typography.Text className={styles.emptyText}>
-						No volume control rule. All series are retained. Aggregate away
-						high-cardinality attributes to reduce cost.
-					</Typography.Text>
-					{canManageVolumeControl && (
-						<Button
-							variant="solid"
-							color="primary"
-							className={styles.setupButton}
-							onClick={openConfig}
-							data-testid="volume-control-setup"
-						>
-							Set up volume control
-						</Button>
-					)}
-				</div>
-			)}
-
-			{canManageVolumeControl && isConfigOpen && (
-				<VolumeControlConfigDrawer
-					metricName={metricName}
-					existingRule={rule ?? null}
-					open={isConfigOpen}
-					onClose={closeConfig}
-				/>
-			)}
-		</div>
-	);
-}
-
-export default VolumeControlSection;

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/configUtils.ts

@@ -1,42 +0,0 @@
-import {
-	MetricreductionruletypesMatchTypeDTO,
-	MetricreductionruletypesGettableReductionRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-import { RuleMode } from './types';
-
-export function modeFromRule(
-	rule: MetricreductionruletypesGettableReductionRuleDTO | null | undefined,
-): { mode: RuleMode; labels: string[] } {
-	if (!rule) {
-		return { mode: 'all', labels: [] };
-	}
-	return {
-		mode:
-			rule.matchType === MetricreductionruletypesMatchTypeDTO.keep
-				? 'include'
-				: 'exclude',
-		labels: rule.labels ?? [],
-	};
-}
-
-export function matchTypeForMode(
-	mode: RuleMode,
-): MetricreductionruletypesMatchTypeDTO {
-	return mode === 'include'
-		? MetricreductionruletypesMatchTypeDTO.keep
-		: MetricreductionruletypesMatchTypeDTO.drop;
-}
-
-export function formatCompact(value: number): string {
-	if (value >= 1e9) {
-		return `${(value / 1e9).toFixed(1)}B`;
-	}
-	if (value >= 1e6) {
-		return `${(value / 1e6).toFixed(1)}M`;
-	}
-	if (value >= 1e3) {
-		return `${(value / 1e3).toFixed(1)}K`;
-	}
-	return `${value}`;
-}

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/types.ts

@@ -1 +0,0 @@
-export type RuleMode = 'all' | 'include' | 'exclude';

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/useVolumeControlConfig.ts

@@ -1,182 +0,0 @@
-import {
-	invalidateGetMetricReductionRule,
-	invalidateListMetricReductionRules,
-	invalidateListMetrics,
-	useDeleteMetricReductionRule,
-	useGetMetricAttributes,
-	usePreviewMetricReductionRule,
-	useUpsertMetricReductionRule,
-} from 'api/generated/services/metrics';
-import {
-	MetricreductionruletypesGettableReductionRulePreviewDTO,
-	MetricreductionruletypesGettableReductionRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { useNotifications } from 'hooks/useNotifications';
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import { matchTypeForMode, modeFromRule } from './configUtils';
-import { RuleMode } from './types';
-
-interface UseVolumeControlConfigParams {
-	metricName: string;
-	existingRule: MetricreductionruletypesGettableReductionRuleDTO | null;
-	open: boolean;
-	onClose: () => void;
-}
-
-export interface UseVolumeControlConfigResult {
-	mode: RuleMode;
-	setMode: (mode: RuleMode) => void;
-	labels: string[];
-	setLabels: (labels: string[]) => void;
-	attributeKeys: string[];
-	isLoadingAttributes: boolean;
-	preview?: MetricreductionruletypesGettableReductionRulePreviewDTO;
-	isPreviewLoading: boolean;
-	save: () => void;
-	remove: () => void;
-	isSaving: boolean;
-	isRemoving: boolean;
-	hasExistingRule: boolean;
-	isSaveDisabled: boolean;
-}
-
-const PREVIEW_DEBOUNCE_MS = 400;
-const SAVE_ERROR_MESSAGE = 'Failed to save volume control rule';
-const REMOVE_ERROR_MESSAGE = 'Failed to remove volume control rule';
-
-export function useVolumeControlConfig({
-	metricName,
-	existingRule,
-	open,
-	onClose,
-}: UseVolumeControlConfigParams): UseVolumeControlConfigResult {
-	const { notifications } = useNotifications();
-	const queryClient = useQueryClient();
-	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const initial = useMemo(() => modeFromRule(existingRule), [existingRule]);
-	const [mode, setMode] = useState<RuleMode>(initial.mode);
-	const [labels, setLabels] = useState<string[]>(initial.labels);
-
-	const attributesQuery = useGetMetricAttributes(
-		{ metricName },
-		{
-			start: minTime ? Math.floor(minTime / 1000000) : undefined,
-			end: maxTime ? Math.floor(maxTime / 1000000) : undefined,
-		},
-		{ query: { enabled: open && !!metricName } },
-	);
-	const attributeKeys = useMemo(
-		() => (attributesQuery.data?.data.attributes ?? []).map((attr) => attr.key),
-		[attributesQuery.data],
-	);
-
-	const previewMutation = usePreviewMetricReductionRule();
-	const { mutate: previewMutate, reset: previewReset } = previewMutation;
-	const [isPreviewPending, setIsPreviewPending] = useState(false);
-
-	useEffect(() => {
-		if (!open || mode === 'all' || labels.length === 0) {
-			previewReset();
-			setIsPreviewPending(false);
-			return undefined;
-		}
-		setIsPreviewPending(true);
-		const timer = setTimeout(() => {
-			previewMutate(
-				{ data: { metricName, matchType: matchTypeForMode(mode), labels } },
-				{ onSettled: () => setIsPreviewPending(false) },
-			);
-		}, PREVIEW_DEBOUNCE_MS);
-		return (): void => clearTimeout(timer);
-	}, [open, mode, labels, metricName, previewMutate, previewReset]);
-
-	const upsertMutation = useUpsertMetricReductionRule();
-	const deleteMutation = useDeleteMetricReductionRule();
-
-	const invalidate = useCallback((): void => {
-		void invalidateGetMetricReductionRule(queryClient, { metricName });
-		void invalidateListMetricReductionRules(queryClient);
-		void invalidateListMetrics(queryClient);
-	}, [queryClient, metricName]);
-
-	const removeRule = useCallback((): void => {
-		deleteMutation.mutate(
-			{ pathParams: { metricName } },
-			{
-				onSuccess: () => {
-					notifications.success({ message: 'Volume control rule removed' });
-					invalidate();
-					onClose();
-				},
-				onError: (error) =>
-					notifications.error({
-						message: error.response?.data?.error?.message ?? REMOVE_ERROR_MESSAGE,
-					}),
-			},
-		);
-	}, [deleteMutation, metricName, notifications, invalidate, onClose]);
-
-	const save = useCallback((): void => {
-		if (mode === 'all') {
-			if (!existingRule) {
-				onClose();
-				return;
-			}
-			removeRule();
-			return;
-		}
-		upsertMutation.mutate(
-			{
-				pathParams: { metricName },
-				data: { matchType: matchTypeForMode(mode), labels },
-			},
-			{
-				onSuccess: () => {
-					notifications.success({ message: 'Volume control rule saved' });
-					invalidate();
-					onClose();
-				},
-				onError: (error) =>
-					notifications.error({
-						message: error.response?.data?.error?.message ?? SAVE_ERROR_MESSAGE,
-					}),
-			},
-		);
-	}, [
-		mode,
-		labels,
-		metricName,
-		existingRule,
-		upsertMutation,
-		removeRule,
-		notifications,
-		invalidate,
-		onClose,
-	]);
-
-	return {
-		mode,
-		setMode,
-		labels,
-		setLabels,
-		attributeKeys,
-		isLoadingAttributes: attributesQuery.isLoading,
-		preview: previewMutation.data?.data,
-		isPreviewLoading: isPreviewPending,
-		save,
-		remove: removeRule,
-		isSaving: upsertMutation.isLoading || deleteMutation.isLoading,
-		isRemoving: deleteMutation.isLoading,
-		hasExistingRule: !!existingRule,
-		isSaveDisabled: mode !== 'all' && labels.length === 0,
-	};
-}

frontend/src/container/MetricsExplorer/MetricDetails/VolumeControl/utils.ts

@@ -1,19 +0,0 @@
-import { MetricreductionruletypesMatchTypeDTO } from 'api/generated/services/sigNoz.schemas';
-
-export function isKeepMode(
-	matchType: MetricreductionruletypesMatchTypeDTO,
-): boolean {
-	return matchType === MetricreductionruletypesMatchTypeDTO.keep;
-}
-
-export function getMatchTypeLabel(
-	matchType: MetricreductionruletypesMatchTypeDTO,
-): string {
-	return isKeepMode(matchType) ? 'Include attributes' : 'Exclude attributes';
-}
-
-export function getLabelVerb(
-	matchType: MetricreductionruletypesMatchTypeDTO,
-): string {
-	return isKeepMode(matchType) ? 'include' : 'exclude';
-}

frontend/src/container/MetricsExplorer/MetricDetails/__tests__/MetricDetails.test.tsx

@@ -77,14 +77,6 @@ jest.mock(
 		},
 );
 
-jest.mock(
-	'container/MetricsExplorer/MetricDetails/VolumeControl/VolumeControlSection',
-	() =>
-		function MockVolumeControlSection(): JSX.Element {
-			return <div data-testid="volume-control-section-mock">Volume Control</div>;
-		},
-);
-
 const useGetMetricMetadataMock = jest.spyOn(
 	metricsExplorerHooks,
 	'useGetMetricMetadata',

frontend/src/container/MetricsExplorer/Summary/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	MetricsexplorertypesStatDTO,
 	MetricsexplorertypesTreemapEntryDTO,

frontend/src/container/MetricsExplorer/VolumeControlTab/VolumeControlBadge.module.scss

@@ -1,27 +0,0 @@
-.badge {
-	display: inline-flex;
-	align-items: center;
-	gap: 5px;
-	height: 20px;
-	padding: 0 8px;
-	border-radius: 99px;
-	font-size: 11px;
-	font-weight: 600;
-}
-
-.active {
-	color: var(--bg-forest-400, #50e7a7);
-	background: rgba(37, 225, 146, 0.1);
-	border: 1px solid rgba(37, 225, 146, 0.22);
-}
-
-.pending {
-	color: var(--bg-amber-400, #ffd778);
-	background: rgba(255, 204, 86, 0.1);
-	border: 1px solid rgba(255, 204, 86, 0.25);
-}
-
-.none {
-	color: var(--bg-vanilla-400, #c0c1c3);
-	font-size: 12px;
-}

frontend/src/container/MetricsExplorer/VolumeControlTab/VolumeControlBadge.tsx

@@ -1,29 +0,0 @@
-import { Gauge } from '@signozhq/icons';
-import { MetricreductionruletypesGettableReductionRuleDTO } from 'api/generated/services/sigNoz.schemas';
-
-import styles from './VolumeControlBadge.module.scss';
-
-interface VolumeControlBadgeProps {
-	rule?: MetricreductionruletypesGettableReductionRuleDTO;
-}
-
-function VolumeControlBadge({ rule }: VolumeControlBadgeProps): JSX.Element {
-	if (!rule) {
-		return (
-			<span className={styles.none} data-testid="vc-badge-none">
-				—
-			</span>
-		);
-	}
-	return (
-		<span
-			className={`${styles.badge} ${rule.active ? styles.active : styles.pending}`}
-			data-testid="vc-badge-active"
-		>
-			<Gauge size={11} />
-			{rule.active ? 'Active' : 'Pending'}
-		</span>
-	);
-}
-
-export default VolumeControlBadge;

frontend/src/container/MetricsExplorer/VolumeControlTab/VolumeControlTab.module.scss

@@ -1,95 +0,0 @@
-.tab {
-	display: flex;
-	flex-direction: column;
-	gap: 16px;
-	padding: 16px 0;
-}
-
-.header {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-}
-
-.title-row {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	color: var(--bg-robin-400, #7190f9);
-}
-
-.title {
-	margin: 0 !important;
-}
-
-.subtitle {
-	font-size: 13px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-	max-width: 680px;
-}
-
-.stats {
-	display: flex;
-	gap: 12px;
-}
-
-.stat {
-	display: flex;
-	flex-direction: column;
-	gap: 6px;
-	min-width: 160px;
-	padding: 12px 16px;
-	border: 1px solid var(--bg-slate-400, #1d212d);
-	border-radius: 6px;
-	background: var(--bg-ink-400, #121317);
-}
-
-.stat-label {
-	font-size: 11px;
-	text-transform: uppercase;
-	letter-spacing: 0.05em;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.stat-value {
-	font-family: 'Geist Mono', monospace;
-	font-size: 22px;
-	font-weight: 600;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.metric-name {
-	font-family: 'Geist Mono', monospace;
-	font-size: 12.5px;
-	color: var(--bg-vanilla-100, #fff);
-}
-
-.attributes {
-	font-family: 'Geist Mono', monospace;
-	font-size: 12px;
-	color: var(--bg-vanilla-300, #e9e9e9);
-}
-
-.muted {
-	font-size: 12px;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.reduction {
-	font-family: 'Geist Mono', monospace;
-	font-size: 12px;
-	font-weight: 600;
-	color: var(--bg-forest-400, #50e7a7);
-}
-
-.empty {
-	padding: 32px 16px;
-	text-align: center;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}
-
-.unavailable {
-	padding: 48px 16px;
-	text-align: center;
-	color: var(--bg-vanilla-400, #c0c1c3);
-}

frontend/src/container/MetricsExplorer/VolumeControlTab/VolumeControlTab.tsx

@@ -1,275 +0,0 @@
-import { Gauge } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-import { Table } from 'antd';
-import type { TableColumnsType, TableProps } from 'antd';
-import { useListMetricReductionRules } from 'api/generated/services/metrics';
-import {
-	ListMetricReductionRulesParams,
-	MetricreductionruletypesGettableReductionRuleDTO,
-	MetricreductionruletypesOrderDTO,
-	MetricreductionruletypesReductionRuleOrderByDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import dayjs from 'dayjs';
-import { useVolumeControlFeatureGate } from 'hooks/metricsExplorer/useVolumeControlFeatureGate';
-import { useCallback, useMemo, useState } from 'react';
-
-import { formatCompact } from '../MetricDetails/VolumeControl/configUtils';
-import {
-	getLabelVerb,
-	getMatchTypeLabel,
-} from '../MetricDetails/VolumeControl/utils';
-import VolumeControlConfigDrawer from '../MetricDetails/VolumeControl/VolumeControlConfigDrawer';
-import VolumeControlBadge from './VolumeControlBadge';
-import styles from './VolumeControlTab.module.scss';
-
-const OrderBy = MetricreductionruletypesReductionRuleOrderByDTO;
-const SortOrder = MetricreductionruletypesOrderDTO;
-const DEFAULT_PAGE_SIZE = 10;
-
-const DEFAULT_PARAMS: Required<ListMetricReductionRulesParams> = {
-	orderBy: OrderBy.reduction,
-	order: SortOrder.desc,
-	offset: 0,
-	limit: DEFAULT_PAGE_SIZE,
-};
-
-function VolumeControlTab(): JSX.Element {
-	const { isVolumeControlEnabled, canManageVolumeControl } =
-		useVolumeControlFeatureGate();
-	const [selectedRule, setSelectedRule] =
-		useState<MetricreductionruletypesGettableReductionRuleDTO | null>(null);
-	const [params, setParams] =
-		useState<Required<ListMetricReductionRulesParams>>(DEFAULT_PARAMS);
-
-	const { data, isLoading } = useListMetricReductionRules(params, {
-		query: { enabled: isVolumeControlEnabled },
-	});
-
-	const rules = data?.data.rules ?? [];
-	const total = data?.data.total ?? 0;
-
-	const sortOrderFor = useCallback(
-		(
-			key: MetricreductionruletypesReductionRuleOrderByDTO,
-		): 'ascend' | 'descend' | undefined => {
-			if (params.orderBy !== key) {
-				return undefined;
-			}
-			return params.order === SortOrder.desc ? 'descend' : 'ascend';
-		},
-		[params],
-	);
-
-	const columns: TableColumnsType<MetricreductionruletypesGettableReductionRuleDTO> =
-		useMemo(
-			() => [
-				{
-					title: 'METRIC',
-					dataIndex: 'metricName',
-					key: OrderBy.metricname,
-					sorter: true,
-					sortOrder: sortOrderFor(OrderBy.metricname),
-					render: (metricName: string): JSX.Element => (
-						<span className={styles.metricName}>{metricName}</span>
-					),
-				},
-				{
-					title: 'STATUS',
-					key: 'status',
-					width: 130,
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => <VolumeControlBadge rule={rule} />,
-				},
-				{
-					title: 'MODE',
-					key: 'mode',
-					width: 160,
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => <span>{getMatchTypeLabel(rule.matchType)}</span>,
-				},
-				{
-					title: 'ATTRIBUTES',
-					key: 'attributes',
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => (
-						<span className={styles.attributes}>
-							{getLabelVerb(rule.matchType)} {(rule.labels ?? []).join(', ') || '—'}
-						</span>
-					),
-				},
-				{
-					title: 'INGESTED',
-					key: OrderBy.ingestedvolume,
-					width: 130,
-					sorter: true,
-					sortOrder: sortOrderFor(OrderBy.ingestedvolume),
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => (
-						<span className={styles.muted}>{formatCompact(rule.ingestedSeries)}</span>
-					),
-				},
-				{
-					title: 'REDUCED',
-					key: OrderBy.reducedvolume,
-					width: 130,
-					sorter: true,
-					sortOrder: sortOrderFor(OrderBy.reducedvolume),
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => <span>{formatCompact(rule.reducedSeries)}</span>,
-				},
-				{
-					title: 'CHANGE',
-					key: OrderBy.reduction,
-					width: 110,
-					sorter: true,
-					sortOrder: sortOrderFor(OrderBy.reduction),
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => {
-						if (rule.reductionPercent <= 0) {
-							return <span className={styles.muted}>—</span>;
-						}
-						return (
-							<span className={styles.reduction}>
-								−{Math.round(rule.reductionPercent)}%
-							</span>
-						);
-					},
-				},
-				{
-					title: 'LAST CONFIGURED',
-					key: OrderBy.lastupdated,
-					width: 240,
-					sorter: true,
-					sortOrder: sortOrderFor(OrderBy.lastupdated),
-					render: (
-						_value: unknown,
-						rule: MetricreductionruletypesGettableReductionRuleDTO,
-					): JSX.Element => (
-						<span className={styles.muted}>
-							{dayjs(rule.updatedAt).format('MMM D, YYYY · h:mm A')}
-							{rule.updatedBy ? ` · ${rule.updatedBy}` : ''}
-						</span>
-					),
-				},
-				...(canManageVolumeControl
-					? ([
-							{
-								title: '',
-								key: 'action',
-								width: 110,
-								render: (
-									_value: unknown,
-									rule: MetricreductionruletypesGettableReductionRuleDTO,
-								): JSX.Element => (
-									<Button
-										variant="ghost"
-										color="secondary"
-										onClick={(): void => setSelectedRule(rule)}
-										data-testid={`vc-manage-${rule.metricName}`}
-									>
-										Manage
-									</Button>
-								),
-							},
-						] as TableColumnsType<MetricreductionruletypesGettableReductionRuleDTO>)
-					: []),
-			],
-			[canManageVolumeControl, sortOrderFor],
-		);
-
-	const handleTableChange: TableProps<MetricreductionruletypesGettableReductionRuleDTO>['onChange'] =
-		(pagination, _filters, sorter): void => {
-			const active = Array.isArray(sorter) ? sorter[0] : sorter;
-			const pageSize = pagination.pageSize ?? DEFAULT_PAGE_SIZE;
-			const current = pagination.current ?? 1;
-
-			setParams({
-				orderBy: active?.order
-					? (active.columnKey as MetricreductionruletypesReductionRuleOrderByDTO)
-					: DEFAULT_PARAMS.orderBy,
-				order: active?.order === 'descend' ? SortOrder.desc : SortOrder.asc,
-				limit: pageSize,
-				offset: (current - 1) * pageSize,
-			});
-		};
-
-	if (!isVolumeControlEnabled) {
-		return (
-			<div className={styles.unavailable} data-testid="volume-control-unavailable">
-				<Typography.Text>
-					Volume control is available on enterprise and cloud plans.
-				</Typography.Text>
-			</div>
-		);
-	}
-
-	return (
-		<div className={styles.tab} data-testid="volume-control-tab">
-			<div className={styles.header}>
-				<div className={styles.titleRow}>
-					<Gauge size={18} />
-					<Typography.Title level={4} className={styles.title}>
-						Volume Control
-					</Typography.Title>
-				</div>
-				<Typography.Text className={styles.subtitle}>
-					Aggregate away high-cardinality attributes to reduce stored metric volume
-					and cost.
-				</Typography.Text>
-			</div>
-
-			<div className={styles.stats}>
-				<div className={styles.stat}>
-					<span className={styles.statLabel}>Active rules</span>
-					<span className={styles.statValue}>{total}</span>
-				</div>
-			</div>
-
-			<Table<MetricreductionruletypesGettableReductionRuleDTO>
-				rowKey="metricName"
-				loading={isLoading}
-				dataSource={rules}
-				columns={columns}
-				onChange={handleTableChange}
-				pagination={{
-					current: Math.floor(params.offset / params.limit) + 1,
-					pageSize: params.limit,
-					total,
-					showSizeChanger: false,
-				}}
-				locale={{
-					emptyText: (
-						<div className={styles.empty} data-testid="volume-control-tab-empty">
-							No volume control rules yet. Open a metric and set one up to start
-							reducing its series volume.
-						</div>
-					),
-				}}
-			/>
-
-			{canManageVolumeControl && selectedRule && (
-				<VolumeControlConfigDrawer
-					metricName={selectedRule.metricName}
-					existingRule={selectedRule}
-					open={!!selectedRule}
-					onClose={(): void => setSelectedRule(null)}
-				/>
-			)}
-		</div>
-	);
-}
-
-export default VolumeControlTab;

frontend/src/container/NewWidget/index.tsx

@@ -823,8 +823,8 @@ function NewWidget({
 				<div className="right-header">
 					<HeaderRightSection
 						enableAnnouncements={false}
-						enableShare={false}
-						enableFeedback={false}
+						enableShare
+						enableFeedback
 					/>
 					{showSwitchToViewModeButton && (
 						<Button

frontend/src/container/TraceMetadata/TraceMetadata.styles.scss

@@ -68,6 +68,10 @@
 				border-left: unset;
 				border-radius: 0px 4px 4px 0px;
 			}
+
+			.new-view-btn {
+				margin-left: 8px;
+			}
 		}
 
 		.second-row {

frontend/src/hooks/aiAssistant/__tests__/useResolvePageType.test.ts

@@ -1,48 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { PageTypeDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import type { AIAssistantVariant } from 'container/AIAssistant/VariantContext';
-import ROUTES from 'constants/routes';
-
-import { useResolvePageType } from '../useResolvePageType';
-
-const mockUseLocation = jest.fn();
-const mockUseVariant = jest.fn();
-
-jest.mock('react-router-dom', () => ({
-	...jest.requireActual('react-router-dom'),
-	useLocation: (): unknown => mockUseLocation(),
-}));
-
-jest.mock('container/AIAssistant/VariantContext', () => ({
-	useVariant: (): unknown => mockUseVariant(),
-}));
-
-function setup(
-	pathname: string,
-	search: string,
-	variant: AIAssistantVariant,
-): PageTypeDTO {
-	mockUseLocation.mockReturnValue({ pathname, search });
-	mockUseVariant.mockReturnValue(variant);
-
-	return renderHook(() => useResolvePageType()).result.current;
-}
-
-describe('useResolvePageType', () => {
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns other for the standalone "page" assistant surface', () => {
-		const pathname = ROUTES.DASHBOARD.replace(':dashboardId', 'dash-123');
-
-		expect(setup(pathname, '', 'page')).toBe(PageTypeDTO.other);
-	});
-
-	it('resolves the underlying page type for embedded variants', () => {
-		const pathname = ROUTES.DASHBOARD.replace(':dashboardId', 'dash-123');
-
-		expect(setup(pathname, '', 'panel')).toBe(PageTypeDTO.dashboard_detail);
-		expect(setup(pathname, '', 'modal')).toBe(PageTypeDTO.dashboard_detail);
-	});
-});

frontend/src/hooks/aiAssistant/useResolvePageType.ts

@@ -1,23 +0,0 @@
-import { useMemo } from 'react';
-import { useLocation } from 'react-router-dom';
-
-import { PageTypeDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { resolvePageType } from 'container/AIAssistant/resolvePageType';
-import { useVariant } from 'container/AIAssistant/VariantContext';
-
-/**
- * React hook wrapper around `resolvePageType` that derives the current
- * `page_type` from the active location and assistant variant.
- */
-export function useResolvePageType(): PageTypeDTO {
-	const location = useLocation();
-	const variant = useVariant();
-
-	return useMemo(
-		() =>
-			resolvePageType(location.pathname, location.search, {
-				isStandaloneAssistant: variant === 'page',
-			}),
-		[location.pathname, location.search, variant],
-	);
-}

frontend/src/hooks/metricsExplorer/useVolumeControlFeatureGate.ts

@@ -1,23 +0,0 @@
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { useAppContext } from 'providers/App/App';
-import { USER_ROLES } from 'types/roles';
-
-interface VolumeControlFeatureGate {
-	isVolumeControlEnabled: boolean;
-	canManageVolumeControl: boolean;
-	isLoading: boolean;
-}
-
-export function useVolumeControlFeatureGate(): VolumeControlFeatureGate {
-	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
-	const { user, isFetchingActiveLicense, activeLicense } = useAppContext();
-
-	const isVolumeControlEnabled = isCloudUser || isEnterpriseSelfHostedUser;
-	const isAdmin = user?.role === USER_ROLES.ADMIN;
-
-	return {
-		isVolumeControlEnabled,
-		canManageVolumeControl: isVolumeControlEnabled && isAdmin,
-		isLoading: isFetchingActiveLicense && !activeLicense,
-	};
-}

frontend/src/lib/uPlotV2/components/Legend/Legend.styles.scss

@@ -44,6 +44,7 @@
 				auto-fill,
 				minmax(var(--legend-average-width, 240px), 1fr)
 			);
+			row-gap: 4px;
 			column-gap: 12px;
 		}
 

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/index.tsx

@@ -20,7 +20,6 @@ import APIError from 'types/api/error';
 import DashboardActions from './DashboardActions/DashboardActions';
 import DashboardInfo from './DashboardInfo/DashboardInfo';
 import { useEditableTitle } from './DashboardInfo/useEditableTitle';
-import { usePublicDashboardMeta } from '../DashboardSettings/PublicDashboard/usePublicDashboardMeta';
 
 import styles from './DashboardPageToolbar.module.scss';
 
@@ -53,10 +52,6 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);
 
-	// Single global fetch of the public-sharing meta (the drawer reuses this cache);
-	// drives the public-access badge.
-	const { isPublic: isPublicDashboard } = usePublicDashboardMeta(id);
-
 	const isAuthor =
 		!!user?.email && !!dashboard.createdBy && dashboard.createdBy === user.email;
 
@@ -122,7 +117,7 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 					image={image}
 					tags={tags}
 					description={description}
-					isPublicDashboard={isPublicDashboard}
+					isPublicDashboard={false}
 					isDashboardLocked={isDashboardLocked}
 					isEditing={isEditing}
 					draft={draft}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboard.module.scss

@@ -1,15 +0,0 @@
-// Publish tab — "status strip" direction (Claude Design: Publish Drawer Final).
-// Fills the drawer height so the actions anchor a footer instead of floating.
-.publishTab {
-	display: flex;
-	flex-direction: column;
-	height: 100%;
-	min-height: 100%;
-}
-
-.content {
-	flex: 1;
-	display: flex;
-	flex-direction: column;
-	gap: 20px;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardActions/PublicDashboardActions.module.scss

@@ -1,12 +0,0 @@
-.footer {
-	position: sticky;
-	z-index: 1;
-	flex: none;
-	display: flex;
-	align-items: center;
-	justify-content: flex-end;
-	gap: 12px;
-	margin-top: 10px;
-	padding-top: 14px;
-	border-top: 1px solid var(--l2-border);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardActions/PublicDashboardActions.tsx

@@ -1,71 +0,0 @@
-import { Globe, RefreshCw, Trash } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-
-import styles from './PublicDashboardActions.module.scss';
-
-interface PublicDashboardActionsProps {
-	isPublic: boolean;
-	disabled: boolean;
-	isPublishing: boolean;
-	isUpdating: boolean;
-	isUnpublishing: boolean;
-	onPublish: () => void;
-	onUpdate: () => void;
-	onUnpublish: () => void;
-}
-
-function PublicDashboardActions({
-	isPublic,
-	disabled,
-	isPublishing,
-	isUpdating,
-	isUnpublishing,
-	onPublish,
-	onUpdate,
-	onUnpublish,
-}: PublicDashboardActionsProps): JSX.Element {
-	return (
-		<div className={styles.footer}>
-			{isPublic ? (
-				<>
-					<Button
-						variant="outlined"
-						color="destructive"
-						disabled={disabled}
-						loading={isUnpublishing}
-						prefix={<Trash size={15} />}
-						testId="public-dashboard-unpublish"
-						onClick={onUnpublish}
-					>
-						Unpublish Dashboard
-					</Button>
-					<Button
-						variant="solid"
-						color="primary"
-						disabled={disabled}
-						loading={isUpdating}
-						prefix={<RefreshCw size={15} />}
-						testId="public-dashboard-update"
-						onClick={onUpdate}
-					>
-						Update Dashboard
-					</Button>
-				</>
-			) : (
-				<Button
-					variant="solid"
-					color="primary"
-					disabled={disabled}
-					loading={isPublishing}
-					prefix={<Globe size={15} />}
-					testId="public-dashboard-publish"
-					onClick={onPublish}
-				>
-					Publish Dashboard
-				</Button>
-			)}
-		</div>
-	);
-}
-
-export default PublicDashboardActions;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardHint/PublicDashboardHint.module.scss

@@ -1,19 +0,0 @@
-.hint {
-	display: flex;
-	align-items: flex-start;
-	gap: 8px;
-	padding-top: 2px;
-	color: var(--l3-foreground);
-}
-
-.hintIcon {
-	flex: none;
-	margin-top: 1px;
-	color: var(--l3-foreground);
-}
-
-.hintText {
-	color: var(--l3-foreground);
-	font-size: 12px;
-	line-height: 1.5;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardHint/PublicDashboardHint.tsx

@@ -1,17 +0,0 @@
-import { Info } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboardHint.module.scss';
-
-function PublicDashboardHint(): JSX.Element {
-	return (
-		<div className={styles.hint}>
-			<Info size={14} className={styles.hintIcon} />
-			<Typography.Text className={styles.hintText}>
-				Dashboard variables aren&apos;t supported on public links.
-			</Typography.Text>
-		</div>
-	);
-}
-
-export default PublicDashboardHint;