feat(volume-control): rules API + UI for aggregating away metric labels

.github/CODEOWNERS

@@ -189,82 +189,6 @@ go.mod @therealpandey
 /frontend/src/container/TriggeredAlerts/ @SigNoz/pulse-frontend
 /frontend/src/container/AnomalyAlertEvaluationView/ @SigNoz/pulse-frontend
 
-## Notification Channels
-/frontend/src/pages/ChannelsEdit/ @SigNoz/pulse-frontend
-/frontend/src/pages/ChannelsNew/ @SigNoz/pulse-frontend
-/frontend/src/container/AllAlertChannels/ @SigNoz/pulse-frontend
-/frontend/src/container/CreateAlertChannels/ @SigNoz/pulse-frontend
-/frontend/src/container/EditAlertChannels/ @SigNoz/pulse-frontend
-
 ## OpenAPI Schema - Generated
 /frontend/src/api/generated/services/ @therealpandey @vikrantgupta25 @srikanthccv
 /docs/api/openapi.yml @therealpandey @vikrantgupta25 @srikanthccv
-
-## Logs
-/frontend/src/pages/Logs/ @SigNoz/events-frontend
-/frontend/src/pages/LogsExplorer/ @SigNoz/events-frontend
-/frontend/src/pages/LogsModulePage/ @SigNoz/events-frontend
-/frontend/src/pages/LogsSettings/ @SigNoz/events-frontend
-/frontend/src/pages/LiveLogs/ @SigNoz/events-frontend
-/frontend/src/container/LogsExplorerChart/ @SigNoz/events-frontend
-/frontend/src/container/LogsExplorerContext/ @SigNoz/events-frontend
-/frontend/src/container/LogsExplorerList/ @SigNoz/events-frontend
-/frontend/src/container/LogsExplorerTable/ @SigNoz/events-frontend
-/frontend/src/container/LogsExplorerViews/ @SigNoz/events-frontend
-/frontend/src/container/LogsFilters/ @SigNoz/events-frontend
-/frontend/src/container/LogsSearchFilter/ @SigNoz/events-frontend
-/frontend/src/container/LogsTable/ @SigNoz/events-frontend
-/frontend/src/container/LogsAggregate/ @SigNoz/events-frontend
-/frontend/src/container/LogsContextList/ @SigNoz/events-frontend
-/frontend/src/container/LogsIndexToFields/ @SigNoz/events-frontend
-/frontend/src/container/LogsLoading/ @SigNoz/events-frontend
-/frontend/src/container/LogsPanelTable/ @SigNoz/events-frontend
-/frontend/src/container/LogControls/ @SigNoz/events-frontend
-/frontend/src/container/LogDetailedView/ @SigNoz/events-frontend
-/frontend/src/container/LogExplorerQuerySection/ @SigNoz/events-frontend
-/frontend/src/container/LogLiveTail/ @SigNoz/events-frontend
-/frontend/src/container/LiveLogs/ @SigNoz/events-frontend
-/frontend/src/container/EmptyLogsSearch/ @SigNoz/events-frontend
-/frontend/src/container/NoLogs/ @SigNoz/events-frontend
-/frontend/src/components/Logs/ @SigNoz/events-frontend
-/frontend/src/components/LogDetail/ @SigNoz/events-frontend
-/frontend/src/components/LogsFormatOptionsMenu/ @SigNoz/events-frontend
-/frontend/src/hooks/logs/ @SigNoz/events-frontend
-
-## Logs Pipelines
-/frontend/src/pages/Pipelines/ @SigNoz/events-frontend
-/frontend/src/container/PipelinePage/ @SigNoz/events-frontend
-
-## Traces / Trace Explorer
-/frontend/src/pages/Trace/ @SigNoz/events-frontend
-/frontend/src/pages/TracesExplorer/ @SigNoz/events-frontend
-/frontend/src/pages/TracesModulePage/ @SigNoz/events-frontend
-/frontend/src/container/Trace/ @SigNoz/events-frontend
-/frontend/src/container/TracesExplorer/ @SigNoz/events-frontend
-/frontend/src/container/TracesTableComponent/ @SigNoz/events-frontend
-
-## Trace Funnels
-/frontend/src/pages/TracesFunnels/ @SigNoz/events-frontend
-/frontend/src/pages/TracesFunnelDetails/ @SigNoz/events-frontend
-/frontend/src/hooks/TracesFunnels/ @SigNoz/events-frontend
-
-## Trace Details
-/frontend/src/pages/TraceDetailsV3/ @SigNoz/events-frontend
-/frontend/src/pages/TraceDetailOldRedirect/ @SigNoz/events-frontend
-/frontend/src/hooks/trace/ @SigNoz/events-frontend
-
-## Exceptions
-/frontend/src/pages/AllErrors/ @SigNoz/events-frontend
-/frontend/src/pages/ErrorDetails/ @SigNoz/events-frontend
-/frontend/src/container/AllError/ @SigNoz/events-frontend
-/frontend/src/container/ErrorDetails/ @SigNoz/events-frontend
-
-## External APIs
-/frontend/src/pages/ApiMonitoring/ @SigNoz/events-frontend
-/frontend/src/container/ApiMonitoring/ @SigNoz/events-frontend
-
-## Messaging Queues
-/frontend/src/pages/MessagingQueues/ @SigNoz/events-frontend
-/frontend/src/components/MessagingQueues/ @SigNoz/events-frontend
-/frontend/src/components/MessagingQueueHealthCheck/ @SigNoz/events-frontend
-/frontend/src/hooks/messagingQueue/ @SigNoz/events-frontend

cmd/community/server.go

@@ -29,6 +29,8 @@ 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"
@@ -119,6 +121,9 @@ 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,6 +24,7 @@ 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"
@@ -46,6 +47,7 @@ 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"
@@ -182,6 +184,9 @@ 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

@@ -647,41 +647,14 @@ components:
           type: string
         name:
           type: string
-        transactionGroups:
-          $ref: '#/components/schemas/AuthtypesTransactionGroups'
       required:
       - name
-      - description
-      - transactionGroups
       type: object
     AuthtypesPostableRotateToken:
       properties:
         refreshToken:
           type: string
       type: object
-    AuthtypesPostableUser:
-      properties:
-        displayName:
-          type: string
-        email:
-          type: string
-        frontendBaseUrl:
-          type: string
-        userRoles:
-          items:
-            $ref: '#/components/schemas/AuthtypesPostableUserRole'
-          type: array
-      required:
-      - email
-      - userRoles
-      type: object
-    AuthtypesPostableUserRole:
-      properties:
-        id:
-          type: string
-      required:
-      - id
-      type: object
     AuthtypesRelation:
       enum:
       - create
@@ -730,34 +703,6 @@ components:
         useRoleAttribute:
           type: boolean
       type: object
-    AuthtypesRoleWithTransactionGroups:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        description:
-          type: string
-        id:
-          type: string
-        name:
-          type: string
-        orgId:
-          type: string
-        transactionGroups:
-          $ref: '#/components/schemas/AuthtypesTransactionGroups'
-        type:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-      required:
-      - id
-      - name
-      - description
-      - type
-      - orgId
-      - transactionGroups
-      type: object
     AuthtypesSamlConfig:
       properties:
         attributeMapping:
@@ -791,35 +736,11 @@ components:
       - relation
       - object
       type: object
-    AuthtypesTransactionGroup:
-      properties:
-        objectGroup:
-          $ref: '#/components/schemas/CoretypesObjectGroup'
-        relation:
-          $ref: '#/components/schemas/AuthtypesRelation'
-      required:
-      - relation
-      - objectGroup
-      type: object
-    AuthtypesTransactionGroups:
-      items:
-        $ref: '#/components/schemas/AuthtypesTransactionGroup'
-      type: array
     AuthtypesUpdatableAuthDomain:
       properties:
         config:
           $ref: '#/components/schemas/AuthtypesAuthDomainConfig'
       type: object
-    AuthtypesUpdatableRole:
-      properties:
-        description:
-          type: string
-        transactionGroups:
-          $ref: '#/components/schemas/AuthtypesTransactionGroups'
-      required:
-      - description
-      - transactionGroups
-      type: object
     AuthtypesUserRole:
       properties:
         createdAt:
@@ -5101,6 +5022,169 @@ 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:
@@ -5217,6 +5301,10 @@ components:
           type: string
         dashboardName:
           type: string
+        groupBy:
+          items:
+            type: string
+          type: array
         widgetId:
           type: string
         widgetName:
@@ -10206,7 +10294,7 @@ paths:
       - global
   /api/v1/invite:
     post:
-      deprecated: true
+      deprecated: false
       description: This endpoint creates an invite for a user
       operationId: CreateInvite
       requestBody:
@@ -10269,7 +10357,7 @@ paths:
       - users
   /api/v1/invite/bulk:
     post:
-      deprecated: true
+      deprecated: false
       description: This endpoint creates a bulk invite for a user
       operationId: CreateBulkInvite
       requestBody:
@@ -10332,15 +10420,6 @@ paths:
         name: limit
         schema:
           type: integer
-      - in: query
-        name: q
-        schema:
-          type: string
-      - in: query
-        name: isOverride
-        schema:
-          nullable: true
-          type: boolean
       responses:
         "200":
           content:
@@ -11146,7 +11225,7 @@ paths:
               schema:
                 properties:
                   data:
-                    $ref: '#/components/schemas/AuthtypesRoleWithTransactionGroups'
+                    $ref: '#/components/schemas/AuthtypesRole'
                   status:
                     type: string
                 required:
@@ -11181,7 +11260,7 @@ paths:
       tags:
       - role
     patch:
-      deprecated: true
+      deprecated: false
       description: This endpoint patches a role
       operationId: PatchRole
       parameters:
@@ -11242,68 +11321,6 @@ paths:
       summary: Patch role
       tags:
       - role
-    put:
-      deprecated: false
-      description: This endpoint updates a role
-      operationId: UpdateRole
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/AuthtypesUpdatableRole'
-      responses:
-        "204":
-          description: No Content
-        "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:
-        - role:update
-      - tokenizer:
-        - role:update
-      summary: Update role
-      tags:
-      - role
   /api/v1/roles/{id}/relations/{relation}/objects:
     get:
       deprecated: false
@@ -11383,7 +11400,7 @@ paths:
       tags:
       - role
     patch:
-      deprecated: true
+      deprecated: false
       description: Patches the objects connected to the specified role via a given
         relation type
       operationId: PatchObjects
@@ -13110,7 +13127,7 @@ paths:
       - tracedetail
   /api/v1/user:
     get:
-      deprecated: true
+      deprecated: false
       description: This endpoint lists all users
       operationId: ListUsersDeprecated
       responses:
@@ -13203,7 +13220,7 @@ paths:
       tags:
       - users
     get:
-      deprecated: true
+      deprecated: false
       description: This endpoint returns the user by id
       operationId: GetUserDeprecated
       parameters:
@@ -13260,7 +13277,7 @@ paths:
       tags:
       - users
     put:
-      deprecated: true
+      deprecated: false
       description: This endpoint updates the user by id
       operationId: UpdateUserDeprecated
       parameters:
@@ -13329,7 +13346,7 @@ paths:
       - users
   /api/v1/user/me:
     get:
-      deprecated: true
+      deprecated: false
       description: This endpoint returns the user I belong to
       operationId: GetMyUserDeprecated
       responses:
@@ -16047,6 +16064,229 @@ 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
@@ -16152,6 +16392,158 @@ 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
@@ -20745,68 +21137,6 @@ paths:
       summary: List users v2
       tags:
       - users
-    post:
-      deprecated: false
-      description: This endpoint creates a user for the organization
-      operationId: CreateUser
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/AuthtypesPostableUser'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TypesIdentifiable'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "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
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create user
-      tags:
-      - users
   /api/v2/users/{id}:
     get:
       deprecated: false

ee/authz/openfgaauthz/provider.go

@@ -179,36 +179,13 @@ func (provider *provider) CreateManagedUserRoleTransactions(ctx context.Context,
 	return provider.Write(ctx, tuples, nil)
 }
 
-func (provider *provider) Create(ctx context.Context, orgID valuer.UUID, role *authtypes.RoleWithTransactionGroups) error {
+func (provider *provider) Create(ctx context.Context, orgID valuer.UUID, role *authtypes.Role) error {
 	_, err := provider.licensing.GetActive(ctx, orgID)
 	if err != nil {
 		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
 	}
 
-	existingRole, err := provider.GetByOrgIDAndName(ctx, orgID, role.Name)
-	if err != nil && !errors.Asc(err, authtypes.ErrCodeRoleNotFound) {
-		return err
-	}
-
-	if existingRole != nil {
-		return errors.Newf(errors.TypeAlreadyExists, authtypes.ErrCodeRoleAlreadyExists, "role with name: %s already exists", existingRole.Name)
-	}
-
-	tuples, err := authtypes.NewTuplesFromTransactionGroups(role.Name, orgID, role.TransactionGroups)
-	if err != nil {
-		return err
-	}
-
-	err = provider.Write(ctx, tuples, nil)
-	if err != nil {
-		return err
-	}
-
-	if err := provider.store.Create(ctx, role.Role); err != nil {
-		return err
-	}
-
-	return nil
+	return provider.store.Create(ctx, role)
 }
 
 func (provider *provider) GetOrCreate(ctx context.Context, orgID valuer.UUID, role *authtypes.Role) (*authtypes.Role, error) {
@@ -236,26 +213,6 @@ func (provider *provider) GetOrCreate(ctx context.Context, orgID valuer.UUID, ro
 	return role, nil
 }
 
-func (provider *provider) GetWithTransactionGroups(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*authtypes.RoleWithTransactionGroups, error) {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	role, err := provider.store.Get(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	tuples, err := provider.readAllTuplesForRole(ctx, role.Name, orgID)
-	if err != nil {
-		return nil, err
-	}
-
-	transactionGroups := authtypes.MustNewTransactionGroupsFromTuples(tuples)
-	return authtypes.MakeRoleWithTransactionGroups(role, transactionGroups), nil
-}
-
 func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*coretypes.Object, error) {
 	_, err := provider.licensing.GetActive(ctx, orgID)
 	if err != nil {
@@ -290,36 +247,6 @@ func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id
 	return objects, nil
 }
 
-func (provider *provider) Update(ctx context.Context, orgID valuer.UUID, updatedRole *authtypes.RoleWithTransactionGroups) error {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	existingRole, err := provider.GetWithTransactionGroups(ctx, orgID, updatedRole.ID)
-	if err != nil {
-		return err
-	}
-
-	additions, deletions := existingRole.TransactionGroups.Diff(updatedRole.TransactionGroups)
-	additionTuples, err := authtypes.NewTuplesFromTransactionGroups(existingRole.Name, orgID, additions)
-	if err != nil {
-		return err
-	}
-
-	deletionTuples, err := authtypes.NewTuplesFromTransactionGroups(existingRole.Name, orgID, deletions)
-	if err != nil {
-		return err
-	}
-
-	err = provider.Write(ctx, additionTuples, deletionTuples)
-	if err != nil {
-		return err
-	}
-
-	return provider.store.Update(ctx, orgID, updatedRole.Role)
-}
-
 func (provider *provider) Patch(ctx context.Context, orgID valuer.UUID, role *authtypes.Role) error {
 	_, err := provider.licensing.GetActive(ctx, orgID)
 	if err != nil {
@@ -359,7 +286,7 @@ func (provider *provider) Delete(ctx context.Context, orgID valuer.UUID, id valu
 		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
 	}
 
-	role, err := provider.GetWithTransactionGroups(ctx, orgID, id)
+	role, err := provider.store.Get(ctx, orgID, id)
 	if err != nil {
 		return err
 	}
@@ -375,12 +302,7 @@ func (provider *provider) Delete(ctx context.Context, orgID valuer.UUID, id valu
 		}
 	}
 
-	tuples, err := authtypes.NewTuplesFromTransactionGroups(role.Name, orgID, role.TransactionGroups)
-	if err != nil {
-		return err
-	}
-
-	if err := provider.Write(ctx, nil, tuples); err != nil {
+	if err := provider.deleteTuples(ctx, role.Name, orgID); err != nil {
 		return errors.WithAdditionalf(err, "failed to delete tuples for the role: %s", role.Name)
 	}
 
@@ -439,7 +361,7 @@ func (provider *provider) getManagedRoleTransactionTuples(orgID valuer.UUID) []*
 	return tuples
 }
 
-func (provider *provider) readAllTuplesForRole(ctx context.Context, roleName string, orgID valuer.UUID) ([]*openfgav1.TupleKey, error) {
+func (provider *provider) deleteTuples(ctx context.Context, roleName string, orgID valuer.UUID) error {
 	subject := authtypes.MustNewSubject(coretypes.NewResourceRole(), roleName, orgID, &coretypes.VerbAssignee)
 
 	tuples := make([]*openfgav1.TupleKey, 0)
@@ -449,10 +371,26 @@ func (provider *provider) readAllTuplesForRole(ctx context.Context, roleName str
 			Object: objectType.StringValue() + ":",
 		})
 		if err != nil {
-			return nil, err
+			return err
 		}
 		tuples = append(tuples, typeTuples...)
 	}
 
-	return tuples, nil
+	if len(tuples) == 0 {
+		return nil
+	}
+
+	for idx := 0; idx < len(tuples); idx += provider.config.OpenFGA.MaxTuplesPerWrite {
+		end := idx + provider.config.OpenFGA.MaxTuplesPerWrite
+		if end > len(tuples) {
+			end = len(tuples)
+		}
+
+		err := provider.Write(ctx, nil, tuples[idx:end])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }

ee/modules/metricreductionrule/implmetricreductionrule/clickhouse.go

@@ -0,0 +1,332 @@
+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

@@ -0,0 +1,390 @@
+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

@@ -0,0 +1,102 @@
+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

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

ee/query-service/app/api/featureFlags.go

@@ -98,15 +98,6 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 		Route:      "",
 	})
 
-	aiObservability := ah.Signoz.Flagger.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, evalCtx)
-	featureSet = append(featureSet, &licensetypes.Feature{
-		Name:       valuer.NewString(flagger.FeatureEnableAIObservability.String()),
-		Active:     aiObservability,
-		Usage:      0,
-		UsageLimit: -1,
-		Route:      "",
-	})
-
 	if constants.IsDotMetricsEnabled {
 		for idx, feature := range featureSet {
 			if feature.Name == licensetypes.DotMetricsEnabled {

frontend/jest.config.ts

@@ -48,14 +48,13 @@ const config: Config.InitialOptions = {
 		],
 		'^.+\\.(js|jsx)$': 'babel-jest',
 	},
-	// TODO: https://github.com/SigNoz/engineering-pod/issues/5334
 	transformIgnorePatterns: [
 		// @chenglou/pretext is ESM-only; @signozhq/ui pulls it in via text-ellipsis.
 		// Pattern 1: allow .pnpm virtual store through (handled by pattern 2), plus root-level ESM packages.
-		'node_modules/(?!(\\.pnpm|lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou/pretext|@signozhq/design-tokens|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid|copy-text-to-clipboard|react-markdown|vfile|vfile-message|unist-util-stringify-position|unified|bail|is-plain-obj|trough|remark-parse|mdast-util-from-markdown|mdast-util-to-string|micromark|micromark-core-commonmark|micromark-extension-gfm|micromark-extension-gfm-autolink-literal|micromark-extension-gfm-footnote|micromark-extension-gfm-strikethrough|micromark-extension-gfm-table|micromark-extension-gfm-tagfilter|micromark-extension-gfm-task-list-item|micromark-factory-destination|micromark-factory-label|micromark-factory-space|micromark-factory-title|micromark-factory-whitespace|micromark-util-character|micromark-util-chunked|micromark-util-classify-character|micromark-util-combine-extensions|micromark-util-decode-numeric-character-reference|micromark-util-decode-string|micromark-util-encode|micromark-util-html-tag-name|micromark-util-normalize-identifier|micromark-util-resolve-all|micromark-util-sanitize-uri|micromark-util-subtokenize|micromark-util-symbol|micromark-util-types|decode-named-character-reference|remark-rehype|mdast-util-to-hast|unist-util-position|trim-lines|unist-util-visit|unist-util-visit-parents|unist-util-is|unist-util-generated|mdast-util-definitions|property-information|hast-util-whitespace|space-separated-tokens|comma-separated-tokens|rehype-raw|hast-util-raw|hast-util-from-parse5|devlop|hastscript|hast-util-parse-selector|vfile-location|web-namespaces|hast-util-to-parse5|zwitch|html-void-elements)/)',
+		'node_modules/(?!(\\.pnpm|lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou/pretext|@signozhq/design-tokens|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid|copy-text-to-clipboard)/)',
 		// Pattern 2: pnpm virtual store — ignore everything except ESM-only packages.
 		// pnpm encodes scoped packages as @scope+name@version, so match on scope prefix.
-		'node_modules/\\.pnpm/(?!(lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid|copy-text-to-clipboard|react-markdown|vfile|vfile-message|unist-util-stringify-position|unified|bail|is-plain-obj|trough|remark-parse|mdast-util-from-markdown|mdast-util-to-string|micromark|decode-named-character-reference|remark-rehype|mdast-util-to-hast|unist-util-position|trim-lines|unist-util-visit|unist-util-visit-parents|unist-util-is|unist-util-generated|mdast-util-definitions|property-information|hast-util-whitespace|space-separated-tokens|comma-separated-tokens|rehype-raw|hast-util-raw|hast-util-from-parse5|devlop|hastscript|hast-util-parse-selector|vfile-location|web-namespaces|hast-util-to-parse5|zwitch|html-void-elements)[^/]*/node_modules)',
+		'node_modules/\\.pnpm/(?!(lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid|copy-text-to-clipboard)[^/]*/node_modules)',
 	],
 	setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
 	testPathIgnorePatterns: ['/node_modules/', '/public/'],

frontend/jest.setup.ts

@@ -29,18 +29,6 @@ if (!HTMLElement.prototype.scrollIntoView) {
 	HTMLElement.prototype.scrollIntoView = function (): void {};
 }
 
-// jsdom doesn't implement the Pointer Capture API, which Radix UI primitives
-// (e.g. @signozhq/ui Select) call when opening. Stub them so those components
-// can be exercised in tests.
-if (!HTMLElement.prototype.hasPointerCapture) {
-	HTMLElement.prototype.hasPointerCapture = function (): boolean {
-		return false;
-	};
-}
-if (!HTMLElement.prototype.releasePointerCapture) {
-	HTMLElement.prototype.releasePointerCapture = function (): void {};
-}
-
 if (typeof window.IntersectionObserver === 'undefined') {
 	class IntersectionObserverMock {
 		observe(): void {}

frontend/package.json

@@ -43,7 +43,7 @@
     "@dnd-kit/modifiers": "7.0.0",
     "@dnd-kit/sortable": "8.0.0",
     "@dnd-kit/utilities": "3.2.2",
-    "@grafana/data": "^11.6.15",
+    "@grafana/data": "^11.6.14",
     "@monaco-editor/react": "^4.7.0",
     "@sentry/react": "10.57.0",
     "@sentry/vite-plugin": "5.3.0",
@@ -79,7 +79,7 @@
     "event-source-polyfill": "1.0.31",
     "eventemitter3": "5.0.1",
     "history": "4.10.1",
-    "http-proxy-middleware": "4.1.1",
+    "http-proxy-middleware": "4.0.0",
     "http-status-codes": "2.3.0",
     "i18next": "^21.6.12",
     "i18next-browser-languagedetector": "^6.1.3",
@@ -231,17 +231,16 @@
     "xml2js": "0.5.0",
     "phin": "^3.7.1",
     "body-parser": "1.20.3",
-    "http-proxy-middleware": "4.1.1",
+    "http-proxy-middleware": "4.0.0",
     "cross-spawn": "7.0.5",
     "cookie": "^0.7.1",
     "serialize-javascript": "6.0.2",
     "prismjs": "1.30.0",
     "got": "11.8.5",
-    "form-data": "4.0.6",
+    "form-data": "4.0.4",
     "brace-expansion": "^2.0.2",
     "on-headers": "^1.1.0",
-    "js-cookie": "^3.0.7",
-    "tmp": "0.2.7",
+    "tmp": "0.2.4",
     "vite": "npm:rolldown-vite@7.3.1"
   }
 }

frontend/pnpm-lock.yaml

@@ -12,17 +12,16 @@ overrides:
   xml2js: 0.5.0
   phin: ^3.7.1
   body-parser: 1.20.3
-  http-proxy-middleware: 4.1.1
+  http-proxy-middleware: 4.0.0
   cross-spawn: 7.0.5
   cookie: ^0.7.1
   serialize-javascript: 6.0.2
   prismjs: 1.30.0
   got: 11.8.5
-  form-data: 4.0.6
+  form-data: 4.0.4
   brace-expansion: ^2.0.2
   on-headers: ^1.1.0
-  js-cookie: ^3.0.7
-  tmp: 0.2.7
+  tmp: 0.2.4
   vite: npm:rolldown-vite@7.3.1
 
 importers:
@@ -57,8 +56,8 @@ importers:
         specifier: 3.2.2
         version: 3.2.2(react@18.2.0)
       '@grafana/data':
-        specifier: ^11.6.15
-        version: 11.6.15(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+        specifier: ^11.6.14
+        version: 11.6.14(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       '@monaco-editor/react':
         specifier: ^4.7.0
         version: 4.7.0(monaco-editor@0.55.1)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
@@ -165,8 +164,8 @@ importers:
         specifier: 4.10.1
         version: 4.10.1
       http-proxy-middleware:
-        specifier: 4.1.1
-        version: 4.1.1
+        specifier: 4.0.0
+        version: 4.0.0
       http-status-codes:
         specifier: 2.3.0
         version: 2.3.0
@@ -1637,14 +1636,14 @@ packages:
   '@gerrit0/mini-shiki@3.23.0':
     resolution: {integrity: sha512-bEMORlG0cqdjVyCEuU0cDQbORWX+kYCeo0kV1lbxF5bt4r7SID2l9bqsxJEM0zndaxpOUT7riCyIVEuqq/Ynxg==}
 
-  '@grafana/data@11.6.15':
-    resolution: {integrity: sha512-q2Zbjr0N9iEGY/zKHm4Z4X5x64806E17W58y7mnvwc0MlbyGPPVulcp/rWA2Nd190mZeafZQPer9u+MaO+0HUQ==}
+  '@grafana/data@11.6.14':
+    resolution: {integrity: sha512-Nsjq1A9m6LbsKsKvOgvAk9Wq7RGjy0V4N9d5YsSnzMwCiw/ov2wblR2bcDpy95uF8KaDTIR2Gf40nJaOYksPMA==}
     peerDependencies:
       react: ^18.0.0
       react-dom: ^18.0.0
 
-  '@grafana/schema@11.6.15':
-    resolution: {integrity: sha512-MPIvGAp9uzkswnH6e+Fmzu+WBTqWMgbv93/8iu56gb+sjCB2LciZLz4KvrPFdw32bWCGSMAGqsML9mgmeJZtGQ==}
+  '@grafana/schema@11.6.14':
+    resolution: {integrity: sha512-YTqgYekb7kiu5NEoQxKF8czJ6QIARmMkCi9cNcynHqYpcDLOv5pg5Q0QtKgiiqHjlYoEeCV6iejdB4hXxzB+VA==}
 
   '@humanfs/core@0.19.2':
     resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
@@ -5168,8 +5167,8 @@ packages:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
 
-  form-data@4.0.6:
-    resolution: {integrity: sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==}
+  form-data@4.0.4:
+    resolution: {integrity: sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==}
     engines: {node: '>= 6'}
 
   format@0.2.2:
@@ -5382,10 +5381,6 @@ packages:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.4:
-    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
-    engines: {node: '>= 0.4'}
-
   hast-util-from-parse5@8.0.1:
     resolution: {integrity: sha512-Er/Iixbc7IEa7r/XLtuG52zoqn/b3Xng/w6aZQ0xGVxzhw5xUFxcRqdPzP6yFi/4HBYRaifaI5fQ1RH8n0ZeOQ==}
 
@@ -5461,8 +5456,8 @@ packages:
     resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==}
     engines: {node: '>= 6'}
 
-  http-proxy-middleware@4.1.1:
-    resolution: {integrity: sha512-KX5ZofGXLFXqFAkQoOWZ+rTtaLTut7m0gyL+QzJrdejtIZ+F4bPPDoe7reISg2+v0CAz5OfVwEJEhty7X+e57g==}
+  http-proxy-middleware@4.0.0:
+    resolution: {integrity: sha512-wuHwaUtmC0XzJNHqRp41zXtt5ojpHbusXGhq6781VvnjWUYPu7opmOF3eomGNujT07kEOnHWZyV9UZzKimVCKA==}
     engines: {node: ^22.15.0 || ^24.0.0 || >=26.0.0}
 
   http-status-codes@2.3.0:
@@ -5472,8 +5467,8 @@ packages:
     resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
     engines: {node: '>= 6'}
 
-  httpxy@0.5.3:
-    resolution: {integrity: sha512-SMS9V6Sn7VWaS11lYhoAr0ceoaiolTWf4jYdJn0NJhCdKMu9R2H9Fh0LBDWBHQF6HRLI1PmaePYsjanSpE5PEw==}
+  httpxy@0.5.1:
+    resolution: {integrity: sha512-JPhqYiixe1A1I+MXDewWDZqeudBGU8Q9jCHYN8ML+779RQzLjTi78HBvWz4jMxUD6h2/vUL12g4q/mFM0OUw1A==}
 
   human-signals@2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
@@ -6046,8 +6041,8 @@ packages:
   js-base64@3.7.5:
     resolution: {integrity: sha512-3MEt5DTINKqfScXKfJFrRbxkrnk2AxPWGBL/ycjz4dK8iqiSJ06UxD8jh8xuh6p10TX4t2+7FsBYVxxQbMg+qA==}
 
-  js-cookie@3.0.8:
-    resolution: {integrity: sha512-yeJd4aNAdYZQjaon2bpD/Gb0B/omw7HQOsynXXcOiWVCacbBcPlgn8S/d1X6blFSaHao7ozqtW7NZW19xpCtIw==}
+  js-cookie@2.2.1:
+    resolution: {integrity: sha512-HvdH2LzI/EAZcUwA8+0nKNtWHqS+ZmijLA30RwZA0bo7ToCckjK5MkGhjED9KoRcXO6BaGI3I9UIzSA1FKFPOQ==}
 
   js-levenshtein@1.1.6:
     resolution: {integrity: sha512-X2BB11YZtrRqY4EnQcLX5Rh373zbK4alC1FW7D7MBhL2gtcC17cTnr6DmfHZeS0s2rTHjUTMMHfG7gO8SSdw+g==}
@@ -8399,8 +8394,8 @@ packages:
     resolution: {integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==}
     engines: {node: ^20.0.0 || >=22.0.0}
 
-  tmp@0.2.7:
-    resolution: {integrity: sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==}
+  tmp@0.2.4:
+    resolution: {integrity: sha512-UdiSoX6ypifLmrfQ/XfiawN6hkjSBpCjhKxxZcWlUUmoXLaCKQU0bx4HF/tdDK2uzRuchf1txGvrWBzYREssoQ==}
     engines: {node: '>=14.14'}
 
   tmpl@1.0.5:
@@ -10323,10 +10318,10 @@ snapshots:
       '@shikijs/types': 3.23.0
       '@shikijs/vscode-textmate': 10.0.2
 
-  '@grafana/data@11.6.15(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
+  '@grafana/data@11.6.14(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
       '@braintree/sanitize-url': 7.0.1
-      '@grafana/schema': 11.6.15
+      '@grafana/schema': 11.6.14
       '@types/d3-interpolate': 3.0.1
       '@types/string-hash': 1.1.3
       d3-interpolate: 3.0.1
@@ -10352,7 +10347,7 @@ snapshots:
       uplot: 1.6.31
       xss: 1.0.14
 
-  '@grafana/schema@11.6.15':
+  '@grafana/schema@11.6.14':
     dependencies:
       tslib: 2.8.1
 
@@ -12891,7 +12886,7 @@ snapshots:
   axios@1.16.0:
     dependencies:
       follow-redirects: 1.16.0
-      form-data: 4.0.6
+      form-data: 4.0.4
       proxy-from-env: 2.1.0
     transitivePeerDependencies:
       - debug
@@ -13838,7 +13833,7 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.4
+      hasown: 2.0.2
 
   es-toolkit@1.46.1: {}
 
@@ -14036,7 +14031,7 @@ snapshots:
     dependencies:
       chardet: 0.7.0
       iconv-lite: 0.4.24
-      tmp: 0.2.7
+      tmp: 0.2.4
 
   fast-deep-equal@3.1.3: {}
 
@@ -14169,12 +14164,12 @@ snapshots:
       cross-spawn: 7.0.5
       signal-exit: 4.1.0
 
-  form-data@4.0.6:
+  form-data@4.0.4:
     dependencies:
       asynckit: 0.4.0
       combined-stream: 1.0.8
       es-set-tostringtag: 2.1.0
-      hasown: 2.0.4
+      hasown: 2.0.2
       mime-types: 2.1.35
 
   format@0.2.2: {}
@@ -14253,7 +14248,7 @@ snapshots:
       get-proto: 1.0.1
       gopd: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.4
+      hasown: 2.0.2
       math-intrinsics: 1.1.0
 
   get-nonce@1.0.1: {}
@@ -14391,10 +14386,6 @@ snapshots:
     dependencies:
       function-bind: 1.1.2
 
-  hasown@2.0.4:
-    dependencies:
-      function-bind: 1.1.2
-
   hast-util-from-parse5@8.0.1:
     dependencies:
       '@types/hast': 3.0.4
@@ -14515,10 +14506,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  http-proxy-middleware@4.1.1:
+  http-proxy-middleware@4.0.0:
     dependencies:
       debug: 4.3.4(supports-color@5.5.0)
-      httpxy: 0.5.3
+      httpxy: 0.5.1
       is-glob: 4.0.3
       is-plain-obj: 4.1.0
       micromatch: 4.0.8
@@ -14534,7 +14525,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  httpxy@0.5.3: {}
+  httpxy@0.5.1: {}
 
   human-signals@2.1.0: {}
 
@@ -15348,7 +15339,7 @@ snapshots:
 
   js-base64@3.7.5: {}
 
-  js-cookie@3.0.8: {}
+  js-cookie@2.2.1: {}
 
   js-levenshtein@1.1.6: {}
 
@@ -15376,7 +15367,7 @@ snapshots:
       decimal.js: 10.6.0
       domexception: 4.0.0
       escodegen: 2.1.0
-      form-data: 4.0.6
+      form-data: 4.0.4
       html-encoding-sniffer: 3.0.0
       http-proxy-agent: 5.0.0
       https-proxy-agent: 5.0.1
@@ -17345,7 +17336,7 @@ snapshots:
       copy-to-clipboard: 3.3.3
       fast-deep-equal: 3.1.3
       fast-shallow-equal: 1.0.0
-      js-cookie: 3.0.8
+      js-cookie: 2.2.1
       nano-css: 5.6.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
@@ -17364,7 +17355,7 @@ snapshots:
       copy-to-clipboard: 3.3.3
       fast-deep-equal: 3.1.3
       fast-shallow-equal: 1.0.0
-      js-cookie: 3.0.8
+      js-cookie: 2.2.1
       nano-css: 5.6.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
@@ -18112,7 +18103,7 @@ snapshots:
 
   tinypool@2.1.0: {}
 
-  tmp@0.2.7: {}
+  tmp@0.2.4: {}
 
   tmpl@1.0.5: {}
 

frontend/src/AppRoutes/Private.tsx

@@ -55,6 +55,7 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 			),
 		[pathname],
 	);
+	const isOldRoute = oldRoutes.indexOf(pathname) > -1;
 	const currentRoute = mapRoutes.get('current');
 	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
 
@@ -82,36 +83,12 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 	}, [usersData?.data]);
 
 	// Handle old routes - redirect to new routes
-	const isOldRoute = oldRoutes.indexOf(pathname) > -1;
 	if (isOldRoute) {
 		const redirectUrl = oldNewRoutesMapping[pathname];
-		// TODO(H4ad): Remove this after https://github.com/SigNoz/engineering-pod/issues/5322
-		// A mapped target may itself carry a query string (e.g. `/alerts?tab=Channels`).
-		// react-router does not re-parse a `?` embedded in the `pathname` field, so split
-		// it out and merge with the incoming search params.
-		const [redirectPath, redirectSearch = ''] = redirectUrl.split('?');
-		const mergedParams = new URLSearchParams(location.search);
-		new URLSearchParams(redirectSearch).forEach((value, name) => {
-			mergedParams.set(name, value);
-		});
-		const search = mergedParams.toString();
 		return (
 			<Redirect
 				to={{
-					pathname: redirectPath,
-					search: search ? `?${search}` : '',
-					hash: location.hash,
-				}}
-			/>
-		);
-	}
-
-	if (pathname.startsWith('/settings/channels/edit/')) {
-		const channelId = pathname.replace('/settings/channels/edit/', '');
-		return (
-			<Redirect
-				to={{
-					pathname: `/alerts/channels/edit/${channelId}`,
+					pathname: redirectUrl,
 					search: location.search,
 					hash: location.hash,
 				}}

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -73,13 +73,7 @@ const queryClient = new QueryClient({
 // Component to capture current location for assertions
 function LocationDisplay(): ReactElement {
 	const location = useLocation();
-	return (
-		<>
-			<div data-testid="location-display">{location.pathname}</div>
-			<div data-testid="location-search">{location.search}</div>
-			<div data-testid="location-hash">{location.hash}</div>
-		</>
-	);
+	return <div data-testid="location-display">{location.pathname}</div>;
 }
 
 // Helper to create mock user
@@ -1481,10 +1475,12 @@ describe('PrivateRoute', () => {
 			await assertRedirectsTo(ROUTES.UN_AUTHORIZED);
 		});
 
-		it('should redirect VIEWER from /alerts/channels/new (ADMIN only)', async () => {
-			// After moving channels under /alerts, CHANNELS_NEW ('/alerts/channels/new')
-			// is an exact, ADMIN-only route with no overlapping non-exact ALL_CHANNELS
-			// route to match last, so a VIEWER is now correctly redirected.
+		it('should not redirect VIEWER from /settings/channels/new due to route matching order (ALL_CHANNELS matches last)', () => {
+			// Note: This tests the ACTUAL behavior of Private.tsx route matching
+			// CHANNELS_NEW has path '/settings/channels/new' with permission ['ADMIN']
+			// ALL_CHANNELS has path '/settings/channels' with permission ['ADMIN', 'EDITOR', 'VIEWER']
+			// Due to non-exact matching and array order, ALL_CHANNELS matches LAST for '/settings/channels/new'
+			// This is a known limitation - actual permission enforcement happens in the page component
 			renderPrivateRoute({
 				initialRoute: ROUTES.CHANNELS_NEW,
 				appContext: {
@@ -1493,7 +1489,8 @@ describe('PrivateRoute', () => {
 				},
 			});
 
-			await assertRedirectsTo(ROUTES.UN_AUTHORIZED);
+			assertRendersChildren();
+			assertStaysOnRoute(ROUTES.CHANNELS_NEW);
 		});
 
 		it('should allow EDITOR to access /get-started route', () => {
@@ -1551,60 +1548,4 @@ describe('PrivateRoute', () => {
 			await assertRedirectsTo(ROUTES.UN_AUTHORIZED);
 		});
 	});
-
-	describe('Old channel route redirects', () => {
-		it.each([
-			['/settings/channels', '/alerts', 'tab=Channels'],
-			['/settings/channels/new', '/alerts/channels/new', ''],
-		])(
-			'should redirect %s to %s',
-			async (oldRoute, expectedPath, expectedSearch) => {
-				renderPrivateRoute({
-					initialRoute: oldRoute,
-					appContext: { isLoggedIn: true },
-				});
-
-				await waitFor(() => {
-					expect(screen.getByTestId('location-display')).toHaveTextContent(
-						expectedPath,
-					);
-				});
-
-				if (expectedSearch) {
-					const search = screen.getByTestId('location-search').textContent ?? '';
-					const params = new URLSearchParams(search);
-					new URLSearchParams(expectedSearch).forEach((value, name) => {
-						expect(params.get(name)).toBe(value);
-					});
-				} else {
-					expect(screen.getByTestId('location-search')).toHaveTextContent('');
-				}
-			},
-		);
-
-		it('should redirect dynamic channel edit route preserving the channel id', async () => {
-			renderPrivateRoute({
-				initialRoute: '/settings/channels/edit/abc123',
-				appContext: { isLoggedIn: true },
-			});
-
-			await assertRedirectsTo('/alerts/channels/edit/abc123');
-		});
-
-		it('should merge incoming query params with the embedded query of the target', async () => {
-			renderPrivateRoute({
-				initialRoute: '/settings/channels?foo=bar',
-				appContext: { isLoggedIn: true },
-			});
-
-			await waitFor(() => {
-				expect(screen.getByTestId('location-display')).toHaveTextContent('/alerts');
-			});
-
-			const search = screen.getByTestId('location-search').textContent ?? '';
-			const params = new URLSearchParams(search);
-			expect(params.get('tab')).toBe('Channels');
-			expect(params.get('foo')).toBe('bar');
-		});
-	});
 });

frontend/src/AppRoutes/pageComponents.ts

@@ -122,13 +122,6 @@ export const DashboardWidget = Loadable(
 		import(/* webpackChunkName: "DashboardWidgetPage" */ 'pages/DashboardWidget'),
 );
 
-export const DashboardPanelEditorPage = Loadable(
-	() =>
-		import(
-			/* webpackChunkName: "DashboardPanelEditorPage" */ 'pages/DashboardPageV2/PanelEditorPage/PanelEditorPage'
-		),
-);
-
 export const EditRulesPage = Loadable(
 	() => import(/* webpackChunkName: "Alerts Edit Page" */ 'pages/EditRules'),
 );
@@ -149,12 +142,12 @@ export const AlertOverview = Loadable(
 	() => import(/* webpackChunkName: "Alert Overview" */ 'pages/AlertList'),
 );
 
-export const ChannelsNew = Loadable(
-	() => import(/* webpackChunkName: "Create Channels" */ 'pages/AlertList'),
+export const CreateAlertChannelAlerts = Loadable(
+	() => import(/* webpackChunkName: "Create Channels" */ 'pages/Settings'),
 );
 
-export const ChannelsEdit = Loadable(
-	() => import(/* webpackChunkName: "Edit Channels" */ 'pages/AlertList'),
+export const AllAlertChannels = Loadable(
+	() => import(/* webpackChunkName: "All Channels" */ 'pages/Settings'),
 );
 
 export const AllErrors = Loadable(

frontend/src/AppRoutes/routes.ts

@@ -5,13 +5,12 @@ import {
 	AIAssistantPage,
 	AlertHistory,
 	AlertOverview,
+	AllAlertChannels,
 	AllErrors,
 	ApiMonitoring,
-	ChannelsEdit,
-	ChannelsNew,
+	CreateAlertChannelAlerts,
 	CreateNewAlerts,
 	DashboardPage,
-	DashboardPanelEditorPage,
 	DashboardsListPage,
 	DashboardWidget,
 	EditRulesPage,
@@ -197,13 +196,6 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 		key: 'DASHBOARD_WIDGET',
 	},
-	{
-		path: ROUTES.DASHBOARD_PANEL_EDITOR,
-		exact: true,
-		component: DashboardPanelEditorPage,
-		isPrivate: true,
-		key: 'DASHBOARD_PANEL_EDITOR',
-	},
 	{
 		path: ROUTES.EDIT_ALERTS,
 		exact: true,
@@ -277,16 +269,16 @@ const routes: AppRoutes[] = [
 	{
 		path: ROUTES.CHANNELS_NEW,
 		exact: true,
-		component: ChannelsNew,
+		component: CreateAlertChannelAlerts,
 		isPrivate: true,
 		key: 'CHANNELS_NEW',
 	},
 	{
-		path: ROUTES.CHANNELS_EDIT,
+		path: ROUTES.ALL_CHANNELS,
 		exact: true,
-		component: ChannelsEdit,
+		component: AllAlertChannels,
 		isPrivate: true,
-		key: 'CHANNELS_EDIT',
+		key: 'ALL_CHANNELS',
 	},
 	{
 		path: ROUTES.ALL_ERROR,
@@ -477,6 +469,13 @@ 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,
@@ -542,9 +541,6 @@ export const oldNewRoutesMapping: Record<string, string> = {
 	'/messaging-queues': '/messaging-queues/overview',
 	'/alerts/edit': '/alerts/overview',
 	'/alerts/type-selection': '/alerts/new',
-	// TODO(H4ad): Update this after https://github.com/SigNoz/engineering-pod/issues/5322
-	'/settings/channels': '/alerts?tab=Channels',
-	'/settings/channels/new': '/alerts/channels/new',
 };
 export const oldRoutes = Object.keys(oldNewRoutesMapping);
 

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

@@ -18,6 +18,7 @@ import type {
 } from 'react-query';
 
 import type {
+	DeleteMetricReductionRulePathParameters,
 	GetMetricAlerts200,
 	GetMetricAlertsPathParameters,
 	GetMetricAttributes200,
@@ -29,18 +30,27 @@ 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';
@@ -771,6 +781,292 @@ 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
@@ -940,6 +1236,192 @@ export const invalidateGetMetricsOnboardingStatus = async (
 	return queryClient;
 };
 
+/**
+ * Returns active metric volume-control (label reduction) rules, sorted and paginated server-side. Enterprise feature.
+ * @summary List metric reduction rules
+ */
+export const listMetricReductionRules = (
+	params?: ListMetricReductionRulesParams,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListMetricReductionRules200>({
+		url: `/api/v2/metrics/reduction_rules`,
+		method: 'GET',
+		params,
+		signal,
+	});
+};
+
+export const getListMetricReductionRulesQueryKey = (
+	params?: ListMetricReductionRulesParams,
+) => {
+	return [
+		`/api/v2/metrics/reduction_rules`,
+		...(params ? [params] : []),
+	] as const;
+};
+
+export const getListMetricReductionRulesQueryOptions = <
+	TData = Awaited<ReturnType<typeof listMetricReductionRules>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	params?: ListMetricReductionRulesParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listMetricReductionRules>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getListMetricReductionRulesQueryKey(params);
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof listMetricReductionRules>>
+	> = ({ signal }) => listMetricReductionRules(params, signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listMetricReductionRules>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListMetricReductionRulesQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listMetricReductionRules>>
+>;
+export type ListMetricReductionRulesQueryError =
+	ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List metric reduction rules
+ */
+
+export function useListMetricReductionRules<
+	TData = Awaited<ReturnType<typeof listMetricReductionRules>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	params?: ListMetricReductionRulesParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listMetricReductionRules>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListMetricReductionRulesQueryOptions(params, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary List metric reduction rules
+ */
+export const invalidateListMetricReductionRules = async (
+	queryClient: QueryClient,
+	params?: ListMetricReductionRulesParams,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListMetricReductionRulesQueryKey(params) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * Estimates the series reduction and related-asset impact of a candidate volume-control rule without persisting it. Enterprise feature.
+ * @summary Preview a metric reduction rule
+ */
+export const previewMetricReductionRule = (
+	metricreductionruletypesPostableReductionRulePreviewDTO?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<PreviewMetricReductionRule200>({
+		url: `/api/v2/metrics/reduction_rules/preview`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: metricreductionruletypesPostableReductionRulePreviewDTO,
+		signal,
+	});
+};
+
+export const getPreviewMetricReductionRuleMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof previewMetricReductionRule>>,
+		TError,
+		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof previewMetricReductionRule>>,
+	TError,
+	{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
+	TContext
+> => {
+	const mutationKey = ['previewMetricReductionRule'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof previewMetricReductionRule>>,
+		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return previewMetricReductionRule(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type PreviewMetricReductionRuleMutationResult = NonNullable<
+	Awaited<ReturnType<typeof previewMetricReductionRule>>
+>;
+export type PreviewMetricReductionRuleMutationBody =
+	| BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO>
+	| undefined;
+export type PreviewMetricReductionRuleMutationError =
+	ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Preview a metric reduction rule
+ */
+export const usePreviewMetricReductionRule = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof previewMetricReductionRule>>,
+		TError,
+		{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof previewMetricReductionRule>>,
+	TError,
+	{ data?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO> },
+	TContext
+> => {
+	return useMutation(getPreviewMetricReductionRuleMutationOptions(options));
+};
 /**
  * This endpoint provides list of metrics with their number of samples and timeseries for the given time range
  * @summary Get metrics statistics

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

@@ -20,7 +20,6 @@ import type {
 import type {
 	AuthtypesPatchableRoleDTO,
 	AuthtypesPostableRoleDTO,
-	AuthtypesUpdatableRoleDTO,
 	CoretypesPatchableObjectsDTO,
 	CreateRole201,
 	DeleteRolePathParameters,
@@ -32,7 +31,6 @@ import type {
 	PatchObjectsPathParameters,
 	PatchRolePathParameters,
 	RenderErrorResponseDTO,
-	UpdateRolePathParameters,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
@@ -367,7 +365,6 @@ export const invalidateGetRole = async (
 
 /**
  * This endpoint patches a role
- * @deprecated
  * @summary Patch role
  */
 export const patchRole = (
@@ -439,7 +436,6 @@ export type PatchRoleMutationBody =
 export type PatchRoleMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Patch role
  */
 export const usePatchRole = <
@@ -466,105 +462,6 @@ export const usePatchRole = <
 > => {
 	return useMutation(getPatchRoleMutationOptions(options));
 };
-/**
- * This endpoint updates a role
- * @summary Update role
- */
-export const updateRole = (
-	{ id }: UpdateRolePathParameters,
-	authtypesUpdatableRoleDTO?: BodyType<AuthtypesUpdatableRoleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/roles/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: authtypesUpdatableRoleDTO,
-		signal,
-	});
-};
-
-export const getUpdateRoleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRole>>,
-		TError,
-		{
-			pathParams: UpdateRolePathParameters;
-			data?: BodyType<AuthtypesUpdatableRoleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateRole>>,
-	TError,
-	{
-		pathParams: UpdateRolePathParameters;
-		data?: BodyType<AuthtypesUpdatableRoleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateRole'];
-	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 updateRole>>,
-		{
-			pathParams: UpdateRolePathParameters;
-			data?: BodyType<AuthtypesUpdatableRoleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateRole(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateRoleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateRole>>
->;
-export type UpdateRoleMutationBody =
-	| BodyType<AuthtypesUpdatableRoleDTO>
-	| undefined;
-export type UpdateRoleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update role
- */
-export const useUpdateRole = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRole>>,
-		TError,
-		{
-			pathParams: UpdateRolePathParameters;
-			data?: BodyType<AuthtypesUpdatableRoleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateRole>>,
-	TError,
-	{
-		pathParams: UpdateRolePathParameters;
-		data?: BodyType<AuthtypesUpdatableRoleDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpdateRoleMutationOptions(options));
-};
 /**
  * Gets all objects connected to the specified role via a given relation type
  * @summary Get objects for a role by relation
@@ -668,7 +565,6 @@ export const invalidateGetObjects = async (
 
 /**
  * Patches the objects connected to the specified role via a given relation type
- * @deprecated
  * @summary Patch objects for a role by relation
  */
 export const patchObjects = (
@@ -740,7 +636,6 @@ export type PatchObjectsMutationBody =
 export type PatchObjectsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Patch objects for a role by relation
  */
 export const usePatchObjects = <

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

@@ -2224,31 +2224,15 @@ export interface AuthtypesPostableEmailPasswordSessionDTO {
 	password?: string;
 }
 
-export interface CoretypesObjectGroupDTO {
-	resource: CoretypesResourceRefDTO;
-	/**
-	 * @type array
-	 */
-	selectors: string[];
-}
-
-export interface AuthtypesTransactionGroupDTO {
-	objectGroup: CoretypesObjectGroupDTO;
-	relation: AuthtypesRelationDTO;
-}
-
-export type AuthtypesTransactionGroupsDTO = AuthtypesTransactionGroupDTO[];
-
 export interface AuthtypesPostableRoleDTO {
 	/**
 	 * @type string
 	 */
-	description: string;
+	description?: string;
 	/**
 	 * @type string
 	 */
 	name: string;
-	transactionGroups: AuthtypesTransactionGroupsDTO;
 }
 
 export interface AuthtypesPostableRotateTokenDTO {
@@ -2258,32 +2242,6 @@ export interface AuthtypesPostableRotateTokenDTO {
 	refreshToken?: string;
 }
 
-export interface AuthtypesPostableUserRoleDTO {
-	/**
-	 * @type string
-	 */
-	id: string;
-}
-
-export interface AuthtypesPostableUserDTO {
-	/**
-	 * @type string
-	 */
-	displayName?: string;
-	/**
-	 * @type string
-	 */
-	email: string;
-	/**
-	 * @type string
-	 */
-	frontendBaseUrl?: string;
-	/**
-	 * @type array
-	 */
-	userRoles: AuthtypesPostableUserRoleDTO[];
-}
-
 export interface AuthtypesRoleDTO {
 	/**
 	 * @type string
@@ -2317,40 +2275,6 @@ export interface AuthtypesRoleDTO {
 	updatedAt?: string;
 }
 
-export interface AuthtypesRoleWithTransactionGroupsDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type string
-	 */
-	description: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	transactionGroups: AuthtypesTransactionGroupsDTO;
-	/**
-	 * @type string
-	 */
-	type: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-}
-
 export interface AuthtypesSessionContextDTO {
 	/**
 	 * @type boolean
@@ -2371,14 +2295,6 @@ export interface AuthtypesUpdatableAuthDomainDTO {
 	config?: AuthtypesAuthDomainConfigDTO;
 }
 
-export interface AuthtypesUpdatableRoleDTO {
-	/**
-	 * @type string
-	 */
-	description: string;
-	transactionGroups: AuthtypesTransactionGroupsDTO;
-}
-
 export interface AuthtypesUserRoleDTO {
 	/**
 	 * @type string
@@ -3149,6 +3065,14 @@ export interface CommonJSONRefDTO {
 	$ref?: string;
 }
 
+export interface CoretypesObjectGroupDTO {
+	resource: CoretypesResourceRefDTO;
+	/**
+	 * @type array
+	 */
+	selectors: string[];
+}
+
 export interface CoretypesPatchableObjectsDTO {
 	/**
 	 * @type array,null
@@ -6653,6 +6577,157 @@ 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
@@ -6814,6 +6889,10 @@ export interface MetricsexplorertypesMetricDashboardDTO {
 	 * @type string
 	 */
 	dashboardName: string;
+	/**
+	 * @type array
+	 */
+	groupBy?: string[];
 	/**
 	 * @type string
 	 */
@@ -9526,16 +9605,6 @@ export type ListLLMPricingRulesParams = {
 	 * @description undefined
 	 */
 	limit?: number;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	q?: string;
-	/**
-	 * @type boolean,null
-	 * @description undefined
-	 */
-	isOverride?: boolean | null;
 };
 
 export type ListLLMPricingRules200 = {
@@ -9645,7 +9714,7 @@ export type GetRolePathParameters = {
 	id: string;
 };
 export type GetRole200 = {
-	data: AuthtypesRoleWithTransactionGroupsDTO;
+	data: AuthtypesRoleDTO;
 	/**
 	 * @type string
 	 */
@@ -9655,9 +9724,6 @@ export type GetRole200 = {
 export type PatchRolePathParameters = {
 	id: string;
 };
-export type UpdateRolePathParameters = {
-	id: string;
-};
 export type GetObjectsPathParameters = {
 	id: string;
 	relation: string;
@@ -10405,6 +10471,31 @@ 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;
 	/**
@@ -10421,6 +10512,43 @@ 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;
 	/**
@@ -10833,14 +10961,6 @@ export type ListUsers200 = {
 	status: string;
 };
 
-export type CreateUser201 = {
-	data: TypesIdentifiableDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetUserPathParameters = {
 	id: string;
 };

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

@@ -18,11 +18,9 @@ import type {
 } from 'react-query';
 
 import type {
-	AuthtypesPostableUserDTO,
 	CreateInvite201,
 	CreateResetPasswordToken201,
 	CreateResetPasswordTokenPathParameters,
-	CreateUser201,
 	DeleteUserPathParameters,
 	GetMyUser200,
 	GetMyUserDeprecated200,
@@ -171,7 +169,6 @@ export const invalidateGetResetPasswordTokenDeprecated = async (
 
 /**
  * This endpoint creates an invite for a user
- * @deprecated
  * @summary Create invite
  */
 export const createInvite = (
@@ -233,7 +230,6 @@ export type CreateInviteMutationBody =
 export type CreateInviteMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Create invite
  */
 export const useCreateInvite = <
@@ -256,7 +252,6 @@ export const useCreateInvite = <
 };
 /**
  * This endpoint creates a bulk invite for a user
- * @deprecated
  * @summary Create bulk invite
  */
 export const createBulkInvite = (
@@ -318,7 +313,6 @@ export type CreateBulkInviteMutationBody =
 export type CreateBulkInviteMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Create bulk invite
  */
 export const useCreateBulkInvite = <
@@ -424,7 +418,6 @@ export const useResetPassword = <
 };
 /**
  * This endpoint lists all users
- * @deprecated
  * @summary List users
  */
 export const listUsersDeprecated = (signal?: AbortSignal) => {
@@ -470,7 +463,6 @@ export type ListUsersDeprecatedQueryResult = NonNullable<
 export type ListUsersDeprecatedQueryError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary List users
  */
 
@@ -494,7 +486,6 @@ export function useListUsersDeprecated<
 }
 
 /**
- * @deprecated
  * @summary List users
  */
 export const invalidateListUsersDeprecated = async (
@@ -590,7 +581,6 @@ export const useDeleteUser = <
 };
 /**
  * This endpoint returns the user by id
- * @deprecated
  * @summary Get user
  */
 export const getUserDeprecated = (
@@ -650,7 +640,6 @@ export type GetUserDeprecatedQueryResult = NonNullable<
 export type GetUserDeprecatedQueryError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Get user
  */
 
@@ -677,7 +666,6 @@ export function useGetUserDeprecated<
 }
 
 /**
- * @deprecated
  * @summary Get user
  */
 export const invalidateGetUserDeprecated = async (
@@ -695,7 +683,6 @@ export const invalidateGetUserDeprecated = async (
 
 /**
  * This endpoint updates the user by id
- * @deprecated
  * @summary Update user
  */
 export const updateUserDeprecated = (
@@ -768,7 +755,6 @@ export type UpdateUserDeprecatedMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Update user
  */
 export const useUpdateUserDeprecated = <
@@ -797,7 +783,6 @@ export const useUpdateUserDeprecated = <
 };
 /**
  * This endpoint returns the user I belong to
- * @deprecated
  * @summary Get my user
  */
 export const getMyUserDeprecated = (signal?: AbortSignal) => {
@@ -843,7 +828,6 @@ export type GetMyUserDeprecatedQueryResult = NonNullable<
 export type GetMyUserDeprecatedQueryError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @deprecated
  * @summary Get my user
  */
 
@@ -867,7 +851,6 @@ export function useGetMyUserDeprecated<
 }
 
 /**
- * @deprecated
  * @summary Get my user
  */
 export const invalidateGetMyUserDeprecated = async (
@@ -1226,89 +1209,6 @@ export const invalidateListUsers = async (
 	return queryClient;
 };
 
-/**
- * This endpoint creates a user for the organization
- * @summary Create user
- */
-export const createUser = (
-	authtypesPostableUserDTO?: BodyType<AuthtypesPostableUserDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateUser201>({
-		url: `/api/v2/users`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: authtypesPostableUserDTO,
-		signal,
-	});
-};
-
-export const getCreateUserMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createUser>>,
-		TError,
-		{ data?: BodyType<AuthtypesPostableUserDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createUser>>,
-	TError,
-	{ data?: BodyType<AuthtypesPostableUserDTO> },
-	TContext
-> => {
-	const mutationKey = ['createUser'];
-	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 createUser>>,
-		{ data?: BodyType<AuthtypesPostableUserDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createUser(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateUserMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createUser>>
->;
-export type CreateUserMutationBody =
-	| BodyType<AuthtypesPostableUserDTO>
-	| undefined;
-export type CreateUserMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create user
- */
-export const useCreateUser = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createUser>>,
-		TError,
-		{ data?: BodyType<AuthtypesPostableUserDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createUser>>,
-	TError,
-	{ data?: BodyType<AuthtypesPostableUserDTO> },
-	TContext
-> => {
-	return useMutation(getCreateUserMutationOptions(options));
-};
 /**
  * This endpoint returns the user by id
  * @summary Get user by user id

frontend/src/api/v5/queryRange/convertV5Response.test.ts

@@ -274,110 +274,4 @@ describe('convertV5ResponseToLegacy', () => {
 			},
 		});
 	});
-
-	it('clickhouse_sql scalar keeps each value column distinct (regression: all-"A" collapse)', () => {
-		const scalar: ScalarData = {
-			columns: [
-				{
-					name: 'service.name',
-					queryName: 'A',
-					aggregationIndex: 0,
-					columnType: 'group',
-				} as unknown as ScalarData['columns'][number],
-				{
-					name: 'current_availability',
-					queryName: 'A',
-					aggregationIndex: 0,
-					columnType: 'aggregation',
-				} as unknown as ScalarData['columns'][number],
-				{
-					name: 'error_budget_remaining',
-					queryName: 'A',
-					aggregationIndex: 1,
-					columnType: 'aggregation',
-				} as unknown as ScalarData['columns'][number],
-				{
-					name: 'budget_status',
-					queryName: 'A',
-					aggregationIndex: 2,
-					columnType: 'group',
-				} as unknown as ScalarData['columns'][number],
-				{
-					name: 'total_requests',
-					queryName: 'A',
-					aggregationIndex: 4,
-					columnType: 'aggregation',
-				} as unknown as ScalarData['columns'][number],
-			],
-			data: [['kuja-api_gateway-service', 99.985, 0.985, 'Healthy ✅', 2181216]],
-		};
-
-		const v5Data: QueryRangeResponseV5 = {
-			type: 'scalar',
-			data: { results: [scalar] },
-			meta: { rowsScanned: 0, bytesScanned: 0, durationMs: 0, stepIntervals: {} },
-		};
-
-		// A clickhouse_sql envelope contributes no aggregation metadata.
-		const params = makeBaseParams('scalar', [
-			{
-				type: 'clickhouse_sql',
-				spec: {
-					name: 'A',
-					query: 'SELECT ...',
-					disabled: false,
-				},
-			} as unknown as QueryRangeRequestV5['compositeQuery']['queries'][number],
-		]);
-
-		const input: SuccessResponse<MetricRangePayloadV5, QueryRangeRequestV5> =
-			makeBaseSuccess({ data: v5Data }, params);
-		// formatForWeb=true is the table-panel path.
-		const result = convertV5ResponseToLegacy(input, { A: '' }, true);
-
-		const [tableEntry] = result.payload.data.result;
-		// Headers keep their real names instead of collapsing to "A".
-		expect(tableEntry.table?.columns).toStrictEqual([
-			{
-				name: 'service.name',
-				queryName: 'A',
-				isValueColumn: false,
-				id: 'service.name',
-			},
-			{
-				name: 'current_availability',
-				queryName: 'A',
-				isValueColumn: true,
-				id: 'current_availability',
-			},
-			{
-				name: 'error_budget_remaining',
-				queryName: 'A',
-				isValueColumn: true,
-				id: 'error_budget_remaining',
-			},
-			{
-				name: 'budget_status',
-				queryName: 'A',
-				isValueColumn: false,
-				id: 'budget_status',
-			},
-			{
-				name: 'total_requests',
-				queryName: 'A',
-				isValueColumn: true,
-				id: 'total_requests',
-			},
-		]);
-		// Ids are unique, so value columns don't overwrite each other in the row.
-		expect(tableEntry.table?.rows?.[0]).toStrictEqual({
-			data: {
-				'service.name': 'kuja-api_gateway-service',
-				current_availability: 99.985,
-				error_budget_remaining: 0.985,
-				budget_status: 'Healthy ✅',
-				total_requests: 2181216,
-			},
-		});
-	});
 });

frontend/src/api/v5/queryRange/convertV5Response.ts

@@ -15,7 +15,6 @@ function getColName(
 	col: ScalarData['columns'][number],
 	legendMap: Record<string, string>,
 	aggregationPerQuery: Record<string, any>,
-	clickhouseQueryNames: Set<string>,
 ): string {
 	if (col.columnType === 'group') {
 		return col.name;
@@ -40,32 +39,16 @@ function getColName(
 		return alias || expression || col.queryName;
 	}
 
-	// clickhouse_sql value columns carry their real SQL alias in col.name — use
-	// it so each value column keeps its own header instead of collapsing onto
-	// the query name. Formulas/promql use placeholder names, so they fall back
-	// to legend || queryName.
-	if (clickhouseQueryNames.has(col.queryName)) {
-		return col.name;
-	}
 	return legend || col.queryName;
 }
 
 function getColId(
 	col: ScalarData['columns'][number],
 	aggregationPerQuery: Record<string, any>,
-	clickhouseQueryNames: Set<string>,
 ): string {
 	if (col.columnType === 'group') {
 		return col.name;
 	}
-
-	// clickhouse_sql value columns are keyed by their real SQL alias so multiple
-	// value columns stay unique instead of all collapsing onto the query name
-	// (which would overwrite every cell in the row with the last column's value).
-	if (clickhouseQueryNames.has(col.queryName)) {
-		return col.name;
-	}
-
 	const aggregation =
 		aggregationPerQuery?.[col.queryName]?.[col.aggregationIndex];
 	const expression = aggregation?.expression || '';
@@ -158,7 +141,6 @@ function convertScalarDataArrayToTable(
 	scalarDataArray: ScalarData[],
 	legendMap: Record<string, string>,
 	aggregationPerQuery: Record<string, any>,
-	clickhouseQueryNames: Set<string>,
 ): QueryDataV3[] {
 	// If no scalar data, return empty structure
 
@@ -184,10 +166,10 @@ function convertScalarDataArrayToTable(
 
 		// Collect columns for this specific query
 		const columns = scalarData?.columns?.map((col) => ({
-			name: getColName(col, legendMap, aggregationPerQuery, clickhouseQueryNames),
+			name: getColName(col, legendMap, aggregationPerQuery),
 			queryName: col.queryName,
 			isValueColumn: col.columnType === 'aggregation',
-			id: getColId(col, aggregationPerQuery, clickhouseQueryNames),
+			id: getColId(col, aggregationPerQuery),
 		}));
 
 		// Process rows for this specific query
@@ -195,13 +177,8 @@ function convertScalarDataArrayToTable(
 			const rowData: Record<string, any> = {};
 
 			scalarData?.columns?.forEach((col, colIndex) => {
-				const columnName = getColName(
-					col,
-					legendMap,
-					aggregationPerQuery,
-					clickhouseQueryNames,
-				);
-				const columnId = getColId(col, aggregationPerQuery, clickhouseQueryNames);
+				const columnName = getColName(col, legendMap, aggregationPerQuery);
+				const columnId = getColId(col, aggregationPerQuery);
 				rowData[columnId || columnName] = dataRow[colIndex];
 			});
 
@@ -225,7 +202,6 @@ function convertScalarWithFormatForWeb(
 	scalarDataArray: ScalarData[],
 	legendMap: Record<string, string>,
 	aggregationPerQuery: Record<string, any>,
-	clickhouseQueryNames: Set<string>,
 ): QueryDataV3[] {
 	if (!scalarDataArray || scalarDataArray.length === 0) {
 		return [];
@@ -234,18 +210,13 @@ function convertScalarWithFormatForWeb(
 	return scalarDataArray.map((scalarData) => {
 		const columns =
 			scalarData.columns?.map((col) => {
-				const colName = getColName(
-					col,
-					legendMap,
-					aggregationPerQuery,
-					clickhouseQueryNames,
-				);
+				const colName = getColName(col, legendMap, aggregationPerQuery);
 
 				return {
 					name: colName,
 					queryName: col.queryName,
 					isValueColumn: col.columnType === 'aggregation',
-					id: getColId(col, aggregationPerQuery, clickhouseQueryNames),
+					id: getColId(col, aggregationPerQuery),
 				};
 			}) || [];
 
@@ -318,7 +289,6 @@ function convertV5DataByType(
 	v5Data: any,
 	legendMap: Record<string, string>,
 	aggregationPerQuery: Record<string, any>,
-	clickhouseQueryNames: Set<string>,
 ): MetricRangePayloadV3['data'] {
 	switch (v5Data?.type) {
 		case 'time_series': {
@@ -337,7 +307,6 @@ function convertV5DataByType(
 				scalarData,
 				legendMap,
 				aggregationPerQuery,
-				clickhouseQueryNames,
 			);
 			return {
 				resultType: 'scalar',
@@ -404,15 +373,6 @@ export function convertV5ResponseToLegacy(
 				{} as Record<string, any>,
 			) || {};
 
-	// clickhouse_sql queries have no aggregation metadata; their value columns
-	// are named/keyed by the real SQL alias the response carries (see getColId).
-	const clickhouseQueryNames = new Set<string>(
-		(params?.compositeQuery?.queries ?? [])
-			.filter((query) => query.type === 'clickhouse_sql')
-			.map((query) => (query.spec as { name?: string })?.name)
-			.filter((name): name is string => !!name),
-	);
-
 	// If formatForWeb is true, return as-is (like existing logic)
 	if (formatForWeb && v5Data?.type === 'scalar') {
 		const scalarData = v5Data.data.results as ScalarData[];
@@ -420,7 +380,6 @@ export function convertV5ResponseToLegacy(
 			scalarData,
 			legendMap,
 			aggregationPerQuery,
-			clickhouseQueryNames,
 		);
 
 		return {
@@ -443,7 +402,6 @@ export function convertV5ResponseToLegacy(
 		v5Data,
 		legendMap,
 		aggregationPerQuery,
-		clickhouseQueryNames,
 	);
 
 	// Create legacy-compatible response structure

frontend/src/constants/features.ts

@@ -12,5 +12,4 @@ export enum FeatureKeys {
 	USE_JSON_BODY = 'use_json_body',
 	USE_FINE_GRAINED_AUTHZ = 'use_fine_grained_authz',
 	USE_DASHBOARD_V2 = 'use_dashboard_v2',
-	EMABLE_AI_OBSERVABILITY = 'enable_ai_observability',
 }

frontend/src/constants/localStorage.ts

@@ -43,6 +43,4 @@ export enum LOCALSTORAGE {
 	DASHBOARD_PREFERENCES = 'DASHBOARD_PREFERENCES',
 	ACTIVE_SIGNOZ_INSTANCE_URL = 'ACTIVE_SIGNOZ_INSTANCE_URL',
 	DASHBOARDS_LIST_VISIBLE_COLUMNS = 'DASHBOARDS_LIST_VISIBLE_COLUMNS',
-	DASHBOARDS_LIST_VIEWS = 'DASHBOARDS_LIST_VIEWS',
-	DASHBOARD_V2_PANEL_COLUMN_WIDTHS = 'DASHBOARD_V2_PANEL_COLUMN_WIDTHS',
 }

frontend/src/constants/routes.ts

@@ -24,16 +24,14 @@ const ROUTES = {
 	ALL_DASHBOARD: '/dashboard',
 	DASHBOARD: '/dashboard/:dashboardId',
 	DASHBOARD_WIDGET: '/dashboard/:dashboardId/:widgetId',
-	DASHBOARD_PANEL_EDITOR: '/dashboard/:dashboardId/panel/:panelId',
 	EDIT_ALERTS: '/alerts/edit',
 	LIST_ALL_ALERT: '/alerts',
 	ALERTS_NEW: '/alerts/new',
 	ALERT_HISTORY: '/alerts/history',
 	ALERT_OVERVIEW: '/alerts/overview',
-	// TODO(H4ad): Add test to forbidden ? in this map after https://github.com/SigNoz/engineering-pod/issues/5322
-	ALL_CHANNELS: '/alerts?tab=Channels',
-	CHANNELS_NEW: '/alerts/channels/new',
-	CHANNELS_EDIT: '/alerts/channels/edit/:channelId',
+	ALL_CHANNELS: '/settings/channels',
+	CHANNELS_NEW: '/settings/channels/new',
+	CHANNELS_EDIT: '/settings/channels/edit/:channelId',
 	ALL_ERROR: '/exceptions',
 	ERROR_DETAIL: '/error-detail',
 	VERSION: '/status',
@@ -79,6 +77,7 @@ const ROUTES = {
 	METRICS_EXPLORER: '/metrics-explorer/summary',
 	METRICS_EXPLORER_EXPLORER: '/metrics-explorer/explorer',
 	METRICS_EXPLORER_VIEWS: '/metrics-explorer/views',
+	METRICS_EXPLORER_VOLUME_CONTROL: '/metrics-explorer/volume-control',
 	API_MONITORING_BASE: '/api-monitoring',
 	API_MONITORING: '/api-monitoring/explorer',
 	METRICS_EXPLORER_BASE: '/metrics-explorer',

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

@@ -94,7 +94,7 @@ describe('resourceRoute', () => {
 
 	it('routes channels to the edit page', () => {
 		expect(resourceRoute(ResourceType.channel, 'channel-uuid-1')).toBe(
-			'/alerts/channels/edit/channel-uuid-1',
+			'/settings/channels/edit/channel-uuid-1',
 		);
 	});
 });

frontend/src/container/AllAlertChannels/AllAlertChannels.styles.scss

@@ -1,4 +1,4 @@
 .alert-channels-container {
-	width: 100%;
-	padding: 0 var(--spacing-8);
+	width: 90%;
+	margin: 12px auto;
 }

frontend/src/container/AppLayout/index.tsx

@@ -408,9 +408,6 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 
 	const isPublicDashboard = pathname.startsWith('/public/dashboard/');
 	const isAIAssistantPage = pathname.startsWith('/ai-assistant/');
-	// The V2 panel editor is a chromeless full-page route (no side nav / top nav),
-	// like the onboarding and public-dashboard screens.
-	const isPanelEditorV2 = routeKey === 'DASHBOARD_PANEL_EDITOR';
 
 	const renderFullScreen =
 		pathname === ROUTES.GET_STARTED ||
@@ -421,8 +418,7 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 		pathname === ROUTES.GET_STARTED_LOGS_MANAGEMENT ||
 		pathname === ROUTES.GET_STARTED_AWS_MONITORING ||
 		pathname === ROUTES.GET_STARTED_AZURE_MONITORING ||
-		isPublicDashboard ||
-		isPanelEditorV2;
+		isPublicDashboard;
 
 	const [showTrialExpiryBanner, setShowTrialExpiryBanner] = useState(false);
 

frontend/src/container/CreateAlertChannels/CreateAlertChannels.styles.scss

@@ -1,5 +1,7 @@
 .create-alert-channels-container {
-	width: 100%;
+	width: 90%;
+	margin: 12px auto;
+
 	border: 1px solid var(--l1-border);
 	background: var(--l2-background);
 	border-radius: 3px;

frontend/src/container/DashboardContainer/visualization/layout/ChartLayout/ChartLayout.styles.scss

@@ -7,17 +7,15 @@
 
 	&--legend-right {
 		flex-direction: row;
+
+		.chart-layout__legend-wrapper {
+			padding-left: 0 !important;
+		}
 	}
 
 	&__legend-wrapper {
-		// The inline height is the legend rectangle from calculateChartDimensions;
-		// border-box keeps the padding inside it so the wrapper doesn't grow past
-		// that height and steal space from the chart. overflow:hidden clips to the
-		// rectangle so the virtualized legend scrolls within it.
-		box-sizing: border-box;
-		min-height: 0;
-		overflow: hidden;
 		padding-left: 12px;
 		padding-bottom: 12px;
+		overflow: auto;
 	}
 }

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

@@ -516,6 +516,11 @@
 	--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,6 +21,7 @@ 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';
 
@@ -190,6 +191,7 @@ function MetricDetails({
 					isLoadingMetricMetadata={isLoadingMetricMetadata}
 					refetchMetricMetadata={refetchMetricMetadata}
 				/>
+				<VolumeControlSection metricName={metricName} />
 				<AllAttributes
 					metricName={metricName}
 					metricType={metadata?.type}

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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,172 @@
+.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

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,114 @@
+.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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,42 @@
+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

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

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

@@ -0,0 +1,182 @@
+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

@@ -0,0 +1,19 @@
+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,6 +77,14 @@ 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,6 +1,5 @@
 import { Color } from '@signozhq/design-tokens';
-import { Tooltip } from 'antd';
-import { TableColumnType as ColumnType } from 'antd';
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
 import {
 	MetricsexplorertypesStatDTO,
 	MetricsexplorertypesTreemapEntryDTO,

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

@@ -0,0 +1,27 @@
+.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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,95 @@
+.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

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

frontend/src/container/RolesSettings/RolesComponents/CreateRoleModal.tsx

@@ -116,8 +116,7 @@ function CreateRoleModal({
 			} else {
 				const data: AuthtypesPostableRoleDTO = {
 					name: values.name,
-					description: values.description || '',
-					transactionGroups: [],
+					...(values.description ? { description: values.description } : {}),
 				};
 				createRole({ data });
 			}

frontend/src/container/SideNav/SideNav.tsx

@@ -80,7 +80,7 @@ import signozBrandLogoUrl from '@/assets/Logos/signoz-brand-logo.svg';
 
 import { useCmdK } from '../../providers/cmdKProvider';
 import { routeConfig } from './config';
-import { buildNavUrl, getQueryString } from './helper';
+import { getQueryString } from './helper';
 import {
 	defaultMoreMenuItems,
 	getUserSettingsDropdownMenuItems,
@@ -486,13 +486,12 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 			const availableParams = routeConfig[key];
 
 			const queryString = getQueryString(availableParams || [], params);
-			const url = buildNavUrl(key, queryString);
 
 			if (pathname !== key) {
 				if (event && isModifierKeyPressed(event)) {
-					openInNewTab(url);
+					openInNewTab(`${key}?${queryString.join('&')}`);
 				} else {
-					history.push(url, {
+					history.push(`${key}?${queryString.join('&')}`, {
 						from: pathname,
 					});
 				}

frontend/src/container/SideNav/helper.ts

@@ -8,14 +8,3 @@ export const getQueryString = (
 		}
 		return '';
 	});
-
-/**
- * @deprecated This should be removed after https://github.com/SigNoz/engineering-pod/issues/5322 is done
- */
-export const buildNavUrl = (key: string, queryString: string[]): string => {
-	if (key.includes('?')) {
-		const extra = queryString.filter(Boolean).join('&');
-		return extra ? `${key}&${extra}` : key;
-	}
-	return `${key}?${queryString.join('&')}`;
-};

frontend/src/container/SideNav/menuItems.tsx

@@ -337,7 +337,6 @@ export const settingsNavSections: SettingsNavSection[] = [
 				isEnabled: true,
 				itemKey: 'account',
 			},
-			// TODO(@SigNoz/pulse-frontend): https://github.com/SigNoz/engineering-pod/issues/5323
 			{
 				key: ROUTES.ALL_CHANNELS,
 				label: 'Notification Channels',

frontend/src/hooks/__tests__/useConfirmableAction.test.ts

@@ -1,61 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-
-import { useConfirmableAction } from '../useConfirmableAction';
-
-describe('useConfirmableAction', () => {
-	it('starts closed and idle', () => {
-		const { result } = renderHook(() =>
-			useConfirmableAction(jest.fn().mockResolvedValue(undefined)),
-		);
-		expect(result.current.open).toBe(false);
-		expect(result.current.isPending).toBe(false);
-	});
-
-	it('request() opens the prompt without running the action', () => {
-		const action = jest.fn().mockResolvedValue(undefined);
-		const { result } = renderHook(() => useConfirmableAction(action));
-
-		act(() => result.current.request());
-
-		expect(result.current.open).toBe(true);
-		expect(action).not.toHaveBeenCalled();
-	});
-
-	it('confirm() runs the action and closes on success', async () => {
-		const action = jest.fn().mockResolvedValue(undefined);
-		const { result } = renderHook(() => useConfirmableAction(action));
-
-		act(() => result.current.request());
-		await act(async () => {
-			await result.current.confirm();
-		});
-
-		expect(action).toHaveBeenCalledTimes(1);
-		expect(result.current.open).toBe(false);
-		expect(result.current.isPending).toBe(false);
-	});
-
-	it('keeps the prompt open and resets pending when the action rejects', async () => {
-		const action = jest.fn().mockRejectedValue(new Error('boom'));
-		const { result } = renderHook(() => useConfirmableAction(action));
-
-		act(() => result.current.request());
-		await act(async () => {
-			await expect(result.current.confirm()).rejects.toThrow('boom');
-		});
-
-		expect(result.current.open).toBe(true);
-		expect(result.current.isPending).toBe(false);
-	});
-
-	it('cancel() closes the prompt without running the action', () => {
-		const action = jest.fn().mockResolvedValue(undefined);
-		const { result } = renderHook(() => useConfirmableAction(action));
-
-		act(() => result.current.request());
-		act(() => result.current.cancel());
-
-		expect(result.current.open).toBe(false);
-		expect(action).not.toHaveBeenCalled();
-	});
-});

frontend/src/hooks/metricsExplorer/useVolumeControlFeatureGate.ts

@@ -0,0 +1,23 @@
+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/hooks/useConfirmableAction.ts

@@ -1,45 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-
-export interface ConfirmableAction {
-	/** Whether the confirmation prompt is open. */
-	open: boolean;
-	/** The confirmed action is in flight. */
-	isPending: boolean;
-	/** Open the confirmation prompt (e.g. from a menu item / button). */
-	request: () => void;
-	/** Run the action, tracking the in-flight flag; closes the prompt on success. */
-	confirm: () => Promise<void>;
-	/** Dismiss the prompt without acting. */
-	cancel: () => void;
-}
-
-/**
- * Generic two-step confirm flow for a (usually destructive) async action.
- * `request()` opens the prompt, `confirm()` runs `action` while tracking an
- * in-flight flag and closes on success, `cancel()` dismisses it. Owns only the
- * confirm state machine — what renders the prompt (dialog, popover) is the
- * caller's concern, so it stays reusable across confirm surfaces.
- */
-export function useConfirmableAction(
-	action: () => Promise<void>,
-): ConfirmableAction {
-	const [open, setOpen] = useState(false);
-	const [isPending, setIsPending] = useState(false);
-
-	const request = useCallback((): void => setOpen(true), []);
-	const cancel = useCallback((): void => setOpen(false), []);
-	const confirm = useCallback(async (): Promise<void> => {
-		setIsPending(true);
-		try {
-			await action();
-			setOpen(false);
-		} finally {
-			setIsPending(false);
-		}
-	}, [action]);
-
-	return useMemo(
-		() => ({ open, isPending, request, confirm, cancel }),
-		[open, isPending, request, confirm, cancel],
-	);
-}

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

@@ -1,5 +1,3 @@
-@use '../../../../styles/scrollbar' as *;
-
 .legend-search-container {
 	flex-shrink: 0;
 	width: 100%;
@@ -17,10 +15,6 @@
 	gap: 12px;
 	height: 100%;
 	width: 100%;
-	// Allow the flex children to shrink below their content height so the
-	// virtualized grid scrolls within the capped legend height instead of
-	// overflowing the wrapper (default min-height:auto would block the shrink).
-	min-height: 0;
 
 	&:has(.legend-item-focused) .legend-item {
 		opacity: 0.3;
@@ -39,11 +33,6 @@
 	}
 
 	.legend-virtuoso-container {
-		// flex:1 + min-height:0 pins the scroller to the space left after the
-		// search box (RIGHT legend) and lets it scroll instead of growing to fit
-		// every row — without this the grid overflows a BOTTOM legend's fixed height.
-		flex: 1;
-		min-height: 0;
 		height: 100%;
 		width: 100%;
 
@@ -78,7 +67,18 @@
 			}
 		}
 
-		@include custom-scrollbar;
+		&::-webkit-scrollbar {
+			width: 0.3rem;
+		}
+
+		&::-webkit-scrollbar-track {
+			background: transparent;
+		}
+
+		&::-webkit-scrollbar-thumb {
+			background: var(--l3-background);
+			border-radius: 0.5rem;
+		}
 	}
 }
 
@@ -108,10 +108,6 @@
 	align-items: center;
 	gap: 6px;
 	padding: 4px 8px;
-	// Include padding within the width so a full-width row (legend-item-right) fits its
-	// column instead of overflowing by the 16px horizontal padding — there is no global
-	// border-box reset, so the default content-box would make it overflow.
-	box-sizing: border-box;
 	max-width: 100%;
 	overflow: hidden;
 	border-radius: 4px;

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -87,7 +87,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<
 			lineConfig.fill = `${finalFillColor}40`;
 		} else if (fillMode && fillMode !== FillMode.None) {
 			if (fillMode === FillMode.Solid) {
-				lineConfig.fill = `${finalFillColor}70`;
+				lineConfig.fill = finalFillColor;
 			} else if (fillMode === FillMode.Gradient) {
 				lineConfig.fill = (self: uPlot): CanvasGradient =>
 					generateGradientFill(self, finalFillColor, 'rgba(0, 0, 0, 0)');

frontend/src/pages/AlertList/index.tsx

@@ -4,17 +4,14 @@ import { Tabs, TabsProps } from 'antd';
 import ConfigureIcon from 'assets/AlertHistory/ConfigureIcon';
 import HeaderRightSection from 'components/HeaderRightSection/HeaderRightSection';
 import ROUTES from 'constants/routes';
-import AllAlertChannels from 'container/AllAlertChannels';
 import AllAlertRules from 'container/ListAlertRules';
 import { PlannedDowntime } from 'container/PlannedDowntime/PlannedDowntime';
 import RoutingPolicies from 'container/RoutingPolicies';
 import TriggeredAlerts from 'container/TriggeredAlerts';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
-import { Cable, GalleryVerticalEnd, Pyramid } from '@signozhq/icons';
+import { GalleryVerticalEnd, Pyramid } from '@signozhq/icons';
 import AlertDetails from 'pages/AlertDetails';
-import ChannelsEdit from 'pages/ChannelsEdit';
-import ChannelsNew from 'pages/ChannelsNew';
 
 import { AlertListSubTabs, AlertListTabs } from './types';
 
@@ -29,9 +26,6 @@ function AllAlertList(): JSX.Element {
 	const subTab = urlQuery.get('subTab');
 	const isAlertHistory = location.pathname === ROUTES.ALERT_HISTORY;
 	const isAlertOverview = location.pathname === ROUTES.ALERT_OVERVIEW;
-	const isChannelsNew = location.pathname === ROUTES.CHANNELS_NEW;
-	const isChannelsEdit = location.pathname.startsWith('/alerts/channels/edit/');
-	const isChannelDetails = isChannelsNew || isChannelsEdit;
 
 	const handleConfigurationTabChange = useCallback(
 		(subTab: string): void => {
@@ -92,22 +86,6 @@ function AllAlertList(): JSX.Element {
 				</div>
 			),
 		},
-		{
-			label: (
-				<div className="periscope-tab top-level-tab">
-					<Cable size={14} />
-					Notification Channels
-				</div>
-			),
-			key: AlertListTabs.CHANNELS,
-			children: (
-				<div className="alert-rules-container">
-					{isChannelsNew && <ChannelsNew />}
-					{isChannelsEdit && <ChannelsEdit />}
-					{!isChannelDetails && <AllAlertChannels />}
-				</div>
-			),
-		},
 		{
 			label: (
 				<div className="periscope-tab top-level-tab">
@@ -120,21 +98,11 @@ function AllAlertList(): JSX.Element {
 		},
 	];
 
-	const getActiveKey = (): string => {
-		if (isAlertHistory || isAlertOverview) {
-			return AlertListTabs.ALERT_RULES;
-		}
-		if (isChannelDetails) {
-			return AlertListTabs.CHANNELS;
-		}
-		return tab || AlertListTabs.ALERT_RULES;
-	};
-
 	return (
 		<Tabs
 			destroyInactiveTabPane
 			items={items}
-			activeKey={getActiveKey()}
+			activeKey={tab || AlertListTabs.ALERT_RULES}
 			onChange={(tab): void => {
 				const queryParams = new URLSearchParams();
 
@@ -152,9 +120,7 @@ function AllAlertList(): JSX.Element {
 				safeNavigate(`/alerts?${queryParams.toString()}`);
 			}}
 			className={`alerts-container ${
-				isAlertHistory || isAlertOverview || isChannelDetails
-					? 'alert-details-tabs'
-					: ''
+				isAlertHistory || isAlertOverview ? 'alert-details-tabs' : ''
 			}`}
 			tabBarExtraContent={
 				<HeaderRightSection

frontend/src/pages/AlertList/types.ts

@@ -7,5 +7,4 @@ export enum AlertListTabs {
 	TRIGGERED_ALERTS = 'TriggeredAlerts',
 	ALERT_RULES = 'AlertRules',
 	CONFIGURATION = 'Configuration',
-	CHANNELS = 'Channels',
 }

frontend/src/pages/ChannelsEdit/index.tsx

@@ -4,9 +4,7 @@ import { useTranslation } from 'react-i18next';
 import { useQuery } from 'react-query';
 import { Typography } from '@signozhq/ui/typography';
 import get from 'api/channels/get';
-import AlertBreadcrumb from 'components/AlertBreadcrumb';
 import Spinner from 'components/Spinner';
-import ROUTES from 'constants/routes';
 import {
 	ChannelType,
 	MsTeamsChannel,
@@ -24,9 +22,9 @@ import './ChannelsEdit.styles.scss';
 function ChannelsEdit(): JSX.Element {
 	const { t } = useTranslation();
 
-	// Extract channelId from URL pathname
+	// Extract channelId from URL pathname since useParams doesn't work in nested routing
 	const { pathname } = window.location;
-	const channelIdMatch = pathname.match(/\/alerts\/channels\/edit\/([^/]+)/);
+	const channelIdMatch = pathname.match(/\/settings\/channels\/edit\/([^/]+)/);
 	const channelId = channelIdMatch ? channelIdMatch[1] : undefined;
 
 	const { isFetching, isError, data, error } = useQuery<
@@ -137,25 +135,17 @@ function ChannelsEdit(): JSX.Element {
 	const target = prepChannelConfig();
 
 	return (
-		<>
-			<AlertBreadcrumb
-				items={[
-					{ title: 'Channels', route: ROUTES.ALL_CHANNELS },
-					{ title: value.name || 'Edit Channel', isLast: true },
-				]}
+		<div className="edit-alert-channels-container">
+			<EditAlertChannels
+				{...{
+					initialValue: {
+						...target.channel,
+						type: target.type,
+						name: value.name,
+					},
+				}}
 			/>
-			<div className="edit-alert-channels-container">
-				<EditAlertChannels
-					{...{
-						initialValue: {
-							...target.channel,
-							type: target.type,
-							name: value.name,
-						},
-					}}
-				/>
-			</div>
-		</>
+		</div>
 	);
 }
 

frontend/src/pages/ChannelsNew/index.tsx

@@ -1,23 +0,0 @@
-import AlertBreadcrumb from 'components/AlertBreadcrumb';
-import ROUTES from 'constants/routes';
-import CreateAlertChannels from 'container/CreateAlertChannels';
-import { ChannelType } from 'container/CreateAlertChannels/config';
-import styles from './styles.module.scss';
-
-function ChannelsNew(): JSX.Element {
-	return (
-		<>
-			<AlertBreadcrumb
-				items={[
-					{ title: 'Channels', route: ROUTES.ALL_CHANNELS },
-					{ title: 'New Channel', isLast: true },
-				]}
-			/>
-			<div className={styles.content}>
-				<CreateAlertChannels preType={ChannelType.Slack} />
-			</div>
-		</>
-	);
-}
-
-export default ChannelsNew;

frontend/src/pages/ChannelsNew/styles.module.scss

@@ -1,4 +0,0 @@
-.content {
-	padding: var(--spacing-8);
-	padding-top: 0px;
-}

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

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

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

@@ -1,34 +1,24 @@
 import { useEffect, useMemo, useState } from 'react';
-import { Info } from '@signozhq/icons';
+import { SelectSimple } from '@signozhq/ui/select';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
-// eslint-disable-next-line signoz/no-antd-components -- fixed-option signal picker
+// eslint-disable-next-line signoz/no-antd-components -- searchable async select: no @signozhq/ui equivalent
 import { Select } from 'antd';
-import { CustomSelect } from 'components/NewSelect';
-import TextToolTip from 'components/TextToolTip';
 import { useGetFieldKeys } from 'hooks/dynamicVariables/useGetFieldKeys';
 import { useGetFieldValues } from 'hooks/dynamicVariables/useGetFieldValues';
 import useDebounce from 'hooks/useDebounce';
-import { isRetryableError } from 'utils/errorUtils';
 
-import {
-	DYNAMIC_SIGNAL_LABEL,
-	DYNAMIC_SIGNALS,
-	type DynamicSignalOption,
-	signalForApi,
-} from '../variableFormModel';
+import { TELEMETRY_SIGNALS, type TelemetrySignal } from '../variableModel';
 import styles from './VariableForm.module.scss';
 
 interface DynamicVariableFieldsProps {
 	attribute: string;
-	signal: DynamicSignalOption;
+	signal: TelemetrySignal;
 	onChange: (patch: {
 		dynamicAttribute?: string;
-		dynamicSignal?: DynamicSignalOption;
+		dynamicSignal?: TelemetrySignal;
 	}) => void;
 	onPreview: (values: (string | number)[]) => void;
-	/** Inline error shown under the attribute field (e.g. duplicate attribute). */
-	attributeError?: string;
 }
 
 /** Dynamic-variable body: telemetry signal + field, whose live values preview. */
@@ -37,24 +27,18 @@ function DynamicVariableFields({
 	signal,
 	onChange,
 	onPreview,
-	attributeError,
 }: DynamicVariableFieldsProps): JSX.Element {
 	const [search, setSearch] = useState('');
 	const debouncedSearch = useDebounce(search, 300);
-	const apiSignal = signalForApi(signal);
 
-	const {
-		data: keyData,
-		isLoading,
-		error,
-		refetch,
-	} = useGetFieldKeys({
-		signal: apiSignal,
+	const { data: keyData, isLoading } = useGetFieldKeys({
+		signal,
 		name: debouncedSearch || undefined,
 	});
 
 	// `keys` is a Record keyed BY field name; the field names are the map keys.
-	// CustomSelect filters the supplied options locally as the user types.
+	// When the API reports the list is `complete`, search filters locally.
+	const isComplete = keyData?.data?.complete === true;
 	const options = useMemo(
 		() =>
 			Object.keys(keyData?.data?.keys ?? {}).map((name) => ({
@@ -65,7 +49,7 @@ function DynamicVariableFields({
 	);
 
 	const { data: valueData } = useGetFieldValues({
-		signal: apiSignal,
+		signal,
 		name: attribute,
 		enabled: !!attribute,
 	});
@@ -78,60 +62,40 @@ function DynamicVariableFields({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [valueData]);
 
-	const errorMessage = error ? (error as Error).message || null : null;
-
 	return (
 		<>
 			<div className={cx(styles.row, styles.sortSection)}>
-				<div className={cx(styles.labelContainer, styles.sourceLabel)}>
+				<div className={styles.labelContainer}>
 					<Typography.Text className={styles.label}>Source</Typography.Text>
-					<TextToolTip
-						text="By default, this searches across logs, traces, and metrics, which can be slow. Selecting a single source improves performance. Many fields share the same values across different signals (for example, `k8s.pod.name` is identical in logs, traces and metrics) making one source enough. Only use `All telemetry` when you need fields that have different values in different signal types."
-						useFilledIcon={false}
-						outlinedIcon={<Info size={14} />}
-					/>
 				</div>
-				<Select
+				<SelectSimple
 					className={styles.sortSelect}
-					popupMatchSelectWidth={false}
 					value={signal}
-					options={DYNAMIC_SIGNALS.map((s) => ({
-						label: DYNAMIC_SIGNAL_LABEL[s],
-						value: s,
-					}))}
+					items={TELEMETRY_SIGNALS.map((s) => ({ label: s, value: s }))}
 					onChange={(value): void =>
-						onChange({ dynamicSignal: value as DynamicSignalOption })
+						onChange({ dynamicSignal: value as TelemetrySignal })
 					}
-					data-testid="variable-signal-select"
+					testId="variable-signal-select"
 				/>
 			</div>
 			<div className={cx(styles.row, styles.sortSection)}>
 				<div className={styles.labelContainer}>
 					<Typography.Text className={styles.label}>Attribute</Typography.Text>
 				</div>
-				<CustomSelect
+				<Select
 					className={styles.searchSelect}
 					showSearch
 					value={attribute || undefined}
 					placeholder="Select a telemetry field"
 					loading={isLoading}
-					options={options}
+					filterOption={isComplete}
 					onSearch={setSearch}
 					onChange={(value): void => onChange({ dynamicAttribute: value as string })}
-					noDataMessage="No fields found"
-					errorMessage={errorMessage}
-					onRetry={(): void => {
-						void refetch();
-					}}
-					showRetryButton={error ? isRetryableError(error) : true}
+					options={options}
+					notFoundContent={isLoading ? 'Loading…' : 'No fields found'}
 					data-testid="variable-field-select"
 				/>
 			</div>
-			{attributeError ? (
-				<Typography.Text className={styles.errorText}>
-					{attributeError}
-				</Typography.Text>
-			) : null}
 		</>
 	);
 }

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

@@ -1,139 +0,0 @@
-import { Badge } from '@signozhq/ui/badge';
-import { Switch } from '@signozhq/ui/switch';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-// eslint-disable-next-line signoz/no-antd-components -- fixed-option sort picker
-import { Select } from 'antd';
-import { CustomSelect } from 'components/NewSelect';
-
-import {
-	VARIABLE_SORT_LABEL,
-	VARIABLE_SORTS,
-	type VariableFormModel,
-	type VariableSort,
-} from '../variableFormModel';
-import styles from './VariableForm.module.scss';
-
-interface ListVariableFieldsProps {
-	model: VariableFormModel;
-	onChange: (patch: Partial<VariableFormModel>) => void;
-	previewValues: (string | number)[];
-	previewError: string | null;
-	defaultValue: string;
-	onDefaultValueChange: (value: string) => void;
-	/** Whether the "ALL values" toggle applies to this type (QUERY / CUSTOM). */
-	showAllOptionField: boolean;
-}
-
-/**
- * Rows shared by the list-style variables (Query / Custom / Dynamic): the value
- * preview, sort, multi-select / ALL toggles and the default-value picker.
- */
-function ListVariableFields({
-	model,
-	onChange,
-	previewValues,
-	previewError,
-	defaultValue,
-	onDefaultValueChange,
-	showAllOptionField,
-}: ListVariableFieldsProps): JSX.Element {
-	return (
-		<>
-			<div className={cx(styles.row, styles.previewSection)}>
-				<Typography.Text className={styles.previewLabel}>
-					Preview of Values
-				</Typography.Text>
-				<div className={styles.previewValues}>
-					{previewError ? (
-						<Typography.Text className={styles.previewError}>
-							{previewError}
-						</Typography.Text>
-					) : (
-						previewValues.map((value, idx) => (
-							<Badge
-								// eslint-disable-next-line react/no-array-index-key -- preview values are display-only and may contain duplicates
-								key={`${value}-${idx}`}
-								color="vanilla"
-							>
-								{value.toString()}
-							</Badge>
-						))
-					)}
-				</div>
-			</div>
-
-			<div className={cx(styles.row, styles.sortSection)}>
-				<div className={styles.labelContainer}>
-					<Typography.Text className={styles.label}>Sort Values</Typography.Text>
-				</div>
-				<Select
-					className={styles.sortSelect}
-					popupMatchSelectWidth={false}
-					value={model.sort}
-					options={VARIABLE_SORTS.map((sort) => ({
-						label: VARIABLE_SORT_LABEL[sort],
-						value: sort,
-					}))}
-					onChange={(value): void => onChange({ sort: value as VariableSort })}
-					data-testid="variable-sort-select"
-				/>
-			</div>
-
-			<div className={cx(styles.row, styles.multiSection)}>
-				<Typography.Text className={styles.rowLabel}>
-					Enable multiple values to be checked
-				</Typography.Text>
-				<Switch
-					value={model.multiSelect}
-					onChange={(checked): void =>
-						onChange({
-							multiSelect: checked,
-							showAllOption: checked ? model.showAllOption : false,
-						})
-					}
-					testId="variable-multi-switch"
-				/>
-			</div>
-
-			{model.multiSelect && showAllOptionField ? (
-				<div className={cx(styles.row, styles.allOptionSection)}>
-					<Typography.Text className={styles.rowLabel}>
-						Include an option for ALL values
-					</Typography.Text>
-					<Switch
-						value={model.showAllOption}
-						onChange={(checked): void => onChange({ showAllOption: checked })}
-						testId="variable-all-switch"
-					/>
-				</div>
-			) : null}
-
-			<div className={cx(styles.row, styles.defaultValueSection)}>
-				<div className={styles.labelContainer}>
-					<Typography.Text className={styles.label}>Default Value</Typography.Text>
-					<Typography.Text className={styles.defaultValueDesc}>
-						{model.type === 'QUERY'
-							? 'Click Test Run Query to see the values or add custom value'
-							: 'Select a value from the preview values or add custom value'}
-					</Typography.Text>
-				</div>
-				<CustomSelect
-					className={styles.searchSelect}
-					showSearch
-					allowClear
-					placeholder="Select a default value"
-					value={defaultValue || undefined}
-					onChange={(value): void => onDefaultValueChange((value as string) ?? '')}
-					options={previewValues.map((value) => ({
-						label: value.toString(),
-						value: value.toString(),
-					}))}
-					data-testid="variable-default-select"
-				/>
-			</div>
-		</>
-	);
-}
-
-export default ListVariableFields;

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

@@ -3,14 +3,14 @@ import { Button } from '@signozhq/ui/button';
 import { Typography } from '@signozhq/ui/typography';
 import dashboardVariablesQuery from 'api/dashboard/variables/dashboardVariablesQuery';
 import Editor from 'components/Editor';
-import type { PayloadVariables } from 'types/api/dashboard/variables/query';
+import sortValues from 'lib/dashboardVariables/sortVariableValues';
 
+import type { VariableSort } from '../variableModel';
 import styles from './VariableForm.module.scss';
 
 interface QueryVariableFieldsProps {
 	queryValue: string;
-	/** Sibling variable selections, so dependent `$vars` in the query resolve. */
-	variables: PayloadVariables;
+	sort: VariableSort;
 	onChange: (queryValue: string) => void;
 	onPreview: (values: (string | number)[]) => void;
 	onError: (message: string | null) => void;
@@ -19,7 +19,7 @@ interface QueryVariableFieldsProps {
 /** Query-variable body: SQL editor + "Test Run Query" that previews the values. */
 function QueryVariableFields({
 	queryValue,
-	variables,
+	sort,
 	onChange,
 	onPreview,
 	onError,
@@ -30,21 +30,20 @@ function QueryVariableFields({
 		setIsRunning(true);
 		onError(null);
 		try {
-			const res = await dashboardVariablesQuery({ query: queryValue, variables });
+			const res = await dashboardVariablesQuery({
+				query: queryValue,
+				variables: {},
+			});
 			if (res.statusCode === 200 && res.payload) {
-				onPreview(res.payload.variableValues ?? []);
+				onPreview(
+					sortValues(res.payload.variableValues ?? [], sort) as (string | number)[],
+				);
 			} else {
 				onError(res.error || 'Failed to run query');
 				onPreview([]);
 			}
 		} catch (err) {
-			// `dashboardVariablesQuery` throws `{ message, details: { error } }`.
-			const detail = (err as { details?: { error?: string } }).details?.error;
-			const message =
-				detail && detail.includes('Syntax error:')
-					? 'Please make sure query is valid and dependent variables are selected'
-					: detail || (err as Error).message || 'Failed to run query';
-			onError(message);
+			onError((err as Error).message || 'Failed to run query');
 			onPreview([]);
 		} finally {
 			setIsRunning(false);

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/VariableForm.module.scss

@@ -5,8 +5,22 @@
 .container {
 	display: flex;
 	flex-direction: column;
+	border: 1px solid var(--l1-border);
 	border-radius: 3px;
-	border: 1px solid var(--l2-border);
+}
+
+.allVariables {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	padding: 10px 16px;
+	border-bottom: 1px solid var(--l1-border);
+}
+
+.allVariablesBtn {
+	--button-height: 24px;
+	--button-padding: 0;
+	color: var(--muted-foreground);
 }
 
 .content {
@@ -28,12 +42,6 @@
 	width: 200px;
 }
 
-.sourceLabel {
-	display: flex;
-	align-items: center;
-	gap: 6px;
-}
-
 .label {
 	color: var(--l2-foreground);
 	font-family: Inter;
@@ -51,7 +59,7 @@
 .textarea,
 .defaultInput {
 	padding: 6px 6px 6px 8px;
-	border: 1px solid var(--l2-border);
+	border: 1px solid var(--l1-border);
 	border-radius: 2px;
 	background: var(--l3-background);
 }
@@ -70,89 +78,48 @@
 	color: var(--bg-amber-500);
 }
 
-/* Variable type — Tabs root composing the picker row + per-type body panels. */
+/* Variable type segmented group */
 .typeSection {
-	display: flex;
-	flex-direction: column;
-	gap: 20px;
-	margin-top: 40px;
-	margin-bottom: 0;
-}
-
-/* Picker row (label left, tabs right); the bottom divider separates type from
-   config. Single line — the tab row scrolls (never wraps) when narrow. */
-.typePicker {
-	display: flex;
 	align-items: center;
 	justify-content: space-between;
-	gap: 16px;
-	padding-bottom: 12px;
-	border-bottom: 1px solid var(--l2-border);
-
-	@media (max-width: 1440px) {
-		flex-wrap: wrap;
-	}
-}
-
-/* Active tab panel — reset the Tabs default padding; body rows handle spacing. */
-.typePanel {
-	padding: 0 !important;
-}
-
-.typeContent {
-	display: flex;
-	flex-direction: column;
-	gap: 20px;
 }
 
 .typeLabelContainer {
 	display: flex;
 	align-items: center;
 	gap: 8px;
-	white-space: nowrap;
+	width: auto;
 }
 
-/* Horizontal scroll so the tab row never wraps to a second line. The scrollbar
-   is hidden — the row stays a single crisp line and scrolls only when narrow. */
-.typeTabsScroll {
-	justify-self: flex-end;
-	--tab-list-wrapper-secondary-padding-left: 0;
-}
-
-/* Connected segmented control, mirroring Overview's SegmentedControl: no outer
-   padding, segments divided by 1px borders, active segment filled + bold. */
-.typeTabs {
-	display: inline-flex;
-	flex-wrap: nowrap;
-	width: max-content;
-	gap: 0;
-	padding: 0;
-	border: 1px solid var(--l2-border);
-	border-radius: 2px;
-	background: transparent;
-}
-
-.typeTab {
-	display: inline-flex;
+.typeBtnGroup {
+	display: grid;
+	grid-template-columns: repeat(4, max-content);
+	height: 32px;
 	flex-shrink: 0;
+	border: 1px solid var(--l1-border);
+	border-radius: 2px;
+	background: var(--l2-background);
+	box-shadow: 0 0 8px 0 rgba(0, 0, 0, 0.1);
+}
+
+.typeBtn {
+	--button-height: 32px;
+	display: flex;
 	align-items: center;
-	gap: 6px;
-	min-height: 24px;
-	padding: 6px 14px;
-	white-space: nowrap;
+	justify-content: center;
+	gap: 4px;
+	min-width: 114px;
 	border-radius: 0;
 	color: var(--l2-foreground);
 
-	&:not(:last-child) {
-		border-right: 1px solid var(--l2-border);
+	& + & {
+		border-left: 1px solid var(--l1-border);
 	}
+}
 
-	&[data-state='active'] {
-		color: var(--l1-foreground);
-		font-weight: 500;
-		// override the Tabs component's default (transparent) active background.
-		background: var(--l3-background) !important;
-	}
+.typeBtnSelected {
+	background: var(--l1-border);
+	color: var(--l1-foreground);
 }
 
 .betaTag {
@@ -171,7 +138,7 @@
 .editorWrap {
 	height: 240px;
 	overflow: hidden;
-	border: 1px solid var(--l2-border);
+	border: 1px solid var(--l1-border);
 	border-radius: 2px;
 }
 
@@ -187,7 +154,7 @@
 
 .customSection :global(.custom-collapse) {
 	width: 100%;
-	border: 1px solid var(--l2-border);
+	border: 1px solid var(--l1-border);
 	border-radius: 3px 3px 0 0;
 
 	:global(.ant-collapse-item) {
@@ -241,7 +208,7 @@
 	min-height: 88px;
 	margin-bottom: 0;
 	padding-bottom: 8px;
-	border: 1px solid var(--l2-border);
+	border: 1px solid var(--l1-border);
 	border-radius: 3px;
 }
 
@@ -304,9 +271,13 @@
 	letter-spacing: -0.07px;
 }
 
+.sortSelect {
+	width: 192px;
+}
+
 .defaultValueSection {
-	display: flex;
-	justify-content: space-between;
+	display: grid;
+	grid-template-columns: max-content 1fr;
 	gap: 1rem;
 	align-items: center;
 	margin-bottom: 0;
@@ -326,21 +297,14 @@
 	letter-spacing: -0.06px;
 }
 
-/* All variable selects (Source / Attribute / Sort / Default Value) share width
-   and a consistent --l2-border outline. */
-.sortSelect,
 .searchSelect {
-	width: 240px;
-	flex-shrink: 0;
-
-	:global(.ant-select-selector) {
-		border-color: var(--l2-border) !important;
-	}
+	width: 100%;
 }
 
-.actionButtons {
-	width: 100%;
+/* Footer */
+.footer {
 	display: flex;
 	justify-content: flex-end;
 	gap: 1rem;
+	margin-top: 12px;
 }

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

@@ -1,199 +1,350 @@
-import { Check, X } from '@signozhq/icons';
+import { useEffect, useState } from 'react';
+import { ArrowLeft, Check, X } from '@signozhq/icons';
+import { Badge } from '@signozhq/ui/badge';
 import { Button } from '@signozhq/ui/button';
 import { Input } from '@signozhq/ui/input';
-import { TabsContent, TabsRoot } from '@signozhq/ui/tabs';
+import { SelectSimple } from '@signozhq/ui/select';
+import { Switch } from '@signozhq/ui/switch';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
-// eslint-disable-next-line signoz/no-antd-components -- TextArea/Collapse: no @signozhq/ui equivalent
-import { Collapse, Input as AntdInput } from 'antd';
+// eslint-disable-next-line signoz/no-antd-components -- TextArea/Collapse/searchable Select: no @signozhq/ui equivalent
+import { Collapse, Input as AntdInput, Select } from 'antd';
+import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
+import sortValues from 'lib/dashboardVariables/sortVariableValues';
 
-import type { VariableType } from '../variableFormModel';
+import {
+	VARIABLE_SORTS,
+	type VariableFormModel,
+	type VariableSort,
+	type VariableType,
+} from '../variableModel';
 import DynamicVariableFields from './DynamicVariableFields';
-import ListVariableFields from './ListVariableFields';
 import QueryVariableFields from './QueryVariableFields';
-import { useVariableForm } from './useVariableForm';
-import VariableTypeTabs from './VariableTypeTabs';
+import VariableTypeSelector from './VariableTypeSelector';
 import styles from './VariableForm.module.scss';
-import BackToAllVariables from '../components/BackToAllVariables/BackToAllVariables';
-import { VariableFormProps } from '../types';
-import VariableInfoForm from '../components/VariableInfoForm/VariableInfoForm';
+
+const SORT_LABEL: Record<VariableSort, string> = {
+	DISABLED: 'Disabled',
+	ASC: 'Ascending',
+	DESC: 'Descending',
+};
+
+function getNameError(name: string, existingNames: string[]): string | null {
+	if (name === '') {
+		return 'Variable name is required';
+	}
+	if (/\s/.test(name)) {
+		return 'Variable name cannot contain whitespaces';
+	}
+	if (existingNames.includes(name)) {
+		return 'Variable name already exists';
+	}
+	return null;
+}
+
+interface VariableFormProps {
+	initial: VariableFormModel;
+	/** Names of the other variables, for uniqueness validation. */
+	existingNames: string[];
+	isSaving: boolean;
+	onClose: () => void;
+	onSave: (model: VariableFormModel) => void;
+}
 
 /**
  * In-drawer variable editor reproducing the V1 VariableItem layout, built on
  * @signozhq components (antd kept only for the monaco editor, TextArea, Collapse
- * and searchable selects). Master→detail: renders in place of the list. Form
- * state/handlers live in {@link useVariableForm}; the shared list-type rows in
- * {@link ListVariableFields}.
+ * and searchable selects). Master→detail: renders in place of the list.
  */
 function VariableForm({
 	initial,
-	siblings,
-	isNew,
+	existingNames,
 	isSaving,
 	onClose,
 	onSave,
 }: VariableFormProps): JSX.Element {
-	const {
-		model,
-		set,
-		onNameChange,
-		selectType,
-		onCustomChange,
-		onDynamicChange,
-		setRawPreview,
-		previewValues,
-		previewError,
-		setPreviewError,
-		defaultValue,
-		setDefaultValue,
-		visibleNameError,
-		nameError,
-		attributeError,
-		cycleError,
-		isListType,
-		showAllOptionField,
-		payloadVariables,
-		handleSave,
-	} = useVariableForm({ initial, siblings, isNew, onSave });
+	const [model, setModel] = useState<VariableFormModel>(initial);
+	const [previewValues, setPreviewValues] = useState<(string | number)[]>([]);
+	const [previewError, setPreviewError] = useState<string | null>(null);
+	const [defaultValue, setDefaultValue] = useState<string>(
+		((initial.defaultValue as { value?: string })?.value ?? '') as string,
+	);
 
-	// Shared list rows (preview/sort/multi/default) for the list-type variables;
-	// rendered as a sibling inside each list-type panel. Only the active panel
-	// mounts (Tabs unmounts the rest), so reusing one element is safe.
-	const listFields = isListType ? (
-		<ListVariableFields
-			model={model}
-			onChange={set}
-			previewValues={previewValues}
-			previewError={previewError}
-			defaultValue={defaultValue}
-			onDefaultValueChange={setDefaultValue}
-			showAllOptionField={showAllOptionField}
-		/>
-	) : null;
+	useEffect(() => {
+		setModel(initial);
+		setPreviewValues([]);
+		setPreviewError(null);
+		setDefaultValue(
+			((initial.defaultValue as { value?: string })?.value ?? '') as string,
+		);
+	}, [initial]);
+
+	const set = (patch: Partial<VariableFormModel>): void =>
+		setModel((prev) => ({ ...prev, ...patch }));
+
+	const selectType = (type: VariableType): void => {
+		set({ type });
+		setPreviewValues([]);
+		setPreviewError(null);
+	};
+
+	const onCustomChange = (value: string): void => {
+		set({ customValue: value });
+		setPreviewValues(
+			sortValues(commaValuesParser(value), model.sort) as (string | number)[],
+		);
+	};
+
+	const trimmedName = model.name.trim();
+	const nameError = getNameError(trimmedName, existingNames);
+
+	const isListType =
+		model.type === 'QUERY' || model.type === 'CUSTOM' || model.type === 'DYNAMIC';
+	const showAllOptionField = model.type === 'QUERY' || model.type === 'CUSTOM';
+
+	const handleSave = (): void => {
+		onSave({
+			...model,
+			name: trimmedName,
+			defaultValue: defaultValue ? { value: defaultValue } : undefined,
+		});
+	};
 
 	return (
-		<div className={styles.container}>
-			<BackToAllVariables onClose={onClose} />
+		<>
+			<div className={styles.container}>
+				<div className={styles.allVariables}>
+					<Button
+						variant="ghost"
+						color="secondary"
+						className={styles.allVariablesBtn}
+						prefix={<ArrowLeft size={14} />}
+						onClick={onClose}
+						testId="variable-form-back"
+					>
+						All variables
+					</Button>
+				</div>
 
-			<div className={styles.content}>
-				<VariableInfoForm
-					title={model.name}
-					description={model.description}
-					onTitleChange={onNameChange}
-					onDescriptionChange={(value): void => set({ description: value })}
-					visibleNameError={visibleNameError}
-				/>
+				<div className={styles.content}>
+					{/* Name */}
+					<div className={cx(styles.row, styles.column)}>
+						<Typography.Text className={styles.label}>Name</Typography.Text>
+						<Input
+							className={styles.input}
+							value={model.name}
+							placeholder="Unique name of the variable"
+							onChange={(e): void => set({ name: e.target.value })}
+							testId="variable-name-input"
+						/>
+						{nameError ? (
+							<Typography.Text className={styles.errorText}>
+								{nameError}
+							</Typography.Text>
+						) : null}
+					</div>
 
-				<TabsRoot
-					className={styles.typeSection}
-					value={model.type}
-					onValueChange={(next): void => selectType(next as VariableType)}
-				>
-					<VariableTypeTabs />
+					{/* Description */}
+					<div className={cx(styles.row, styles.column)}>
+						<Typography.Text className={styles.label}>Description</Typography.Text>
+						<AntdInput.TextArea
+							className={styles.textarea}
+							value={model.description}
+							placeholder="Enter a description for the variable"
+							rows={3}
+							onChange={(e): void => set({ description: e.target.value })}
+							data-testid="variable-description-input"
+						/>
+					</div>
 
-					<TabsContent value="DYNAMIC" className={styles.typePanel}>
-						<div className={styles.typeContent}>
-							<DynamicVariableFields
-								attribute={model.dynamicAttribute}
-								signal={model.dynamicSignal}
-								onChange={onDynamicChange}
-								onPreview={setRawPreview}
-								attributeError={attributeError}
+					{/* Variable Type */}
+					<VariableTypeSelector value={model.type} onChange={selectType} />
+
+					{/* Type-specific body */}
+					{model.type === 'DYNAMIC' ? (
+						<DynamicVariableFields
+							attribute={model.dynamicAttribute}
+							signal={model.dynamicSignal}
+							onChange={(patch): void => set(patch)}
+							onPreview={setPreviewValues}
+						/>
+					) : null}
+
+					{model.type === 'QUERY' ? (
+						<QueryVariableFields
+							queryValue={model.queryValue}
+							sort={model.sort}
+							onChange={(queryValue): void => set({ queryValue })}
+							onPreview={setPreviewValues}
+							onError={setPreviewError}
+						/>
+					) : null}
+
+					{model.type === 'CUSTOM' ? (
+						<div className={cx(styles.row, styles.customSection)}>
+							<Collapse
+								collapsible="header"
+								rootClassName="custom-collapse"
+								defaultActiveKey={['1']}
+								items={[
+									{
+										key: '1',
+										label: 'Options',
+										children: (
+											<AntdInput.TextArea
+												value={model.customValue}
+												placeholder="Enter options separated by commas."
+												rootClassName="comma-input"
+												onChange={(e): void => onCustomChange(e.target.value)}
+												data-testid="variable-custom-input"
+											/>
+										),
+									},
+								]}
 							/>
-							{listFields}
 						</div>
-					</TabsContent>
+					) : null}
 
-					<TabsContent value="QUERY" className={styles.typePanel}>
-						<div className={styles.typeContent}>
-							<QueryVariableFields
-								queryValue={model.queryValue}
-								variables={payloadVariables}
-								onChange={(queryValue): void => set({ queryValue })}
-								onPreview={setRawPreview}
-								onError={setPreviewError}
+					{model.type === 'TEXT' ? (
+						<div className={cx(styles.row, styles.textboxSection)}>
+							<div className={styles.labelContainer}>
+								<Typography.Text className={styles.label}>
+									Default Value
+								</Typography.Text>
+							</div>
+							<Input
+								className={styles.defaultInput}
+								value={model.textValue}
+								placeholder="Enter a default value (if any)..."
+								onChange={(e): void => set({ textValue: e.target.value })}
+								testId="variable-text-input"
 							/>
-							{listFields}
 						</div>
-					</TabsContent>
+					) : null}
 
-					<TabsContent value="CUSTOM" className={styles.typePanel}>
-						<div className={styles.typeContent}>
-							<div className={cx(styles.row, styles.customSection)}>
-								<Collapse
-									collapsible="header"
-									rootClassName="custom-collapse"
-									defaultActiveKey={['1']}
-									items={[
-										{
-											key: '1',
-											label: 'Options',
-											children: (
-												<AntdInput.TextArea
-													value={model.customValue}
-													placeholder="Enter options separated by commas."
-													rootClassName="comma-input"
-													onChange={(e): void => onCustomChange(e.target.value)}
-													data-testid="variable-custom-input"
-												/>
-											),
-										},
-									]}
+					{/* Shared rows for list-type variables */}
+					{isListType ? (
+						<>
+							<div className={cx(styles.row, styles.previewSection)}>
+								<Typography.Text className={styles.previewLabel}>
+									Preview of Values
+								</Typography.Text>
+								<div className={styles.previewValues}>
+									{previewError ? (
+										<Typography.Text className={styles.previewError}>
+											{previewError}
+										</Typography.Text>
+									) : (
+										previewValues.map((value, idx) => (
+											<Badge
+												// eslint-disable-next-line react/no-array-index-key -- preview values are display-only and may contain duplicates
+												key={`${value}-${idx}`}
+												color="vanilla"
+											>
+												{value.toString()}
+											</Badge>
+										))
+									)}
+								</div>
+							</div>
+
+							<div className={cx(styles.row, styles.sortSection)}>
+								<div className={styles.labelContainer}>
+									<Typography.Text className={styles.label}>Sort Values</Typography.Text>
+								</div>
+								<SelectSimple
+									className={styles.sortSelect}
+									value={model.sort}
+									items={VARIABLE_SORTS.map((sort) => ({
+										label: SORT_LABEL[sort],
+										value: sort,
+									}))}
+									onChange={(value): void => set({ sort: value as VariableSort })}
+									testId="variable-sort-select"
 								/>
 							</div>
-							{listFields}
-						</div>
-					</TabsContent>
 
-					<TabsContent value="TEXT" className={styles.typePanel}>
-						<div className={styles.typeContent}>
-							<div className={cx(styles.row, styles.textboxSection)}>
+							<div className={cx(styles.row, styles.multiSection)}>
+								<Typography.Text className={styles.rowLabel}>
+									Enable multiple values to be checked
+								</Typography.Text>
+								<Switch
+									value={model.multiSelect}
+									onChange={(checked): void => {
+										set({
+											multiSelect: checked,
+											showAllOption: checked ? model.showAllOption : false,
+										});
+									}}
+									testId="variable-multi-switch"
+								/>
+							</div>
+
+							{model.multiSelect && showAllOptionField ? (
+								<div className={cx(styles.row, styles.allOptionSection)}>
+									<Typography.Text className={styles.rowLabel}>
+										Include an option for ALL values
+									</Typography.Text>
+									<Switch
+										value={model.showAllOption}
+										onChange={(checked): void => set({ showAllOption: checked })}
+										testId="variable-all-switch"
+									/>
+								</div>
+							) : null}
+
+							<div className={cx(styles.row, styles.defaultValueSection)}>
 								<div className={styles.labelContainer}>
 									<Typography.Text className={styles.label}>
 										Default Value
 									</Typography.Text>
+									<Typography.Text className={styles.defaultValueDesc}>
+										{model.type === 'QUERY'
+											? 'Click Test Run Query to see the values or add custom value'
+											: 'Select a value from the preview values or add custom value'}
+									</Typography.Text>
 								</div>
-								<Input
-									className={styles.defaultInput}
-									value={model.textValue}
-									placeholder="Enter a default value (if any)..."
-									onChange={(e): void => set({ textValue: e.target.value })}
-									testId="variable-text-input"
+								<Select
+									className={styles.searchSelect}
+									showSearch
+									allowClear
+									placeholder="Select a default value"
+									value={defaultValue || undefined}
+									onChange={(value): void => setDefaultValue(value ?? '')}
+									options={previewValues.map((value) => ({
+										label: value.toString(),
+										value: value.toString(),
+									}))}
+									data-testid="variable-default-select"
 								/>
 							</div>
-						</div>
-					</TabsContent>
-				</TabsRoot>
-
-				{cycleError ? (
-					<Typography.Text className={styles.errorText}>
-						{cycleError}
-					</Typography.Text>
-				) : null}
-
-				<div className={styles.actionButtons}>
-					<Button
-						variant="outlined"
-						color="secondary"
-						prefix={<X size={14} />}
-						onClick={onClose}
-					>
-						Discard
-					</Button>
-					<Button
-						variant="solid"
-						color="primary"
-						prefix={<Check size={14} />}
-						disabled={!!nameError || !!attributeError}
-						loading={isSaving}
-						onClick={handleSave}
-						testId="variable-save"
-					>
-						Save Variable
-					</Button>
+						</>
+					) : null}
 				</div>
 			</div>
-		</div>
+
+			<div className={styles.footer}>
+				<Button
+					variant="solid"
+					color="secondary"
+					prefix={<X size={14} />}
+					onClick={onClose}
+				>
+					Discard
+				</Button>
+				<Button
+					variant="solid"
+					color="primary"
+					prefix={<Check size={14} />}
+					disabled={!!nameError}
+					loading={isSaving}
+					onClick={handleSave}
+					testId="variable-save"
+				>
+					Save Variable
+				</Button>
+			</div>
+		</>
 	);
 }
 

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

@@ -0,0 +1,99 @@
+import {
+	ClipboardType,
+	DatabaseZap,
+	Info,
+	LayoutList,
+	Pyramid,
+} from '@signozhq/icons';
+import { Badge } from '@signozhq/ui/badge';
+import { Button } from '@signozhq/ui/button';
+import { Typography } from '@signozhq/ui/typography';
+import cx from 'classnames';
+import TextToolTip from 'components/TextToolTip';
+
+import type { VariableType } from '../variableModel';
+import styles from './VariableForm.module.scss';
+
+interface VariableTypeSelectorProps {
+	value: VariableType;
+	onChange: (type: VariableType) => void;
+}
+
+/** The segmented Dynamic / Textbox / Custom / Query type picker. */
+function VariableTypeSelector({
+	value,
+	onChange,
+}: VariableTypeSelectorProps): JSX.Element {
+	return (
+		<div className={cx(styles.row, styles.typeSection)}>
+			<div className={styles.typeLabelContainer}>
+				<Typography.Text className={styles.label}>Variable Type</Typography.Text>
+				<TextToolTip
+					text="Learn more about supported variable types"
+					url="https://signoz.io/docs/userguide/manage-variables/#supported-variable-types"
+					urlText="here"
+					useFilledIcon={false}
+					outlinedIcon={<Info size={14} />}
+				/>
+			</div>
+			<div className={styles.typeBtnGroup}>
+				<Button
+					variant="ghost"
+					color="secondary"
+					prefix={<Pyramid size={14} />}
+					className={cx(styles.typeBtn, {
+						[styles.typeBtnSelected]: value === 'DYNAMIC',
+					})}
+					onClick={(): void => onChange('DYNAMIC')}
+					testId="variable-type-dynamic"
+				>
+					Dynamic
+					<Badge color="robin" className={styles.betaTag}>
+						Beta
+					</Badge>
+				</Button>
+				<Button
+					variant="ghost"
+					color="secondary"
+					prefix={<ClipboardType size={14} />}
+					className={cx(styles.typeBtn, {
+						[styles.typeBtnSelected]: value === 'TEXT',
+					})}
+					onClick={(): void => onChange('TEXT')}
+					testId="variable-type-textbox"
+				>
+					Textbox
+				</Button>
+				<Button
+					variant="ghost"
+					color="secondary"
+					prefix={<LayoutList size={14} />}
+					className={cx(styles.typeBtn, {
+						[styles.typeBtnSelected]: value === 'CUSTOM',
+					})}
+					onClick={(): void => onChange('CUSTOM')}
+					testId="variable-type-custom"
+				>
+					Custom
+				</Button>
+				<Button
+					variant="ghost"
+					color="secondary"
+					prefix={<DatabaseZap size={14} />}
+					className={cx(styles.typeBtn, {
+						[styles.typeBtnSelected]: value === 'QUERY',
+					})}
+					onClick={(): void => onChange('QUERY')}
+					testId="variable-type-query"
+				>
+					Query
+					<Badge color="amber" className={styles.betaTag}>
+						Not Recommended
+					</Badge>
+				</Button>
+			</div>
+		</div>
+	);
+}
+
+export default VariableTypeSelector;

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

@@ -1,93 +0,0 @@
-import {
-	ClipboardType,
-	DatabaseZap,
-	Info,
-	LayoutList,
-	Pyramid,
-} from '@signozhq/icons';
-import { Badge } from '@signozhq/ui/badge';
-import { TabsList, TabsTrigger } from '@signozhq/ui/tabs';
-import { Typography } from '@signozhq/ui/typography';
-import TextToolTip from 'components/TextToolTip';
-
-import styles from './VariableForm.module.scss';
-
-/**
- * Presentational trigger row for the variable-type tabs (label + segmented
- * triggers). Must render inside a `TabsRoot`, which owns the active state and
- * change handling; the matching `TabsContent` panels are siblings in the root.
- */
-function VariableTypeTabs(): JSX.Element {
-	return (
-		<div className={styles.typePicker}>
-			<div className={styles.typeLabelContainer}>
-				<Typography.Text className={styles.label}>Variable Type</Typography.Text>
-				<TextToolTip
-					text="Learn more about supported variable types"
-					url="https://signoz.io/docs/userguide/manage-variables/#supported-variable-types"
-					urlText="here"
-					useFilledIcon={false}
-					outlinedIcon={<Info size={14} />}
-				/>
-			</div>
-
-			<div className={styles.typeTabsScroll}>
-				<TabsList variant="secondary" className={styles.typeTabs}>
-					<TabsTrigger
-						value="DYNAMIC"
-						className={styles.typeTab}
-						testId="variable-type-dynamic"
-					>
-						<Pyramid size={14} />
-						Dynamic
-						<Badge color="robin" className={styles.betaTag}>
-							Beta
-						</Badge>
-					</TabsTrigger>
-					<TabsTrigger
-						value="TEXT"
-						className={styles.typeTab}
-						testId="variable-type-textbox"
-					>
-						<ClipboardType size={14} />
-						Textbox
-					</TabsTrigger>
-					<TabsTrigger
-						value="CUSTOM"
-						className={styles.typeTab}
-						testId="variable-type-custom"
-					>
-						<LayoutList size={14} />
-						Custom
-					</TabsTrigger>
-					<TabsTrigger
-						value="QUERY"
-						className={styles.typeTab}
-						testId="variable-type-query"
-					>
-						<DatabaseZap size={14} />
-						Query
-						<Badge color="amber" className={styles.betaTag}>
-							Not Recommended
-						</Badge>
-						<span
-							className={styles.betaTag}
-							onClick={(e): void => e.stopPropagation()}
-							role="presentation"
-						>
-							<TextToolTip
-								text="Learn why we don't recommend"
-								url="https://signoz.io/docs/userguide/manage-variables/#why-avoid-clickhouse-query-variables"
-								urlText="here"
-								useFilledIcon={false}
-								outlinedIcon={<Info size={14} />}
-							/>
-						</span>
-					</TabsTrigger>
-				</TabsList>
-			</div>
-		</div>
-	);
-}
-
-export default VariableTypeTabs;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/useVariableForm.ts

@@ -1,191 +0,0 @@
-import { useEffect, useMemo, useState } from 'react';
-import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
-import type { PayloadVariables } from 'types/api/dashboard/variables/query';
-
-import type { VariableSelectionMap } from '../../../VariablesBar/selectionTypes';
-import { useDashboardStore } from '../../../store/useDashboardStore';
-import { detectVariableCycle } from '../variableDependencies';
-import {
-	sortValuesByOrder,
-	type VariableFormModel,
-	type VariableType,
-} from '../variableFormModel';
-import { getAttributeError, getNameError } from './variableValidation';
-
-// Stable reference so the zustand selector never returns a fresh object (which
-// would make useSyncExternalStore loop) when this dashboard has no selections.
-const EMPTY_SELECTIONS: VariableSelectionMap = {};
-
-interface UseVariableFormArgs {
-	initial: VariableFormModel;
-	siblings: VariableFormModel[];
-	isNew: boolean;
-	onSave: (model: VariableFormModel) => void;
-}
-
-export interface UseVariableForm {
-	model: VariableFormModel;
-	set: (patch: Partial<VariableFormModel>) => void;
-	onNameChange: (value: string) => void;
-	selectType: (type: VariableType) => void;
-	onCustomChange: (value: string) => void;
-	onDynamicChange: (patch: Partial<VariableFormModel>) => void;
-	setRawPreview: (values: (string | number)[]) => void;
-	previewValues: (string | number)[];
-	previewError: string | null;
-	setPreviewError: (message: string | null) => void;
-	defaultValue: string;
-	setDefaultValue: (value: string) => void;
-	visibleNameError: string | null;
-	nameError: string | null;
-	attributeError: string | undefined;
-	cycleError: string | null;
-	isListType: boolean;
-	showAllOptionField: boolean;
-	payloadVariables: PayloadVariables;
-	handleSave: () => void;
-}
-
-const readDefaultValue = (model: VariableFormModel): string =>
-	((model.defaultValue as { value?: string })?.value ?? '') as string;
-
-/** Form state, derivations and handlers for the variable editor. */
-export function useVariableForm({
-	initial,
-	siblings,
-	isNew,
-	onSave,
-}: UseVariableFormArgs): UseVariableForm {
-	const [model, setModel] = useState<VariableFormModel>(initial);
-	// Raw, unsorted preview; `previewValues` applies the chosen sort so a shown
-	// preview re-sorts when Sort changes.
-	const [rawPreview, setRawPreview] = useState<(string | number)[]>([]);
-	const [previewError, setPreviewError] = useState<string | null>(null);
-	const [cycleError, setCycleError] = useState<string | null>(null);
-	// In add mode, mirror the chosen attribute into the name until the user types.
-	const [nameTouched, setNameTouched] = useState(false);
-	const [defaultValue, setDefaultValue] = useState<string>(
-		readDefaultValue(initial),
-	);
-
-	useEffect(() => {
-		setModel(initial);
-		setRawPreview([]);
-		setPreviewError(null);
-		setCycleError(null);
-		setNameTouched(false);
-		setDefaultValue(readDefaultValue(initial));
-	}, [initial]);
-
-	const set = (patch: Partial<VariableFormModel>): void =>
-		setModel((prev) => ({ ...prev, ...patch }));
-
-	const previewValues = useMemo(
-		() => sortValuesByOrder(rawPreview, model.sort) as (string | number)[],
-		[rawPreview, model.sort],
-	);
-
-	const existingNames = useMemo(() => siblings.map((v) => v.name), [siblings]);
-
-	const existingDynamicAttributes = useMemo(
-		() =>
-			siblings
-				.filter((v) => v.type === 'DYNAMIC' && v.dynamicAttribute)
-				.map((v) => v.dynamicAttribute),
-		[siblings],
-	);
-
-	// Sibling selections feed the Query "Test Run" so dependent `$vars` resolve.
-	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const selections = useDashboardStore(
-		(s) => s.variableValues[dashboardId ?? ''] ?? EMPTY_SELECTIONS,
-	);
-	const payloadVariables = useMemo<PayloadVariables>(() => {
-		const out: PayloadVariables = {};
-		siblings.forEach((v) => {
-			if (v.name) {
-				out[v.name] = selections[v.name]?.value ?? null;
-			}
-		});
-		return out;
-	}, [siblings, selections]);
-
-	const trimmedName = model.name.trim();
-	const nameError = getNameError(trimmedName, existingNames, initial.name);
-	// Surface the message only once the field is dirty; Save stays disabled regardless.
-	const visibleNameError = nameTouched ? nameError : null;
-	const attributeError = getAttributeError(model, existingDynamicAttributes);
-
-	const isListType =
-		model.type === 'QUERY' || model.type === 'CUSTOM' || model.type === 'DYNAMIC';
-	const showAllOptionField = model.type === 'QUERY' || model.type === 'CUSTOM';
-
-	const onNameChange = (value: string): void => {
-		setNameTouched(true);
-		set({ name: value });
-	};
-
-	const selectType = (type: VariableType): void => {
-		set({ type });
-		setRawPreview([]);
-		setPreviewError(null);
-	};
-
-	const onCustomChange = (value: string): void => {
-		set({ customValue: value });
-		setRawPreview(commaValuesParser(value));
-	};
-
-	// In add mode, mirror the selected attribute into the name until the user
-	// edits the name themselves (matches the V1 dynamic-variable behaviour).
-	const onDynamicChange = (patch: Partial<VariableFormModel>): void => {
-		if (isNew && !nameTouched && patch.dynamicAttribute) {
-			set({ ...patch, name: patch.dynamicAttribute });
-		} else {
-			set(patch);
-		}
-	};
-
-	const handleSave = (): void => {
-		const next: VariableFormModel = {
-			...model,
-			name: trimmedName,
-			defaultValue: defaultValue ? { value: defaultValue } : undefined,
-		};
-
-		const cycle = detectVariableCycle([...siblings, next]);
-		if (cycle) {
-			setCycleError(
-				`Cannot save: circular dependency detected between variables: ${cycle.join(
-					' → ',
-				)}`,
-			);
-			return;
-		}
-		setCycleError(null);
-		onSave(next);
-	};
-
-	return {
-		model,
-		set,
-		onNameChange,
-		selectType,
-		onCustomChange,
-		onDynamicChange,
-		setRawPreview,
-		previewValues,
-		previewError,
-		setPreviewError,
-		defaultValue,
-		setDefaultValue,
-		visibleNameError,
-		nameError,
-		attributeError,
-		cycleError,
-		isListType,
-		showAllOptionField,
-		payloadVariables,
-		handleSave,
-	};
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/variableValidation.ts

@@ -1,37 +0,0 @@
-import type { VariableFormModel } from '../variableFormModel';
-
-/**
- * Name validation, mirroring V1: empty / whitespace are rejected, and the name
- * set includes self, but keeping your own (original) name is always allowed.
- */
-export function getNameError(
-	name: string,
-	existingNames: string[],
-	originalName: string,
-): string | null {
-	if (name === '') {
-		return 'Variable name is required';
-	}
-	if (/\s/.test(name)) {
-		return 'Variable name cannot contain whitespaces';
-	}
-	if (name !== originalName && existingNames.includes(name)) {
-		return 'Variable name already exists';
-	}
-	return null;
-}
-
-/** Rejects a dynamic variable reusing an attribute already bound elsewhere. */
-export function getAttributeError(
-	model: VariableFormModel,
-	existingDynamicAttributes: string[],
-): string | undefined {
-	if (
-		model.type === 'DYNAMIC' &&
-		model.dynamicAttribute &&
-		existingDynamicAttributes.includes(model.dynamicAttribute)
-	) {
-		return 'A variable with this attribute key already exists';
-	}
-	return undefined;
-}

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

@@ -1,140 +0,0 @@
-import type { CSSProperties } from 'react';
-import { Check, GripVertical, PenLine, Trash2, X } from '@signozhq/icons';
-import { useSortable } from '@dnd-kit/sortable';
-import { CSS } from '@dnd-kit/utilities';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-
-import type { VariableFormModel } from './variableFormModel';
-import styles from './Variables.module.scss';
-
-const TYPE_LABEL: Record<VariableFormModel['type'], string> = {
-	QUERY: 'Query',
-	CUSTOM: 'Custom',
-	TEXT: 'Text',
-	DYNAMIC: 'Dynamic',
-};
-
-interface VariableRowProps {
-	variable: VariableFormModel;
-	index: number;
-	canEdit: boolean;
-	/** True when this row's delete is awaiting inline confirmation. */
-	isConfirmingDelete: boolean;
-	onEdit: (index: number) => void;
-	onRequestDelete: (index: number) => void;
-	onConfirmDelete: (index: number) => void;
-	onCancelDelete: () => void;
-}
-
-/** A single draggable variable row (drag handle + meta + inline actions). */
-function VariableRow({
-	variable,
-	index,
-	canEdit,
-	isConfirmingDelete,
-	onEdit,
-	onRequestDelete,
-	onConfirmDelete,
-	onCancelDelete,
-}: VariableRowProps): JSX.Element {
-	const {
-		attributes,
-		listeners,
-		setNodeRef,
-		setActivatorNodeRef,
-		transform,
-		transition,
-		isDragging,
-	} = useSortable({ id: variable.name });
-
-	const style: CSSProperties = {
-		transform: CSS.Transform.toString(transform),
-		transition,
-		...(isDragging ? { position: 'relative', zIndex: 1, opacity: 0.8 } : {}),
-	};
-
-	return (
-		<div
-			ref={setNodeRef}
-			style={style}
-			className={styles.row}
-			data-testid={`variable-row-${variable.name}`}
-		>
-			<div className={styles.rowMain}>
-				{canEdit ? (
-					<span
-						ref={setActivatorNodeRef}
-						className={styles.dragHandle}
-						aria-label="Reorder variable"
-						{...attributes}
-						{...listeners}
-					>
-						<GripVertical size={14} />
-					</span>
-				) : null}
-				<Typography.Text className={styles.varName}>
-					${variable.name}
-				</Typography.Text>
-				<span className={styles.typeTag}>{TYPE_LABEL[variable.type]}</span>
-				{variable.description ? (
-					<Typography.Text className={styles.varDesc}>
-						{variable.description}
-					</Typography.Text>
-				) : null}
-			</div>
-
-			{canEdit && isConfirmingDelete ? (
-				<div className={styles.rowActions}>
-					<Typography.Text className={styles.confirmText}>Delete?</Typography.Text>
-					<Button
-						variant="ghost"
-						color="destructive"
-						size="icon"
-						onClick={(): void => onConfirmDelete(index)}
-						aria-label="Confirm delete"
-						testId={`variable-delete-confirm-${variable.name}`}
-					>
-						<Check size={14} />
-					</Button>
-					<Button
-						variant="ghost"
-						color="secondary"
-						size="icon"
-						onClick={onCancelDelete}
-						aria-label="Cancel delete"
-					>
-						<X size={14} />
-					</Button>
-				</div>
-			) : null}
-
-			{canEdit && !isConfirmingDelete ? (
-				<div className={styles.rowActions}>
-					<Button
-						variant="ghost"
-						color="secondary"
-						size="icon"
-						onClick={(): void => onEdit(index)}
-						aria-label="Edit variable"
-						testId={`variable-edit-${variable.name}`}
-					>
-						<PenLine size={14} />
-					</Button>
-					<Button
-						variant="ghost"
-						color="secondary"
-						size="icon"
-						onClick={(): void => onRequestDelete(index)}
-						aria-label="Delete variable"
-						testId={`variable-delete-${variable.name}`}
-					>
-						<Trash2 size={14} />
-					</Button>
-				</div>
-			) : null}
-		</div>
-	);
-}
-
-export default VariableRow;

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

@@ -2,11 +2,13 @@
 	display: flex;
 	flex-direction: column;
 	gap: 16px;
+	padding: 20px 16px;
 }
 
 .header {
 	display: flex;
-	justify-content: flex-end;
+	align-items: flex-start;
+	justify-content: space-between;
 	gap: 16px;
 }
 
@@ -28,6 +30,14 @@
 	color: var(--l2-foreground);
 }
 
+.empty {
+	padding: 32px;
+	text-align: center;
+	border: 1px dashed var(--l1-border);
+	border-radius: 4px;
+	color: var(--l2-foreground);
+}
+
 .list {
 	display: flex;
 	flex-direction: column;
@@ -52,15 +62,6 @@
 	min-width: 0;
 }
 
-.dragHandle {
-	display: flex;
-	flex-shrink: 0;
-	align-items: center;
-	color: var(--l3-foreground);
-	cursor: grab;
-	touch-action: none;
-}
-
 .varName {
 	font-weight: 500;
 	color: var(--l1-foreground);

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

@@ -1,20 +1,24 @@
-import type { DragEndEvent } from '@dnd-kit/core';
 import {
-	DndContext,
-	PointerSensor,
-	useSensor,
-	useSensors,
-} from '@dnd-kit/core';
-import { restrictToVerticalAxis } from '@dnd-kit/modifiers';
-import {
-	SortableContext,
-	verticalListSortingStrategy,
-} from '@dnd-kit/sortable';
+	Check,
+	ChevronDown,
+	ChevronUp,
+	PenLine,
+	Trash2,
+	X,
+} from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import { Typography } from '@signozhq/ui/typography';
 
-import VariableRow from './VariableRow';
-import type { VariableFormModel } from './variableFormModel';
+import type { VariableFormModel } from './variableModel';
 import styles from './Variables.module.scss';
 
+const TYPE_LABEL: Record<VariableFormModel['type'], string> = {
+	QUERY: 'Query',
+	CUSTOM: 'Custom',
+	TEXT: 'Text',
+	DYNAMIC: 'Dynamic',
+};
+
 interface VariablesListProps {
 	variables: VariableFormModel[];
 	canEdit: boolean;
@@ -37,48 +41,98 @@ function VariablesList({
 	onCancelDelete,
 	onMove,
 }: VariablesListProps): JSX.Element {
-	const sensors = useSensors(
-		useSensor(PointerSensor, { activationConstraint: { distance: 1 } }),
-	);
-
-	const handleDragEnd = ({ active, over }: DragEndEvent): void => {
-		if (!over || active.id === over.id) {
-			return;
-		}
-		const from = variables.findIndex((v) => v.name === active.id);
-		const to = variables.findIndex((v) => v.name === over.id);
-		if (from !== -1 && to !== -1) {
-			onMove(from, to);
-		}
-	};
-
 	return (
-		<DndContext
-			sensors={sensors}
-			modifiers={[restrictToVerticalAxis]}
-			onDragEnd={handleDragEnd}
-		>
-			<SortableContext
-				items={variables.map((v) => v.name)}
-				strategy={verticalListSortingStrategy}
-			>
-				<div className={styles.list} data-testid="variables-list">
-					{variables.map((variable, index) => (
-						<VariableRow
-							key={variable.name || `variable-${index}`}
-							variable={variable}
-							index={index}
-							canEdit={canEdit}
-							isConfirmingDelete={confirmingIndex === index}
-							onEdit={onEdit}
-							onRequestDelete={onRequestDelete}
-							onConfirmDelete={onConfirmDelete}
-							onCancelDelete={onCancelDelete}
-						/>
-					))}
+		<div className={styles.list} data-testid="variables-list">
+			{variables.map((variable, index) => (
+				<div
+					className={styles.row}
+					key={variable.name || `variable-${index}`}
+					data-testid={`variable-row-${variable.name}`}
+				>
+					<div className={styles.rowMain}>
+						<Typography.Text className={styles.varName}>
+							${variable.name}
+						</Typography.Text>
+						<span className={styles.typeTag}>{TYPE_LABEL[variable.type]}</span>
+						{variable.description ? (
+							<Typography.Text className={styles.varDesc}>
+								{variable.description}
+							</Typography.Text>
+						) : null}
+					</div>
+
+					{canEdit && confirmingIndex === index ? (
+						<div className={styles.rowActions}>
+							<Typography.Text className={styles.confirmText}>Delete?</Typography.Text>
+							<Button
+								variant="ghost"
+								color="destructive"
+								size="icon"
+								onClick={(): void => onConfirmDelete(index)}
+								aria-label="Confirm delete"
+								testId={`variable-delete-confirm-${variable.name}`}
+							>
+								<Check size={14} />
+							</Button>
+							<Button
+								variant="ghost"
+								color="secondary"
+								size="icon"
+								onClick={onCancelDelete}
+								aria-label="Cancel delete"
+							>
+								<X size={14} />
+							</Button>
+						</div>
+					) : null}
+
+					{canEdit && confirmingIndex !== index ? (
+						<div className={styles.rowActions}>
+							<Button
+								variant="ghost"
+								color="secondary"
+								size="icon"
+								disabled={index === 0}
+								onClick={(): void => onMove(index, index - 1)}
+								aria-label="Move up"
+							>
+								<ChevronUp size={14} />
+							</Button>
+							<Button
+								variant="ghost"
+								color="secondary"
+								size="icon"
+								disabled={index === variables.length - 1}
+								onClick={(): void => onMove(index, index + 1)}
+								aria-label="Move down"
+							>
+								<ChevronDown size={14} />
+							</Button>
+							<Button
+								variant="ghost"
+								color="secondary"
+								size="icon"
+								onClick={(): void => onEdit(index)}
+								aria-label="Edit variable"
+								testId={`variable-edit-${variable.name}`}
+							>
+								<PenLine size={14} />
+							</Button>
+							<Button
+								variant="ghost"
+								color="secondary"
+								size="icon"
+								onClick={(): void => onRequestDelete(index)}
+								aria-label="Delete variable"
+								testId={`variable-delete-${variable.name}`}
+							>
+								<Trash2 size={14} />
+							</Button>
+						</div>
+					) : null}
 				</div>
-			</SortableContext>
-		</DndContext>
+			))}
+		</div>
 	);
 }
 

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/AddVariableButton.tsx

@@ -1,26 +0,0 @@
-import { Plus } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-
-const AddVariableButton = ({
-	isEditable,
-	setIsEditing,
-}: {
-	isEditable: boolean;
-	setIsEditing: (state: { type: 'new' }) => void;
-}): JSX.Element => {
-	return (
-		<Button
-			variant="solid"
-			color="primary"
-			prefix={<Plus size={14} />}
-			size="md"
-			onClick={(): void => setIsEditing({ type: 'new' })}
-			testId="add-variable"
-			disabled={!isEditable}
-		>
-			Add variable
-		</Button>
-	);
-};
-
-export default AddVariableButton;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/BackToAllVariables/BackToAllVariables.module.scss

@@ -1,11 +0,0 @@
-.backToAllVariables {
-	gap: 8px;
-	padding: 8px;
-	border-bottom: 1px solid var(--l3-border);
-}
-
-.backToAllVariablesButton {
-	--button-font-size: 14px;
-	--button-padding: var(--spacing-5) var(--spacing-3);
-	color: var(--l1-foreground);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/BackToAllVariables/BackToAllVariables.tsx

@@ -1,28 +0,0 @@
-import { ArrowLeft } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import styles from './BackToAllVariables.module.scss';
-import { VariableFormProps } from '../../types';
-
-const BackToAllVariables = ({
-	onClose,
-}: {
-	onClose: VariableFormProps['onClose'];
-}): JSX.Element => {
-	return (
-		<div className={styles.backToAllVariables}>
-			<Button
-				variant="ghost"
-				color="secondary"
-				className={styles.backToAllVariablesButton}
-				prefix={<ArrowLeft size={14} />}
-				onClick={onClose}
-				testId="variable-form-back"
-				size="md"
-			>
-				All variables
-			</Button>
-		</div>
-	);
-};
-
-export default BackToAllVariables;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/NoVariablesCard/NoVariables.module.scss

@@ -1,25 +0,0 @@
-.noVariablesCard {
-	display: flex;
-	align-items: center;
-	justify-content: space-between;
-	gap: 16px;
-}
-
-.noVariablesCopy {
-	display: flex;
-	flex-direction: column;
-	gap: 2px;
-}
-
-.noVariablesTitle {
-	color: var(--l1-foreground);
-	font-size: 14px;
-	font-weight: 500;
-	line-height: 20px;
-}
-
-.noVariablesInfo {
-	color: var(--l3-foreground);
-	font-size: 13px;
-	line-height: 18px;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/NoVariablesCard/NoVariablesCard.tsx

@@ -1,28 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import AddVariableButton from '../AddVariableButton';
-import { EditingState } from '../../types';
-import styles from './NoVariables.module.scss';
-
-const NoVariablesCard = ({
-	isEditable,
-	setIsEditing,
-}: {
-	isEditable: boolean;
-	setIsEditing: React.Dispatch<React.SetStateAction<EditingState | null>>;
-}): JSX.Element => {
-	return (
-		<div className={styles.noVariablesCard}>
-			<div className={styles.noVariablesCopy}>
-				<Typography.Text className={styles.noVariablesTitle}>
-					No variables yet
-				</Typography.Text>
-				<Typography.Text className={styles.noVariablesInfo}>
-					Create a variable to parameterize your panel queries.
-				</Typography.Text>
-			</div>
-			<AddVariableButton isEditable={isEditable} setIsEditing={setIsEditing} />
-		</div>
-	);
-};
-
-export default NoVariablesCard;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/VariableInfoForm/VariableInfoForm.module.scss

@@ -1,25 +0,0 @@
-.infoItemContainer {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-}
-
-.infoTitle {
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 12px;
-}
-
-.variableNameInput {
-	border-radius: 2px;
-	border: 1px solid var(--l2-border);
-
-	&::placeholder {
-		color: var(--l3-foreground);
-	}
-}
-
-.descriptionTextArea {
-	border-radius: 2px;
-	border: 1px solid var(--l2-border);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/components/VariableInfoForm/VariableInfoForm.tsx

@@ -1,60 +0,0 @@
-import { Input } from '@signozhq/ui/input';
-import { Typography } from '@signozhq/ui/typography';
-// eslint-disable-next-line signoz/no-antd-components -- multiline TextArea has no @signozhq/ui equivalent yet
-import { Input as AntdInput } from 'antd';
-
-import styles from './VariableInfoForm.module.scss';
-import variableFormStyles from '../../VariableForm/VariableForm.module.scss';
-
-interface VariableInfoFormProps {
-	title: string;
-	description: string;
-	onTitleChange: (value: string) => void;
-	onDescriptionChange: (value: string) => void;
-	visibleNameError: string | null;
-}
-
-function VariableInfoForm({
-	title,
-	description,
-	onTitleChange,
-	onDescriptionChange,
-	visibleNameError,
-}: VariableInfoFormProps): JSX.Element {
-	return (
-		<>
-			<div className={styles.infoItemContainer}>
-				<Typography className={styles.infoTitle}>Name</Typography>
-
-				<Input
-					testId="variable-name"
-					className={styles.variableNameInput}
-					value={title}
-					onChange={(e): void => onTitleChange(e.target.value)}
-					placeholder="Unique name of the variable"
-				/>
-
-				{visibleNameError ? (
-					<Typography.Text className={variableFormStyles.errorText}>
-						<sup>*</sup>&nbsp;
-						{visibleNameError}
-					</Typography.Text>
-				) : null}
-			</div>
-
-			<div className={styles.infoItemContainer}>
-				<Typography className={styles.infoTitle}>Description</Typography>
-				<AntdInput.TextArea
-					className={styles.descriptionTextArea}
-					value={description}
-					placeholder="Enter a description for the variable"
-					data-testid="dashboard-desc"
-					rows={3}
-					onChange={(e): void => onDescriptionChange(e.target.value)}
-				/>
-			</div>
-		</>
-	);
-}
-
-export default VariableInfoForm;

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

@@ -1,75 +1,75 @@
 import { useEffect, useMemo, useState } from 'react';
+import { Plus } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import { Typography } from '@signozhq/ui/typography';
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
-import cx from 'classnames';
 
-import settingsStyles from '../DashboardSettings.module.scss';
 import { useDashboardStore } from '../../store/useDashboardStore';
 import { useSaveVariables } from './useSaveVariables';
 import { dtoToFormModel } from './variableAdapters';
 import {
 	emptyVariableFormModel,
 	type VariableFormModel,
-} from './variableFormModel';
+} from './variableModel';
 import VariableForm from './VariableForm/VariableForm';
 import VariablesList from './VariablesList';
 import styles from './Variables.module.scss';
-import AddVariableButton from './components/AddVariableButton';
-import NoVariablesCard from './components/NoVariablesCard/NoVariablesCard';
-import { EditingState } from './types';
 
 interface VariablesSettingsProps {
 	dashboard: DashboardtypesGettableDashboardV2DTO;
 }
 
+/** `null` index = adding a new variable; a number = editing that row. */
+type EditingState = { index: number | null } | null;
+
 function VariablesSettings({ dashboard }: VariablesSettingsProps): JSX.Element {
 	const isEditable = useDashboardStore((s) => s.isEditable);
 	const { save, isSaving } = useSaveVariables();
 
-	const initialFormModels = useMemo(
-		() => dashboard.spec.variables.map(dtoToFormModel),
-		[dashboard.spec.variables],
+	const initialModels = useMemo(
+		() => (dashboard.spec?.variables ?? []).map(dtoToFormModel),
+		[dashboard.spec?.variables],
 	);
-	const [variables, setVariables] =
-		useState<VariableFormModel[]>(initialFormModels);
+	const [variables, setVariables] = useState<VariableFormModel[]>(initialModels);
 
 	// Resync from the dashboard after a save round-trips (refetch bumps updatedAt).
 	useEffect(() => {
-		setVariables(initialFormModels);
+		setVariables(initialModels);
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [dashboard.updatedAt]);
 
-	const [isEditing, setIsEditing] = useState<EditingState>(null);
+	const [editing, setEditing] = useState<EditingState>(null);
 	const [confirmDeleteIndex, setConfirmDeleteIndex] = useState<number | null>(
 		null,
 	);
 
-	const editingFormModel: VariableFormModel | null = useMemo(() => {
-		if (!isEditing) {
+	const editingModel: VariableFormModel | null = useMemo(() => {
+		if (!editing) {
 			return null;
 		}
-		return isEditing.type === 'new'
+		return editing.index === null
 			? emptyVariableFormModel()
-			: variables[isEditing.index];
-	}, [isEditing, variables]);
+			: variables[editing.index];
+	}, [editing, variables]);
 
-	const siblings = useMemo(() => {
-		const self = isEditing?.type === 'edit' ? isEditing.index : null;
-		return variables.filter((_, i) => i !== self);
-	}, [variables, isEditing]);
+	const existingNames = useMemo(() => {
+		const self = editing?.index ?? null;
+		return variables.filter((_, i) => i !== self).map((v) => v.name);
+	}, [variables, editing]);
 
 	const persist = (next: VariableFormModel[]): void => {
 		setVariables(next);
 		void save(next);
 	};
 
-	const handleFormSave = (Formmodel: VariableFormModel): void => {
+	const handleFormSave = (model: VariableFormModel): void => {
 		const next = [...variables];
-		if (isEditing?.type === 'new') {
-			next.push(Formmodel);
-		} else if (isEditing?.type === 'edit') {
-			next[isEditing.index] = Formmodel;
+		if (editing?.index == null) {
+			next.push(model);
+		} else {
+			next[editing.index] = model;
 		}
-		setIsEditing(null);
+		setEditing(null);
 		persist(next);
 	};
 
@@ -88,14 +88,14 @@ function VariablesSettings({ dashboard }: VariablesSettingsProps): JSX.Element {
 		setConfirmDeleteIndex(null);
 	};
 
-	if (editingFormModel) {
+	// Detail view — edit/new form replaces the list in place (no modal).
+	if (editingModel) {
 		return (
 			<VariableForm
-				initial={editingFormModel}
-				siblings={siblings}
-				isNew={isEditing?.type === 'new'}
+				initial={editingModel}
+				existingNames={existingNames}
 				isSaving={isSaving}
-				onClose={(): void => setIsEditing(null)}
+				onClose={(): void => setEditing(null)}
 				onSave={handleFormSave}
 			/>
 		);
@@ -103,25 +103,42 @@ function VariablesSettings({ dashboard }: VariablesSettingsProps): JSX.Element {
 
 	// Master view — the variables list.
 	return (
-		<div className={cx(styles.container, settingsStyles.settingsCard)}>
+		<div className={styles.container}>
+			<div className={styles.header}>
+				<div className={styles.titleRow}>
+					<Typography.Text className={styles.title}>Variables</Typography.Text>
+					<Typography.Text className={styles.subtitle}>
+						Define variables to parameterize panel queries.
+					</Typography.Text>
+				</div>
+				{isEditable ? (
+					<Button
+						variant="solid"
+						color="primary"
+						prefix={<Plus size={14} />}
+						onClick={(): void => setEditing({ index: null })}
+						testId="add-variable"
+					>
+						New variable
+					</Button>
+				) : null}
+			</div>
+
 			{variables.length === 0 ? (
-				<NoVariablesCard isEditable={isEditable} setIsEditing={setIsEditing} />
+				<div className={styles.empty}>
+					<Typography.Text>No variables defined yet.</Typography.Text>
+				</div>
 			) : (
-				<>
-					<div className={styles.header}>
-						<AddVariableButton isEditable={isEditable} setIsEditing={setIsEditing} />
-					</div>
-					<VariablesList
-						variables={variables}
-						canEdit={isEditable}
-						confirmingIndex={confirmDeleteIndex}
-						onEdit={(index): void => setIsEditing({ type: 'edit', index })}
-						onRequestDelete={(index): void => setConfirmDeleteIndex(index)}
-						onConfirmDelete={handleConfirmDelete}
-						onCancelDelete={(): void => setConfirmDeleteIndex(null)}
-						onMove={handleMove}
-					/>
-				</>
+				<VariablesList
+					variables={variables}
+					canEdit={isEditable}
+					confirmingIndex={confirmDeleteIndex}
+					onEdit={(index): void => setEditing({ index })}
+					onRequestDelete={(index): void => setConfirmDeleteIndex(index)}
+					onConfirmDelete={handleConfirmDelete}
+					onCancelDelete={(): void => setConfirmDeleteIndex(null)}
+					onMove={handleMove}
+				/>
 			)}
 		</div>
 	);

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

@@ -1,18 +0,0 @@
-import { VariableFormModel } from './variableFormModel';
-
-/** `null` index = adding a new variable; a number = editing that row. */
-export type EditingState =
-	| { type: 'new' }
-	| { type: 'edit'; index: number }
-	| null;
-
-export interface VariableFormProps {
-	initial: VariableFormModel;
-	/** The other variables (excluding this one), for uniqueness & cycle checks. */
-	siblings: VariableFormModel[];
-	/** True when adding a new variable (enables auto-naming from the attribute). */
-	isNew: boolean;
-	isSaving: boolean;
-	onClose: () => void;
-	onSave: (model: VariableFormModel) => void;
-}

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

@@ -6,7 +6,7 @@ import APIError from 'types/api/error';
 
 import { useDashboardStore } from '../../store/useDashboardStore';
 import { formModelToDto } from './variableAdapters';
-import type { VariableFormModel } from './variableFormModel';
+import type { VariableFormModel } from './variableModel';
 import { buildVariablesPatch } from './variablePatchOps';
 
 interface UseSaveVariables {

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

@@ -4,6 +4,7 @@ import {
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpecDTOKind as CustomPluginKind,
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesDynamicVariableSpecDTOKind as DynamicPluginKind,
 	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpecDTOKind as QueryPluginKind,
+	TelemetrytypesSignalDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type {
 	DashboardtypesListVariableSpecDTO,
@@ -13,24 +14,21 @@ import type {
 } from 'api/generated/services/sigNoz.schemas';
 
 import {
-	DYNAMIC_SIGNAL_ALL,
-	type DynamicSignalOption,
 	emptyVariableFormModel,
-	signalForApi,
-	VARIABLE_SORT_DISABLED,
+	PLUGIN_KIND,
+	type TelemetrySignal,
 	type VariableFormModel,
 	type VariableSort,
-} from './variableFormModel';
+} from './variableModel';
 
 /** DTO envelope → flat form model (for display / editing). */
 export function dtoToFormModel(
 	dto: DashboardtypesVariableDTO,
 ): VariableFormModel {
 	const base = emptyVariableFormModel();
-	const display = dto.spec.display;
+	const display = dto.spec?.display;
 	const common: VariableFormModel = {
 		...base,
-		// TODO
 		name: dto.spec?.name ?? display?.name ?? '',
 		description: display?.description ?? '',
 	};
@@ -52,7 +50,7 @@ export function dtoToFormModel(
 		...common,
 		multiSelect: spec.allowMultiple ?? false,
 		showAllOption: spec.allowAllValue ?? false,
-		sort: (spec.sort as VariableSort) ?? VARIABLE_SORT_DISABLED,
+		sort: (spec.sort as VariableSort) ?? 'DISABLED',
 		defaultValue: spec.defaultValue,
 	};
 	const plugin = spec.plugin;
@@ -69,9 +67,7 @@ export function dtoToFormModel(
 			...listCommon,
 			type: 'DYNAMIC',
 			dynamicAttribute: plugin.spec.name ?? '',
-			// An omitted wire signal means "all telemetry".
-			dynamicSignal:
-				(plugin.spec.signal as DynamicSignalOption) ?? DYNAMIC_SIGNAL_ALL,
+			dynamicSignal: (plugin.spec.signal as TelemetrySignal) ?? 'traces',
 		};
 	}
 	// Default to Query (also covers a query plugin or a missing/unknown plugin).
@@ -99,7 +95,7 @@ function buildPlugin(
 				kind: DynamicPluginKind['signoz/DynamicVariable'],
 				spec: {
 					name: model.dynamicAttribute,
-					signal: signalForApi(model.dynamicSignal),
+					signal: model.dynamicSignal as TelemetrytypesSignalDTO,
 				},
 			};
 		case 'QUERY':
@@ -118,6 +114,7 @@ export function formModelToDto(
 	const display = {
 		name: model.name,
 		description: model.description,
+		hidden: model.hidden,
 	};
 
 	if (model.type === 'TEXT') {
@@ -138,10 +135,7 @@ export function formModelToDto(
 			name: model.name,
 			display,
 			allowMultiple: model.multiSelect,
-			// Dynamic variables always expose the aggregate "ALL" entry (matches V1,
-			// which forced showALLOption true on save); other types respect the toggle.
-			allowAllValue: model.type === 'DYNAMIC' ? true : model.showAllOption,
-			// model.sort is already a Perses sort token (`none` / `alphabetical-*`).
+			allowAllValue: model.showAllOption,
 			sort: model.sort,
 			defaultValue: model.defaultValue,
 			plugin: buildPlugin(model),
@@ -155,3 +149,5 @@ export function variableTypeOf(
 ): VariableFormModel['type'] {
 	return dtoToFormModel(dto).type;
 }
+
+export { PLUGIN_KIND };

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

@@ -1,35 +0,0 @@
-import {
-	buildDependencies,
-	buildDependencyGraph,
-} from 'container/DashboardContainer/DashboardVariablesSelection/util';
-import type { IDashboardVariable } from 'types/api/dashboard/getAll';
-
-import type { VariableFormModel } from './variableFormModel';
-
-/**
- * Detects a circular reference among QUERY variables (a query referencing
- * another that, transitively, references it back). Reuses the V1 dependency
- * graph helpers, which key off `name` / `type` / `queryValue` only.
- *
- * Returns the names forming the cycle, or `null` when the set is acyclic.
- */
-export function detectVariableCycle(
-	variables: VariableFormModel[],
-): string[] | null {
-	const asDbVariables = variables
-		.filter((variable) => variable.name)
-		.map(
-			(variable) =>
-				({
-					name: variable.name,
-					type: variable.type,
-					queryValue: variable.queryValue,
-				}) as IDashboardVariable,
-		);
-
-	const { hasCycle, cycleNodes } = buildDependencyGraph(
-		buildDependencies(asDbVariables),
-	);
-
-	return hasCycle ? (cycleNodes ?? []) : null;
-}

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

@@ -1,154 +0,0 @@
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import type { VariableDefaultValueDTO } from 'api/generated/services/sigNoz.schemas';
-import { sortBy } from 'lodash-es';
-
-/**
- * The four variable types the editor exposes. No generated enum exists for this
- * — it's a UI grouping over the wire's envelope + plugin kinds: the TextVariable
- * envelope → `TEXT`, and a ListVariable's `DashboardtypesVariablePluginKindDTO`
- * (`signoz/QueryVariable` | `signoz/CustomVariable` | `signoz/DynamicVariable`)
- * → `QUERY` | `CUSTOM` | `DYNAMIC`. Replace with a generated enum if the backend
- * ever exposes a single variable-kind type.
- */
-export type VariableType = 'QUERY' | 'CUSTOM' | 'TEXT' | 'DYNAMIC';
-
-/** Telemetry signal — the generated enum (traces / logs / metrics). */
-export type TelemetrySignal = TelemetrytypesSignalDTO;
-
-/**
- * Signal selected in the dynamic-variable editor. `'all'` is UI-only (the
- * generated `TelemetrytypesSignalDTO` has no "all") — it searches across every
- * signal and maps to an omitted `signal` on the wire (see {@link signalForApi}).
- */
-export const DYNAMIC_SIGNAL_ALL = 'all' as const;
-export type DynamicSignalOption = TelemetrySignal | typeof DYNAMIC_SIGNAL_ALL;
-
-/**
- * Sort order for list-variable values. The wire (Perses) validates `sort`
- * against a fixed method set. There is no generated TS enum for it
- * (`DashboardtypesListOrderDTO` is the query-builder order, a different field),
- * so we mirror the Perses `Sort` tokens here.
- */
-export const VARIABLE_SORT = {
-	DISABLED: 'none',
-	ASC: 'alphabetical-asc',
-	DESC: 'alphabetical-desc',
-	NUMERICAL_ASC: 'numerical-asc',
-	NUMERICAL_DESC: 'numerical-desc',
-	CI_ASC: 'alphabetical-ci-asc',
-	CI_DESC: 'alphabetical-ci-desc',
-} as const;
-
-export type VariableSort = (typeof VARIABLE_SORT)[keyof typeof VARIABLE_SORT];
-
-/** Persisted "no sort" value (Perses `none`). */
-export const VARIABLE_SORT_DISABLED: VariableSort = VARIABLE_SORT.DISABLED;
-
-export const VARIABLE_SORTS: VariableSort[] = [
-	VARIABLE_SORT.DISABLED,
-	VARIABLE_SORT.ASC,
-	VARIABLE_SORT.DESC,
-	VARIABLE_SORT.NUMERICAL_ASC,
-	VARIABLE_SORT.NUMERICAL_DESC,
-	VARIABLE_SORT.CI_ASC,
-	VARIABLE_SORT.CI_DESC,
-];
-
-export const VARIABLE_SORT_LABEL: Record<VariableSort, string> = {
-	[VARIABLE_SORT.DISABLED]: 'Disabled',
-	[VARIABLE_SORT.ASC]: 'Alphabetical (ascending)',
-	[VARIABLE_SORT.DESC]: 'Alphabetical (descending)',
-	[VARIABLE_SORT.NUMERICAL_ASC]: 'Numerical (ascending)',
-	[VARIABLE_SORT.NUMERICAL_DESC]: 'Numerical (descending)',
-	[VARIABLE_SORT.CI_ASC]: 'Alphabetical, case-insensitive (ascending)',
-	[VARIABLE_SORT.CI_DESC]: 'Alphabetical, case-insensitive (descending)',
-};
-
-export const DYNAMIC_SIGNALS: DynamicSignalOption[] = [
-	DYNAMIC_SIGNAL_ALL,
-	TelemetrytypesSignalDTO.traces,
-	TelemetrytypesSignalDTO.logs,
-	TelemetrytypesSignalDTO.metrics,
-];
-
-export const DYNAMIC_SIGNAL_LABEL: Record<DynamicSignalOption, string> = {
-	[DYNAMIC_SIGNAL_ALL]: 'All telemetry',
-	[TelemetrytypesSignalDTO.traces]: 'Traces',
-	[TelemetrytypesSignalDTO.logs]: 'Logs',
-	[TelemetrytypesSignalDTO.metrics]: 'Metrics',
-};
-
-/** Maps the editor's signal selection to the wire value (`'all'` → omitted). */
-export function signalForApi(
-	signal: DynamicSignalOption,
-): TelemetrySignal | undefined {
-	return signal === DYNAMIC_SIGNAL_ALL ? undefined : signal;
-}
-
-type SortableValues = (string | number | boolean)[];
-
-/** Sorts preview / option values by the variable's chosen order (no-op when disabled). */
-export function sortValuesByOrder(
-	values: SortableValues,
-	sort: VariableSort,
-): SortableValues {
-	switch (sort) {
-		case VARIABLE_SORT.ASC:
-			return sortBy(values);
-		case VARIABLE_SORT.DESC:
-			return sortBy(values).reverse();
-		case VARIABLE_SORT.NUMERICAL_ASC:
-			return sortBy(values, (value) => Number(value));
-		case VARIABLE_SORT.NUMERICAL_DESC:
-			return sortBy(values, (value) => Number(value)).reverse();
-		case VARIABLE_SORT.CI_ASC:
-			return sortBy(values, (value) => String(value).toLowerCase());
-		case VARIABLE_SORT.CI_DESC:
-			return sortBy(values, (value) => String(value).toLowerCase()).reverse();
-		default:
-			return values;
-	}
-}
-
-export interface VariableFormModel {
-	/** Stable identifier, referenced in queries (e.g. `$name`); must be unique. */
-	name: string;
-	description: string;
-	type: VariableType;
-
-	// List-variable common fields (Query / Custom / Dynamic).
-	multiSelect: boolean;
-	showAllOption: boolean;
-	sort: VariableSort;
-
-	// Type-specific.
-	queryValue: string; // QUERY
-	customValue: string; // CUSTOM
-	textValue: string; // TEXT
-	textConstant: boolean; // TEXT
-	dynamicAttribute: string; // DYNAMIC — the telemetry field name
-	dynamicSignal: DynamicSignalOption; // DYNAMIC — the telemetry signal
-
-	/**
-	 * Runtime-selected default, not editable in the management tab yet; carried
-	 * through edits so saving a definition doesn't clobber it.
-	 */
-	defaultValue?: VariableDefaultValueDTO;
-}
-
-export function emptyVariableFormModel(): VariableFormModel {
-	return {
-		name: '',
-		description: '',
-		type: 'DYNAMIC',
-		multiSelect: false,
-		showAllOption: false,
-		sort: VARIABLE_SORT_DISABLED,
-		queryValue: '',
-		customValue: '',
-		textValue: '',
-		textConstant: false,
-		dynamicAttribute: '',
-		dynamicSignal: DYNAMIC_SIGNAL_ALL,
-	};
-}

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

@@ -0,0 +1,78 @@
+import type { VariableDefaultValueDTO } from 'api/generated/services/sigNoz.schemas';
+
+/**
+ * Flat, UI-friendly representation of a V2 dashboard variable. The wire format
+ * (`DashboardtypesVariableDTO`) is a nested envelope/plugin union that is awkward
+ * to bind a form to; `variableAdapters` converts between this model and the DTO.
+ */
+
+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). */
+export const ENVELOPE_KIND = {
+	LIST: 'ListVariable',
+	TEXT: 'TextVariable',
+} as const;
+
+export const PLUGIN_KIND = {
+	QUERY: 'signoz/QueryVariable',
+	CUSTOM: 'signoz/CustomVariable',
+	DYNAMIC: 'signoz/DynamicVariable',
+} as const;
+
+export const VARIABLE_SORTS: VariableSort[] = ['DISABLED', 'ASC', 'DESC'];
+
+export const TELEMETRY_SIGNALS: TelemetrySignal[] = [
+	'traces',
+	'logs',
+	'metrics',
+];
+
+export interface VariableFormModel {
+	/** Stable identifier, referenced in queries (e.g. `$name`); must be unique. */
+	name: string;
+	description: string;
+	hidden: boolean;
+	type: VariableType;
+
+	// List-variable common fields (Query / Custom / Dynamic).
+	multiSelect: boolean;
+	showAllOption: boolean;
+	sort: VariableSort;
+
+	// Type-specific.
+	queryValue: string; // QUERY
+	customValue: string; // CUSTOM
+	textValue: string; // TEXT
+	textConstant: boolean; // TEXT
+	dynamicAttribute: string; // DYNAMIC — the telemetry field name
+	dynamicSignal: TelemetrySignal; // DYNAMIC — the telemetry signal
+
+	/**
+	 * Runtime-selected default, not editable in the management tab yet; carried
+	 * through edits so saving a definition doesn't clobber it.
+	 */
+	defaultValue?: VariableDefaultValueDTO;
+}
+
+export function emptyVariableFormModel(): VariableFormModel {
+	return {
+		name: '',
+		description: '',
+		hidden: false,
+		type: 'QUERY',
+		multiSelect: false,
+		showAllOption: false,
+		sort: 'DISABLED',
+		queryValue: '',
+		customValue: '',
+		textValue: '',
+		textConstant: false,
+		dynamicAttribute: '',
+		dynamicSignal: 'traces',
+	};
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.module.scss

@@ -1,90 +0,0 @@
-.config {
-	display: flex;
-	flex-direction: column;
-	flex: 1;
-	// padding: 18px 18px 44px;
-	background-color: var(--l1-background);
-	overflow-y: auto;
-	overflow-x: hidden;
-
-	//TODO: replace this with custom-scrollbar mixin
-	// Thin, unobtrusive scrollbar (replaces the chunky native bar).
-	$thumb: color-mix(in srgb, var(--bg-vanilla-100) 16%, transparent);
-
-	scrollbar-width: thin;
-	scrollbar-color: $thumb transparent;
-
-	&::-webkit-scrollbar {
-		width: 8px;
-	}
-
-	&::-webkit-scrollbar-track {
-		background: transparent;
-	}
-
-	&::-webkit-scrollbar-thumb {
-		background: $thumb;
-		border-radius: 999px;
-		border: 2px solid transparent;
-		background-clip: padding-box;
-	}
-}
-
-.heading {
-	margin-bottom: 18px;
-	padding: 16px 16px 0 16px;
-}
-
-.title {
-	display: flex;
-	align-items: baseline;
-	gap: 9px;
-	white-space: nowrap;
-}
-
-.subtitle {
-	font-size: 12px;
-	color: var(--text-vanilla-400);
-}
-
-.eyebrow {
-	display: block;
-	margin: 0 2px 10px;
-	font-size: 11px;
-	font-weight: 600;
-	letter-spacing: 0.06em;
-	text-transform: uppercase;
-	color: var(--l1-foreground);
-}
-
-.group {
-	display: flex;
-	flex-direction: column;
-	gap: 16px;
-	padding: 0 16px;
-}
-
-.field {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-}
-
-.divider {
-	height: 1px;
-	background: var(--l2-border);
-	margin: 18px 0;
-}
-
-.sectionsContainer {
-	padding: 0 16px;
-}
-
-.sections {
-	display: flex;
-	flex-direction: column;
-
-	& > * + * {
-		border-top: 1px solid var(--l2-border);
-	}
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx

@@ -1,108 +0,0 @@
-import { Input } from 'antd';
-import { Typography } from '@signozhq/ui/typography';
-import type {
-	DashboardtypesPanelSpecDTO,
-	TelemetrytypesSignalDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { getPanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/registry';
-import { getBuilderQueries } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/getBuilderQueries';
-
-import type { LegendSeries } from '../hooks/useLegendSeries';
-import type { TableColumnOption } from '../hooks/useTableColumns';
-import SectionSlot from './SectionSlot/SectionSlot';
-
-import styles from './ConfigPane.module.scss';
-import { PanelKind } from '../../Panels/types/panelKind';
-
-interface ConfigPaneProps {
-	/** Full plugin kind (e.g. `signoz/TimeSeriesPanel`); drives which sections show. */
-	panelKind: PanelKind;
-	/** The panel spec — the single editing surface (title/description + section slices). */
-	spec: DashboardtypesPanelSpecDTO;
-	onChangeSpec: (next: DashboardtypesPanelSpecDTO) => void;
-	/** Panel's resolved series, provided to sections that need them (legend colors). */
-	legendSeries: LegendSeries[];
-	/** Table panel's resolved value columns, for the table-only editors. */
-	tableColumns: TableColumnOption[];
-}
-
-/**
- * Right-hand configuration pane. Renders the always-present general fields (title +
- * description) followed by the panel kind's configuration sections (Formatting, Axes,
- * …). The section list is declared per kind (`PanelDefinition.sections`) and rendered
- * generically via the section registry — only sections with a built editor appear.
- */
-function ConfigPane({
-	panelKind,
-	spec,
-	onChangeSpec,
-	legendSeries,
-	tableColumns,
-}: ConfigPaneProps): JSX.Element {
-	const definition = getPanelDefinition(panelKind);
-	const sections = definition?.sections ?? [];
-
-	const signal = getBuilderQueries(spec.queries)[0]?.signal as
-		| TelemetrytypesSignalDTO
-		| undefined;
-
-	// Title/description are just a slice of the spec — edit them through the same
-	// onChangeSpec path the sections use, so there's a single editing surface.
-	const setDisplayField = (field: 'name' | 'description', value: string): void =>
-		onChangeSpec({ ...spec, display: { ...spec.display, [field]: value } });
-
-	return (
-		<div className={styles.config}>
-			<header className={styles.heading}>
-				<Typography.Text>Panel settings</Typography.Text>
-			</header>
-
-			<div className={styles.group}>
-				<div className={styles.field}>
-					<Typography.Text>Title</Typography.Text>
-					<Input
-						data-testid="panel-editor-v2-title"
-						value={spec.display.name}
-						placeholder="Panel title"
-						onChange={(e): void => setDisplayField('name', e.target.value)}
-					/>
-				</div>
-
-				<div className={styles.field}>
-					<Typography.Text>Description</Typography.Text>
-					<Input.TextArea
-						data-testid="panel-editor-v2-description"
-						value={spec.display.description ?? ''}
-						placeholder="Add a description"
-						rows={3}
-						onChange={(e): void => setDisplayField('description', e.target.value)}
-					/>
-				</div>
-			</div>
-
-			{sections.length > 0 && (
-				<>
-					<div className={styles.divider} />
-					<div className={styles.sectionsContainer}>
-						<span className={styles.eyebrow}>Display</span>
-						<div className={styles.sections}>
-							{sections.map((config) => (
-								<SectionSlot
-									key={config.kind}
-									config={config}
-									spec={spec}
-									onChangeSpec={onChangeSpec}
-									legendSeries={legendSeries}
-									tableColumns={tableColumns}
-									signal={signal}
-								/>
-							))}
-						</div>
-					</div>
-				</>
-			)}
-		</div>
-	);
-}
-
-export default ConfigPane;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsx

@@ -1,77 +0,0 @@
-import type {
-	DashboardtypesPanelSpecDTO,
-	TelemetrytypesSignalDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import {
-	type PanelFormattingSlice,
-	SECTION_METADATA,
-	type SectionConfig,
-} from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
-
-import type { LegendSeries } from '../../hooks/useLegendSeries';
-import type { TableColumnOption } from '../../hooks/useTableColumns';
-import { resolveSectionEditor } from '../sectionRegistry';
-import SettingsSection from '../SettingsSection/SettingsSection';
-
-interface SectionSlotProps {
-	config: SectionConfig;
-	spec: DashboardtypesPanelSpecDTO;
-	onChangeSpec: (next: DashboardtypesPanelSpecDTO) => void;
-	/** Resolved series, forwarded to editors that need them (legend colors). */
-	legendSeries: LegendSeries[];
-	/** Table panel's resolved value columns, for the table-only editors. */
-	tableColumns: TableColumnOption[];
-	/** Panel's telemetry signal, for editors that fetch field suggestions (List columns). */
-	signal?: TelemetrytypesSignalDTO;
-}
-
-/**
- * Renders one configuration section: its collapsible wrapper plus the registered editor
- * for `config.kind`, wired through the registry's spec lens. Renders nothing when the
- * kind has no editor yet (sections roll out incrementally), so a kind can declare a
- * section before its editor exists.
- */
-function SectionSlot({
-	config,
-	spec,
-	onChangeSpec,
-	legendSeries,
-	tableColumns,
-	signal,
-}: SectionSlotProps): JSX.Element | null {
-	// A kind can hide a section based on current spec state (e.g. Histogram legend once
-	// queries are merged) — skip it before resolving the editor.
-	if (config.isHidden?.(spec)) {
-		return null;
-	}
-
-	const editor = resolveSectionEditor(config.kind);
-	if (!editor) {
-		return null;
-	}
-
-	const { title, icon: Icon } = SECTION_METADATA[config.kind];
-	const { Component, get, update } = editor;
-	// Atomic sections carry no `controls`; controlled ones do.
-	const controls = 'controls' in config ? config.controls : undefined;
-	// The panel's formatting unit, forwarded to editors that scope to it (thresholds
-	// restrict their unit picker to this unit's category, as in V1).
-	const yAxisUnit = (spec.plugin.spec as { formatting?: PanelFormattingSlice })
-		.formatting?.unit;
-
-	return (
-		<SettingsSection title={title} icon={<Icon size={15} />}>
-			<Component
-				value={get(spec)}
-				controls={controls}
-				onChange={(next): void => onChangeSpec(update(spec, next))}
-				legendSeries={legendSeries}
-				yAxisUnit={yAxisUnit}
-				tableColumns={tableColumns}
-				signal={signal}
-			/>
-		</SettingsSection>
-	);
-}
-
-export default SectionSlot;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SettingsSection/SettingsSection.module.scss

@@ -1,54 +0,0 @@
-.header {
-	display: flex;
-	align-items: center;
-	gap: 11px;
-	width: 100%;
-	height: 44px;
-	padding: 0 4px;
-	border: none;
-	background: transparent;
-	cursor: pointer;
-	color: var(--text-vanilla-100);
-	border-radius: 4px;
-}
-
-.iconTile {
-	display: grid;
-	place-items: center;
-	width: 27px;
-	height: 27px;
-	flex: none;
-	border-radius: 3px;
-	background: var(--l3-background);
-	color: var(--l3-foreground);
-	transition: all 0.15s ease;
-}
-
-.iconTileOpen {
-	background: color-mix(in srgb, var(--bg-robin-400) 14%, transparent);
-	color: var(--bg-robin-400);
-}
-
-.title {
-	flex: 1;
-	text-align: left;
-	font-weight: 600;
-	color: var(--l2-foreground);
-}
-
-.chevron {
-	flex: none;
-	color: var(--l2-border);
-	transition: transform 0.15s ease;
-
-	&.open {
-		transform: rotate(180deg);
-	}
-}
-
-.body {
-	display: flex;
-	flex-direction: column;
-	gap: 16px;
-	padding: 2px 0 18px;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SettingsSection/SettingsSection.tsx

@@ -1,54 +0,0 @@
-import { type ReactNode, useState } from 'react';
-import { ChevronDown } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-
-import styles from './SettingsSection.module.scss';
-
-interface SettingsSectionProps {
-	title: string;
-	icon?: ReactNode;
-	defaultOpen?: boolean;
-	children: ReactNode;
-}
-
-/**
- * Collapsible container for one configuration section in the V2 panel editor's
- * ConfigPane. Header shows an icon tile (accented when expanded), the title, and a
- * rotating chevron; sections are separated by hairline dividers (no surrounding boxes),
- * matching the Configure-panel design.
- */
-function SettingsSection({
-	title,
-	icon,
-	defaultOpen = false,
-	children,
-}: SettingsSectionProps): JSX.Element {
-	const [isOpen, setIsOpen] = useState(defaultOpen);
-
-	return (
-		<section className={styles.section}>
-			<button
-				type="button"
-				className={styles.header}
-				aria-expanded={isOpen}
-				data-testid={`config-section-${title}`}
-				onClick={(): void => setIsOpen((prev) => !prev)}
-			>
-				{icon && (
-					<span className={cx(styles.iconTile, { [styles.iconTileOpen]: isOpen })}>
-						{icon}
-					</span>
-				)}
-				<Typography.Text className={styles.title}>{title}</Typography.Text>
-				<ChevronDown
-					size={15}
-					className={cx(styles.chevron, { [styles.open]: isOpen })}
-				/>
-			</button>
-			{isOpen && <div className={styles.body}>{children}</div>}
-		</section>
-	);
-}
-
-export default SettingsSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/__tests__/ConfigPane.test.tsx

@@ -1,69 +0,0 @@
-import { fireEvent, render, screen } from '@testing-library/react';
-import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';
-
-import ConfigPane from '../ConfigPane';
-import { PanelKind } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
-
-function spec(unit?: string): DashboardtypesPanelSpecDTO {
-	return {
-		display: { name: 'CPU', description: 'usage' },
-		plugin: {
-			kind: 'signoz/TimeSeriesPanel',
-			spec: unit ? { formatting: { unit } } : {},
-		},
-		queries: [],
-	} as unknown as DashboardtypesPanelSpecDTO;
-}
-
-function renderConfigPane(
-	overrides: Partial<React.ComponentProps<typeof ConfigPane>> = {},
-): React.ComponentProps<typeof ConfigPane> {
-	const props: React.ComponentProps<typeof ConfigPane> = {
-		panelKind: 'signoz/TimeSeriesPanel',
-		spec: spec(),
-		onChangeSpec: jest.fn(),
-		legendSeries: [],
-		tableColumns: [],
-		...overrides,
-	};
-	render(<ConfigPane {...props} />);
-	return props;
-}
-
-describe('ConfigPane', () => {
-	it('renders the seeded title and description', () => {
-		renderConfigPane();
-
-		expect(screen.getByTestId('panel-editor-v2-title')).toHaveValue('CPU');
-		expect(screen.getByTestId('panel-editor-v2-description')).toHaveValue(
-			'usage',
-		);
-	});
-
-	it('reports title edits through onChangeSpec (into spec.display)', () => {
-		const { onChangeSpec } = renderConfigPane();
-
-		fireEvent.change(screen.getByTestId('panel-editor-v2-title'), {
-			target: { value: 'Memory' },
-		});
-
-		expect(onChangeSpec).toHaveBeenCalledWith(
-			expect.objectContaining({
-				display: { name: 'Memory', description: 'usage' },
-			}),
-		);
-	});
-
-	it('renders the Formatting section for a kind that declares it', () => {
-		renderConfigPane();
-		// The TimeSeries kind declares a Formatting section; its collapsible header shows.
-		expect(screen.getByTestId('config-section-Formatting')).toBeInTheDocument();
-	});
-
-	it('omits the Formatting section for an unknown kind', () => {
-		renderConfigPane({ panelKind: 'signoz/UnknownPanel' as PanelKind });
-		expect(
-			screen.queryByTestId('config-section-Formatting'),
-		).not.toBeInTheDocument();
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSegmented/ConfigSegmented.module.scss

@@ -1,10 +0,0 @@
-.group {
-	width: min(350px, 100%);
-}
-
-.segment {
-	display: inline-flex;
-	align-items: center;
-	gap: 6px;
-	white-space: nowrap;
-}