fix: update openapi

.github/workflows/integrationci.yaml

@@ -38,6 +38,7 @@ jobs:
       fail-fast: false
       matrix:
         suite:
+          - aiobservability
           - alerts
           - basepath
           - callbackauthn

cmd/community/server.go

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

cmd/enterprise/server.go

@@ -24,7 +24,6 @@ import (
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration/implcloudprovider"
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
-	eeimplmetricreductionrule "github.com/SigNoz/signoz/ee/modules/metricreductionrule/implmetricreductionrule"
 	eequerier "github.com/SigNoz/signoz/ee/querier"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
 	eerules "github.com/SigNoz/signoz/ee/query-service/rules"
@@ -47,7 +46,6 @@ import (
 	pkgcloudintegration "github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
@@ -184,9 +182,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return implcloudintegration.NewModule(pkgcloudintegration.NewStore(sqlStore), dashboardModule, global, zeus, gateway, licensing, serviceAccount, cloudProvidersMap, config)
 		},
-		func() metricreductionrule.Module {
-			return eeimplmetricreductionrule.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, eerules.PrepareTaskFunc, eerules.TestNotification))
 		},

docs/api/openapi.yml

@@ -5138,221 +5138,6 @@ components:
       required:
       - rules
       type: object
-    MetricreductionruletypesAffectedAsset:
-      properties:
-        id:
-          type: string
-        impactedLabels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        name:
-          type: string
-        type:
-          $ref: '#/components/schemas/MetricreductionruletypesAssetType'
-        widget:
-          $ref: '#/components/schemas/MetricreductionruletypesAffectedWidget'
-      required:
-      - type
-      - id
-      - name
-      - impactedLabels
-      type: object
-    MetricreductionruletypesAffectedWidget:
-      properties:
-        id:
-          type: string
-        name:
-          type: string
-      required:
-      - id
-      - name
-      type: object
-    MetricreductionruletypesAssetType:
-      enum:
-      - dashboard
-      - alert_rule
-      type: string
-    MetricreductionruletypesGettableReductionRule:
-      properties:
-        active:
-          type: boolean
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        effectiveFrom:
-          format: date-time
-          type: string
-        id:
-          type: string
-        ingestedSeries:
-          minimum: 0
-          type: integer
-        labels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        matchType:
-          $ref: '#/components/schemas/MetricreductionruletypesMatchType'
-        metricName:
-          type: string
-        reductionPercent:
-          format: double
-          type: number
-        retainedSeries:
-          minimum: 0
-          type: integer
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - metricName
-      - matchType
-      - labels
-      - effectiveFrom
-      - active
-      - ingestedSeries
-      - retainedSeries
-      - reductionPercent
-      type: object
-    MetricreductionruletypesGettableReductionRulePreview:
-      properties:
-        affectedAssets:
-          items:
-            $ref: '#/components/schemas/MetricreductionruletypesAffectedAsset'
-          nullable: true
-          type: array
-        currentRetainedSeries:
-          minimum: 0
-          type: integer
-        droppedLabels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        effectiveFrom:
-          format: date-time
-          type: string
-        ingestedSeries:
-          minimum: 0
-          type: integer
-        reductionPercent:
-          format: double
-          type: number
-        retainedSeries:
-          minimum: 0
-          type: integer
-      required:
-      - ingestedSeries
-      - currentRetainedSeries
-      - retainedSeries
-      - reductionPercent
-      - droppedLabels
-      - affectedAssets
-      - effectiveFrom
-      type: object
-    MetricreductionruletypesGettableReductionRuleStats:
-      properties:
-        estimatedMonthlySavingsUsd:
-          format: double
-          type: number
-        ingestedSeries:
-          minimum: 0
-          type: integer
-        retainedSeries:
-          minimum: 0
-          type: integer
-      required:
-      - ingestedSeries
-      - retainedSeries
-      - estimatedMonthlySavingsUsd
-      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'
-        metricName:
-          type: string
-      required:
-      - metricName
-      - 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:
-      - metric
-      - ingested_volume
-      - reduced_volume
-      - reduction
-      - last_updated
-      type: string
-    MetricreductionruletypesUpdatableReductionRule:
-      properties:
-        labels:
-          items:
-            type: string
-          nullable: true
-          type: array
-        matchType:
-          $ref: '#/components/schemas/MetricreductionruletypesMatchType'
-      required:
-      - matchType
-      - labels
-      type: object
     MetricsexplorertypesInspectMetricsRequest:
       properties:
         end:
@@ -7323,6 +7108,21 @@ components:
       required:
       - items
       type: object
+    SpantypesGettableSpanMapperTest:
+      properties:
+        collectorLogs:
+          items:
+            type: string
+          nullable: true
+          type: array
+        spans:
+          items:
+            $ref: '#/components/schemas/SpantypesSpanMapperTestSpan'
+          nullable: true
+          type: array
+      required:
+      - spans
+      type: object
     SpantypesGettableTraceAggregations:
       properties:
         aggregations:
@@ -7410,6 +7210,39 @@ components:
       - name
       - condition
       type: object
+    SpantypesPostableSpanMapperTest:
+      properties:
+        groups:
+          items:
+            $ref: '#/components/schemas/SpantypesPostableSpanMapperTestGroup'
+          nullable: true
+          type: array
+        spans:
+          items:
+            $ref: '#/components/schemas/SpantypesSpanMapperTestSpan'
+          nullable: true
+          type: array
+      required:
+      - spans
+      - groups
+      type: object
+    SpantypesPostableSpanMapperTestGroup:
+      properties:
+        condition:
+          $ref: '#/components/schemas/SpantypesSpanMapperGroupCondition'
+        enabled:
+          type: boolean
+        mappers:
+          items:
+            $ref: '#/components/schemas/SpantypesPostableSpanMapper'
+          nullable: true
+          type: array
+        name:
+          type: string
+      required:
+      - name
+      - condition
+      type: object
     SpantypesPostableTraceAggregations:
       properties:
         aggregations:
@@ -7571,6 +7404,17 @@ components:
       - operation
       - priority
       type: object
+    SpantypesSpanMapperTestSpan:
+      properties:
+        attributes:
+          additionalProperties: {}
+          nullable: true
+          type: object
+        resource:
+          additionalProperties: {}
+          nullable: true
+          type: object
+      type: object
     SpantypesUpdatableSpanMapper:
       properties:
         config:
@@ -13199,6 +13043,69 @@ paths:
       summary: Update a span mapper
       tags:
       - spanmapper
+  /api/v1/span_mapper_groups/test:
+    post:
+      deprecated: false
+      description: Tests how span mappers would transform sample spans
+      operationId: TestSpanMappers
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SpantypesPostableSpanMapperTest'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpantypesGettableSpanMapperTest'
+                  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
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Test span mappers against sample spans
+      tags:
+      - spanmapper
   /api/v1/stats:
     get:
       deprecated: false
@@ -15839,566 +15746,6 @@ paths:
       summary: Liveness check
       tags:
       - health
-  /api/v2/metric_reduction_rules:
-    get:
-      deprecated: false
-      description: Returns active metric volume-control (label reduction) rules.
-      operationId: ListMetricReductionRules
-      parameters:
-      - in: query
-        name: orderBy
-        schema:
-          $ref: '#/components/schemas/MetricreductionruletypesReductionRuleOrderBy'
-      - in: query
-        name: order
-        schema:
-          $ref: '#/components/schemas/MetricreductionruletypesOrder'
-      - in: query
-        name: search
-        schema:
-          type: string
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - 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
-    post:
-      deprecated: false
-      description: Creates a volume-control rule for a metric and returns it with
-        its id; fails if the metric already has a rule.
-      operationId: CreateMetricReductionRule
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/MetricreductionruletypesPostableReductionRule'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRule'
-                  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
-        "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 a metric reduction rule
-      tags:
-      - metrics
-  /api/v2/metric_reduction_rules/{id}:
-    delete:
-      deprecated: false
-      description: Deletes a volume-control rule by its id.
-      operationId: DeleteMetricReductionRuleByID
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      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:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a metric reduction rule by id
-      tags:
-      - metrics
-    get:
-      deprecated: false
-      description: Returns a single volume-control rule by its id.
-      operationId: GetMetricReductionRuleByID
-      parameters:
-      - in: path
-        name: id
-        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
-        "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 by id
-      tags:
-      - metrics
-    put:
-      deprecated: false
-      description: Updates the match type and labels of a volume-control rule by its
-        id; the metric name is immutable.
-      operationId: UpdateMetricReductionRuleByID
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/MetricreductionruletypesUpdatableReductionRule'
-      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: Update a metric reduction rule by id
-      tags:
-      - metrics
-  /api/v2/metric_reduction_rules/preview:
-    post:
-      deprecated: false
-      description: Estimates the series reduction and related-asset impact of a candidate
-        volume-control rule without persisting it.
-      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/metric_reduction_rules/stats:
-    get:
-      deprecated: false
-      description: Returns total ingested vs retained series and the estimated monthly
-        savings across all volume-control rules.
-      operationId: GetMetricReductionRuleStats
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricreductionruletypesGettableReductionRuleStats'
-                  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: Metric reduction stats
-      tags:
-      - metrics
-  /api/v2/metric_reduction_rules/timeseries:
-    get:
-      deprecated: false
-      description: Returns ingested vs retained series over time across all volume-control
-        rules (hourly buckets), in the query-range time-series response shape.
-      operationId: GetMetricReductionRuleTimeseries
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Querybuildertypesv5QueryRangeResponse'
-                  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: Metric reduction volume over time
-      tags:
-      - metrics
   /api/v2/metrics:
     get:
       deprecated: false

ee/modules/metricreductionrule/implmetricreductionrule/module.go

@@ -1,52 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct{}
-
-func NewModule() metricreductionrule.Module {
-	return &module{}
-}
-
-var errNotImplemented = errors.New(errors.TypeUnsupported, metricreductionruletypes.ErrCodeMetricReductionRuleUnsupported,
-	"metric volume control is not yet implemented")
-
-func (m *module) List(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) Create(_ context.Context, _ valuer.UUID, _ string, _ *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) GetByID(_ context.Context, _ valuer.UUID, _ valuer.UUID) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) UpdateByID(_ context.Context, _ valuer.UUID, _ string, _ valuer.UUID, _ *metricreductionruletypes.UpdatableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) DeleteByID(_ context.Context, _ valuer.UUID, _ valuer.UUID) error {
-	return errNotImplemented
-}
-
-func (m *module) Preview(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) Stats(_ context.Context, _ valuer.UUID) (*metricreductionruletypes.GettableReductionRuleStats, error) {
-	return nil, errNotImplemented
-}
-
-func (m *module) Timeseries(_ context.Context, _ valuer.UUID) (*querybuildertypesv5.QueryRangeResponse, error) {
-	return nil, errNotImplemented
-}

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

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

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

@@ -18,8 +18,6 @@ import type {
 } from 'react-query';
 
 import type {
-	CreateMetricReductionRule201,
-	DeleteMetricReductionRuleByIDPathParameters,
 	GetMetricAlerts200,
 	GetMetricAlertsParams,
 	GetMetricAttributes200,
@@ -30,762 +28,22 @@ import type {
 	GetMetricHighlightsParams,
 	GetMetricMetadata200,
 	GetMetricMetadataParams,
-	GetMetricReductionRuleByID200,
-	GetMetricReductionRuleByIDPathParameters,
-	GetMetricReductionRuleStats200,
-	GetMetricReductionRuleTimeseries200,
 	GetMetricsOnboardingStatus200,
 	GetMetricsStats200,
 	GetMetricsTreemap200,
 	InspectMetrics200,
-	ListMetricReductionRules200,
-	ListMetricReductionRulesParams,
 	ListMetrics200,
 	ListMetricsParams,
-	MetricreductionruletypesPostableReductionRuleDTO,
-	MetricreductionruletypesPostableReductionRulePreviewDTO,
-	MetricreductionruletypesUpdatableReductionRuleDTO,
 	MetricsexplorertypesInspectMetricsRequestDTO,
 	MetricsexplorertypesStatsRequestDTO,
 	MetricsexplorertypesTreemapRequestDTO,
 	MetricsexplorertypesUpdateMetricMetadataRequestDTO,
-	PreviewMetricReductionRule200,
 	RenderErrorResponseDTO,
-	UpdateMetricReductionRuleByID200,
-	UpdateMetricReductionRuleByIDPathParameters,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
-/**
- * Returns active metric volume-control (label reduction) rules.
- * @summary List metric reduction rules
- */
-export const listMetricReductionRules = (
-	params?: ListMetricReductionRulesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListMetricReductionRules200>({
-		url: `/api/v2/metric_reduction_rules`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListMetricReductionRulesQueryKey = (
-	params?: ListMetricReductionRulesParams,
-) => {
-	return [
-		`/api/v2/metric_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;
-};
-
-/**
- * Creates a volume-control rule for a metric and returns it with its id; fails if the metric already has a rule.
- * @summary Create a metric reduction rule
- */
-export const createMetricReductionRule = (
-	metricreductionruletypesPostableReductionRuleDTO?: BodyType<MetricreductionruletypesPostableReductionRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateMetricReductionRule201>({
-		url: `/api/v2/metric_reduction_rules`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: metricreductionruletypesPostableReductionRuleDTO,
-		signal,
-	});
-};
-
-export const getCreateMetricReductionRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMetricReductionRule>>,
-		TError,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createMetricReductionRule>>,
-	TError,
-	{ data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO> },
-	TContext
-> => {
-	const mutationKey = ['createMetricReductionRule'];
-	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 createMetricReductionRule>>,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createMetricReductionRule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateMetricReductionRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createMetricReductionRule>>
->;
-export type CreateMetricReductionRuleMutationBody =
-	| BodyType<MetricreductionruletypesPostableReductionRuleDTO>
-	| undefined;
-export type CreateMetricReductionRuleMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a metric reduction rule
- */
-export const useCreateMetricReductionRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMetricReductionRule>>,
-		TError,
-		{ data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createMetricReductionRule>>,
-	TError,
-	{ data?: BodyType<MetricreductionruletypesPostableReductionRuleDTO> },
-	TContext
-> => {
-	return useMutation(getCreateMetricReductionRuleMutationOptions(options));
-};
-/**
- * Deletes a volume-control rule by its id.
- * @summary Delete a metric reduction rule by id
- */
-export const deleteMetricReductionRuleByID = (
-	{ id }: DeleteMetricReductionRuleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v2/metric_reduction_rules/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteMetricReductionRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMetricReductionRuleByID>>,
-		TError,
-		{ pathParams: DeleteMetricReductionRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMetricReductionRuleByID>>,
-	TError,
-	{ pathParams: DeleteMetricReductionRuleByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMetricReductionRuleByID'];
-	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 deleteMetricReductionRuleByID>>,
-		{ pathParams: DeleteMetricReductionRuleByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMetricReductionRuleByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMetricReductionRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMetricReductionRuleByID>>
->;
-
-export type DeleteMetricReductionRuleByIDMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a metric reduction rule by id
- */
-export const useDeleteMetricReductionRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMetricReductionRuleByID>>,
-		TError,
-		{ pathParams: DeleteMetricReductionRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMetricReductionRuleByID>>,
-	TError,
-	{ pathParams: DeleteMetricReductionRuleByIDPathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteMetricReductionRuleByIDMutationOptions(options));
-};
-/**
- * Returns a single volume-control rule by its id.
- * @summary Get a metric reduction rule by id
- */
-export const getMetricReductionRuleByID = (
-	{ id }: GetMetricReductionRuleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetMetricReductionRuleByID200>({
-		url: `/api/v2/metric_reduction_rules/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricReductionRuleByIDQueryKey = ({
-	id,
-}: GetMetricReductionRuleByIDPathParameters) => {
-	return [`/api/v2/metric_reduction_rules/${id}`] as const;
-};
-
-export const getGetMetricReductionRuleByIDQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetMetricReductionRuleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricReductionRuleByID>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricReductionRuleByIDQueryKey({ id });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricReductionRuleByID>>
-	> = ({ signal }) => getMetricReductionRuleByID({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleByID>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricReductionRuleByIDQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricReductionRuleByID>>
->;
-export type GetMetricReductionRuleByIDQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a metric reduction rule by id
- */
-
-export function useGetMetricReductionRuleByID<
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetMetricReductionRuleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricReductionRuleByID>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricReductionRuleByIDQueryOptions(
-		{ id },
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get a metric reduction rule by id
- */
-export const invalidateGetMetricReductionRuleByID = async (
-	queryClient: QueryClient,
-	{ id }: GetMetricReductionRuleByIDPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricReductionRuleByIDQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Updates the match type and labels of a volume-control rule by its id; the metric name is immutable.
- * @summary Update a metric reduction rule by id
- */
-export const updateMetricReductionRuleByID = (
-	{ id }: UpdateMetricReductionRuleByIDPathParameters,
-	metricreductionruletypesUpdatableReductionRuleDTO?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UpdateMetricReductionRuleByID200>({
-		url: `/api/v2/metric_reduction_rules/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: metricreductionruletypesUpdatableReductionRuleDTO,
-		signal,
-	});
-};
-
-export const getUpdateMetricReductionRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMetricReductionRuleByID>>,
-		TError,
-		{
-			pathParams: UpdateMetricReductionRuleByIDPathParameters;
-			data?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMetricReductionRuleByID>>,
-	TError,
-	{
-		pathParams: UpdateMetricReductionRuleByIDPathParameters;
-		data?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateMetricReductionRuleByID'];
-	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 updateMetricReductionRuleByID>>,
-		{
-			pathParams: UpdateMetricReductionRuleByIDPathParameters;
-			data?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateMetricReductionRuleByID(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMetricReductionRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMetricReductionRuleByID>>
->;
-export type UpdateMetricReductionRuleByIDMutationBody =
-	| BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>
-	| undefined;
-export type UpdateMetricReductionRuleByIDMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a metric reduction rule by id
- */
-export const useUpdateMetricReductionRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMetricReductionRuleByID>>,
-		TError,
-		{
-			pathParams: UpdateMetricReductionRuleByIDPathParameters;
-			data?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMetricReductionRuleByID>>,
-	TError,
-	{
-		pathParams: UpdateMetricReductionRuleByIDPathParameters;
-		data?: BodyType<MetricreductionruletypesUpdatableReductionRuleDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpdateMetricReductionRuleByIDMutationOptions(options));
-};
-/**
- * Estimates the series reduction and related-asset impact of a candidate volume-control rule without persisting it.
- * @summary Preview a metric reduction rule
- */
-export const previewMetricReductionRule = (
-	metricreductionruletypesPostableReductionRulePreviewDTO?: BodyType<MetricreductionruletypesPostableReductionRulePreviewDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PreviewMetricReductionRule200>({
-		url: `/api/v2/metric_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));
-};
-/**
- * Returns total ingested vs retained series and the estimated monthly savings across all volume-control rules.
- * @summary Metric reduction stats
- */
-export const getMetricReductionRuleStats = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetMetricReductionRuleStats200>({
-		url: `/api/v2/metric_reduction_rules/stats`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricReductionRuleStatsQueryKey = () => {
-	return [`/api/v2/metric_reduction_rules/stats`] as const;
-};
-
-export const getGetMetricReductionRuleStatsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleStats>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricReductionRuleStatsQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricReductionRuleStats>>
-	> = ({ signal }) => getMetricReductionRuleStats(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleStats>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricReductionRuleStatsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricReductionRuleStats>>
->;
-export type GetMetricReductionRuleStatsQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Metric reduction stats
- */
-
-export function useGetMetricReductionRuleStats<
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleStats>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricReductionRuleStatsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Metric reduction stats
- */
-export const invalidateGetMetricReductionRuleStats = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricReductionRuleStatsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns ingested vs retained series over time across all volume-control rules (hourly buckets), in the query-range time-series response shape.
- * @summary Metric reduction volume over time
- */
-export const getMetricReductionRuleTimeseries = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetMetricReductionRuleTimeseries200>({
-		url: `/api/v2/metric_reduction_rules/timeseries`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricReductionRuleTimeseriesQueryKey = () => {
-	return [`/api/v2/metric_reduction_rules/timeseries`] as const;
-};
-
-export const getGetMetricReductionRuleTimeseriesQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricReductionRuleTimeseriesQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>
-	> = ({ signal }) => getMetricReductionRuleTimeseries(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricReductionRuleTimeseriesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>
->;
-export type GetMetricReductionRuleTimeseriesQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Metric reduction volume over time
- */
-
-export function useGetMetricReductionRuleTimeseries<
-	TData = Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricReductionRuleTimeseries>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricReductionRuleTimeseriesQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Metric reduction volume over time
- */
-export const invalidateGetMetricReductionRuleTimeseries = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricReductionRuleTimeseriesQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint returns a list of distinct metric names within the specified time range
  * @summary List metric names

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

@@ -6689,213 +6689,6 @@ export interface LlmpricingruletypesUpdatableLLMPricingRulesDTO {
 	rules: LlmpricingruletypesUpdatableLLMPricingRuleDTO[] | null;
 }
 
-export enum MetricreductionruletypesAssetTypeDTO {
-	dashboard = 'dashboard',
-	alert_rule = 'alert_rule',
-}
-export interface MetricreductionruletypesAffectedWidgetDTO {
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface MetricreductionruletypesAffectedAssetDTO {
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type array,null
-	 */
-	impactedLabels: string[] | null;
-	/**
-	 * @type string
-	 */
-	name: string;
-	type: MetricreductionruletypesAssetTypeDTO;
-	widget?: MetricreductionruletypesAffectedWidgetDTO;
-}
-
-export enum MetricreductionruletypesMatchTypeDTO {
-	drop = 'drop',
-	keep = 'keep',
-}
-export interface MetricreductionruletypesGettableReductionRuleDTO {
-	/**
-	 * @type boolean
-	 */
-	active: boolean;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	effectiveFrom: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	ingestedSeries: number;
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	reductionPercent: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	retainedSeries: number;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface MetricreductionruletypesGettableReductionRulePreviewDTO {
-	/**
-	 * @type array,null
-	 */
-	affectedAssets: MetricreductionruletypesAffectedAssetDTO[] | null;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	currentRetainedSeries: number;
-	/**
-	 * @type array,null
-	 */
-	droppedLabels: string[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	effectiveFrom: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	ingestedSeries: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	reductionPercent: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	retainedSeries: number;
-}
-
-export interface MetricreductionruletypesGettableReductionRuleStatsDTO {
-	/**
-	 * @type number
-	 * @format double
-	 */
-	estimatedMonthlySavingsUsd: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	ingestedSeries: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	retainedSeries: 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;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-}
-
-export interface MetricreductionruletypesPostableReductionRulePreviewDTO {
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	lookbackMs?: number;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-}
-
-export enum MetricreductionruletypesReductionRuleOrderByDTO {
-	metric = 'metric',
-	ingested_volume = 'ingested_volume',
-	reduced_volume = 'reduced_volume',
-	reduction = 'reduction',
-	last_updated = 'last_updated',
-}
-export interface MetricreductionruletypesUpdatableReductionRuleDTO {
-	/**
-	 * @type array,null
-	 */
-	labels: string[] | null;
-	matchType: MetricreductionruletypesMatchTypeDTO;
-}
-
 export interface MetricsexplorertypesInspectMetricsRequestDTO {
 	/**
 	 * @type integer
@@ -8454,6 +8247,48 @@ export interface SpantypesGettableSpanMapperGroupsDTO {
 	items: SpantypesSpanMapperGroupDTO[];
 }
 
+export type SpantypesSpanMapperTestSpanDTOAttributesAnyOf = {
+	[key: string]: unknown;
+};
+
+/**
+ * @nullable
+ */
+export type SpantypesSpanMapperTestSpanDTOAttributes =
+	SpantypesSpanMapperTestSpanDTOAttributesAnyOf | null;
+
+export type SpantypesSpanMapperTestSpanDTOResourceAnyOf = {
+	[key: string]: unknown;
+};
+
+/**
+ * @nullable
+ */
+export type SpantypesSpanMapperTestSpanDTOResource =
+	SpantypesSpanMapperTestSpanDTOResourceAnyOf | null;
+
+export interface SpantypesSpanMapperTestSpanDTO {
+	/**
+	 * @type object,null
+	 */
+	attributes?: SpantypesSpanMapperTestSpanDTOAttributes;
+	/**
+	 * @type object,null
+	 */
+	resource?: SpantypesSpanMapperTestSpanDTOResource;
+}
+
+export interface SpantypesGettableSpanMapperTestDTO {
+	/**
+	 * @type array,null
+	 */
+	collectorLogs?: string[] | null;
+	/**
+	 * @type array,null
+	 */
+	spans: SpantypesSpanMapperTestSpanDTO[] | null;
+}
+
 export enum SpantypesSpanAggregationTypeDTO {
 	span_count = 'span_count',
 	execution_time_percentage = 'execution_time_percentage',
@@ -8749,6 +8584,33 @@ export interface SpantypesPostableSpanMapperGroupDTO {
 	name: string;
 }
 
+export interface SpantypesPostableSpanMapperTestGroupDTO {
+	condition: SpantypesSpanMapperGroupConditionDTO | null;
+	/**
+	 * @type boolean
+	 */
+	enabled?: boolean;
+	/**
+	 * @type array,null
+	 */
+	mappers?: SpantypesPostableSpanMapperDTO[] | null;
+	/**
+	 * @type string
+	 */
+	name: string;
+}
+
+export interface SpantypesPostableSpanMapperTestDTO {
+	/**
+	 * @type array,null
+	 */
+	groups: SpantypesPostableSpanMapperTestGroupDTO[] | null;
+	/**
+	 * @type array,null
+	 */
+	spans: SpantypesSpanMapperTestSpanDTO[] | null;
+}
+
 export interface SpantypesSpanAggregationDTO {
 	aggregation: SpantypesSpanAggregationTypeDTO;
 	field: TelemetrytypesTelemetryFieldKeyDTO;
@@ -10130,6 +9992,14 @@ export type UpdateSpanMapperPathParameters = {
 	groupId: string;
 	mapperId: string;
 };
+export type TestSpanMappers200 = {
+	data: SpantypesGettableSpanMapperTestDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type GetStats200Data = { [key: string]: unknown };
 
 export type GetStats200 = {
@@ -10541,102 +10411,6 @@ export type Livez200 = {
 	status: string;
 };
 
-export type ListMetricReductionRulesParams = {
-	/**
-	 * @description undefined
-	 */
-	orderBy?: MetricreductionruletypesReductionRuleOrderByDTO;
-	/**
-	 * @description undefined
-	 */
-	order?: MetricreductionruletypesOrderDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	search?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	metricName?: string;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-};
-
-export type ListMetricReductionRules200 = {
-	data: MetricreductionruletypesGettableReductionRulesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateMetricReductionRule201 = {
-	data: MetricreductionruletypesGettableReductionRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteMetricReductionRuleByIDPathParameters = {
-	id: string;
-};
-export type GetMetricReductionRuleByIDPathParameters = {
-	id: string;
-};
-export type GetMetricReductionRuleByID200 = {
-	data: MetricreductionruletypesGettableReductionRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type UpdateMetricReductionRuleByIDPathParameters = {
-	id: string;
-};
-export type UpdateMetricReductionRuleByID200 = {
-	data: MetricreductionruletypesGettableReductionRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type PreviewMetricReductionRule200 = {
-	data: MetricreductionruletypesGettableReductionRulePreviewDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetMetricReductionRuleStats200 = {
-	data: MetricreductionruletypesGettableReductionRuleStatsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetMetricReductionRuleTimeseries200 = {
-	data: Querybuildertypesv5QueryRangeResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListMetricsParams = {
 	/**
 	 * @type integer,null

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

@@ -30,8 +30,10 @@ import type {
 	RenderErrorResponseDTO,
 	SpantypesPostableSpanMapperDTO,
 	SpantypesPostableSpanMapperGroupDTO,
+	SpantypesPostableSpanMapperTestDTO,
 	SpantypesUpdatableSpanMapperDTO,
 	SpantypesUpdatableSpanMapperGroupDTO,
+	TestSpanMappers200,
 	UpdateSpanMapperGroupPathParameters,
 	UpdateSpanMapperPathParameters,
 } from '../sigNoz.schemas';
@@ -780,3 +782,86 @@ export const useUpdateSpanMapper = <
 > => {
 	return useMutation(getUpdateSpanMapperMutationOptions(options));
 };
+/**
+ * Tests how span mappers would transform sample spans
+ * @summary Test span mappers against sample spans
+ */
+export const testSpanMappers = (
+	spantypesPostableSpanMapperTestDTO?: BodyType<SpantypesPostableSpanMapperTestDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<TestSpanMappers200>({
+		url: `/api/v1/span_mapper_groups/test`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: spantypesPostableSpanMapperTestDTO,
+		signal,
+	});
+};
+
+export const getTestSpanMappersMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testSpanMappers>>,
+		TError,
+		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof testSpanMappers>>,
+	TError,
+	{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
+	TContext
+> => {
+	const mutationKey = ['testSpanMappers'];
+	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 testSpanMappers>>,
+		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return testSpanMappers(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type TestSpanMappersMutationResult = NonNullable<
+	Awaited<ReturnType<typeof testSpanMappers>>
+>;
+export type TestSpanMappersMutationBody =
+	| BodyType<SpantypesPostableSpanMapperTestDTO>
+	| undefined;
+export type TestSpanMappersMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Test span mappers against sample spans
+ */
+export const useTestSpanMappers = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testSpanMappers>>,
+		TError,
+		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof testSpanMappers>>,
+	TError,
+	{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
+	TContext
+> => {
+	return useMutation(getTestSpanMappersMutationOptions(options));
+};

go.mod

@@ -9,7 +9,7 @@ require (
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/clickhouse-go-mock v0.14.0
 	github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd
-	github.com/SigNoz/signoz-otel-collector v0.144.3
+	github.com/SigNoz/signoz-otel-collector v0.144.6-rc.1.0.20260625043036-fb3dbb450bbd
 	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/antonmedv/expr v1.15.3
 	github.com/bytedance/sonic v1.14.1
@@ -150,10 +150,6 @@ require (
 	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
-	go.opentelemetry.io/collector/client v1.54.0 // indirect
-	go.opentelemetry.io/collector/config/configoptional v1.50.0 // indirect
-	go.opentelemetry.io/collector/config/configretry v1.50.0 // indirect
-	go.opentelemetry.io/collector/exporter/exporterhelper v0.144.0 // indirect
 	go.opentelemetry.io/collector/internal/componentalias v0.148.0 // indirect
 	go.opentelemetry.io/collector/pdata/xpdata v0.148.0 // indirect
 	go.uber.org/goleak v1.3.0 // indirect

go.sum

@@ -110,11 +110,13 @@ github.com/SigNoz/expr v1.17.7-beta h1:FyZkleM5dTQ0O6muQfwGpoH5A2ohmN/XTasRCO72g
 github.com/SigNoz/expr v1.17.7-beta/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd h1:Bk43AsDYe0fhkbj57eGXx8H3ZJ4zhmQXBnrW523ktj8=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd/go.mod h1:nxRcH/OEdM8QxzH37xkGzomr1O0JpYBRS6pwjsWW6Pc=
-github.com/SigNoz/signoz-otel-collector v0.144.3 h1:/7PPIqIpPsaWtrgnfHam2XVYP41ZlgEKLHzQO8oVxcA=
-github.com/SigNoz/signoz-otel-collector v0.144.3/go.mod h1:9pLVpcIQvUT88ZiNnZN/MI+XLruvwC+Xm2UzPmGjNfA=
+github.com/SigNoz/signoz-otel-collector v0.144.6-rc.1.0.20260625043036-fb3dbb450bbd h1:MGQATRMNEsBrdHzHb7uj2JIzLXXgQNcNxZHfmAAIIs8=
+github.com/SigNoz/signoz-otel-collector v0.144.6-rc.1.0.20260625043036-fb3dbb450bbd/go.mod h1:Jw1Y3s/ZOSz6RmLjZtj2A7wK6bse0T4pxs+oggBQnSs=
 github.com/Yiling-J/theine-go v0.6.2 h1:1GeoXeQ0O0AUkiwj2S9Jc0Mzx+hpqzmqsJ4kIC4M9AY=
 github.com/Yiling-J/theine-go v0.6.2/go.mod h1:08QpMa5JZ2pKN+UJCRrCasWYO1IKCdl54Xa836rpmDU=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
+github.com/alecthomas/participle/v2 v2.1.4 h1:W/H79S8Sat/krZ3el6sQMvMaahJ+XcM9WSI2naI7w2U=
+github.com/alecthomas/participle/v2 v2.1.4/go.mod h1:8tqVbpTX20Ru4NfYQgZf4mP18eXPTBViyMWiArNEgGI=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
@@ -124,6 +126,10 @@ github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b h1:mimo19zliBX/vS
 github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b/go.mod h1:fvzegU4vN3H1qMT+8wDmzjAcDONcgo2/SZ/TyfdUOFs=
 github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
 github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+github.com/antchfx/xmlquery v1.5.0 h1:uAi+mO40ZWfyU6mlUBxRVvL6uBNZ6LMU4M3+mQIBV4c=
+github.com/antchfx/xmlquery v1.5.0/go.mod h1:lJfWRXzYMK1ss32zm1GQV3gMIW/HFey3xDZmkP1SuNc=
+github.com/antchfx/xpath v1.3.6 h1:s0y+ElRRtTQdfHP609qFu0+c6bglDv20pqOViQjjdPI=
+github.com/antchfx/xpath v1.3.6/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ=
 github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw=
@@ -286,6 +292,8 @@ github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s
 github.com/ebitengine/purego v0.9.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/edsrzf/mmap-go v1.2.0 h1:hXLYlkbaPzt1SaQk+anYwKSRNhufIDCchSPkUD6dD84=
 github.com/edsrzf/mmap-go v1.2.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q=
+github.com/elastic/go-grok v0.3.1 h1:WEhUxe2KrwycMnlvMimJXvzRa7DoByJB4PVUIE1ZD/U=
+github.com/elastic/go-grok v0.3.1/go.mod h1:n38ls8ZgOboZRgKcjMY8eFeZFMmcL9n2lP0iHhIDk64=
 github.com/elastic/lunes v0.2.0 h1:WI3bsdOTuaYXVe2DS1KbqA7u7FOHN4o8qJw80ZyZoQs=
 github.com/elastic/lunes v0.2.0/go.mod h1:u3W/BdONWTrh0JjNZ21C907dDc+cUZttZrGa625nf2k=
 github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 h1:oP4q0fw+fOSWn3DfFi4EXdT+B+gTtzx8GC9xsc26Znk=
@@ -461,6 +469,7 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
@@ -674,6 +683,8 @@ github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI
 github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
 github.com/iancoleman/orderedmap v0.3.0 h1:5cbR2grmZR/DiVt+VJopEhtVs9YGInGIxAoMJn+Ichc=
 github.com/iancoleman/orderedmap v0.3.0/go.mod h1:XuLcCUkdL5owUCQeF2Ue9uuw1EptkJDkXXS7VoV7XGE=
+github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
+github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -866,12 +877,18 @@ github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal
 github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal v0.144.0/go.mod h1:O2rZKRXk1WeYhzfJBVXES/g7+PlIds/TzPZW/4NfTNA=
 github.com/open-telemetry/opentelemetry-collector-contrib/internal/exp/metrics v0.148.0 h1:CiTjQE/Hh5xK2t56ogrDK4nl0+tJPNmASCs4zEYZ/xU=
 github.com/open-telemetry/opentelemetry-collector-contrib/internal/exp/metrics v0.148.0/go.mod h1:WUFkzTiOpt7EYyL67gv1GOf3RD8qKWGtin3lY9LYzW4=
+github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter v0.144.0 h1:Ywu5mU4K5TMJigiXdyZloCRs/cq3/2OnoK3WjxNHWJo=
+github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter v0.144.0/go.mod h1:iebqlu6UvpiV1hO37r1sXA9fXaCaA8sQXilG0///xss=
+github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl v0.144.0 h1:TMRTvQSAeeLtkKwSrqcbectxDRPiqB6yYM3IvjC75es=
+github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl v0.144.0/go.mod h1:1HU0qJ4hFrphDebuBs3I4DPQ6zyBFGinQ5/bXEUM7pw=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatatest v0.148.0 h1:i12duJOl5VCb9mbb8FfZCaP2CjeXbNsbg82JjSe7sy8=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatatest v0.148.0/go.mod h1:jyw+QvkmCrF/oYy31O2ndb5KZZK4l+iR89msnV3LN/k=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil v0.148.0 h1:1TLg6YrS3Au6F7xw3ws2Njbwj13IMqPplvGFi+18fWs=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil v0.148.0/go.mod h1:P8hZEDIQk4REgUWyLhSVRHwTxK6KkifKfg36BmmQ/DI=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza v0.144.0 h1:EIAygME70IOdEwaSr6bA3Wcdp7hXEqRsGsVfrI5v8OA=
 github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza v0.144.0/go.mod h1:3Y6ctEEwRg19B0jqsrQH6Hiquqte+zC0ZxpXLLSa5sA=
+github.com/open-telemetry/opentelemetry-collector-contrib/processor/attributesprocessor v0.144.0 h1:gRk73SsIJv3q/HI0kxMRN5TiIiJj+MRxrz0GEYx3jZw=
+github.com/open-telemetry/opentelemetry-collector-contrib/processor/attributesprocessor v0.144.0/go.mod h1:7b8ZcPdN6JSm6+LUq3rienoqHHiX60kyoOHDPCMM+L8=
 github.com/open-telemetry/opentelemetry-collector-contrib/processor/deltatocumulativeprocessor v0.148.0 h1:xgD/kNGp/wWY+bwY599Pc01OamYN17phRiTP934bM5Y=
 github.com/open-telemetry/opentelemetry-collector-contrib/processor/deltatocumulativeprocessor v0.148.0/go.mod h1:ZK7wvaefla9lB3bAW0rNKt7IzRPcTRQoOFqr4sZy/XM=
 github.com/open-telemetry/opentelemetry-collector-contrib/processor/logstransformprocessor v0.144.0 h1:HbmpzTixpQG/xGhQuQoiJTXQPrixe+yivAsF6tl2o4g=
@@ -1119,6 +1136,10 @@ github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GH
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/twmb/murmur3 v1.1.8 h1:8Yt9taO/WN3l08xErzjeschgZU2QSrwm1kclYq+0aRg=
+github.com/twmb/murmur3 v1.1.8/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ=
+github.com/ua-parser/uap-go v0.0.0-20240611065828-3a4781585db6 h1:SIKIoA4e/5Y9ZOl0DCe3eVMLPOQzJxgZpfdHHeauNTM=
+github.com/ua-parser/uap-go v0.0.0-20240611065828-3a4781585db6/go.mod h1:BUbeWZiieNxAuuADTBNb3/aeje6on3DhU3rpWsQSB1E=
 github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
 github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
 github.com/uptrace/bun v1.2.9 h1:OOt2DlIcRUMSZPr6iXDFg/LaQd59kOxbAjpIVHddKRs=

pkg/apiserver/signozapiserver/metricreductionrule.go

@@ -1,156 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addMetricReductionRuleRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/metric_reduction_rules", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.List),
-		handler.OpenAPIDef{
-			ID:                  "ListMetricReductionRules",
-			Tags:                []string{"metrics"},
-			Summary:             "List metric reduction rules",
-			Description:         "Returns active metric volume-control (label reduction) rules.",
-			RequestQuery:        new(metricreductionruletypes.ListReductionRulesParams),
-			Response:            new(metricreductionruletypes.GettableReductionRules),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusUnauthorized, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.Create),
-		handler.OpenAPIDef{
-			ID:                  "CreateMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Create a metric reduction rule",
-			Description:         "Creates a volume-control rule for a metric and returns it with its id; fails if the metric already has a rule.",
-			Request:             new(metricreductionruletypes.PostableReductionRule),
-			RequestContentType:  "application/json",
-			Response:            new(metricreductionruletypes.GettableReductionRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusConflict, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/stats", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.Stats),
-		handler.OpenAPIDef{
-			ID:                  "GetMetricReductionRuleStats",
-			Tags:                []string{"metrics"},
-			Summary:             "Metric reduction stats",
-			Description:         "Returns total ingested vs retained series and the estimated monthly savings across all volume-control rules.",
-			Response:            new(metricreductionruletypes.GettableReductionRuleStats),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusUnauthorized, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/timeseries", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.Timeseries),
-		handler.OpenAPIDef{
-			ID:                  "GetMetricReductionRuleTimeseries",
-			Tags:                []string{"metrics"},
-			Summary:             "Metric reduction volume over time",
-			Description:         "Returns ingested vs retained series over time across all volume-control rules (hourly buckets), in the query-range time-series response shape.",
-			Response:            new(querybuildertypesv5.QueryRangeResponse),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusUnauthorized, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/preview", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.Preview),
-		handler.OpenAPIDef{
-			ID:                  "PreviewMetricReductionRule",
-			Tags:                []string{"metrics"},
-			Summary:             "Preview a metric reduction rule",
-			Description:         "Estimates the series reduction and related-asset impact of a candidate volume-control rule without persisting it.",
-			Request:             new(metricreductionruletypes.PostableReductionRulePreview),
-			RequestContentType:  "application/json",
-			Response:            new(metricreductionruletypes.GettableReductionRulePreview),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/{id}", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.metricReductionRuleHandler.GetByID),
-		handler.OpenAPIDef{
-			ID:                  "GetMetricReductionRuleByID",
-			Tags:                []string{"metrics"},
-			Summary:             "Get a metric reduction rule by id",
-			Description:         "Returns a single volume-control rule by its id.",
-			Response:            new(metricreductionruletypes.GettableReductionRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusUnauthorized, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/{id}", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.UpdateByID),
-		handler.OpenAPIDef{
-			ID:                  "UpdateMetricReductionRuleByID",
-			Tags:                []string{"metrics"},
-			Summary:             "Update a metric reduction rule by id",
-			Description:         "Updates the match type and labels of a volume-control rule by its id; the metric name is immutable.",
-			Request:             new(metricreductionruletypes.UpdatableReductionRule),
-			RequestContentType:  "application/json",
-			Response:            new(metricreductionruletypes.GettableReductionRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/metric_reduction_rules/{id}", handler.New(
-		provider.authzMiddleware.AdminAccess(provider.metricReductionRuleHandler.DeleteByID),
-		handler.OpenAPIDef{
-			ID:                "DeleteMetricReductionRuleByID",
-			Tags:              []string{"metrics"},
-			Summary:           "Delete a metric reduction rule by id",
-			Description:       "Deletes a volume-control rule by its id.",
-			SuccessStatusCode: http.StatusNoContent,
-			ErrorStatusCodes:  []int{http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusNotImplemented, http.StatusUnavailableForLegalReasons, http.StatusInternalServerError},
-			SecuritySchemes:   newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

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

pkg/apiserver/signozapiserver/spanmapper.go

@@ -51,6 +51,26 @@ func (provider *provider) addSpanMapperRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v1/span_mapper_groups/test", handler.New(
+		provider.authzMiddleware.ViewAccess(provider.spanMapperHandler.TestMappers),
+		handler.OpenAPIDef{
+			ID:                  "TestSpanMappers",
+			Tags:                []string{"spanmapper"},
+			Summary:             "Test span mappers against sample spans",
+			Description:         "Tests how span mappers would transform sample spans",
+			Request:             new(spantypes.PostableSpanMapperTest),
+			RequestContentType:  "application/json",
+			Response:            new(spantypes.GettableSpanMapperTest),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
 	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}", handler.New(
 		provider.authzMiddleware.AdminAccess(provider.spanMapperHandler.UpdateGroup),
 		handler.OpenAPIDef{

pkg/modules/metricreductionrule/implmetricreductionrule/handler.go

@@ -1,198 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module metricreductionrule.Module
-}
-
-func NewHandler(module metricreductionrule.Module) metricreductionrule.Handler {
-	return &handler{module: module}
-}
-
-func idFromPath(r *http.Request) (valuer.UUID, error) {
-	id, err := valuer.NewUUID(mux.Vars(r)["id"])
-	if err != nil {
-		return valuer.UUID{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "id must be a valid uuid")
-	}
-	return id, nil
-}
-
-func (h *handler) List(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var params metricreductionruletypes.ListReductionRulesParams
-	if err := binding.Query.BindQuery(r.URL.Query(), &params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.List(r.Context(), valuer.MustNewUUID(claims.OrgID), &params)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Preview(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var in metricreductionruletypes.PostableReductionRulePreview
-	if err := binding.JSON.BindBody(r.Body, &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Preview(r.Context(), valuer.MustNewUUID(claims.OrgID), &in)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Stats(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Stats(r.Context(), valuer.MustNewUUID(claims.OrgID))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Timeseries(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.Timeseries(r.Context(), valuer.MustNewUUID(claims.OrgID))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) Create(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var in metricreductionruletypes.PostableReductionRule
-	if err := binding.JSON.BindBody(r.Body, &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	out, err := h.module.Create(r.Context(), valuer.MustNewUUID(claims.OrgID), claims.Email, &in)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, out)
-}
-
-func (h *handler) GetByID(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := idFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.GetByID(r.Context(), valuer.MustNewUUID(claims.OrgID), id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) UpdateByID(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := idFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var in metricreductionruletypes.UpdatableReductionRule
-	if err := binding.JSON.BindBody(r.Body, &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := h.module.UpdateByID(r.Context(), valuer.MustNewUUID(claims.OrgID), claims.Email, id, &in)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (h *handler) DeleteByID(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := idFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteByID(r.Context(), valuer.MustNewUUID(claims.OrgID), id); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}

pkg/modules/metricreductionrule/implmetricreductionrule/module.go

@@ -1,52 +0,0 @@
-package implmetricreductionrule
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/metricreductionrule"
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct{}
-
-func NewModule() metricreductionrule.Module {
-	return &module{}
-}
-
-var errUnsupported = errors.New(errors.TypeUnsupported, metricreductionruletypes.ErrCodeMetricReductionRuleUnsupported,
-	"metric volume control is an enterprise feature")
-
-func (m *module) List(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) Create(_ context.Context, _ valuer.UUID, _ string, _ *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) GetByID(_ context.Context, _ valuer.UUID, _ valuer.UUID) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) UpdateByID(_ context.Context, _ valuer.UUID, _ string, _ valuer.UUID, _ *metricreductionruletypes.UpdatableReductionRule) (*metricreductionruletypes.GettableReductionRule, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) DeleteByID(_ context.Context, _ valuer.UUID, _ valuer.UUID) error {
-	return errUnsupported
-}
-
-func (m *module) Preview(_ context.Context, _ valuer.UUID, _ *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) Stats(_ context.Context, _ valuer.UUID) (*metricreductionruletypes.GettableReductionRuleStats, error) {
-	return nil, errUnsupported
-}
-
-func (m *module) Timeseries(_ context.Context, _ valuer.UUID) (*querybuildertypesv5.QueryRangeResponse, error) {
-	return nil, errUnsupported
-}

pkg/modules/metricreductionrule/metricreductionrule.go

@@ -1,32 +0,0 @@
-package metricreductionrule
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Module interface {
-	List(ctx context.Context, orgID valuer.UUID, params *metricreductionruletypes.ListReductionRulesParams) (*metricreductionruletypes.GettableReductionRules, error)
-	Create(ctx context.Context, orgID valuer.UUID, userEmail string, req *metricreductionruletypes.PostableReductionRule) (*metricreductionruletypes.GettableReductionRule, error)
-	GetByID(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*metricreductionruletypes.GettableReductionRule, error)
-	UpdateByID(ctx context.Context, orgID valuer.UUID, userEmail string, id valuer.UUID, req *metricreductionruletypes.UpdatableReductionRule) (*metricreductionruletypes.GettableReductionRule, error)
-	DeleteByID(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-	Preview(ctx context.Context, orgID valuer.UUID, req *metricreductionruletypes.PostableReductionRulePreview) (*metricreductionruletypes.GettableReductionRulePreview, error)
-	Stats(ctx context.Context, orgID valuer.UUID) (*metricreductionruletypes.GettableReductionRuleStats, error)
-	Timeseries(ctx context.Context, orgID valuer.UUID) (*querybuildertypesv5.QueryRangeResponse, error)
-}
-
-type Handler interface {
-	List(rw http.ResponseWriter, r *http.Request)
-	Create(rw http.ResponseWriter, r *http.Request)
-	GetByID(rw http.ResponseWriter, r *http.Request)
-	UpdateByID(rw http.ResponseWriter, r *http.Request)
-	DeleteByID(rw http.ResponseWriter, r *http.Request)
-	Preview(rw http.ResponseWriter, r *http.Request)
-	Stats(rw http.ResponseWriter, r *http.Request)
-	Timeseries(rw http.ResponseWriter, r *http.Request)
-}

pkg/modules/spanmapper/implspanmapper/handler.go

@@ -273,6 +273,35 @@ func (h *handler) DeleteMapper(rw http.ResponseWriter, r *http.Request) {
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
+// TestMappers handles POST /api/v1/span_mapper_groups/test.
+func (h *handler) TestMappers(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID := valuer.MustNewUUID(claims.OrgID)
+
+	req := new(spantypes.PostableSpanMapperTest)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groups := spantypes.NewSpanMapperGroupsWithMappersFromPostable(orgID, req.Groups)
+	out, collectorLogs, err := h.module.TestMappers(ctx, orgID, req.Spans, groups)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, &spantypes.GettableSpanMapperTest{Spans: out, CollectorLogs: collectorLogs})
+}
+
 // groupIDFromPath extracts and validates the {id} or {groupId} path variable.
 func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
 	vars := mux.Vars(r)

pkg/modules/spanmapper/implspanmapper/module.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/types/opamptypes"
@@ -102,6 +103,56 @@ func (module *module) DeleteMapper(ctx context.Context, orgID, groupID, id value
 	return nil
 }
 
+func (module *module) TestMappers(ctx context.Context, orgID valuer.UUID, spans []spantypes.SpanMapperTestSpan, groups []*spantypes.SpanMapperGroupWithMappers) ([]spantypes.SpanMapperTestSpan, []string, error) {
+	if len(spans) == 0 {
+		return nil, nil, errors.New(errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "'spans' must contain at least one span")
+	}
+
+	resolved, err := module.backfillMappers(ctx, orgID, groups)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out, collectorLogs, err := spantypes.SimulateSpanMappersProcessing(ctx, resolved, spans)
+	if err != nil {
+		return nil, nil, err
+	}
+	return out, collectorLogs, nil
+}
+
+// backfillMappers loads saved mappers for any group whose Mappers is nil.
+func (module *module) backfillMappers(ctx context.Context, orgID valuer.UUID, groups []*spantypes.SpanMapperGroupWithMappers) ([]*spantypes.SpanMapperGroupWithMappers, error) {
+	// Load the enabled saved groups for this org, so we can look up by name.
+	// Disabled groups aren't part of the live collector config, so there's
+	// nothing to backfill from them.
+	enabled := true
+	savedGroups, err := module.store.ListGroups(ctx, orgID, &spantypes.ListSpanMapperGroupsQuery{Enabled: &enabled})
+	if err != nil {
+		return nil, err
+	}
+	savedByName := make(map[string]*spantypes.SpanMapperGroup, len(savedGroups))
+	for _, g := range savedGroups {
+		savedByName[g.Name] = g
+	}
+
+	// For each group in the request, if Mappers is nil, load the saved mappers for that group name.
+	for _, g := range groups {
+		if g.Mappers != nil {
+			continue
+		}
+		saved, ok := savedByName[g.Group.Name]
+		if !ok {
+			return nil, errors.Newf(errors.TypeInvalidInput, spantypes.ErrCodeMappingGroupNotFound, "no saved group named %q to load mappers from; send 'mappers' for new or edited groups", g.Group.Name)
+		}
+		loaded, err := module.store.ListMappers(ctx, orgID, saved.ID)
+		if err != nil {
+			return nil, err
+		}
+		g.Mappers = loaded
+	}
+	return groups, nil
+}
+
 func (module *module) AgentFeatureType() agentConf.AgentFeatureType {
 	return spantypes.SpanAttrMappingFeatureType
 }

pkg/modules/spanmapper/spanmapper.go

@@ -27,6 +27,7 @@ type Module interface {
 	CreateMapper(ctx context.Context, orgID, groupID valuer.UUID, mapper *spantypes.SpanMapper) error
 	UpdateMapper(ctx context.Context, orgID, groupID, id valuer.UUID, fieldContext spantypes.FieldContext, config *spantypes.SpanMapperConfig, enabled *bool, updatedBy string) error
 	DeleteMapper(ctx context.Context, orgID, groupID, id valuer.UUID) error
+	TestMappers(ctx context.Context, orgID valuer.UUID, spans []spantypes.SpanMapperTestSpan, groups []*spantypes.SpanMapperGroupWithMappers) ([]spantypes.SpanMapperTestSpan, []string, error)
 }
 
 // Handler defines the HTTP handler interface for mapping group and mapper endpoints.
@@ -42,4 +43,5 @@ type Handler interface {
 	CreateMapper(rw http.ResponseWriter, r *http.Request)
 	UpdateMapper(rw http.ResponseWriter, r *http.Request)
 	DeleteMapper(rw http.ResponseWriter, r *http.Request)
+	TestMappers(rw http.ResponseWriter, r *http.Request)
 }

pkg/signoz/handler.go

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

pkg/signoz/handler_test.go

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

pkg/signoz/module.go

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

pkg/signoz/module_test.go

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

pkg/signoz/openapi.go

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

pkg/signoz/provider.go

@@ -295,7 +295,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			modules.Dashboard,
 			handlers.Dashboard,
 			handlers.MetricsExplorer,
-			handlers.MetricReductionRule,
 			handlers.InfraMonitoring,
 			handlers.GatewayHandler,
 			handlers.Fields,

pkg/signoz/signoz.go

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

pkg/types/metricreductionruletypes/list.go

@@ -1,59 +0,0 @@
-package metricreductionruletypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Order struct {
-	valuer.String
-}
-
-var (
-	OrderAsc  = Order{valuer.NewString("asc")}
-	OrderDesc = Order{valuer.NewString("desc")}
-)
-
-func (Order) Enum() []any {
-	return []any{OrderAsc, OrderDesc}
-}
-
-type ReductionRuleOrderBy struct {
-	valuer.String
-}
-
-var (
-	OrderByMetricName     = ReductionRuleOrderBy{valuer.NewString("metric")}
-	OrderByIngestedVolume = ReductionRuleOrderBy{valuer.NewString("ingested_volume")}
-	OrderByReducedVolume  = ReductionRuleOrderBy{valuer.NewString("reduced_volume")}
-	OrderByReduction      = ReductionRuleOrderBy{valuer.NewString("reduction")}
-	OrderByLastUpdated    = ReductionRuleOrderBy{valuer.NewString("last_updated")}
-)
-
-func (ReductionRuleOrderBy) Enum() []any {
-	return []any{OrderByMetricName, OrderByIngestedVolume, OrderByReducedVolume, OrderByReduction, OrderByLastUpdated}
-}
-
-type ListReductionRulesParams struct {
-	OrderBy    ReductionRuleOrderBy `query:"orderBy,default=reduction" json:"orderBy"`
-	Order      Order                `query:"order,default=desc" json:"order"`
-	Search     string               `query:"search" json:"search"`
-	MetricName string               `query:"metricName" json:"metricName,omitempty"`
-	Offset     int                  `query:"offset" json:"offset"`
-	Limit      int                  `query:"limit,default=10" json:"limit"`
-}
-
-const maxReductionRulesPageSize = 1000
-
-func (p *ListReductionRulesParams) Validate() error {
-	if p.Limit <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be greater than 0")
-	}
-	if p.Limit > maxReductionRulesPageSize {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must not exceed %d", maxReductionRulesPageSize)
-	}
-	if p.Offset < 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset must not be negative")
-	}
-	return nil
-}

pkg/types/metricreductionruletypes/list_test.go

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

pkg/types/metricreductionruletypes/preview.go

@@ -1,68 +0,0 @@
-package metricreductionruletypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type AssetType struct {
-	valuer.String
-}
-
-var (
-	AssetTypeDashboard = AssetType{valuer.NewString("dashboard")}
-	AssetTypeAlert     = AssetType{valuer.NewString("alert_rule")}
-)
-
-func (AssetType) Enum() []any {
-	return []any{AssetTypeDashboard, AssetTypeAlert}
-}
-
-type PostableReductionRulePreview struct {
-	MetricName string    `json:"metricName" required:"true"`
-	MatchType  MatchType `json:"matchType" required:"true"`
-	Labels     []string  `json:"labels" required:"true" nullable:"true"`
-	LookbackMs int64     `json:"lookbackMs,omitempty"`
-}
-
-func (req *PostableReductionRulePreview) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-	if req.MetricName == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-	if req.MatchType != MatchTypeDrop && req.MatchType != MatchTypeKeep {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"matchType must be one of %q or %q", MatchTypeDrop.StringValue(), MatchTypeKeep.StringValue())
-	}
-	if len(req.Labels) == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "labels must not be empty")
-	}
-	return nil
-}
-
-type AffectedWidget struct {
-	ID   string `json:"id" required:"true"`
-	Name string `json:"name" required:"true"`
-}
-
-type AffectedAsset struct {
-	Type           AssetType       `json:"type" required:"true"`
-	ID             string          `json:"id" required:"true"`
-	Name           string          `json:"name" required:"true"`
-	Widget         *AffectedWidget `json:"widget,omitempty"`
-	ImpactedLabels []string        `json:"impactedLabels" required:"true" nullable:"true"`
-}
-
-type GettableReductionRulePreview struct {
-	IngestedSeries        uint64          `json:"ingestedSeries" required:"true"`
-	CurrentRetainedSeries uint64          `json:"currentRetainedSeries" required:"true"`
-	RetainedSeries        uint64          `json:"retainedSeries" required:"true"`
-	ReductionPercent      float64         `json:"reductionPercent" required:"true"`
-	DroppedLabels         []string        `json:"droppedLabels" required:"true" nullable:"true"`
-	AffectedAssets        []AffectedAsset `json:"affectedAssets" required:"true" nullable:"true"`
-	EffectiveFrom         time.Time       `json:"effectiveFrom" required:"true"`
-}

pkg/types/metricreductionruletypes/reduction_rule.go

@@ -1,168 +0,0 @@
-package metricreductionruletypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-var (
-	ErrCodeMetricReductionRuleUnsupported           = errors.MustNewCode("metric_reduction_rule_unsupported")
-	ErrCodeMetricReductionRuleNotFound              = errors.MustNewCode("metric_reduction_rule_not_found")
-	ErrCodeMetricReductionRuleAlreadyExists         = errors.MustNewCode("metric_reduction_rule_already_exists")
-	ErrCodeMetricReductionRuleProtectedLabel        = errors.MustNewCode("metric_reduction_rule_protected_label")
-	ErrCodeMetricReductionRuleUnsupportedMetricType = errors.MustNewCode("metric_reduction_rule_unsupported_metric_type")
-)
-
-type MatchType struct {
-	valuer.String
-}
-
-var (
-	MatchTypeDrop = MatchType{valuer.NewString("drop")}
-	MatchTypeKeep = MatchType{valuer.NewString("keep")}
-)
-
-func (MatchType) Enum() []any {
-	return []any{MatchTypeDrop, MatchTypeKeep}
-}
-
-// LabelList is a []string persisted as a single JSON text column.
-type LabelList []string
-
-func (l LabelList) Value() (driver.Value, error) {
-	if l == nil {
-		return "[]", nil
-	}
-	b, err := json.Marshal(l)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (l *LabelList) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*l = nil
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "metricreductionruletypes: cannot scan %T into LabelList", src)
-	}
-	return json.Unmarshal(raw, l)
-}
-
-type ReductionRule struct {
-	bun.BaseModel `bun:"table:metric_reduction_rule" json:"-"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID         valuer.UUID `bun:"org_id,type:text,notnull"`
-	MetricName    string      `bun:"metric_name,type:text,notnull"`
-	MatchType     MatchType   `bun:"match_type,type:text,notnull"`
-	Labels        LabelList   `bun:"labels,type:text,notnull,default:'[]'"`
-	EffectiveFrom time.Time   `bun:"effective_from,notnull"`
-}
-
-func NewReductionRule(orgID valuer.UUID, metricName string, matchType MatchType, labels []string, effectiveFrom time.Time, by string) *ReductionRule {
-	now := time.Now()
-	return &ReductionRule{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable: types.UserAuditable{CreatedBy: by, UpdatedBy: by},
-		OrgID:         orgID,
-		MetricName:    metricName,
-		MatchType:     matchType,
-		Labels:        LabelList(labels),
-		EffectiveFrom: effectiveFrom,
-	}
-}
-
-type GettableReductionRule struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	MetricName       string    `json:"metricName" required:"true"`
-	MatchType        MatchType `json:"matchType" required:"true"`
-	Labels           []string  `json:"labels" required:"true" nullable:"true"`
-	EffectiveFrom    time.Time `json:"effectiveFrom" required:"true"`
-	Active           bool      `json:"active" required:"true"`
-	IngestedSeries   uint64    `json:"ingestedSeries" required:"true"`
-	RetainedSeries   uint64    `json:"retainedSeries" required:"true"`
-	ReductionPercent float64   `json:"reductionPercent" required:"true"`
-}
-
-type GettableReductionRules struct {
-	Rules []GettableReductionRule `json:"rules" required:"true" nullable:"true"`
-	Total int                     `json:"total" required:"true"`
-}
-
-type UpdatableReductionRule struct {
-	MatchType MatchType `json:"matchType" required:"true"`
-	Labels    []string  `json:"labels" required:"true" nullable:"true"`
-}
-
-type PostableReductionRule struct {
-	MetricName string `json:"metricName" required:"true"`
-	UpdatableReductionRule
-}
-
-var protectedLabels = map[string]struct{}{
-	"le":                     {},
-	"quantile":               {},
-	"__name__":               {},
-	"__temporality__":        {},
-	"deployment.environment": {},
-}
-
-// IsProtectedLabel reports whether a label is always retained regardless of a reduction rule.
-func IsProtectedLabel(label string) bool {
-	_, ok := protectedLabels[label]
-	return ok
-}
-
-func (req *UpdatableReductionRule) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-	if req.MatchType != MatchTypeDrop && req.MatchType != MatchTypeKeep {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"matchType must be one of %q or %q", MatchTypeDrop.StringValue(), MatchTypeKeep.StringValue())
-	}
-	if len(req.Labels) == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"labels must not be empty; to allow all attributes, delete the rule instead")
-	}
-	if req.MatchType == MatchTypeDrop {
-		for _, label := range req.Labels {
-			if IsProtectedLabel(label) {
-				return errors.Newf(errors.TypeInvalidInput, ErrCodeMetricReductionRuleProtectedLabel,
-					"label %q is protected and cannot be dropped", label)
-			}
-		}
-	}
-	return nil
-}
-
-func (req *PostableReductionRule) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-	if req.MetricName == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName is required")
-	}
-	return req.UpdatableReductionRule.Validate()
-}

pkg/types/metricreductionruletypes/reduction_rule_test.go

@@ -1,40 +0,0 @@
-package metricreductionruletypes_test
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
-	"github.com/stretchr/testify/require"
-)
-
-func TestUpdatableReductionRuleValidate(t *testing.T) {
-	cases := []struct {
-		name    string
-		req     *metricreductionruletypes.UpdatableReductionRule
-		wantErr bool
-	}{
-		{"nil", nil, true},
-		{"invalid match type", &metricreductionruletypes.UpdatableReductionRule{Labels: []string{"host"}}, true},
-		{"empty labels", &metricreductionruletypes.UpdatableReductionRule{MatchType: metricreductionruletypes.MatchTypeDrop}, true},
-		{"drop protected label", &metricreductionruletypes.UpdatableReductionRule{MatchType: metricreductionruletypes.MatchTypeDrop, Labels: []string{"host", "le"}}, true},
-		{"keep protected label is allowed", &metricreductionruletypes.UpdatableReductionRule{MatchType: metricreductionruletypes.MatchTypeKeep, Labels: []string{"le"}}, false},
-		{"valid drop", &metricreductionruletypes.UpdatableReductionRule{MatchType: metricreductionruletypes.MatchTypeDrop, Labels: []string{"host"}}, false},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if tc.wantErr {
-				require.Error(t, tc.req.Validate())
-				return
-			}
-			require.NoError(t, tc.req.Validate())
-		})
-	}
-}
-
-func TestPostableReductionRuleValidate(t *testing.T) {
-	valid := metricreductionruletypes.UpdatableReductionRule{MatchType: metricreductionruletypes.MatchTypeKeep, Labels: []string{"host"}}
-
-	require.Error(t, (*metricreductionruletypes.PostableReductionRule)(nil).Validate(), "nil request")
-	require.Error(t, (&metricreductionruletypes.PostableReductionRule{UpdatableReductionRule: valid}).Validate(), "metricName required")
-	require.NoError(t, (&metricreductionruletypes.PostableReductionRule{MetricName: "m", UpdatableReductionRule: valid}).Validate())
-}

pkg/types/metricreductionruletypes/stats.go

@@ -1,8 +0,0 @@
-package metricreductionruletypes
-
-// GettableReductionRuleStats is the aggregate volume-control summary across all of an org's rules.
-type GettableReductionRuleStats struct {
-	IngestedSeries             uint64  `json:"ingestedSeries" required:"true"`
-	RetainedSeries             uint64  `json:"retainedSeries" required:"true"`
-	EstimatedMonthlySavingsUsd float64 `json:"estimatedMonthlySavingsUsd" required:"true"`
-}

pkg/types/spantypes/spanmappersimulator.go

@@ -0,0 +1,186 @@
+package spantypes
+
+import (
+	"context"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz-otel-collector/pkg/collectorsimulator"
+	"github.com/SigNoz/signoz-otel-collector/processor/signozspanmapperprocessor"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"go.opentelemetry.io/collector/otelcol"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	ErrCodeProcessorFactoryMapFailed  = errors.MustNewCode("processor_factory_map_failed")
+	ErrCodeSpanMapperSimulationFailed = errors.MustNewCode("span_mapper_simulation_failed")
+)
+
+const spanInputOrderAttr = "__signoz_input_idx__"
+
+func SimulateSpanMappersProcessing(ctx context.Context, groups []*SpanMapperGroupWithMappers, spans []SpanMapperTestSpan) ([]SpanMapperTestSpan, []string, error) {
+	enabled := filterEnabledGroupsWithMappers(groups)
+	if len(enabled) < 1 {
+		return spans, nil, nil
+	}
+
+	// this is done to preserve the order in which the request was sent
+	for i := range spans {
+		if spans[i].Attributes == nil {
+			spans[i].Attributes = map[string]any{}
+		}
+		spans[i].Attributes[spanInputOrderAttr] = int64(i)
+	}
+	simulatorInput := SpansToPTraces(spans)
+
+	processorFactories, err := otelcol.MakeFactoryMap(signozspanmapperprocessor.NewFactory())
+	if err != nil {
+		return nil, nil, errors.WrapInternalf(err, ErrCodeProcessorFactoryMapFailed, "could not construct processor factory map")
+	}
+
+	configGenerator := func(baseConf []byte) ([]byte, error) {
+		withProcessor, err := GenerateCollectorConfigWithSpanMapperProcessor(baseConf, enabled)
+		if err != nil {
+			return nil, err
+		}
+		return wireSpanMapperIntoTracesPipeline(withProcessor)
+	}
+
+	// signozspanmapperprocessor does no batching; spans flow through immediately.
+	timeout := 200 * time.Millisecond
+
+	outputTraces, collectorErrs, simErr := collectorsimulator.SimulateTracesProcessing(
+		ctx,
+		processorFactories,
+		configGenerator,
+		simulatorInput,
+		timeout,
+	)
+	if simErr != nil {
+		if errors.Is(simErr, collectorsimulator.ErrInvalidConfig) {
+			return nil, nil, errors.WrapInvalidInputf(simErr, errors.CodeInvalidInput, "invalid config")
+		}
+		return nil, nil, errors.WrapInternalf(simErr, ErrCodeSpanMapperSimulationFailed, "could not simulate span mapper processing")
+	}
+
+	outputSpans := PTracesToSpans(outputTraces)
+
+	sort.Slice(outputSpans, func(i, j int) bool {
+		iIdx, _ := outputSpans[i].Attributes[spanInputOrderAttr].(int64)
+		jIdx, _ := outputSpans[j].Attributes[spanInputOrderAttr].(int64)
+		return iIdx < jIdx
+	})
+	for _, s := range outputSpans {
+		delete(s.Attributes, spanInputOrderAttr)
+	}
+
+	collectorWarnAndErrorLogs := []string{}
+	for _, log := range collectorErrs {
+		if log == "" || strings.Contains(log, "featuregate.go") {
+			continue
+		}
+		collectorWarnAndErrorLogs = append(collectorWarnAndErrorLogs, log)
+	}
+
+	return outputSpans, collectorWarnAndErrorLogs, nil
+}
+
+func SpansToPTraces(spans []SpanMapperTestSpan) []ptrace.Traces {
+	result := make([]ptrace.Traces, 0, len(spans))
+	for _, s := range spans {
+		td := ptrace.NewTraces()
+		rs := td.ResourceSpans().AppendEmpty()
+		if s.Resource != nil {
+			_ = rs.Resource().Attributes().FromRaw(s.Resource)
+		}
+		sl := rs.ScopeSpans().AppendEmpty()
+		span := sl.Spans().AppendEmpty()
+		if s.Attributes != nil {
+			_ = span.Attributes().FromRaw(s.Attributes)
+		}
+		result = append(result, td)
+	}
+	return result
+}
+
+func PTracesToSpans(traces []ptrace.Traces) []SpanMapperTestSpan {
+	result := []SpanMapperTestSpan{}
+	for _, td := range traces {
+		rss := td.ResourceSpans()
+		for i := 0; i < rss.Len(); i++ {
+			rs := rss.At(i)
+			resourceAttrs := rs.Resource().Attributes().AsRaw()
+			ilss := rs.ScopeSpans()
+			for j := 0; j < ilss.Len(); j++ {
+				spans := ilss.At(j).Spans()
+				for k := 0; k < spans.Len(); k++ {
+					result = append(result, SpanMapperTestSpan{
+						Attributes: spans.At(k).Attributes().AsRaw(),
+						Resource:   resourceAttrs,
+					})
+				}
+			}
+		}
+	}
+	return result
+}
+
+// wireSpanMapperIntoTracesPipeline appends "signozspanmapper" to
+// service.pipelines.traces.processors so the processor defined by
+// GenerateCollectorConfigWithSpanMapperProcessor actually runs against the
+// traces flowing through the simulator. Idempotent: skips appending if the
+// processor name is already present.
+func wireSpanMapperIntoTracesPipeline(confYaml []byte) ([]byte, error) {
+	var conf map[string]any
+	if err := yaml.Unmarshal(confYaml, &conf); err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, ErrCodeInvalidCollectorConfig, "failed to unmarshal collector config for pipeline wiring")
+	}
+	service, _ := conf["service"].(map[string]any)
+	if service == nil {
+		return confYaml, nil
+	}
+	pipelines, _ := service["pipelines"].(map[string]any)
+	if pipelines == nil {
+		return confYaml, nil
+	}
+	traces, _ := pipelines["traces"].(map[string]any)
+	if traces == nil {
+		return confYaml, nil
+	}
+
+	procs, _ := traces["processors"].([]any)
+	for _, p := range procs {
+		if name, ok := p.(string); ok && name == ProcessorName {
+			return confYaml, nil
+		}
+	}
+	traces["processors"] = append(procs, ProcessorName)
+
+	out, err := yaml.Marshal(conf)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, ErrCodeBuildMappingProcessorConfig, "failed to marshal collector config after pipeline wiring")
+	}
+	return out, nil
+}
+
+func filterEnabledGroupsWithMappers(groups []*SpanMapperGroupWithMappers) []*SpanMapperGroupWithMappers {
+	out := make([]*SpanMapperGroupWithMappers, 0, len(groups))
+	for _, gm := range groups {
+		if gm == nil || gm.Group == nil || !gm.Group.Enabled {
+			continue
+		}
+		enabled := make([]*SpanMapper, 0, len(gm.Mappers))
+		for _, m := range gm.Mappers {
+			if m != nil && m.Enabled {
+				enabled = append(enabled, m)
+			}
+		}
+		if len(enabled) > 0 {
+			out = append(out, &SpanMapperGroupWithMappers{Group: gm.Group, Mappers: enabled})
+		}
+	}
+	return out
+}

pkg/types/spantypes/spanmappersimulator_test.go

@@ -0,0 +1,43 @@
+package spantypes
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestSimulateSpanMappersProcessing_EndToEnd is an integration test: it spins
+// up an actual in-memory otel-collector pipeline with signozspanmapperprocessor
+// and verifies the produced span has the expected target attribute.
+func TestSimulateSpanMappersProcessing_EndToEnd(t *testing.T) {
+	groups := []*SpanMapperGroupWithMappers{{
+		Group: &SpanMapperGroup{
+			Name:      "llm",
+			Condition: SpanMapperGroupCondition{Attributes: []string{"model"}},
+			Enabled:   true,
+		},
+		Mappers: []*SpanMapper{{
+			Name:         "gen_ai.request.model",
+			FieldContext: FieldContextSpanAttribute,
+			Config: SpanMapperConfig{Sources: []SpanMapperSource{
+				{Key: "llm.model", Context: FieldContextSpanAttribute, Operation: SpanMapperOperationCopy, Priority: 1},
+			}},
+			Enabled: true,
+		}},
+	}}
+
+	spans := []SpanMapperTestSpan{{Attributes: map[string]any{"llm.model": "gpt-4"}}}
+
+	out, _, err := SimulateSpanMappersProcessing(context.Background(), groups, spans)
+
+	require.NoError(t, err)
+	require.Len(t, out, 1)
+	assert.Equal(t, "gpt-4", out[0].Attributes["gen_ai.request.model"], "target attribute must be populated by the spanmapper processor")
+	// Source attribute is preserved (copy, not move).
+	assert.Equal(t, "gpt-4", out[0].Attributes["llm.model"])
+	// Order-tracking attribute is stripped from the output.
+	_, hasOrderAttr := out[0].Attributes[spanInputOrderAttr]
+	assert.False(t, hasOrderAttr, "internal ordering attribute must be removed from the response")
+}

pkg/types/spantypes/spanmappertest.go

@@ -0,0 +1,54 @@
+package spantypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type SpanMapperTestSpan struct {
+	Attributes map[string]any `json:"attributes"`
+	Resource   map[string]any `json:"resource"`
+}
+
+// Mappers is optional because the module can backfill from the store by Group.Name.
+type PostableSpanMapperTestGroup struct {
+	PostableSpanMapperGroup
+	Mappers []PostableSpanMapper `json:"mappers"`
+}
+
+type PostableSpanMapperTest struct {
+	Spans  []SpanMapperTestSpan          `json:"spans"  required:"true"`
+	Groups []PostableSpanMapperTestGroup `json:"groups" required:"true"`
+}
+
+type GettableSpanMapperTest struct {
+	Spans         []SpanMapperTestSpan `json:"spans" required:"true"`
+	CollectorLogs []string             `json:"collectorLogs" nullable:"true"`
+}
+
+func NewSpanMapperGroupsWithMappersFromPostable(orgID valuer.UUID, in []PostableSpanMapperTestGroup) []*SpanMapperGroupWithMappers {
+	out := make([]*SpanMapperGroupWithMappers, 0, len(in))
+	for _, pg := range in {
+		var mappers []*SpanMapper
+		if pg.Mappers != nil {
+			mappers = make([]*SpanMapper, 0, len(pg.Mappers))
+			for _, pm := range pg.Mappers {
+				mappers = append(mappers, &SpanMapper{
+					Name:         pm.Name,
+					FieldContext: pm.FieldContext,
+					Config:       pm.Config,
+					Enabled:      pm.Enabled,
+				})
+			}
+		}
+		out = append(out, &SpanMapperGroupWithMappers{
+			Group: &SpanMapperGroup{
+				OrgID:     orgID,
+				Name:      pg.Name,
+				Condition: pg.Condition,
+				Enabled:   pg.Enabled,
+			},
+			Mappers: mappers,
+		})
+	}
+	return out
+}

pkg/types/telemetrytypes/field.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/SigNoz/signoz-otel-collector/exporter/jsontypeexporter"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -22,7 +21,7 @@ const (
 	// BodyJSONStringSearchPrefix is the prefix used for body JSON search queries.
 	// e.g., "body.status" where "body." is the prefix.
 	BodyJSONStringSearchPrefix = "body."
-	ArraySep                   = jsontypeexporter.ArraySeparator
+	ArraySep                   = "[]."
 	ArraySepSuffix             = "[]"
 	// TODO(Piyush): Remove once we've migrated to the new array syntax.
 	ArrayAnyIndex       = "[*]."

pkg/types/telemetrytypes/json_access_plan.go

@@ -6,7 +6,6 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/SigNoz/signoz-otel-collector/exporter/jsontypeexporter"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -76,7 +75,7 @@ func (n *JSONAccessNode) Alias() string {
 	parentAlias := strings.TrimLeft(n.Parent.Alias(), "`")
 	parentAlias = strings.TrimRight(parentAlias, "`")
 
-	sep := jsontypeexporter.ArraySeparator
+	sep := "[]."
 	if n.Parent.isRoot {
 		sep = "."
 	}

tests/integration/tests/aiobservability/01_span_mapper.py

@@ -0,0 +1,174 @@
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+
+GROUPS_PATH = "/api/v1/span_mapper_groups"
+
+
+def _auth_headers(token: str) -> dict[str, str]:
+    return {
+        "authorization": f"Bearer {token}",
+        "content-type": "application/json",
+    }
+
+
+def test_create_groups_and_simulate_with_backfill(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+) -> None:
+    """
+    Setup:
+    Create a mapping group and a mapper through the CRUD API, then hit the
+    simulate endpoint with two groups: the saved one referenced by name only
+    (server backfills its mappers from the store) and a second, unsaved group
+    sent with inline mappers.
+
+    Tests:
+    1. Create a group (POST /span_mapper_groups) and read back its id
+    2. Create a mapper in that group (POST .../{groupId}/span_mappers)
+    3. List groups and mappers and verify what we created is persisted
+    4. Simulate spans against both groups: a matching span gets the saved
+       group's mappers (backfilled, copy) and the inline group's mappers
+       (move) applied, while a span matching no condition passes through
+    5. Delete the group and verify it (and its mappers) are gone
+    """
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    create_group = requests.post(
+        signoz.self.host_configs["8080"].get(GROUPS_PATH),
+        timeout=10,
+        headers=_auth_headers(token),
+        json={
+            "name": "llm-backfill",
+            "condition": {"attributes": ["model"], "resource": []},
+            "enabled": True,
+        },
+    )
+
+    assert create_group.status_code == HTTPStatus.CREATED
+    group = create_group.json()["data"]
+    group_id = group["id"]
+    assert group["name"] == "llm-backfill"
+    assert group["enabled"] is True
+
+    create_mapper = requests.post(
+        signoz.self.host_configs["8080"].get(f"{GROUPS_PATH}/{group_id}/span_mappers"),
+        timeout=10,
+        headers=_auth_headers(token),
+        json={
+            "name": "gen_ai.request.model",
+            "fieldContext": "attribute",
+            "config": {
+                "sources": [
+                    {
+                        "key": "llm.model",
+                        "context": "attribute",
+                        "operation": "copy",
+                        "priority": 1,
+                    }
+                ]
+            },
+            "enabled": True,
+        },
+    )
+
+    assert create_mapper.status_code == HTTPStatus.CREATED
+    mapper = create_mapper.json()["data"]
+    assert mapper["name"] == "gen_ai.request.model"
+    assert mapper["group_id"] == group_id
+
+    list_groups = requests.get(
+        signoz.self.host_configs["8080"].get(GROUPS_PATH),
+        timeout=10,
+        headers=_auth_headers(token),
+    )
+    assert list_groups.status_code == HTTPStatus.OK
+    assert group_id in [g["id"] for g in list_groups.json()["data"]["items"]]
+
+    list_mappers = requests.get(
+        signoz.self.host_configs["8080"].get(f"{GROUPS_PATH}/{group_id}/span_mappers"),
+        timeout=10,
+        headers=_auth_headers(token),
+    )
+    assert list_mappers.status_code == HTTPStatus.OK
+    assert "gen_ai.request.model" in [m["name"] for m in list_mappers.json()["data"]["items"]]
+
+    simulate = requests.post(
+        signoz.self.host_configs["8080"].get(f"{GROUPS_PATH}/test"),
+        timeout=10,
+        headers=_auth_headers(token),
+        json={
+            "spans": [
+                {
+                    "attributes": {"llm.model": "gpt-4", "db.system": "postgres"},
+                    "resource": {},
+                },
+                # Matches no group condition, so it must pass through untouched.
+                {
+                    "attributes": {"http.method": "GET"},
+                    "resource": {},
+                },
+            ],
+            "groups": [
+                # No "mappers" key: the server backfills them from the saved group.
+                {
+                    "name": "llm-backfill",
+                    "condition": {"attributes": ["model"], "resource": []},
+                    "enabled": True,
+                },
+                # Unsaved group; mappers provided inline.
+                {
+                    "name": "db-inline",
+                    "condition": {"attributes": ["db"], "resource": []},
+                    "enabled": True,
+                    "mappers": [
+                        {
+                            "name": "db.name",
+                            "fieldContext": "attribute",
+                            "config": {
+                                "sources": [
+                                    {
+                                        "key": "db.system",
+                                        "context": "attribute",
+                                        "operation": "move",
+                                        "priority": 1,
+                                    }
+                                ]
+                            },
+                            "enabled": True,
+                        }
+                    ],
+                },
+            ],
+        },
+    )
+
+    assert simulate.status_code == HTTPStatus.OK
+    out_spans = simulate.json()["data"]["spans"]
+    assert len(out_spans) == 2
+    attrs = out_spans[0]["attributes"]
+    assert attrs["gen_ai.request.model"] == "gpt-4"  # backfilled mapper applied
+    assert attrs["llm.model"] == "gpt-4"  # copy preserves source
+    assert attrs["db.name"] == "postgres"  # inline mapper applied
+    assert "db.system" not in attrs  # move removes source
+    assert out_spans[1]["attributes"] == {"http.method": "GET"}  # unchanged
+
+    delete_group = requests.delete(
+        signoz.self.host_configs["8080"].get(f"{GROUPS_PATH}/{group_id}"),
+        timeout=10,
+        headers=_auth_headers(token),
+    )
+    assert delete_group.status_code == HTTPStatus.NO_CONTENT
+
+    list_after_delete = requests.get(
+        signoz.self.host_configs["8080"].get(GROUPS_PATH),
+        timeout=10,
+        headers=_auth_headers(token),
+    )
+    assert list_after_delete.status_code == HTTPStatus.OK
+    assert group_id not in [g["id"] for g in list_after_delete.json()["data"]["items"]]

tests/integration/tests/querier/03_metrics.py

@@ -15,7 +15,6 @@ from fixtures.querier import (
     build_builder_query,
     find_named_result,
     get_all_warnings,
-    get_error_message,
     index_series_by_label,
     make_query_request,
 )