Merge branch 'main' into nv/schema-changes

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))
 		},

docs/api/openapi.yml

@@ -2437,17 +2437,6 @@ components:
         url:
           type: string
       type: object
-    DashboardTextVariableSpec:
-      properties:
-        constant:
-          type: boolean
-        display:
-          $ref: '#/components/schemas/VariableDisplay'
-        name:
-          type: string
-        value:
-          type: string
-      type: object
     DashboardtypesAxes:
       properties:
         isLogScale:
@@ -2812,9 +2801,15 @@ components:
             type: string
           nullable: true
           type: object
+        mode:
+          $ref: '#/components/schemas/DashboardtypesLegendMode'
         position:
           $ref: '#/components/schemas/DashboardtypesLegendPosition'
       type: object
+    DashboardtypesLegendMode:
+      enum:
+      - list
+      type: string
     DashboardtypesLegendPosition:
       enum:
       - bottom
@@ -2865,15 +2860,25 @@ components:
         display:
           $ref: '#/components/schemas/DashboardtypesDisplay'
         name:
+          minLength: 1
           type: string
         plugin:
           $ref: '#/components/schemas/DashboardtypesVariablePlugin'
         sort:
-          nullable: true
-          type: string
+          $ref: '#/components/schemas/DashboardtypesListVariableSpecSort'
       required:
-      - display
+      - name
       type: object
+    DashboardtypesListVariableSpecSort:
+      enum:
+      - none
+      - alphabetical-asc
+      - alphabetical-desc
+      - numerical-asc
+      - numerical-desc
+      - alphabetical-ci-asc
+      - alphabetical-ci-desc
+      type: string
     DashboardtypesListableDashboardForUserV2:
       properties:
         dashboards:
@@ -3383,8 +3388,13 @@ components:
     DashboardtypesSpanGaps:
       properties:
         fillLessThan:
+          description: The maximum gap size to connect when fillOnlyBelow is true.
+            Gaps larger than this duration are left disconnected.
           type: string
         fillOnlyBelow:
+          description: Controls whether lines connect across null values. When false
+            (default), all gaps are connected. When true, only gaps smaller than fillLessThan
+            are connected.
           type: boolean
       type: object
     DashboardtypesStorableDashboardData:
@@ -3432,6 +3442,20 @@ components:
       - color
       - columnName
       type: object
+    DashboardtypesTextVariableSpec:
+      properties:
+        constant:
+          type: boolean
+        display:
+          $ref: '#/components/schemas/DashboardtypesDisplay'
+        name:
+          minLength: 1
+          type: string
+        value:
+          type: string
+      required:
+      - name
+      type: object
     DashboardtypesThresholdFormat:
       enum:
       - text
@@ -3451,7 +3475,6 @@ components:
       required:
       - value
       - color
-      - label
       type: object
     DashboardtypesTimePreference:
       enum:
@@ -3536,23 +3559,11 @@ components:
       discriminator:
         mapping:
           ListVariable: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec'
-          TextVariable: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec'
+          TextVariable: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpec'
         propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec'
-      - $ref: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec'
-      type: object
-    DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec:
-      properties:
-        kind:
-          enum:
-          - TextVariable
-          type: string
-        spec:
-          $ref: '#/components/schemas/DashboardTextVariableSpec'
-      required:
-      - kind
-      - spec
+      - $ref: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpec'
       type: object
     DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec:
       properties:
@@ -3566,6 +3577,18 @@ components:
       - kind
       - spec
       type: object
+    DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpec:
+      properties:
+        kind:
+          enum:
+          - TextVariable
+          type: string
+        spec:
+          $ref: '#/components/schemas/DashboardtypesTextVariableSpec'
+      required:
+      - kind
+      - spec
+      type: object
     DashboardtypesVariablePlugin:
       discriminator:
         mapping:
@@ -5022,169 +5045,6 @@ components:
       required:
       - rules
       type: object
-    MetricreductionruletypesAffectedAsset:
-      properties:
-        id:
-          type: string
-        impactedLabels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        name:
-          type: string
-        type:
-          $ref: '#/components/schemas/MetricreductionruletypesAssetType'
-        widget:
-          type: string
-      required:
-      - type
-      - id
-      - name
-      - impactedLabels
-      type: object
-    MetricreductionruletypesAssetType:
-      enum:
-      - dashboard
-      - alert_rule
-      type: string
-    MetricreductionruletypesGettableReductionRule:
-      properties:
-        active:
-          type: boolean
-        effectiveFrom:
-          format: date-time
-          type: string
-        ingestedSeries:
-          minimum: 0
-          type: integer
-        labels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        matchType:
-          $ref: '#/components/schemas/MetricreductionruletypesMatchType'
-        metricName:
-          type: string
-        reducedSeries:
-          minimum: 0
-          type: integer
-        reductionPercent:
-          format: double
-          type: number
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - metricName
-      - matchType
-      - labels
-      - effectiveFrom
-      - updatedAt
-      - updatedBy
-      - active
-      - ingestedSeries
-      - reducedSeries
-      - reductionPercent
-      type: object
-    MetricreductionruletypesGettableReductionRulePreview:
-      properties:
-        affectedAssets:
-          items:
-            $ref: '#/components/schemas/MetricreductionruletypesAffectedAsset'
-          nullable: true
-          type: array
-        droppedLabels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        effectiveFrom:
-          format: date-time
-          type: string
-        ingestedSeries:
-          minimum: 0
-          type: integer
-        reducedSeries:
-          minimum: 0
-          type: integer
-        reductionPercent:
-          format: double
-          type: number
-      required:
-      - ingestedSeries
-      - reducedSeries
-      - reductionPercent
-      - droppedLabels
-      - affectedAssets
-      - effectiveFrom
-      type: object
-    MetricreductionruletypesGettableReductionRules:
-      properties:
-        rules:
-          items:
-            $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRule'
-          nullable: true
-          type: array
-        total:
-          type: integer
-      required:
-      - rules
-      - total
-      type: object
-    MetricreductionruletypesMatchType:
-      enum:
-      - drop
-      - keep
-      type: string
-    MetricreductionruletypesOrder:
-      enum:
-      - asc
-      - desc
-      type: string
-    MetricreductionruletypesPostableReductionRule:
-      properties:
-        labels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        matchType:
-          $ref: '#/components/schemas/MetricreductionruletypesMatchType'
-      required:
-      - matchType
-      - labels
-      type: object
-    MetricreductionruletypesPostableReductionRulePreview:
-      properties:
-        labels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        lookbackMs:
-          format: int64
-          type: integer
-        matchType:
-          $ref: '#/components/schemas/MetricreductionruletypesMatchType'
-        metricName:
-          type: string
-      required:
-      - metricName
-      - matchType
-      - labels
-      type: object
-    MetricreductionruletypesReductionRuleOrderBy:
-      enum:
-      - metricname
-      - ingestedvolume
-      - reducedvolume
-      - reduction
-      - lastupdated
-      type: string
     MetricsexplorertypesInspectMetricsRequest:
       properties:
         end:
@@ -5301,10 +5161,6 @@ components:
           type: string
         dashboardName:
           type: string
-        groupBy:
-          items:
-            type: string
-          type: array
         widgetId:
           type: string
         widgetName:
@@ -7818,15 +7674,6 @@ components:
       type: object
     VariableDefaultValue:
       type: object
-    VariableDisplay:
-      properties:
-        description:
-          type: string
-        hidden:
-          type: boolean
-        name:
-          type: string
-      type: object
     ZeustypesGettableHost:
       properties:
         hosts:
@@ -16064,229 +15911,6 @@ paths:
       summary: Update metric metadata
       tags:
       - metrics
-  /api/v2/metrics/{metric_name}/reduction_rule:
-    delete:
-      deprecated: false
-      description: Removes the volume-control (label reduction) rule for a specified
-        metric, reverting it to full fidelity. Admin only; enterprise feature.
-      operationId: DeleteMetricReductionRule
-      parameters:
-      - in: path
-        name: metric_name
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "451":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unavailable For Legal Reasons
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a metric reduction rule
-      tags:
-      - metrics
-    get:
-      deprecated: false
-      description: Returns the active volume-control (label reduction) rule for a
-        specified metric. Enterprise feature.
-      operationId: GetMetricReductionRule
-      parameters:
-      - in: path
-        name: metric_name
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "451":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unavailable For Legal Reasons
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get a metric reduction rule
-      tags:
-      - metrics
-    put:
-      deprecated: false
-      description: 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.
-      operationId: UpsertMetricReductionRule
-      parameters:
-      - in: path
-        name: metric_name
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/MetricreductionruletypesPostableReductionRule'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "451":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unavailable For Legal Reasons
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create or update a metric reduction rule
-      tags:
-      - metrics
   /api/v2/metrics/inspect:
     post:
       deprecated: false
@@ -16392,158 +16016,6 @@ paths:
       summary: Check if non-SigNoz metrics have been received
       tags:
       - metrics
-  /api/v2/metrics/reduction_rules:
-    get:
-      deprecated: false
-      description: Returns active metric volume-control (label reduction) rules, sorted
-        and paginated server-side. Enterprise feature.
-      operationId: ListMetricReductionRules
-      parameters:
-      - in: query
-        name: orderBy
-        schema:
-          $ref: '#/components/schemas/MetricreductionruletypesReductionRuleOrderBy'
-      - in: query
-        name: order
-        schema:
-          $ref: '#/components/schemas/MetricreductionruletypesOrder'
-      - in: query
-        name: offset
-        schema:
-          type: integer
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRules'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "451":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unavailable For Legal Reasons
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List metric reduction rules
-      tags:
-      - metrics
-  /api/v2/metrics/reduction_rules/preview:
-    post:
-      deprecated: false
-      description: Estimates the series reduction and related-asset impact of a candidate
-        volume-control rule without persisting it. Enterprise feature.
-      operationId: PreviewMetricReductionRule
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/MetricreductionruletypesPostableReductionRulePreview'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRulePreview'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "451":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unavailable For Legal Reasons
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Preview a metric reduction rule
-      tags:
-      - metrics
   /api/v2/metrics/stats:
     post:
       deprecated: false

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")
-}

frontend/src/AppRoutes/routes.ts

@@ -469,13 +469,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/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';
@@ -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/sigNoz.schemas.ts

@@ -3154,37 +3154,6 @@ export interface DashboardLinkDTO {
 	url?: string;
 }
 
-export interface VariableDisplayDTO {
-	/**
-	 * @type string
-	 */
-	description?: string;
-	/**
-	 * @type boolean
-	 */
-	hidden?: boolean;
-	/**
-	 * @type string
-	 */
-	name?: string;
-}
-
-export interface DashboardTextVariableSpecDTO {
-	/**
-	 * @type boolean
-	 */
-	constant?: boolean;
-	display?: VariableDisplayDTO;
-	/**
-	 * @type string
-	 */
-	name?: string;
-	/**
-	 * @type string
-	 */
-	value?: string;
-}
-
 export interface DashboardtypesAxesDTO {
 	/**
 	 * @type boolean
@@ -3216,6 +3185,9 @@ export interface DashboardtypesPanelFormattingDTO {
 	unit?: string;
 }
 
+export enum DashboardtypesLegendModeDTO {
+	list = 'list',
+}
 export enum DashboardtypesLegendPositionDTO {
 	bottom = 'bottom',
 	right = 'right',
@@ -3235,6 +3207,7 @@ export interface DashboardtypesLegendDTO {
 	 * @type object,null
 	 */
 	customColors?: DashboardtypesLegendDTOCustomColors;
+	mode?: DashboardtypesLegendModeDTO;
 	position?: DashboardtypesLegendPositionDTO;
 }
 
@@ -3246,7 +3219,7 @@ export interface DashboardtypesThresholdWithLabelDTO {
 	/**
 	 * @type string
 	 */
-	label: string;
+	label?: string;
 	/**
 	 * @type string
 	 */
@@ -3911,10 +3884,12 @@ export enum DashboardtypesLineStyleDTO {
 export interface DashboardtypesSpanGapsDTO {
 	/**
 	 * @type string
+	 * @description The maximum gap size to connect when fillOnlyBelow is true. Gaps larger than this duration are left disconnected.
 	 */
 	fillLessThan?: string;
 	/**
 	 * @type boolean
+	 * @description Controls whether lines connect across null values. When false (default), all gaps are connected. When true, only gaps smaller than fillLessThan are connected.
 	 */
 	fillOnlyBelow?: boolean;
 }
@@ -4546,6 +4521,15 @@ export type DashboardtypesVariablePluginDTO =
 	| DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpecDTO
 	| DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpecDTO;
 
+export enum DashboardtypesListVariableSpecSortDTO {
+	none = 'none',
+	'alphabetical-asc' = 'alphabetical-asc',
+	'alphabetical-desc' = 'alphabetical-desc',
+	'numerical-asc' = 'numerical-asc',
+	'numerical-desc' = 'numerical-desc',
+	'alphabetical-ci-asc' = 'alphabetical-ci-asc',
+	'alphabetical-ci-desc' = 'alphabetical-ci-desc',
+}
 export interface DashboardtypesListVariableSpecDTO {
 	/**
 	 * @type boolean
@@ -4564,16 +4548,14 @@ export interface DashboardtypesListVariableSpecDTO {
 	 */
 	customAllValue?: string;
 	defaultValue?: VariableDefaultValueDTO;
-	display: DashboardtypesDisplayDTO;
+	display?: DashboardtypesDisplayDTO;
 	/**
 	 * @type string
+	 * @minLength 1
 	 */
-	name?: string;
+	name: string;
 	plugin?: DashboardtypesVariablePluginDTO;
-	/**
-	 * @type string,null
-	 */
-	sort?: string | null;
+	sort?: DashboardtypesListVariableSpecSortDTO;
 }
 
 export interface DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpecDTO {
@@ -4585,21 +4567,38 @@ export interface DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDash
 	spec: DashboardtypesListVariableSpecDTO;
 }
 
-export enum DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTOKind {
+export enum DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpecDTOKind {
 	TextVariable = 'TextVariable',
 }
-export interface DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTO {
+export interface DashboardtypesTextVariableSpecDTO {
+	/**
+	 * @type boolean
+	 */
+	constant?: boolean;
+	display?: DashboardtypesDisplayDTO;
+	/**
+	 * @type string
+	 * @minLength 1
+	 */
+	name: string;
+	/**
+	 * @type string
+	 */
+	value?: string;
+}
+
+export interface DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpecDTO {
 	/**
 	 * @enum TextVariable
 	 * @type string
 	 */
-	kind: DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTOKind;
-	spec: DashboardTextVariableSpecDTO;
+	kind: DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpecDTOKind;
+	spec: DashboardtypesTextVariableSpecDTO;
 }
 
 export type DashboardtypesVariableDTO =
 	| DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpecDTO
-	| DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTO;
+	| DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpecDTO;
 
 export interface DashboardtypesDashboardSpecDTO {
 	/**
@@ -6577,157 +6576,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 +6737,6 @@ export interface MetricsexplorertypesMetricDashboardDTO {
 	 * @type string
 	 */
 	dashboardName: string;
-	/**
-	 * @type array
-	 */
-	groupBy?: string[];
 	/**
 	 * @type string
 	 */
@@ -10471,31 +10315,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 +10331,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/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/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/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/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/QueryVariableFields.tsx

@@ -2,15 +2,16 @@ import { useState } from 'react';
 import { Button } from '@signozhq/ui/button';
 import { Typography } from '@signozhq/ui/typography';
 import dashboardVariablesQuery from 'api/dashboard/variables/dashboardVariablesQuery';
+import { DashboardtypesListVariableSpecSortDTO as VariableSortDTO } from 'api/generated/services/sigNoz.schemas';
 import Editor from 'components/Editor';
 import sortValues from 'lib/dashboardVariables/sortVariableValues';
 
-import type { VariableSort } from '../variableModel';
+import { sortDirectionOf } from '../variableModel';
 import styles from './VariableForm.module.scss';
 
 interface QueryVariableFieldsProps {
 	queryValue: string;
-	sort: VariableSort;
+	sort: VariableSortDTO;
 	onChange: (queryValue: string) => void;
 	onPreview: (values: (string | number)[]) => void;
 	onError: (message: string | null) => void;
@@ -36,7 +37,10 @@ function QueryVariableFields({
 			});
 			if (res.statusCode === 200 && res.payload) {
 				onPreview(
-					sortValues(res.payload.variableValues ?? [], sort) as (string | number)[],
+					sortValues(res.payload.variableValues ?? [], sortDirectionOf(sort)) as (
+						| string
+						| number
+					)[],
 				);
 			} else {
 				onError(res.error || 'Failed to run query');

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/VariableForm.tsx

@@ -12,10 +12,12 @@ import { Collapse, Input as AntdInput, Select } from 'antd';
 import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
 import sortValues from 'lib/dashboardVariables/sortVariableValues';
 
+import { DashboardtypesListVariableSpecSortDTO as VariableSortDTO } from 'api/generated/services/sigNoz.schemas';
+
 import {
+	sortDirectionOf,
 	VARIABLE_SORTS,
 	type VariableFormModel,
-	type VariableSort,
 	type VariableType,
 } from '../variableModel';
 import DynamicVariableFields from './DynamicVariableFields';
@@ -23,10 +25,16 @@ import QueryVariableFields from './QueryVariableFields';
 import VariableTypeSelector from './VariableTypeSelector';
 import styles from './VariableForm.module.scss';
 
-const SORT_LABEL: Record<VariableSort, string> = {
-	DISABLED: 'Disabled',
-	ASC: 'Ascending',
-	DESC: 'Descending',
+const SORT_LABEL: Record<VariableSortDTO, string> = {
+	[VariableSortDTO.none]: 'Disabled',
+	[VariableSortDTO['alphabetical-asc']]: 'Alphabetical (asc)',
+	[VariableSortDTO['alphabetical-desc']]: 'Alphabetical (desc)',
+	[VariableSortDTO['numerical-asc']]: 'Numerical (asc)',
+	[VariableSortDTO['numerical-desc']]: 'Numerical (desc)',
+	[VariableSortDTO['alphabetical-ci-asc']]:
+		'Alphabetical, case-insensitive (asc)',
+	[VariableSortDTO['alphabetical-ci-desc']]:
+		'Alphabetical, case-insensitive (desc)',
 };
 
 function getNameError(name: string, existingNames: string[]): string | null {
@@ -91,7 +99,10 @@ function VariableForm({
 	const onCustomChange = (value: string): void => {
 		set({ customValue: value });
 		setPreviewValues(
-			sortValues(commaValuesParser(value), model.sort) as (string | number)[],
+			sortValues(commaValuesParser(value), sortDirectionOf(model.sort)) as (
+				| string
+				| number
+			)[],
 		);
 	};
 
@@ -259,7 +270,7 @@ function VariableForm({
 										label: SORT_LABEL[sort],
 										value: sort,
 									}))}
-									onChange={(value): void => set({ sort: value as VariableSort })}
+									onChange={(value): void => set({ sort: value as VariableSortDTO })}
 									testId="variable-sort-select"
 								/>
 							</div>

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variableAdapters.ts

@@ -1,16 +1,17 @@
 import {
-	DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTOKind as TextEnvelopeKind,
+	DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpecDTOKind as TextEnvelopeKind,
 	DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpecDTOKind as ListEnvelopeKind,
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpecDTOKind as CustomPluginKind,
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesDynamicVariableSpecDTOKind as DynamicPluginKind,
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpecDTOKind as QueryPluginKind,
+	DashboardtypesListVariableSpecSortDTO as VariableSortDTO,
 	TelemetrytypesSignalDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type {
 	DashboardtypesListVariableSpecDTO,
 	DashboardtypesVariableDTO,
 	DashboardtypesVariablePluginDTO,
-	DashboardTextVariableSpecDTO,
+	DashboardtypesTextVariableSpecDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
 import {
@@ -18,7 +19,6 @@ import {
 	PLUGIN_KIND,
 	type TelemetrySignal,
 	type VariableFormModel,
-	type VariableSort,
 } from './variableModel';
 
 /** DTO envelope → flat form model (for display / editing). */
@@ -35,7 +35,7 @@ export function dtoToFormModel(
 
 	// Text variable — a distinct envelope (no list plugin).
 	if (dto.kind === TextEnvelopeKind.TextVariable) {
-		const spec = dto.spec as DashboardTextVariableSpecDTO;
+		const spec = dto.spec as DashboardtypesTextVariableSpecDTO;
 		return {
 			...common,
 			type: 'TEXT',
@@ -50,7 +50,7 @@ export function dtoToFormModel(
 		...common,
 		multiSelect: spec.allowMultiple ?? false,
 		showAllOption: spec.allowAllValue ?? false,
-		sort: (spec.sort as VariableSort) ?? 'DISABLED',
+		sort: spec.sort ?? VariableSortDTO.none,
 		defaultValue: spec.defaultValue,
 	};
 	const plugin = spec.plugin;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variableModel.ts

@@ -1,4 +1,6 @@
+import { DashboardtypesListVariableSpecSortDTO as VariableSortDTO } from 'api/generated/services/sigNoz.schemas';
 import type { VariableDefaultValueDTO } from 'api/generated/services/sigNoz.schemas';
+import type { TSortVariableValuesType } from 'types/api/dashboard/getAll';
 
 /**
  * Flat, UI-friendly representation of a V2 dashboard variable. The wire format
@@ -8,8 +10,6 @@ import type { VariableDefaultValueDTO } from 'api/generated/services/sigNoz.sche
 
 export type VariableType = 'QUERY' | 'CUSTOM' | 'TEXT' | 'DYNAMIC';
 
-export type VariableSort = 'DISABLED' | 'ASC' | 'DESC';
-
 export type TelemetrySignal = 'traces' | 'logs' | 'metrics';
 
 /** Wire `kind` discriminators (string values of the generated enums). */
@@ -24,7 +24,20 @@ export const PLUGIN_KIND = {
 	DYNAMIC: 'signoz/DynamicVariable',
 } as const;
 
-export const VARIABLE_SORTS: VariableSort[] = ['DISABLED', 'ASC', 'DESC'];
+export const VARIABLE_SORTS: VariableSortDTO[] = Object.values(VariableSortDTO);
+
+/** Direction the preview sorter should apply for a given wire sort value. */
+export function sortDirectionOf(
+	sort: VariableSortDTO,
+): TSortVariableValuesType {
+	if (sort.endsWith('-asc')) {
+		return 'ASC';
+	}
+	if (sort.endsWith('-desc')) {
+		return 'DESC';
+	}
+	return 'DISABLED';
+}
 
 export const TELEMETRY_SIGNALS: TelemetrySignal[] = [
 	'traces',
@@ -42,7 +55,7 @@ export interface VariableFormModel {
 	// List-variable common fields (Query / Custom / Dynamic).
 	multiSelect: boolean;
 	showAllOption: boolean;
-	sort: VariableSort;
+	sort: VariableSortDTO;
 
 	// Type-specific.
 	queryValue: string; // QUERY
@@ -67,7 +80,7 @@ export function emptyVariableFormModel(): VariableFormModel {
 		type: 'QUERY',
 		multiSelect: false,
 		showAllOption: false,
-		sort: 'DISABLED',
+		sort: VariableSortDTO.none,
 		queryValue: '',
 		customValue: '',
 		textValue: '',

frontend/src/pages/MetricsExplorer/MetricsExplorerPage.tsx

@@ -3,29 +3,19 @@ import { useLocation } from 'react-use';
 import RouteTab from 'components/RouteTab';
 import { TabRoutes } from 'components/RouteTab/types';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { useVolumeControlFeatureGate } from 'hooks/metricsExplorer/useVolumeControlFeatureGate';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
 import history from 'lib/history';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { Explorer, Summary, Views, VolumeControl } from './constants';
+import { Explorer, Summary, Views } from './constants';
 
 import './MetricsExplorerPage.styles.scss';
 
 function MetricsExplorerPage(): JSX.Element {
 	const { pathname } = useLocation();
-	const { isVolumeControlEnabled } = useVolumeControlFeatureGate();
 
-	const routes: TabRoutes[] = useMemo(
-		() => [
-			Summary,
-			...(isVolumeControlEnabled ? [VolumeControl] : []),
-			Explorer,
-			Views,
-		],
-		[isVolumeControlEnabled],
-	);
+	const routes: TabRoutes[] = [Summary, Explorer, Views];
 
 	const { updateAllQueriesOperators } = useQueryBuilder();
 

frontend/src/pages/MetricsExplorer/constants.tsx

@@ -2,8 +2,7 @@ import { TabRoutes } from 'components/RouteTab/types';
 import ROUTES from 'constants/routes';
 import ExplorerPage from 'container/MetricsExplorer/Explorer';
 import SummaryPage from 'container/MetricsExplorer/Summary';
-import VolumeControlTab from 'container/MetricsExplorer/VolumeControlTab/VolumeControlTab';
-import { BarChart, Compass, Gauge, TowerControl } from '@signozhq/icons';
+import { BarChart, Compass, TowerControl } from '@signozhq/icons';
 import SaveView from 'pages/SaveView';
 
 export const Summary: TabRoutes = {
@@ -38,14 +37,3 @@ export const Views: TabRoutes = {
 	route: ROUTES.METRICS_EXPLORER_VIEWS,
 	key: ROUTES.METRICS_EXPLORER_VIEWS,
 };
-
-export const VolumeControl: TabRoutes = {
-	Component: VolumeControlTab,
-	name: (
-		<div className="tab-item">
-			<Gauge size={16} /> Volume Control
-		</div>
-	),
-	route: ROUTES.METRICS_EXPLORER_VOLUME_CONTROL,
-	key: ROUTES.METRICS_EXPLORER_VOLUME_CONTROL,
-};

frontend/src/utils/permission/index.ts

@@ -122,7 +122,6 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	METRICS_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	METRICS_EXPLORER_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	METRICS_EXPLORER_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],
-	METRICS_EXPLORER_VOLUME_CONTROL: ['ADMIN', 'EDITOR', 'VIEWER'],
 	API_MONITORING: ['ADMIN', 'EDITOR', 'VIEWER'],
 	WORKSPACE_ACCESS_RESTRICTED: ['ADMIN', 'EDITOR', 'VIEWER'],
 	METRICS_EXPLORER_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],

pkg/apiserver/signozapiserver/metricreductionrule.go

@@ -1,104 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addMetricReductionRuleRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/metrics/reduction_rules", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.List),
-		handler.OpenAPIDef{
-			ID:                  "ListMetricReductionRules",
-			Tags:                []string{"metrics"},
-			Summary:             "List metric reduction rules",
-			Description:         "Returns active metric volume-control (label reduction) rules, sorted and paginated server-side. Enterprise feature.",
-			RequestQuery:        new(metricreductionruletypes.ListReductionRulesParams),
-			Response:            new(metricreductionruletypes.GettableReductionRules),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusUnauthorized, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metrics/reduction_rules/preview", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.Preview),
-		handler.OpenAPIDef{
-			ID:                  "PreviewMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Preview a metric reduction rule",
-			Description:         "Estimates the series reduction and related-asset impact of a candidate volume-control rule without persisting it. Enterprise feature.",
-			Request:             new(metricreductionruletypes.PostableReductionRulePreview),
-			RequestContentType:  "application/json",
-			Response:            new(metricreductionruletypes.GettableReductionRulePreview),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metrics/{metric_name}/reduction_rule", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.Get),
-		handler.OpenAPIDef{
-			ID:                  "GetMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Get a metric reduction rule",
-			Description:         "Returns the active volume-control (label reduction) rule for a specified metric. Enterprise feature.",
-			Response:            new(metricreductionruletypes.GettableReductionRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metrics/{metric_name}/reduction_rule", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.Upsert),
-		handler.OpenAPIDef{
-			ID:                  "UpsertMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Create or update a metric reduction rule",
-			Description:         "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.",
-			Request:             new(metricreductionruletypes.PostableReductionRule),
-			RequestContentType:  "application/json",
-			Response:            new(metricreductionruletypes.GettableReductionRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metrics/{metric_name}/reduction_rule", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.Delete),
-		handler.OpenAPIDef{
-			ID:                  "DeleteMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Delete a metric reduction rule",
-			Description:         "Removes the volume-control (label reduction) rule for a specified metric, reverting it to full fidelity. Admin only; enterprise feature.",
-			Response:            nil,
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

@@ -18,7 +18,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -40,40 +39,39 @@ import (
 )
 
 type provider struct {
-	config                     apiserver.Config
-	settings                   factory.ScopedProviderSettings
-	router                     *mux.Router
-	authzMiddleware            *middleware.AuthZ
-	authzService               authz.AuthZ
-	orgHandler                 organization.Handler
-	userHandler                user.Handler
-	sessionHandler             session.Handler
-	authDomainHandler          authdomain.Handler
-	preferenceHandler          preference.Handler
-	globalHandler              global.Handler
-	promoteHandler             promote.Handler
-	flaggerHandler             flagger.Handler
-	dashboardModule            dashboard.Module
-	dashboardHandler           dashboard.Handler
-	metricsExplorerHandler     metricsexplorer.Handler
-	metricReductionRuleHandler metricreductionrule.Handler
-	infraMonitoringHandler     inframonitoring.Handler
-	gatewayHandler             gateway.Handler
-	fieldsHandler              fields.Handler
-	authzHandler               authz.Handler
-	rawDataExportHandler       rawdataexport.Handler
-	zeusHandler                zeus.Handler
-	querierHandler             querier.Handler
-	serviceAccountHandler      serviceaccount.Handler
-	factoryHandler             factory.Handler
-	cloudIntegrationHandler    cloudintegration.Handler
-	ruleStateHistoryHandler    rulestatehistory.Handler
-	spanMapperHandler          spanmapper.Handler
-	alertmanagerHandler        alertmanager.Handler
-	traceDetailHandler         tracedetail.Handler
-	rulerHandler               ruler.Handler
-	llmPricingRuleHandler      llmpricingrule.Handler
-	statsHandler               statsreporter.Handler
+	config                  apiserver.Config
+	settings                factory.ScopedProviderSettings
+	router                  *mux.Router
+	authzMiddleware         *middleware.AuthZ
+	authzService            authz.AuthZ
+	orgHandler              organization.Handler
+	userHandler             user.Handler
+	sessionHandler          session.Handler
+	authDomainHandler       authdomain.Handler
+	preferenceHandler       preference.Handler
+	globalHandler           global.Handler
+	promoteHandler          promote.Handler
+	flaggerHandler          flagger.Handler
+	dashboardModule         dashboard.Module
+	dashboardHandler        dashboard.Handler
+	metricsExplorerHandler  metricsexplorer.Handler
+	infraMonitoringHandler  inframonitoring.Handler
+	gatewayHandler          gateway.Handler
+	fieldsHandler           fields.Handler
+	authzHandler            authz.Handler
+	rawDataExportHandler    rawdataexport.Handler
+	zeusHandler             zeus.Handler
+	querierHandler          querier.Handler
+	serviceAccountHandler   serviceaccount.Handler
+	factoryHandler          factory.Handler
+	cloudIntegrationHandler cloudintegration.Handler
+	ruleStateHistoryHandler rulestatehistory.Handler
+	spanMapperHandler       spanmapper.Handler
+	alertmanagerHandler     alertmanager.Handler
+	traceDetailHandler      tracedetail.Handler
+	rulerHandler            ruler.Handler
+	llmPricingRuleHandler   llmpricingrule.Handler
+	statsHandler            statsreporter.Handler
 }
 
 func NewFactory(
@@ -90,7 +88,6 @@ func NewFactory(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	metricReductionRuleHandler metricreductionrule.Handler,
 	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
@@ -127,7 +124,6 @@ func NewFactory(
 			dashboardModule,
 			dashboardHandler,
 			metricsExplorerHandler,
-			metricReductionRuleHandler,
 			infraMonitoringHandler,
 			gatewayHandler,
 			fieldsHandler,
@@ -166,7 +162,6 @@ func newProvider(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	metricReductionRuleHandler metricreductionrule.Handler,
 	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
@@ -189,39 +184,38 @@ func newProvider(
 	router := mux.NewRouter().UseEncodedPath()
 
 	provider := &provider{
-		config:                     config,
-		settings:                   settings,
-		router:                     router,
-		orgHandler:                 orgHandler,
-		userHandler:                userHandler,
-		authzService:               authzService,
-		sessionHandler:             sessionHandler,
-		authDomainHandler:          authDomainHandler,
-		preferenceHandler:          preferenceHandler,
-		globalHandler:              globalHandler,
-		promoteHandler:             promoteHandler,
-		flaggerHandler:             flaggerHandler,
-		dashboardModule:            dashboardModule,
-		dashboardHandler:           dashboardHandler,
-		metricsExplorerHandler:     metricsExplorerHandler,
-		metricReductionRuleHandler: metricReductionRuleHandler,
-		infraMonitoringHandler:     infraMonitoringHandler,
-		gatewayHandler:             gatewayHandler,
-		fieldsHandler:              fieldsHandler,
-		authzHandler:               authzHandler,
-		rawDataExportHandler:       rawDataExportHandler,
-		zeusHandler:                zeusHandler,
-		querierHandler:             querierHandler,
-		serviceAccountHandler:      serviceAccountHandler,
-		factoryHandler:             factoryHandler,
-		cloudIntegrationHandler:    cloudIntegrationHandler,
-		ruleStateHistoryHandler:    ruleStateHistoryHandler,
-		spanMapperHandler:          spanMapperHandler,
-		alertmanagerHandler:        alertmanagerHandler,
-		traceDetailHandler:         traceDetailHandler,
-		rulerHandler:               rulerHandler,
-		llmPricingRuleHandler:      llmPricingRuleHandler,
-		statsHandler:               statsHandler,
+		config:                  config,
+		settings:                settings,
+		router:                  router,
+		orgHandler:              orgHandler,
+		userHandler:             userHandler,
+		authzService:            authzService,
+		sessionHandler:          sessionHandler,
+		authDomainHandler:       authDomainHandler,
+		preferenceHandler:       preferenceHandler,
+		globalHandler:           globalHandler,
+		promoteHandler:          promoteHandler,
+		flaggerHandler:          flaggerHandler,
+		dashboardModule:         dashboardModule,
+		dashboardHandler:        dashboardHandler,
+		metricsExplorerHandler:  metricsExplorerHandler,
+		infraMonitoringHandler:  infraMonitoringHandler,
+		gatewayHandler:          gatewayHandler,
+		fieldsHandler:           fieldsHandler,
+		authzHandler:            authzHandler,
+		rawDataExportHandler:    rawDataExportHandler,
+		zeusHandler:             zeusHandler,
+		querierHandler:          querierHandler,
+		serviceAccountHandler:   serviceAccountHandler,
+		factoryHandler:          factoryHandler,
+		cloudIntegrationHandler: cloudIntegrationHandler,
+		ruleStateHistoryHandler: ruleStateHistoryHandler,
+		spanMapperHandler:       spanMapperHandler,
+		alertmanagerHandler:     alertmanagerHandler,
+		traceDetailHandler:      traceDetailHandler,
+		rulerHandler:            rulerHandler,
+		llmPricingRuleHandler:   llmPricingRuleHandler,
+		statsHandler:            statsHandler,
 	}
 
 	provider.authzMiddleware = middleware.NewAuthZ(settings.Logger(), orgGetter, authzService)
@@ -278,10 +272,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addMetricReductionRuleRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addInfraMonitoringRoutes(router); err != nil {
 		return err
 	}

pkg/modules/dashboard/impldashboard/module.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"log/slog"
 	"slices"
-	"strings"
 
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -208,14 +207,12 @@ func (module *module) GetByMetricNames(ctx context.Context, orgID valuer.UUID, m
 			module.checkPromQLQueriesForMetricNames(ctx, query, metricNames, foundMetrics)
 
 			// Add widget to results for all found metrics
-			groupByByMetric := module.collectBuilderGroupBy(query, metricNames)
 			for metricName := range foundMetrics {
 				result[metricName] = append(result[metricName], map[string]string{
 					"dashboard_id":   dashboard.ID,
 					"widget_name":    widgetTitle,
 					"widget_id":      widgetID,
 					"dashboard_name": dashTitle,
-					"group_by":       strings.Join(groupByByMetric[metricName], ","),
 				})
 			}
 		}
@@ -309,68 +306,6 @@ func (module *module) checkBuilderQueriesForMetricNames(query map[string]interfa
 	}
 }
 
-// collectBuilderGroupBy returns, per metric, the group-by attribute keys used alongside it in the
-// builder queries of a widget.
-func (module *module) collectBuilderGroupBy(query map[string]interface{}, metricNames []string) map[string][]string {
-	out := make(map[string][]string)
-	builder, ok := query["builder"].(map[string]interface{})
-	if !ok {
-		return out
-	}
-	queryData, ok := builder["queryData"].([]interface{})
-	if !ok {
-		return out
-	}
-	for _, qd := range queryData {
-		data, ok := qd.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		if dataSource, ok := data["dataSource"].(string); !ok || dataSource != "metrics" {
-			continue
-		}
-		aggregations, ok := data["aggregations"].([]interface{})
-		if !ok {
-			continue
-		}
-		groupByKeys := groupByKeysFromData(data["groupBy"])
-		if len(groupByKeys) == 0 {
-			continue
-		}
-		for _, agg := range aggregations {
-			aggMap, ok := agg.(map[string]interface{})
-			if !ok {
-				continue
-			}
-			metricName, ok := aggMap["metricName"].(string)
-			if !ok || metricName == "" || !slices.Contains(metricNames, metricName) {
-				continue
-			}
-			out[metricName] = append(out[metricName], groupByKeys...)
-		}
-	}
-	return out
-}
-
-// groupByKeysFromData extracts attribute names from a builder query's groupBy (JSON []GroupByKey).
-func groupByKeysFromData(v interface{}) []string {
-	arr, ok := v.([]interface{})
-	if !ok {
-		return nil
-	}
-	var keys []string
-	for _, item := range arr {
-		m, ok := item.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		if name, ok := m["name"].(string); ok && name != "" {
-			keys = append(keys, name)
-		}
-	}
-	return keys
-}
-
 // checkClickHouseQueriesForMetricNames checks clickhouse_sql[] array for metric names in query strings.
 func (module *module) checkClickHouseQueriesForMetricNames(ctx context.Context, query map[string]interface{}, metricNames []string, foundMetrics map[string]bool) {
 	clickhouseSQL, ok := query["clickhouse_sql"].([]interface{})

pkg/modules/metricreductionrule/implmetricreductionrule/handler.go

@@ -1,156 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module metricreductionrule.Module
-}
-
-func NewHandler(module metricreductionrule.Module) metricreductionrule.Handler {
-	return &handler{module: module}
-}
-
-func metricNameFromPath(r *http.Request) (string, error) {
-	metricName := mux.Vars(r)["metric_name"]
-	if metricName == "" {
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "metric_name is required in URL path")
-	}
-	return metricName, nil
-}
-
-func (h *handler) List(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var params metricreductionruletypes.ListReductionRulesParams
-	if err := binding.Query.BindQuery(r.URL.Query(), &params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.List(r.Context(), valuer.MustNewUUID(claims.OrgID), &params)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Get(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	metricName, err := metricNameFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Get(r.Context(), valuer.MustNewUUID(claims.OrgID), metricName)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Upsert(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	metricName, err := metricNameFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var in metricreductionruletypes.PostableReductionRule
-	if err := binding.JSON.BindBody(r.Body, &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	in.MetricName = metricName
-
-	if err := in.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Upsert(r.Context(), valuer.MustNewUUID(claims.OrgID), claims.Email, &in)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Delete(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	metricName, err := metricNameFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.Delete(r.Context(), valuer.MustNewUUID(claims.OrgID), metricName); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (h *handler) Preview(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var in metricreductionruletypes.PostableReductionRulePreview
-	if err := binding.JSON.BindBody(r.Body, &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := in.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Preview(r.Context(), valuer.MustNewUUID(claims.OrgID), &in)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}

pkg/modules/metricreductionrule/implmetricreductionrule/module.go

@@ -1,41 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct{}
-
-func NewModule() metricreductionrule.Module {
-	return &module{}
-}
-
-func errUnsupported() error {
-	return errors.Newf(errors.TypeUnsupported, metricreductionruletypes.ErrCodeMetricReductionRuleUnsupported,
-		"metric volume control is an enterprise feature")
-}
-
-func (m *module) List(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error) {
-	return nil, errUnsupported()
-}
-
-func (m *module) Get(_ context.Context, _ valuer.UUID, _ string) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errUnsupported()
-}
-
-func (m *module) Upsert(_ context.Context, _ valuer.UUID, _ string, _ *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errUnsupported()
-}
-
-func (m *module) Delete(_ context.Context, _ valuer.UUID, _ string) error {
-	return errUnsupported()
-}
-
-func (m *module) Preview(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error) {
-	return nil, errUnsupported()
-}

pkg/modules/metricreductionrule/metricreductionrule.go

@@ -1,25 +0,0 @@
-package metricreductionrule
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Module interface {
-	List(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error)
-	Get(ctx context.Context, orgID valuer.UUID, metricName string) (*metricreductionruletypes.GettableReductionRule, error)
-	Upsert(ctx context.Context, orgID valuer.UUID, userEmail string, req *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error)
-	Delete(ctx context.Context, orgID valuer.UUID, metricName string) error
-	Preview(ctx context.Context, orgID valuer.UUID, req *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error)
-}
-
-type Handler interface {
-	List(rw http.ResponseWriter, r *http.Request)
-	Get(rw http.ResponseWriter, r *http.Request)
-	Upsert(rw http.ResponseWriter, r *http.Request)
-	Delete(rw http.ResponseWriter, r *http.Request)
-	Preview(rw http.ResponseWriter, r *http.Request)
-}

pkg/modules/metricsexplorer/implmetricsexplorer/module.go

@@ -377,16 +377,11 @@ func (m *module) GetMetricDashboards(ctx context.Context, orgID valuer.UUID, met
 	if dashboardList, ok := data[metricName]; ok {
 		dashboards = make([]metricsexplorertypes.MetricDashboard, 0, len(dashboardList))
 		for _, item := range dashboardList {
-			var groupBy []string
-			if gb := item["group_by"]; gb != "" {
-				groupBy = strings.Split(gb, ",")
-			}
 			dashboards = append(dashboards, metricsexplorertypes.MetricDashboard{
 				DashboardName: item["dashboard_name"],
 				DashboardID:   item["dashboard_id"],
 				WidgetID:      item["widget_id"],
 				WidgetName:    item["widget_name"],
-				GroupBy:       groupBy,
 			})
 		}
 	}

pkg/signoz/handler.go

@@ -24,8 +24,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule/impllmpricingrule"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule/implmetricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
@@ -66,7 +64,6 @@ type Handlers struct {
 	SpanPercentile          spanpercentile.Handler
 	Services                services.Handler
 	MetricsExplorer         metricsexplorer.Handler
-	MetricReductionRule     metricreductionrule.Handler
 	InfraMonitoring         inframonitoring.Handler
 	Global                  global.Handler
 	FlaggerHandler          flagger.Handler
@@ -113,7 +110,6 @@ func NewHandlers(
 		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
 		Services:                implservices.NewHandler(modules.Services),
 		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
-		MetricReductionRule:     implmetricreductionrule.NewHandler(modules.MetricReductionRule),
 		InfraMonitoring:         implinframonitoring.NewHandler(modules.InfraMonitoring),
 		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
 		Global:                  signozglobal.NewHandler(global),

pkg/signoz/handler_test.go

@@ -59,7 +59,7 @@ func TestNewHandlers(t *testing.T) {
 	userGetter := impluser.NewGetter(impluser.NewStore(sqlstore, providerSettings), userRoleStore, flagger)
 
 	retentionGetter := implretention.NewGetter(implretention.NewStore(sqlstore))
-	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, nil, nil, retentionGetter, flagger, tagModule, nil)
+	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore, nil, nil, retentionGetter, flagger, tagModule)
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
 	registryHandler := factory.NewHandler(nil)

pkg/signoz/module.go

@@ -21,7 +21,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule/impllmpricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/logspipeline"
 	"github.com/SigNoz/signoz/pkg/modules/logspipeline/impllogspipeline"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -67,34 +66,33 @@ import (
 )
 
 type Modules struct {
-	OrgGetter           organization.Getter
-	OrgSetter           organization.Setter
-	Preference          preference.Module
-	UserSetter          user.Setter
-	UserGetter          user.Getter
-	RetentionGetter     retention.Getter
-	SavedView           savedview.Module
-	Apdex               apdex.Module
-	Dashboard           dashboard.Module
-	QuickFilter         quickfilter.Module
-	TraceFunnel         tracefunnel.Module
-	RawDataExport       rawdataexport.Module
-	AuthDomain          authdomain.Module
-	Session             session.Module
-	Services            services.Module
-	SpanPercentile      spanpercentile.Module
-	MetricsExplorer     metricsexplorer.Module
-	MetricReductionRule metricreductionrule.Module
-	InfraMonitoring     inframonitoring.Module
-	Promote             promote.Module
-	ServiceAccount      serviceaccount.Module
-	CloudIntegration    cloudintegration.Module
-	LogsPipeline        logspipeline.Module
-	RuleStateHistory    rulestatehistory.Module
-	TraceDetail         tracedetail.Module
-	SpanMapper          spanmapper.Module
-	LLMPricingRule      llmpricingrule.Module
-	Tag                 tag.Module
+	OrgGetter        organization.Getter
+	OrgSetter        organization.Setter
+	Preference       preference.Module
+	UserSetter       user.Setter
+	UserGetter       user.Getter
+	RetentionGetter  retention.Getter
+	SavedView        savedview.Module
+	Apdex            apdex.Module
+	Dashboard        dashboard.Module
+	QuickFilter      quickfilter.Module
+	TraceFunnel      tracefunnel.Module
+	RawDataExport    rawdataexport.Module
+	AuthDomain       authdomain.Module
+	Session          session.Module
+	Services         services.Module
+	SpanPercentile   spanpercentile.Module
+	MetricsExplorer  metricsexplorer.Module
+	InfraMonitoring  inframonitoring.Module
+	Promote          promote.Module
+	ServiceAccount   serviceaccount.Module
+	CloudIntegration cloudintegration.Module
+	LogsPipeline     logspipeline.Module
+	RuleStateHistory rulestatehistory.Module
+	TraceDetail      tracedetail.Module
+	SpanMapper       spanmapper.Module
+	LLMPricingRule   llmpricingrule.Module
+	Tag              tag.Module
 }
 
 func NewModules(
@@ -121,7 +119,6 @@ func NewModules(
 	retentionGetter retention.Getter,
 	fl flagger.Flagger,
 	tagModule tag.Module,
-	metricReductionRule metricreductionrule.Module,
 ) Modules {
 	quickfilter := implquickfilter.NewModule(implquickfilter.NewStore(sqlstore))
 	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter)
@@ -133,33 +130,32 @@ func NewModules(
 	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
 
 	return Modules{
-		OrgGetter:           orgGetter,
-		OrgSetter:           orgSetter,
-		Preference:          implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
-		SavedView:           implsavedview.NewModule(sqlstore),
-		Apdex:               implapdex.NewModule(sqlstore),
-		Dashboard:           dashboard,
-		UserSetter:          userSetter,
-		UserGetter:          userGetter,
-		RetentionGetter:     retentionGetter,
-		QuickFilter:         quickfilter,
-		TraceFunnel:         impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
-		RawDataExport:       implrawdataexport.NewModule(querier),
-		AuthDomain:          implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs),
-		Session:             implsession.NewModule(providerSettings, authNs, userSetter, userGetter, implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs), tokenizer, orgGetter),
-		SpanPercentile:      implspanpercentile.NewModule(querier, providerSettings),
-		Services:            implservices.NewModule(querier, telemetryStore),
-		MetricsExplorer:     implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
-		MetricReductionRule: metricReductionRule,
-		InfraMonitoring:     implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, providerSettings, config.InfraMonitoring),
-		Promote:             implpromote.NewModule(telemetryMetadataStore, telemetryStore),
-		ServiceAccount:      serviceAccount,
-		LogsPipeline:        impllogspipeline.NewModule(sqlstore),
-		RuleStateHistory:    implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger)),
-		CloudIntegration:    cloudIntegrationModule,
-		TraceDetail:         impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
-		SpanMapper:          implspanmapper.NewModule(implspanmapper.NewStore(sqlstore)),
-		LLMPricingRule:      impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore)),
-		Tag:                 tagModule,
+		OrgGetter:        orgGetter,
+		OrgSetter:        orgSetter,
+		Preference:       implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
+		SavedView:        implsavedview.NewModule(sqlstore),
+		Apdex:            implapdex.NewModule(sqlstore),
+		Dashboard:        dashboard,
+		UserSetter:       userSetter,
+		UserGetter:       userGetter,
+		RetentionGetter:  retentionGetter,
+		QuickFilter:      quickfilter,
+		TraceFunnel:      impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
+		RawDataExport:    implrawdataexport.NewModule(querier),
+		AuthDomain:       implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs),
+		Session:          implsession.NewModule(providerSettings, authNs, userSetter, userGetter, implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs), tokenizer, orgGetter),
+		SpanPercentile:   implspanpercentile.NewModule(querier, providerSettings),
+		Services:         implservices.NewModule(querier, telemetryStore),
+		MetricsExplorer:  implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
+		InfraMonitoring:  implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, providerSettings, config.InfraMonitoring),
+		Promote:          implpromote.NewModule(telemetryMetadataStore, telemetryStore),
+		ServiceAccount:   serviceAccount,
+		LogsPipeline:     impllogspipeline.NewModule(sqlstore),
+		RuleStateHistory: implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger)),
+		CloudIntegration: cloudIntegrationModule,
+		TraceDetail:      impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
+		SpanMapper:       implspanmapper.NewModule(implspanmapper.NewStore(sqlstore)),
+		LLMPricingRule:   impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore)),
+		Tag:              tagModule,
 	}
 }

pkg/signoz/module_test.go

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

pkg/signoz/openapi.go

@@ -23,7 +23,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -69,7 +68,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ dashboard.Module }{},
 		struct{ dashboard.Handler }{},
 		struct{ metricsexplorer.Handler }{},
-		struct{ metricreductionrule.Handler }{},
 		struct{ inframonitoring.Handler }{},
 		struct{ gateway.Handler }{},
 		struct{ fields.Handler }{},

pkg/signoz/provider.go

@@ -215,7 +215,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewRecreateUserDashboardPreferenceFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateRecurrenceBoundsFactory(sqlstore),
 		sqlmigration.NewAddDashboardViewFactory(sqlstore, sqlschema),
-		sqlmigration.NewAddMetricReductionRulesFactory(sqlstore, sqlschema),
 	)
 }
 
@@ -296,7 +295,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			modules.Dashboard,
 			handlers.Dashboard,
 			handlers.MetricsExplorer,
-			handlers.MetricReductionRule,
 			handlers.InfraMonitoring,
 			handlers.GatewayHandler,
 			handlers.Fields,

pkg/signoz/signoz.go

@@ -26,7 +26,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/retention"
@@ -115,7 +114,6 @@ func New(
 	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
 	querierHandlerCallback func(factory.ProviderSettings, querier.Querier, analytics.Analytics) querier.Handler,
 	cloudIntegrationCallback func(sqlstore.SQLStore, dashboard.Module, global.Global, zeus.Zeus, gateway.Gateway, licensing.Licensing, serviceaccount.Module, cloudintegration.Config) (cloudintegration.Module, error),
-	metricReductionRuleModuleCallback func(sqlstore.SQLStore, telemetrystore.TelemetryStore, dashboard.Module, queryparser.QueryParser, licensing.Licensing, factory.ProviderSettings, int) metricreductionrule.Module,
 	rulerProviderFactories func(cache.Cache, alertmanager.Alertmanager, sqlstore.SQLStore, telemetrystore.TelemetryStore, telemetrytypes.MetadataStore, prometheus.Prometheus, organization.Getter, rulestatehistory.Module, querier.Querier, queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]],
 ) (*SigNoz, error) {
 	// Initialize instrumentation
@@ -466,10 +464,8 @@ func New(
 		return nil, err
 	}
 
-	metricReductionRuleModule := metricReductionRuleModuleCallback(sqlstore, telemetrystore, dashboard, queryParser, licensing, providerSettings, config.MetricsExplorer.TelemetryStore.Threads)
-
 	// Initialize all modules
-	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, userGetter, userRoleStore, serviceAccount, cloudIntegrationModule, retentionGetter, flagger, tagModule, metricReductionRuleModule)
+	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, userGetter, userRoleStore, serviceAccount, cloudIntegrationModule, retentionGetter, flagger, tagModule)
 
 	// Initialize ruler from the variant-specific provider factories
 	rulerInstance, err := factory.NewProviderFromNamedMap(ctx, providerSettings, config.Ruler, rulerProviderFactories(cache, alertmanager, sqlstore, telemetrystore, telemetryMetadataStore, prometheus, orgGetter, modules.RuleStateHistory, querier, queryParser), "signoz")

pkg/sqlmigration/096_add_metric_reduction_rules.go

@@ -1,90 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addMetricReductionRules struct {
-	sqlschema sqlschema.SQLSchema
-	sqlstore  sqlstore.SQLStore
-}
-
-func NewAddMetricReductionRulesFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_metric_reduction_rule"), func(_ context.Context, _ factory.ProviderSettings, _ Config) (SQLMigration, error) {
-		return &addMetricReductionRules{
-			sqlschema: sqlschema,
-			sqlstore:  sqlstore,
-		}, nil
-	})
-}
-
-func (migration *addMetricReductionRules) Register(migrations *migrate.Migrations) error {
-	if err := migrations.Register(migration.Up, migration.Down); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (migration *addMetricReductionRules) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	sqls := [][]byte{}
-
-	tableSQLs := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "metric_reduction_rule",
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "metric_name", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "match_type", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "labels", DataType: sqlschema.DataTypeText, Nullable: false, Default: "'[]'"},
-			{Name: "effective_from", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "created_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "updated_by", DataType: sqlschema.DataTypeText, Nullable: false},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
-			ColumnNames: []sqlschema.ColumnName{"id"},
-		},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-	sqls = append(sqls, tableSQLs...)
-
-	indexSQLs := migration.sqlschema.Operator().CreateIndex(&sqlschema.UniqueIndex{
-		TableName:   "metric_reduction_rule",
-		ColumnNames: []sqlschema.ColumnName{"org_id", "metric_name"},
-	})
-	sqls = append(sqls, indexSQLs...)
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addMetricReductionRules) Down(context.Context, *bun.DB) error {
-	return nil
-}

pkg/telemetrymetrics/stmt_builder_test.go

@@ -244,7 +244,7 @@ func TestStatementBuilder(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query:    "WITH __temporal_aggregation_cte AS (SELECT ts, `k8s.statefulset.name`, multiIf(row_number() OVER rate_window = 1, nan, (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) < 0, per_series_value / (ts - lagInFrame(ts, 1) OVER rate_window), (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) / (ts - lagInFrame(ts, 1) OVER rate_window)) AS per_series_value FROM (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(30)) AS ts, `k8s.statefulset.name`, max(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'k8s.statefulset.name') AS `k8s.statefulset.name` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) AND __normalized = ? AND JSONExtractString(labels, 'k8s.statefulset.name') = ? GROUP BY fingerprint, `k8s.statefulset.name`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `k8s.statefulset.name` ORDER BY fingerprint, ts) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)), __spatial_aggregation_cte AS (SELECT ts, `k8s.statefulset.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `k8s.statefulset.name`) SELECT * FROM __spatial_aggregation_cte ORDER BY `k8s.statefulset.name`, ts",
+				Query: "WITH __temporal_aggregation_cte AS (SELECT ts, `k8s.statefulset.name`, multiIf(row_number() OVER rate_window = 1, nan, (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) < 0, per_series_value / (ts - lagInFrame(ts, 1) OVER rate_window), (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) / (ts - lagInFrame(ts, 1) OVER rate_window)) AS per_series_value FROM (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(30)) AS ts, `k8s.statefulset.name`, max(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'k8s.statefulset.name') AS `k8s.statefulset.name` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) AND __normalized = ? AND JSONExtractString(labels, 'k8s.statefulset.name') = ? GROUP BY fingerprint, `k8s.statefulset.name`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `k8s.statefulset.name` ORDER BY fingerprint, ts) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)), __spatial_aggregation_cte AS (SELECT ts, `k8s.statefulset.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `k8s.statefulset.name`) SELECT * FROM __spatial_aggregation_cte ORDER BY `k8s.statefulset.name`, ts",
 				Args:     []any{"signoz_calls_total", uint64(1747936800000), uint64(1747983420000), "cumulative", false, "my-statefulset", "signoz_calls_total", uint64(1747947360000), uint64(1747983420000), 0},
 				Warnings: []string{"key `k8s.statefulset.name` not found on metric signoz_calls_total"},
 			},

pkg/telemetrymetrics/tables.go

@@ -9,34 +9,27 @@ import (
 )
 
 const (
-	DBName                          = "signoz_metrics"
-	UpdatedMetadataTableName        = "distributed_updated_metadata"
-	UpdatedMetadataLocalTableName   = "updated_metadata"
-	SamplesV4TableName              = "distributed_samples_v4"
-	SamplesV4LocalTableName         = "samples_v4"
-	SamplesV4Agg5mTableName         = "distributed_samples_v4_agg_5m"
-	SamplesV4Agg5mLocalTableName    = "samples_v4_agg_5m"
-	SamplesV4Agg30mTableName        = "distributed_samples_v4_agg_30m"
-	SamplesV4Agg30mLocalTableName   = "samples_v4_agg_30m"
-	ExpHistogramTableName           = "distributed_exp_hist"
-	ExpHistogramLocalTableName      = "exp_hist"
-	TimeseriesV4TableName           = "distributed_time_series_v4"
-	TimeseriesV4LocalTableName      = "time_series_v4"
-	TimeseriesV46hrsTableName       = "distributed_time_series_v4_6hrs"
-	TimeseriesV46hrsLocalTableName  = "time_series_v4_6hrs"
-	TimeseriesV41dayTableName       = "distributed_time_series_v4_1day"
-	TimeseriesV41dayLocalTableName  = "time_series_v4_1day"
-	TimeseriesV41weekTableName      = "distributed_time_series_v4_1week"
-	TimeseriesV41weekLocalTableName = "time_series_v4_1week"
-	// Reduction tables written by the collector; see signoz-otel-collector#839.
-	TimeseriesV4BufferTableName       = "distributed_time_series_v4_buffer"
-	TimeseriesV4BufferLocalTableName  = "time_series_v4_buffer"
-	TimeseriesV4ReducedTableName      = "distributed_time_series_v4_reduced"
-	TimeseriesV4ReducedLocalTableName = "time_series_v4_reduced"
-	AttributesMetadataTableName       = "distributed_metadata"
-	AttributesMetadataLocalTableName  = "metadata"
-	ReductionRulesTableName           = "distributed_metric_reduction_rules"
-	ReductionRulesLocalTableName      = "metric_reduction_rules"
+	DBName                           = "signoz_metrics"
+	UpdatedMetadataTableName         = "distributed_updated_metadata"
+	UpdatedMetadataLocalTableName    = "updated_metadata"
+	SamplesV4TableName               = "distributed_samples_v4"
+	SamplesV4LocalTableName          = "samples_v4"
+	SamplesV4Agg5mTableName          = "distributed_samples_v4_agg_5m"
+	SamplesV4Agg5mLocalTableName     = "samples_v4_agg_5m"
+	SamplesV4Agg30mTableName         = "distributed_samples_v4_agg_30m"
+	SamplesV4Agg30mLocalTableName    = "samples_v4_agg_30m"
+	ExpHistogramTableName            = "distributed_exp_hist"
+	ExpHistogramLocalTableName       = "exp_hist"
+	TimeseriesV4TableName            = "distributed_time_series_v4"
+	TimeseriesV4LocalTableName       = "time_series_v4"
+	TimeseriesV46hrsTableName        = "distributed_time_series_v4_6hrs"
+	TimeseriesV46hrsLocalTableName   = "time_series_v4_6hrs"
+	TimeseriesV41dayTableName        = "distributed_time_series_v4_1day"
+	TimeseriesV41dayLocalTableName   = "time_series_v4_1day"
+	TimeseriesV41weekTableName       = "distributed_time_series_v4_1week"
+	TimeseriesV41weekLocalTableName  = "time_series_v4_1week"
+	AttributesMetadataTableName      = "distributed_metadata"
+	AttributesMetadataLocalTableName = "metadata"
 )
 
 var (

pkg/types/dashboardtypes/perses_dashboard_convertors_test.go

@@ -38,7 +38,7 @@ func newTestDashboardV2(t *testing.T, orgID valuer.UUID, source Source) *Dashboa
 								FillMode:          FillModeSolid,
 								SpanGaps:          SpanGaps{FillLessThan: valuer.MustParseTextDuration("60s")},
 							},
-							Legend: Legend{Position: LegendPositionBottom},
+							Legend: Legend{Position: LegendPositionBottom, Mode: LegendModeList},
 						},
 					},
 					Queries: []Query{

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -48,7 +48,42 @@ func (d *DashboardSpec) UnmarshalJSON(data []byte) error {
 // ══════════════════════════════════════════════
 
 func (d *DashboardSpec) Validate() error {
+	if err := d.validateVariables(); err != nil {
+		return err
+	}
+	if err := d.validatePanels(); err != nil {
+		return err
+	}
+	return d.validateLayouts()
+}
+
+// validateVariables rejects two variables sharing the same name.
+func (d *DashboardSpec) validateVariables() error {
+	seen := make(map[string]struct{}, len(d.Variables))
+	for i, v := range d.Variables {
+		var name string
+		switch s := v.Spec.(type) {
+		case *ListVariableSpec:
+			name = s.Name
+		case *TextVariableSpec:
+			name = s.Name
+		default:
+			// Unreachable via UnmarshalJSON; reaching here means a Go caller broke the Kind/Spec pairing.
+			return errors.NewInternalf(errors.CodeInternal, "spec.variables[%d].spec: unexpected variable spec type %T", i, v.Spec)
+		}
+		if _, dup := seen[name]; dup {
+			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.variables[%d]: duplicate variable name %q", i, name)
+		}
+		seen[name] = struct{}{}
+	}
+	return nil
+}
+
+func (d *DashboardSpec) validatePanels() error {
 	for key, panel := range d.Panels {
+		if err := common.ValidateID(key); err != nil {
+			return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "spec.panels: %s", err.Error())
+		}
 		if panel == nil {
 			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.panels.%s: panel must not be null", key)
 		}
@@ -69,6 +104,13 @@ func (d *DashboardSpec) Validate() error {
 }
 
 func validateQueryAllowedForPanel(plugin QueryPlugin, allowed []QueryPluginKind, panelKind PanelPluginKind, path string) error {
+	compositeSubQueryTypeToPluginKind := map[qb.QueryType]QueryPluginKind{
+		qb.QueryTypeBuilder:       QueryKindBuilder,
+		qb.QueryTypeFormula:       QueryKindFormula,
+		qb.QueryTypeTraceOperator: QueryKindTraceOperator,
+		qb.QueryTypePromQL:        QueryKindPromQL,
+		qb.QueryTypeClickHouseSQL: QueryKindClickHouseSQL,
+	}
 	if !slices.Contains(allowed, plugin.Kind) {
 		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
 			"%s: query kind %q is not supported by panel kind %q", path, plugin.Kind, panelKind)
@@ -96,12 +138,35 @@ func validateQueryAllowedForPanel(plugin QueryPlugin, allowed []QueryPluginKind,
 	return nil
 }
 
-var (
-	compositeSubQueryTypeToPluginKind = map[qb.QueryType]QueryPluginKind{
-		qb.QueryTypeBuilder:       QueryKindBuilder,
-		qb.QueryTypeFormula:       QueryKindFormula,
-		qb.QueryTypeTraceOperator: QueryKindTraceOperator,
-		qb.QueryTypePromQL:        QueryKindPromQL,
-		qb.QueryTypeClickHouseSQL: QueryKindClickHouseSQL,
+// validateLayouts rejects grid items referencing a panel that doesn't exist.
+func (d *DashboardSpec) validateLayouts() error {
+	for li, layout := range d.Layouts {
+		grid, ok := layout.Spec.(*dashboard.GridLayoutSpec)
+		if !ok {
+			// Unreachable via UnmarshalJSON; reaching here means a Go caller broke the Kind/Spec pairing.
+			return errors.NewInternalf(errors.CodeInternal, "spec.layouts[%d].spec: unexpected layout spec type %T", li, layout.Spec)
+		}
+		for ii, item := range grid.Items {
+			path := fmt.Sprintf("spec.layouts[%d].spec.items[%d].content", li, ii)
+			if item.Content == nil {
+				return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: content reference is required", path)
+			}
+			key, err := panelKeyFromRef(item.Content.Path, item.Content.Ref, path)
+			if err != nil {
+				return err
+			}
+			if _, ok := d.Panels[key]; !ok {
+				return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: references unknown panel %q", path, key)
+			}
+		}
 	}
-)
+	return nil
+}
+
+// panelKeyFromRef extracts <key> from a "#/spec/panels/<key>" content ref.
+func panelKeyFromRef(refPath []string, ref string, path string) (string, error) {
+	if len(refPath) != 3 || refPath[0] != "spec" || refPath[1] != "panels" {
+		return "", errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: %q must reference a panel as \"#/spec/panels/<key>\"", path, ref)
+	}
+	return refPath[2], nil
+}

pkg/types/dashboardtypes/perses_dashboard_patch.go

@@ -73,7 +73,7 @@ func (p PatchableDashboardV2) Apply(existing *DashboardV2) (*UpdatableDashboardV
 	}
 	patched, err := p.patch.ApplyWithOptions(raw, &jsonpatch.ApplyOptions{AllowMissingPathOnRemove: true, EnsurePathExistsOnAdd: true})
 	if err != nil {
-		return nil, errors.Wrap(err, errors.TypeInvalidInput, ErrCodeDashboardInvalidPatch, "JSON Patch could not be applied to the target dashboard")
+		return nil, errors.Wrap(err, errors.TypeInvalidInput, ErrCodeDashboardInvalidPatch, "JSON Patch could not be applied to the target dashboard").WithAdditional(err.Error())
 	}
 	out := &UpdatableDashboardV2{}
 	if err := json.Unmarshal(patched, out); err != nil {

pkg/types/dashboardtypes/perses_dashboard_patch_test.go

@@ -405,6 +405,7 @@ func TestPatchableDashboardV2_Apply(t *testing.T) {
 		out, err := decode(t, `[
 			{"op": "replace", "path": "/spec/display/name", "value": "Multi-step"},
 			{"op": "remove",  "path": "/spec/panels/p2"},
+			{"op": "remove",  "path": "/spec/layouts/0/spec/items/1"},
 			{"op": "add",     "path": "/tags/-", "value": {"key": "env", "value": "staging"}}
 		]`).Apply(base)
 		require.NoError(t, err)

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -112,6 +112,174 @@ func TestValidateOnlyVariables(t *testing.T) {
 	require.NoError(t, err, "expected valid")
 }
 
+func TestInvalidateDuplicateVariableNames(t *testing.T) {
+	data := []byte(`{
+		"variables": [
+			{
+				"kind": "TextVariable",
+				"spec": {"name": "env", "value": "prod"}
+			},
+			{
+				"kind": "ListVariable",
+				"spec": {
+					"name": "env",
+					"allowAllValue": false,
+					"allowMultiple": false,
+					"plugin": {
+						"kind": "signoz/DynamicVariable",
+						"spec": {"name": "service.name", "signal": "metrics"}
+					}
+				}
+			}
+		],
+		"layouts": []
+	}`)
+	_, err := unmarshalDashboard(data)
+	require.Error(t, err, "expected error for duplicate variable name")
+	require.Contains(t, err.Error(), `duplicate variable name "env"`)
+}
+
+func TestInvalidateVariableNameWithInvalidChars(t *testing.T) {
+	listVarWithName := func(name string) []byte {
+		return []byte(`{
+			"variables": [
+				{
+					"kind": "ListVariable",
+					"spec": {
+						"name": "` + name + `",
+						"allowAllValue": false,
+						"allowMultiple": false,
+						"plugin": {
+							"kind": "signoz/DynamicVariable",
+							"spec": {"name": "service.name", "signal": "metrics"}
+						}
+					}
+				}
+			],
+			"layouts": []
+		}`)
+	}
+	for _, name := range []string{"my var", "cost$", "bad!", "a/b"} {
+		t.Run(name, func(t *testing.T) {
+			_, err := unmarshalDashboard(listVarWithName(name))
+			require.Error(t, err, "expected error for invalid variable name %q", name)
+			require.Contains(t, err.Error(), "is not a correct name")
+		})
+	}
+	for _, name := range []string{"service", "my_var", "MY_VAR", "MixedCase9", "with-hyphen", "with.dot"} {
+		t.Run(name, func(t *testing.T) {
+			_, err := unmarshalDashboard(listVarWithName(name))
+			require.NoError(t, err, "expected valid variable name %q", name)
+		})
+	}
+	t.Run("digits only", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVarWithName("123"))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "cannot contain only digits")
+	})
+}
+
+func TestInvalidatePanelKey(t *testing.T) {
+	data := []byte(`{
+		"panels": {
+			"bad key!": {
+				"kind": "Panel",
+				"spec": {
+					"plugin": {"kind": "signoz/TablePanel", "spec": {}},
+					"queries": [{
+						"kind": "time_series",
+						"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
+							"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]
+						}}}
+					}]
+				}
+			}
+		},
+		"layouts": []
+	}`)
+	_, err := unmarshalDashboard(data)
+	require.Error(t, err, "expected error for invalid panel key")
+	require.Contains(t, err.Error(), "is not a correct name")
+}
+
+func TestInvalidateListVariableCrossFields(t *testing.T) {
+	listVar := func(specFields string) []byte {
+		return []byte(`{
+			"variables": [
+				{
+					"kind": "ListVariable",
+					"spec": {
+						"name": "service",
+						` + specFields + `
+						"plugin": {
+							"kind": "signoz/DynamicVariable",
+							"spec": {"name": "service.name", "signal": "metrics"}
+						}
+					}
+				}
+			],
+			"layouts": []
+		}`)
+	}
+
+	t.Run("customAllValue without allowAllValue", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVar(`"allowAllValue": false, "allowMultiple": false, "customAllValue": "*",`))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "customAllValue cannot be set")
+	})
+
+	t.Run("list defaultValue without allowMultiple", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVar(`"allowAllValue": false, "allowMultiple": false, "defaultValue": ["a", "b"],`))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "allowMultiple")
+	})
+
+	t.Run("single-element list default without allowMultiple", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVar(`"allowAllValue": false, "allowMultiple": false, "defaultValue": ["only"],`))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "allowMultiple")
+	})
+
+	t.Run("valid sort is accepted", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVar(`"sort": "alphabetical-asc",`))
+		require.NoError(t, err)
+	})
+
+	t.Run("unknown sort is rejected", func(t *testing.T) {
+		_, err := unmarshalDashboard(listVar(`"sort": "bogus",`))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "unknown sort")
+	})
+}
+
+func TestInvalidateEmptyVariableName(t *testing.T) {
+	cases := map[string][]byte{
+		"text variable": []byte(`{
+			"variables": [{"kind": "TextVariable", "spec": {"name": "", "value": "x"}}],
+			"layouts": []
+		}`),
+		"list variable": []byte(`{
+			"variables": [{
+				"kind": "ListVariable",
+				"spec": {
+					"name": "",
+					"allowAllValue": false,
+					"allowMultiple": false,
+					"plugin": {"kind": "signoz/DynamicVariable", "spec": {"name": "service.name", "signal": "metrics"}}
+				}
+			}],
+			"layouts": []
+		}`),
+	}
+	for name, data := range cases {
+		t.Run(name, func(t *testing.T) {
+			_, err := unmarshalDashboard(data)
+			require.Error(t, err, "expected error for empty variable name")
+			require.Contains(t, err.Error(), "name cannot be empty")
+		})
+	}
+}
+
 func TestInvalidateUnknownPluginKind(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -270,6 +438,65 @@ func TestInvalidateOneInvalidPanel(t *testing.T) {
 	require.Contains(t, err.Error(), "FakePanel", "error should mention FakePanel")
 }
 
+func TestInvalidateLayoutPanelReferences(t *testing.T) {
+	validPanels := `"panels": {
+		"p1": {
+			"kind": "Panel",
+			"spec": {
+				"plugin": {"kind": "signoz/TablePanel", "spec": {}},
+				"queries": [{
+					"kind": "time_series",
+					"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
+						"name": "A", "signal": "logs", "aggregations": [{"expression": "count()"}]
+					}}}
+				}]
+			}
+		}
+	}`
+	layout := func(items string) []byte {
+		return []byte(`{` + validPanels + `, "layouts": [{"kind": "Grid", "spec": {"items": [` + items + `]}}]}`)
+	}
+
+	tests := []struct {
+		name        string
+		data        []byte
+		wantContain string
+	}{
+		{
+			name:        "reference to unknown panel",
+			data:        layout(`{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/ghost"}}`),
+			wantContain: `references unknown panel "ghost"`,
+		},
+		{
+			name:        "reference not pointing at a panel",
+			data:        layout(`{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/variables/p1"}}`),
+			wantContain: "must reference a panel",
+		},
+		{
+			name:        "reference missing spec prefix",
+			data:        layout(`{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/panels/p1"}}`),
+			wantContain: "must reference a panel",
+		},
+		{
+			name:        "valid reference",
+			data:        layout(`{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/p1"}}`),
+			wantContain: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := unmarshalDashboard(tt.data)
+			if tt.wantContain == "" {
+				require.NoError(t, err)
+				return
+			}
+			require.Error(t, err)
+			require.Contains(t, err.Error(), tt.wantContain)
+		})
+	}
+}
+
 func TestRejectUnknownFieldsInPluginSpec(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -569,6 +796,24 @@ func TestInvalidateBadPanelSpecValues(t *testing.T) {
 			}`,
 			wantContain: "legend position",
 		},
+		{
+			name: "bad legend mode",
+			data: `{
+				"panels": {
+					"p1": {
+						"kind": "Panel",
+						"spec": {
+							"plugin": {
+								"kind": "signoz/BarChartPanel",
+								"spec": {"legend": {"mode": "grid"}}
+							}
+						}
+					}
+				},
+				"layouts": []
+			}`,
+			wantContain: "legend mode",
+		},
 		{
 			name: "bad threshold format",
 			data: `{
@@ -634,6 +879,39 @@ func TestInvalidateBadPanelSpecValues(t *testing.T) {
 	}
 }
 
+// Label on ThresholdWithLabel is optional — the backend never reads it, so a
+// threshold with an omitted or empty label must validate cleanly.
+func TestThresholdLabelOptional(t *testing.T) {
+	for _, tt := range []struct {
+		name      string
+		threshold string
+	}{
+		{name: "label omitted", threshold: `{"value": 100, "color": "Red"}`},
+		{name: "label empty", threshold: `{"value": 100, "color": "Red", "label": ""}`},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			data := []byte(`{
+				"panels": {
+					"p1": {
+						"kind": "Panel",
+						"spec": {
+							"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {"thresholds": [` + tt.threshold + `]}},
+							"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+						}
+					}
+				},
+				"layouts": []
+			}`)
+			d, err := unmarshalDashboard(data)
+			require.NoError(t, err, "threshold without a label should validate")
+
+			spec := d.Panels["p1"].Spec.Plugin.Spec.(*TimeSeriesPanelSpec)
+			require.Len(t, spec.Thresholds, 1)
+			require.Empty(t, spec.Thresholds[0].Label, "label should remain empty")
+		})
+	}
+}
+
 func TestInvalidatePanelWithoutQueries(t *testing.T) {
 	data := []byte(`{
 		"panels": {
@@ -749,11 +1027,6 @@ func TestValidateRequiredFields(t *testing.T) {
 			data:        wrapPanel("signoz/TimeSeriesPanel", `{"thresholds": [{"value": 100, "label": "high", "color": ""}]}`),
 			wantContain: "Color",
 		},
-		{
-			name:        "ThresholdWithLabel missing label",
-			data:        wrapPanel("signoz/TimeSeriesPanel", `{"thresholds": [{"value": 100, "color": "Red", "label": ""}]}`),
-			wantContain: "Label",
-		},
 		{
 			name:        "ComparisonThreshold missing value",
 			data:        wrapPanel("signoz/NumberPanel", `{"thresholds": [{"operator": "above", "format": "text", "color": "Red"}]}`),
@@ -811,10 +1084,11 @@ func TestTimeSeriesPanelDefaults(t *testing.T) {
 	require.Equal(t, "2", spec.Formatting.DecimalPrecision.ValueOrDefault(), "expected DecimalPrecision default 2")
 	require.Equal(t, "spline", spec.ChartAppearance.LineInterpolation.ValueOrDefault(), "expected LineInterpolation default spline")
 	require.Equal(t, "solid", spec.ChartAppearance.LineStyle.ValueOrDefault(), "expected LineStyle default solid")
-	require.Equal(t, "solid", spec.ChartAppearance.FillMode.ValueOrDefault(), "expected FillMode default solid")
+	require.Equal(t, "none", spec.ChartAppearance.FillMode.ValueOrDefault(), "expected FillMode default none")
 	require.False(t, spec.ChartAppearance.SpanGaps.FillOnlyBelow, "expected SpanGaps.FillOnlyBelow default false")
 	require.Equal(t, "global_time", spec.Visualization.TimePreference.ValueOrDefault(), "expected TimePreference default global_time")
 	require.Equal(t, "bottom", spec.Legend.Position.ValueOrDefault(), "expected LegendPosition default bottom")
+	require.Equal(t, "list", spec.Legend.Mode.ValueOrDefault(), "expected LegendMode default list")
 
 	// Re-marshal the full dashboard (what we'd store in DB / return in API response)
 	// and verify the output contains the default values.
@@ -825,9 +1099,10 @@ func TestTimeSeriesPanelDefaults(t *testing.T) {
 		"decimalPrecision":  `"2"`,
 		"lineInterpolation": `"spline"`,
 		"lineStyle":         `"solid"`,
-		"fillMode":          `"solid"`,
+		"fillMode":          `"none"`,
 		"timePreference":    `"global_time"`,
 		"position":          `"bottom"`,
+		"mode":              `"list"`,
 	} {
 		assert.Contains(t, outputStr, `"`+field+`":`+want, "expected stored/response JSON to contain %s:%s", field, want)
 	}
@@ -930,7 +1205,7 @@ func TestStorageRoundTrip(t *testing.T) {
 	assert.Equal(t, "2", tsSpec.Formatting.DecimalPrecision.ValueOrDefault())
 	assert.Equal(t, "spline", tsSpec.ChartAppearance.LineInterpolation.ValueOrDefault())
 	assert.Equal(t, "solid", tsSpec.ChartAppearance.LineStyle.ValueOrDefault())
-	assert.Equal(t, "solid", tsSpec.ChartAppearance.FillMode.ValueOrDefault())
+	assert.Equal(t, "none", tsSpec.ChartAppearance.FillMode.ValueOrDefault())
 	assert.Equal(t, "global_time", tsSpec.Visualization.TimePreference.ValueOrDefault())
 	assert.Equal(t, "bottom", tsSpec.Legend.Position.ValueOrDefault())
 	numSpec := d.Panels["p2"].Spec.Plugin.Spec.(*NumberPanelSpec)
@@ -950,7 +1225,7 @@ func TestStorageRoundTrip(t *testing.T) {
 	assert.Equal(t, "2", tsLoaded.Formatting.DecimalPrecision.ValueOrDefault(), "after load")
 	assert.Equal(t, "spline", tsLoaded.ChartAppearance.LineInterpolation.ValueOrDefault(), "after load")
 	assert.Equal(t, "solid", tsLoaded.ChartAppearance.LineStyle.ValueOrDefault(), "after load")
-	assert.Equal(t, "solid", tsLoaded.ChartAppearance.FillMode.ValueOrDefault(), "after load")
+	assert.Equal(t, "none", tsLoaded.ChartAppearance.FillMode.ValueOrDefault(), "after load")
 	assert.Equal(t, "global_time", tsLoaded.Visualization.TimePreference.ValueOrDefault(), "after load")
 	assert.Equal(t, "bottom", tsLoaded.Legend.Position.ValueOrDefault(), "after load")
 	numLoaded := loaded.Panels["p2"].Spec.Plugin.Spec.(*NumberPanelSpec)
@@ -966,7 +1241,7 @@ func TestStorageRoundTrip(t *testing.T) {
 		"decimalPrecision":  `"2"`,
 		"lineInterpolation": `"spline"`,
 		"lineStyle":         `"solid"`,
-		"fillMode":          `"solid"`,
+		"fillMode":          `"none"`,
 		"timePreference":    `"global_time"`,
 		"position":          `"bottom"`,
 		"format":            `"text"`,

pkg/types/dashboardtypes/perses_drift_test.go

@@ -30,6 +30,7 @@ func TestDashboardSpecMatchesPerses(t *testing.T) {
 		{"DatasourceSpec", typeOf[DatasourceSpec](), typeOf[datasource.Spec]()},
 		{"Variable", typeOf[Variable](), typeOf[dashboard.Variable]()},
 		{"ListVariableSpec", typeOf[ListVariableSpec](), typeOf[dashboard.ListVariableSpec]()},
+		{"TextVariableSpec", typeOf[TextVariableSpec](), typeOf[dashboard.TextVariableSpec]()},
 		{"Layout", typeOf[Layout](), typeOf[dashboard.Layout]()},
 	}
 

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -51,7 +51,7 @@ func (p *PanelPlugin) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	p.Kind = PanelPluginKind(kind)
-	p.Spec = spec
+	p.Spec = *spec
 	return nil
 }
 
@@ -110,7 +110,7 @@ func (p *QueryPlugin) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	p.Kind = QueryPluginKind(kind)
-	p.Spec = spec
+	p.Spec = *spec
 	return nil
 }
 
@@ -165,7 +165,7 @@ func (p *VariablePlugin) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	p.Kind = VariablePluginKind(kind)
-	p.Spec = spec
+	p.Spec = *spec
 	return nil
 }
 
@@ -215,7 +215,7 @@ func (p *DatasourcePlugin) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	p.Kind = DatasourcePluginKind(kind)
-	p.Spec = spec
+	p.Spec = *spec
 	return nil
 }
 
@@ -297,8 +297,7 @@ func extractKindAndSpec(data []byte) (string, []byte, error) {
 	return head.Kind, head.Spec, nil
 }
 
-// decodeSpec strict-decodes a spec JSON into target and runs struct-tag validation (go-playground/validator).
-func decodeSpec(specJSON []byte, target any, kind string) (any, error) {
+func decodeSpec[T any](specJSON []byte, target T, kind string) (*T, error) {
 	if len(specJSON) == 0 {
 		return nil, errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "kind %q: spec is required", kind)
 	}
@@ -310,7 +309,12 @@ func decodeSpec(specJSON []byte, target any, kind string) (any, error) {
 	if err := validator.New().Struct(target); err != nil {
 		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "kind %q: spec failed validation", kind)
 	}
-	return target, nil
+	if v, ok := any(target).(interface{ validate() error }); ok {
+		if err := v.validate(); err != nil {
+			return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "kind %q: %s", kind, err.Error())
+		}
+	}
+	return &target, nil
 }
 
 // signozDiscriminatorKey is the extension key that signoz.attachDiscriminators

pkg/types/dashboardtypes/perses_replicas.go

@@ -4,9 +4,11 @@ import (
 	"encoding/json"
 	"maps"
 	"slices"
+	"strconv"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/perses/spec/go/common"
 	"github.com/perses/spec/go/dashboard"
 	"github.com/perses/spec/go/dashboard/variable"
@@ -84,7 +86,7 @@ type QuerySpec struct {
 // ══════════════════════════════════════════════
 
 // Variable is the list/text sum type. Spec is set to *ListVariableSpec or
-// *dashboard.TextVariableSpec by UnmarshalJSON based on Kind. The schema is a
+// *TextVariableSpec by UnmarshalJSON based on Kind. The schema is a
 // discriminated oneOf (see JSONSchemaOneOf).
 type Variable struct {
 	Kind variable.Kind `json:"kind" required:"true"`
@@ -94,7 +96,7 @@ type Variable struct {
 func (Variable) PrepareJSONSchema(s *jsonschema.Schema) error {
 	return markDiscriminator(s, "kind", map[string]string{
 		string(variable.KindList): schemaRef("DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec"),
-		string(variable.KindText): schemaRef("DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec"),
+		string(variable.KindText): schemaRef("DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesTextVariableSpec"),
 	})
 }
 
@@ -110,14 +112,14 @@ func (v *Variable) UnmarshalJSON(data []byte) error {
 			return err
 		}
 		v.Kind = variable.KindList
-		v.Spec = spec
+		v.Spec = *spec
 	case string(variable.KindText):
-		spec, err := decodeSpec(specJSON, new(dashboard.TextVariableSpec), kind)
+		spec, err := decodeSpec(specJSON, new(TextVariableSpec), kind)
 		if err != nil {
 			return err
 		}
 		v.Kind = variable.KindText
-		v.Spec = spec
+		v.Spec = *spec
 	default:
 		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "unknown variable kind %q; allowed values: %s", kind, allowedValuesForKind([]variable.Kind{variable.KindList, variable.KindText}))
 	}
@@ -127,7 +129,7 @@ func (v *Variable) UnmarshalJSON(data []byte) error {
 func (Variable) JSONSchemaOneOf() []any {
 	return []any{
 		VariableEnvelope[ListVariableSpec]{Kind: string(variable.KindList)},
-		VariableEnvelope[dashboard.TextVariableSpec]{Kind: string(variable.KindText)},
+		VariableEnvelope[TextVariableSpec]{Kind: string(variable.KindText)},
 	}
 }
 
@@ -143,15 +145,106 @@ func (v VariableEnvelope[S]) PrepareJSONSchema(s *jsonschema.Schema) error {
 // ListVariableSpec mirrors dashboard.ListVariableSpec (variable.ListSpec
 // fields + Name) but with a typed VariablePlugin replacing common.Plugin.
 type ListVariableSpec struct {
-	Display         Display                `json:"display" required:"true"`
+	Display         *Display               `json:"display,omitempty"`
 	DefaultValue    *variable.DefaultValue `json:"defaultValue,omitempty"`
 	AllowAllValue   bool                   `json:"allowAllValue"`
 	AllowMultiple   bool                   `json:"allowMultiple"`
 	CustomAllValue  string                 `json:"customAllValue,omitempty"`
 	CapturingRegexp string                 `json:"capturingRegexp,omitempty"`
-	Sort            *variable.Sort         `json:"sort,omitempty"`
+	Sort            ListVariableSpecSort   `json:"sort,omitzero"`
 	Plugin          VariablePlugin         `json:"plugin"`
-	Name            string                 `json:"name"`
+	Name            string                 `json:"name" required:"true" minLength:"1"`
+}
+
+// validate mirrors perses ListVariableSpec validation (plus the digits-only name
+// check perses only applies to text variables); run by decodeSpec on unmarshal.
+func (s *ListVariableSpec) validate() error {
+	if err := common.ValidateID(s.Name); err != nil {
+		return err
+	}
+	if _, err := strconv.Atoi(s.Name); err == nil {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "variable name cannot contain only digits")
+	}
+	if s.CustomAllValue != "" && !s.AllowAllValue {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "customAllValue cannot be set if allowAllValue is not set to true")
+	}
+	if s.DefaultValue != nil && len(s.DefaultValue.SliceValues) > 0 && !s.AllowMultiple {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "defaultValue cannot be a list if allowMultiple is not set to true")
+	}
+	return nil
+}
+
+// ListVariableSpecSort is the value-list sort method, mirrored from Perses as a
+// stable enum so the allowed values surface in the generated OpenAPI schema.
+type ListVariableSpecSort struct{ valuer.String }
+
+var (
+	SortNone                            = ListVariableSpecSort{valuer.NewString("none")}
+	SortAlphabeticalAsc                 = ListVariableSpecSort{valuer.NewString("alphabetical-asc")}
+	SortAlphabeticalDesc                = ListVariableSpecSort{valuer.NewString("alphabetical-desc")}
+	SortNumericalAsc                    = ListVariableSpecSort{valuer.NewString("numerical-asc")}
+	SortNumericalDesc                   = ListVariableSpecSort{valuer.NewString("numerical-desc")}
+	SortAlphabeticalCaseInsensitiveAsc  = ListVariableSpecSort{valuer.NewString("alphabetical-ci-asc")}
+	SortAlphabeticalCaseInsensitiveDesc = ListVariableSpecSort{valuer.NewString("alphabetical-ci-desc")}
+)
+
+func (ListVariableSpecSort) Enum() []any {
+	return []any{
+		SortNone,
+		SortAlphabeticalAsc,
+		SortAlphabeticalDesc,
+		SortNumericalAsc,
+		SortNumericalDesc,
+		SortAlphabeticalCaseInsensitiveAsc,
+		SortAlphabeticalCaseInsensitiveDesc,
+	}
+}
+
+func (s ListVariableSpecSort) IsValid() bool {
+	return slices.ContainsFunc(s.Enum(), func(v any) bool { return v == s })
+}
+
+// UnmarshalJSON validates against the enum on decode (valuer.String alone
+// accepts any string). An empty value is allowed and means "no sort", matching
+// Perses.
+func (s *ListVariableSpecSort) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid sort: must be a string, one of `none`, `alphabetical-asc`, `alphabetical-desc`, `numerical-asc`, `numerical-desc`, `alphabetical-ci-asc`, or `alphabetical-ci-desc`")
+	}
+	if v == "" {
+		*s = ListVariableSpecSort{}
+		return nil
+	}
+	sort := ListVariableSpecSort{valuer.NewString(v)}
+	if !sort.IsValid() {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "unknown sort %q: must be `none`, `alphabetical-asc`, `alphabetical-desc`, `numerical-asc`, `numerical-desc`, `alphabetical-ci-asc`, or `alphabetical-ci-desc`", v)
+	}
+	*s = sort
+	return nil
+}
+
+// TextVariableSpec replicates dashboard.TextVariableSpec so name can carry the
+// required/non-empty schema tags perses leaves off.
+type TextVariableSpec struct {
+	Display  *Display `json:"display,omitempty"`
+	Value    string   `json:"value"`
+	Constant bool     `json:"constant,omitempty"`
+	Name     string   `json:"name" required:"true" minLength:"1"`
+}
+
+// validate mirrors perses TextVariableSpec validation; run by decodeSpec on unmarshal.
+func (s *TextVariableSpec) validate() error {
+	if err := common.ValidateID(s.Name); err != nil {
+		return err
+	}
+	if _, err := strconv.Atoi(s.Name); err == nil {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "variable name cannot contain only digits")
+	}
+	if s.Value == "" && s.Constant {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "value for a constant text variable cannot be empty")
+	}
+	return nil
 }
 
 // ══════════════════════════════════════════════
@@ -194,7 +287,7 @@ func (l *Layout) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	l.Kind = dashboard.LayoutKind(kind)
-	l.Spec = spec
+	l.Spec = *spec
 	return nil
 }
 

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -241,6 +241,7 @@ type TableFormatting struct {
 
 type Legend struct {
 	Position     LegendPosition    `json:"position"`
+	Mode         LegendMode        `json:"mode"`
 	CustomColors map[string]string `json:"customColors"`
 }
 
@@ -248,7 +249,7 @@ type ThresholdWithLabel struct {
 	Value float64 `json:"value" validate:"required" required:"true"`
 	Unit  string  `json:"unit"`
 	Color string  `json:"color" validate:"required" required:"true"`
-	Label string  `json:"label" validate:"required" required:"true"`
+	Label string  `json:"label"`
 }
 
 type ComparisonThreshold struct {
@@ -358,6 +359,47 @@ func (l *LegendPosition) UnmarshalJSON(data []byte) error {
 	}
 }
 
+type LegendMode struct{ valuer.String }
+
+var (
+	LegendModeList  = LegendMode{valuer.NewString("list")} // default
+	LegendModeTable = LegendMode{valuer.NewString("table")}
+)
+
+func (LegendMode) Enum() []any {
+	return []any{LegendModeList} // others are not supported in UI yet
+}
+
+func (m LegendMode) ValueOrDefault() string {
+	if m.IsZero() {
+		return LegendModeList.StringValue()
+	}
+	return m.StringValue()
+}
+
+func (m LegendMode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.ValueOrDefault())
+}
+
+func (m *LegendMode) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid legend mode: must be a string, one of `list` or `table`")
+	}
+	if v == "" {
+		*m = LegendModeList
+		return nil
+	}
+	lm := LegendMode{valuer.NewString(v)}
+	switch lm {
+	case LegendModeList, LegendModeTable:
+		*m = lm
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid legend mode %q: must be `list` or `table`", v)
+	}
+}
+
 type ThresholdFormat struct{ valuer.String }
 
 var (
@@ -534,9 +576,9 @@ func (ls *LineStyle) UnmarshalJSON(data []byte) error {
 type FillMode struct{ valuer.String }
 
 var (
-	FillModeSolid    = FillMode{valuer.NewString("solid")} // default
+	FillModeSolid    = FillMode{valuer.NewString("solid")}
 	FillModeGradient = FillMode{valuer.NewString("gradient")}
-	FillModeNone     = FillMode{valuer.NewString("none")}
+	FillModeNone     = FillMode{valuer.NewString("none")} // default
 )
 
 func (FillMode) Enum() []any {
@@ -545,7 +587,7 @@ func (FillMode) Enum() []any {
 
 func (fm FillMode) ValueOrDefault() string {
 	if fm.IsZero() {
-		return FillModeSolid.StringValue()
+		return FillModeNone.StringValue()
 	}
 	return fm.StringValue()
 }
@@ -560,7 +602,7 @@ func (fm *FillMode) UnmarshalJSON(data []byte) error {
 		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid fill mode: must be a string, one of `solid`, `gradient`, or `none`")
 	}
 	if v == "" {
-		*fm = FillModeSolid
+		*fm = FillModeNone
 		return nil
 	}
 	val := FillMode{valuer.NewString(v)}
@@ -573,12 +615,9 @@ func (fm *FillMode) UnmarshalJSON(data []byte) error {
 	}
 }
 
-// SpanGaps controls whether lines connect across null values.
-// When FillOnlyBelow is false (default), all gaps are connected.
-// When FillOnlyBelow is true, only gaps smaller than FillLessThan are connected.
 type SpanGaps struct {
-	FillOnlyBelow bool                `json:"fillOnlyBelow"`
-	FillLessThan  valuer.TextDuration `json:"fillLessThan"`
+	FillOnlyBelow bool                `json:"fillOnlyBelow" description:"Controls whether lines connect across null values. When false (default), all gaps are connected. When true, only gaps smaller than fillLessThan are connected."`
+	FillLessThan  valuer.TextDuration `json:"fillLessThan" description:"The maximum gap size to connect when fillOnlyBelow is true. Gaps larger than this duration are left disconnected."`
 }
 
 type PrecisionOption struct{ valuer.String }

pkg/types/metricreductionruletypes/reduction_rule.go

@@ -1,232 +0,0 @@
-package metricreductionruletypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-var (
-	ErrCodeMetricReductionRuleUnsupported           = errors.MustNewCode("metric_reduction_rule_unsupported")
-	ErrCodeMetricReductionRuleNotFound              = errors.MustNewCode("metric_reduction_rule_not_found")
-	ErrCodeMetricReductionRuleProtectedLabel        = errors.MustNewCode("metric_reduction_rule_protected_label")
-	ErrCodeMetricReductionRuleUnsupportedMetricType = errors.MustNewCode("metric_reduction_rule_unsupported_metric_type")
-)
-
-type MatchType struct {
-	valuer.String
-}
-
-var (
-	MatchTypeDrop = MatchType{valuer.NewString("drop")}
-	MatchTypeKeep = MatchType{valuer.NewString("keep")}
-)
-
-func (MatchType) Enum() []any {
-	return []any{MatchTypeDrop, MatchTypeKeep}
-}
-
-type AssetType struct {
-	valuer.String
-}
-
-var (
-	AssetTypeDashboard = AssetType{valuer.NewString("dashboard")}
-	AssetTypeAlert     = AssetType{valuer.NewString("alert_rule")}
-)
-
-func (AssetType) Enum() []any {
-	return []any{AssetTypeDashboard, AssetTypeAlert}
-}
-
-type Order struct {
-	valuer.String
-}
-
-var (
-	OrderAsc  = Order{valuer.NewString("asc")}
-	OrderDesc = Order{valuer.NewString("desc")}
-)
-
-func (Order) Enum() []any {
-	return []any{OrderAsc, OrderDesc}
-}
-
-type ReductionRuleOrderBy struct {
-	valuer.String
-}
-
-var (
-	OrderByMetricName     = ReductionRuleOrderBy{valuer.NewString("metricName")}
-	OrderByIngestedVolume = ReductionRuleOrderBy{valuer.NewString("ingestedVolume")}
-	OrderByReducedVolume  = ReductionRuleOrderBy{valuer.NewString("reducedVolume")}
-	OrderByReduction      = ReductionRuleOrderBy{valuer.NewString("reduction")}
-	OrderByLastUpdated    = ReductionRuleOrderBy{valuer.NewString("lastUpdated")}
-)
-
-func (ReductionRuleOrderBy) Enum() []any {
-	return []any{OrderByMetricName, OrderByIngestedVolume, OrderByReducedVolume, OrderByReduction, OrderByLastUpdated}
-}
-
-// LabelList is a []string persisted as a single JSON text column.
-type LabelList []string
-
-func (l LabelList) Value() (driver.Value, error) {
-	if l == nil {
-		return "[]", nil
-	}
-	b, err := json.Marshal(l)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (l *LabelList) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*l = nil
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "metricreductionruletypes: cannot scan %T into LabelList", src)
-	}
-	return json.Unmarshal(raw, l)
-}
-
-type StorableReductionRule struct {
-	bun.BaseModel `bun:"table:metric_reduction_rule" json:"-"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID         valuer.UUID `bun:"org_id,type:text,notnull"`
-	MetricName    string      `bun:"metric_name,type:text,notnull"`
-	MatchType     MatchType   `bun:"match_type,type:text,notnull"`
-	Labels        LabelList   `bun:"labels,type:text,notnull,default:'[]'"`
-	EffectiveFrom time.Time   `bun:"effective_from,notnull"`
-}
-
-func NewReductionRule(orgID valuer.UUID, metricName string, matchType MatchType, labels []string, effectiveFrom time.Time, by string) *StorableReductionRule {
-	now := time.Now()
-	return &StorableReductionRule{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable: types.UserAuditable{CreatedBy: by, UpdatedBy: by},
-		OrgID:         orgID,
-		MetricName:    metricName,
-		MatchType:     matchType,
-		Labels:        LabelList(labels),
-		EffectiveFrom: effectiveFrom,
-	}
-}
-
-type GettableReductionRule struct {
-	MetricName       string    `json:"metricName" required:"true"`
-	MatchType        MatchType `json:"matchType" required:"true"`
-	Labels           []string  `json:"labels" required:"true" nullable:"true"`
-	EffectiveFrom    time.Time `json:"effectiveFrom" required:"true"`
-	UpdatedAt        time.Time `json:"updatedAt" required:"true"`
-	UpdatedBy        string    `json:"updatedBy" required:"true"`
-	Active           bool      `json:"active" required:"true"`
-	IngestedSeries   uint64    `json:"ingestedSeries" required:"true"`
-	ReducedSeries    uint64    `json:"reducedSeries" required:"true"`
-	ReductionPercent float64   `json:"reductionPercent" required:"true"`
-}
-
-type GettableReductionRules struct {
-	Rules []GettableReductionRule `json:"rules" required:"true" nullable:"true"`
-	Total int                     `json:"total" required:"true"`
-}
-
-type ListReductionRulesParams struct {
-	OrderBy ReductionRuleOrderBy `query:"orderBy,default=reduction" json:"orderBy"`
-	Order   Order                `query:"order,default=desc" json:"order"`
-	Offset  int                  `query:"offset" json:"offset"`
-	Limit   int                  `query:"limit" json:"limit"`
-}
-
-func (p *ListReductionRulesParams) Validate() error {
-	if p.Limit <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be greater than 0")
-	}
-	if p.Offset < 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset must not be negative")
-	}
-	return nil
-}
-
-type PostableReductionRule struct {
-	MetricName string    `json:"-"`
-	MatchType  MatchType `json:"matchType" required:"true"`
-	Labels     []string  `json:"labels" required:"true" nullable:"true"`
-}
-
-func (req *PostableReductionRule) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-	if req.MetricName == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-	if req.MatchType != MatchTypeDrop && req.MatchType != MatchTypeKeep {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"matchType must be one of %q or %q", MatchTypeDrop.StringValue(), MatchTypeKeep.StringValue())
-	}
-	if len(req.Labels) == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"labels must not be empty; to allow all attributes, delete the rule instead")
-	}
-	return nil
-}
-
-type PostableReductionRulePreview struct {
-	MetricName string    `json:"metricName" required:"true"`
-	MatchType  MatchType `json:"matchType" required:"true"`
-	Labels     []string  `json:"labels" required:"true" nullable:"true"`
-	LookbackMs int64     `json:"lookbackMs,omitempty"`
-}
-
-func (req *PostableReductionRulePreview) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-	if req.MetricName == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-	if req.MatchType != MatchTypeDrop && req.MatchType != MatchTypeKeep {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"matchType must be one of %q or %q", MatchTypeDrop.StringValue(), MatchTypeKeep.StringValue())
-	}
-	if len(req.Labels) == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "labels must not be empty")
-	}
-	return nil
-}
-
-type AffectedAsset struct {
-	Type           AssetType `json:"type" required:"true"`
-	ID             string    `json:"id" required:"true"`
-	Name           string    `json:"name" required:"true"`
-	Widget         string    `json:"widget,omitempty"`
-	ImpactedLabels []string  `json:"impactedLabels" required:"true" nullable:"true"`
-}
-
-type GettableReductionRulePreview struct {
-	IngestedSeries   uint64          `json:"ingestedSeries" required:"true"`
-	ReducedSeries    uint64          `json:"reducedSeries" required:"true"`
-	ReductionPercent float64         `json:"reductionPercent" required:"true"`
-	DroppedLabels    []string        `json:"droppedLabels" required:"true" nullable:"true"`
-	AffectedAssets   []AffectedAsset `json:"affectedAssets" required:"true" nullable:"true"`
-	EffectiveFrom    time.Time       `json:"effectiveFrom" required:"true"`
-}

pkg/types/metricreductionruletypes/reduction_rule_test.go

@@ -1,24 +0,0 @@
-package metricreductionruletypes_test
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestListReductionRulesParamsSortDefaults(t *testing.T) {
-	var params metricreductionruletypes.ListReductionRulesParams
-	require.NoError(t, binding.Query.BindQuery(map[string][]string{"limit": {"10"}}, &params))
-
-	assert.Equal(t, metricreductionruletypes.OrderByReduction, params.OrderBy, "orderBy defaults to reduction")
-	assert.Equal(t, metricreductionruletypes.OrderDesc, params.Order, "order defaults to desc")
-}
-
-func TestListReductionRulesParamsValidate(t *testing.T) {
-	require.Error(t, (&metricreductionruletypes.ListReductionRulesParams{Limit: 0}).Validate(), "limit must be set")
-	require.Error(t, (&metricreductionruletypes.ListReductionRulesParams{Limit: 10, Offset: -1}).Validate(), "offset must not be negative")
-	require.NoError(t, (&metricreductionruletypes.ListReductionRulesParams{Limit: 10}).Validate())
-}

pkg/types/metricreductionruletypes/store.go

@@ -1,15 +0,0 @@
-package metricreductionruletypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	List(ctx context.Context, orgID valuer.UUID, params *ListReductionRulesParams) ([]*StorableReductionRule, int, error)
-	Get(ctx context.Context, orgID valuer.UUID, metricName string) (*StorableReductionRule, error)
-	Upsert(ctx context.Context, rule *StorableReductionRule) error
-	Delete(ctx context.Context, orgID valuer.UUID, metricName string) error
-	RunInTx(ctx context.Context, cb func(ctx context.Context) error) error
-}

pkg/types/metricsexplorertypes/metricsexplorer.go

@@ -241,11 +241,10 @@ type MetricAlertsResponse struct {
 
 // MetricDashboard represents a dashboard/widget referencing a metric.
 type MetricDashboard struct {
-	DashboardName string   `json:"dashboardName" required:"true"`
-	DashboardID   string   `json:"dashboardId" required:"true"`
-	WidgetID      string   `json:"widgetId" required:"true"`
-	WidgetName    string   `json:"widgetName" required:"true"`
-	GroupBy       []string `json:"groupBy,omitempty"`
+	DashboardName string `json:"dashboardName" required:"true"`
+	DashboardID   string `json:"dashboardId" required:"true"`
+	WidgetID      string `json:"widgetId" required:"true"`
+	WidgetName    string `json:"widgetName" required:"true"`
 }
 
 // MetricDashboardsResponse represents the response for metric dashboards endpoint.