chore: comment correction

Merge branch 'infraM/v2_pods_list_api' into feat/v2_pods_list_api_phase_counts
chore: pod phase with local table of time series as counts
2026-04-25 13:20:24 +01:00 · 2026-04-24 17:14:56 +05:30 · 2026-04-24 16:47:15 +05:30 · 2026-04-24 15:27:38 +05:30 · 2026-04-24 14:58:26 +05:30 · 2026-04-24 14:36:43 +05:30
44 changed files with 1580 additions and 3441 deletions
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -2467,6 +2467,97 @@ components:
      - requiredMetricsCheck
      - endTimeBeforeRetention
      type: object
+    InframonitoringtypesPodPhase:
+      enum:
+      - pending
+      - running
+      - succeeded
+      - failed
+      - unknown
+      - ""
+      type: string
+    InframonitoringtypesPodRecord:
+      properties:
+        failedPodCount:
+          type: integer
+        meta:
+          additionalProperties: {}
+          nullable: true
+          type: object
+        pendingPodCount:
+          type: integer
+        podAge:
+          format: int64
+          type: integer
+        podCPU:
+          format: double
+          type: number
+        podCPULimit:
+          format: double
+          type: number
+        podCPURequest:
+          format: double
+          type: number
+        podMemory:
+          format: double
+          type: number
+        podMemoryLimit:
+          format: double
+          type: number
+        podMemoryRequest:
+          format: double
+          type: number
+        podPhase:
+          $ref: '#/components/schemas/InframonitoringtypesPodPhase'
+        podUID:
+          type: string
+        runningPodCount:
+          type: integer
+        succeededPodCount:
+          type: integer
+        unknownPodCount:
+          type: integer
+      required:
+      - podUID
+      - podCPU
+      - podCPURequest
+      - podCPULimit
+      - podMemory
+      - podMemoryRequest
+      - podMemoryLimit
+      - podPhase
+      - pendingPodCount
+      - runningPodCount
+      - succeededPodCount
+      - failedPodCount
+      - unknownPodCount
+      - podAge
+      - meta
+      type: object
+    InframonitoringtypesPods:
+      properties:
+        endTimeBeforeRetention:
+          type: boolean
+        records:
+          items:
+            $ref: '#/components/schemas/InframonitoringtypesPodRecord'
+          nullable: true
+          type: array
+        requiredMetricsCheck:
+          $ref: '#/components/schemas/InframonitoringtypesRequiredMetricsCheck'
+        total:
+          type: integer
+        type:
+          $ref: '#/components/schemas/InframonitoringtypesResponseType'
+        warning:
+          $ref: '#/components/schemas/Querybuildertypesv5QueryWarnData'
+      required:
+      - type
+      - records
+      - total
+      - requiredMetricsCheck
+      - endTimeBeforeRetention
+      type: object
    InframonitoringtypesPostableHosts:
      properties:
        end:
@@ -2493,6 +2584,32 @@ components:
      - end
      - limit
      type: object
+    InframonitoringtypesPostablePods:
+      properties:
+        end:
+          format: int64
+          type: integer
+        filter:
+          $ref: '#/components/schemas/Querybuildertypesv5Filter'
+        groupBy:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5GroupByKey'
+          nullable: true
+          type: array
+        limit:
+          type: integer
+        offset:
+          type: integer
+        orderBy:
+          $ref: '#/components/schemas/Querybuildertypesv5OrderBy'
+        start:
+          format: int64
+          type: integer
+      required:
+      - start
+      - end
+      - limit
+      type: object
    InframonitoringtypesRequiredMetricsCheck:
      properties:
        missingMetrics:
@@ -4489,184 +4606,6 @@ components:
      type: object
    Sigv4SigV4Config:
      type: object
-    SpantypesFieldContext:
-      enum:
-      - attribute
-      - resource
-      type: string
-    SpantypesGettableSpanMapperGroups:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanMapperGroup'
-          type: array
-      required:
-      - items
-      type: object
-    SpantypesPostableSpanMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpantypesSpanMapperConfig'
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpantypesFieldContext'
-        name:
-          type: string
-      required:
-      - name
-      - field_context
-      - config
-      type: object
-    SpantypesPostableSpanMapperGroup:
-      properties:
-        category:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCategory'
-        condition:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCondition'
-        enabled:
-          type: boolean
-        name:
-          type: string
-      required:
-      - name
-      - category
-      - condition
-      type: object
-    SpantypesSpanMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpantypesSpanMapperConfig'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpantypesFieldContext'
-        group_id:
-          type: string
-        id:
-          type: string
-        name:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - group_id
-      - name
-      - field_context
-      - config
-      - enabled
-      type: object
-    SpantypesSpanMapperConfig:
-      properties:
-        sources:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanMapperSource'
-          nullable: true
-          type: array
-      required:
-      - sources
-      type: object
-    SpantypesSpanMapperGroup:
-      properties:
-        category:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCategory'
-        condition:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCondition'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        id:
-          type: string
-        name:
-          type: string
-        orgId:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - name
-      - category
-      - condition
-      - enabled
-      type: object
-    SpantypesSpanMapperGroupCategory:
-      type: object
-    SpantypesSpanMapperGroupCondition:
-      properties:
-        attributes:
-          items:
-            type: string
-          nullable: true
-          type: array
-        resource:
-          items:
-            type: string
-          nullable: true
-          type: array
-      required:
-      - attributes
-      - resource
-      type: object
-    SpantypesSpanMapperOperation:
-      enum:
-      - move
-      - copy
-      type: string
-    SpantypesSpanMapperSource:
-      properties:
-        context:
-          $ref: '#/components/schemas/SpantypesFieldContext'
-        key:
-          type: string
-        operation:
-          $ref: '#/components/schemas/SpantypesSpanMapperOperation'
-        priority:
-          type: integer
-      required:
-      - key
-      - context
-      - operation
-      - priority
-      type: object
-    SpantypesUpdatableSpanMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpantypesSpanMapperConfig'
-        enabled:
-          nullable: true
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpantypesFieldContext'
-      type: object
-    SpantypesUpdatableSpanMapperGroup:
-      properties:
-        condition:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCondition'
-        enabled:
-          nullable: true
-          type: boolean
-        name:
-          nullable: true
-          type: string
-      type: object
    TelemetrytypesFieldContext:
      enum:
      - metric
@@ -9409,487 +9348,6 @@ paths:
      summary: Updates my service account
      tags:
      - serviceaccount
-  /api/v1/span_mapper_groups:
-    get:
-      deprecated: false
-      description: Returns all span attribute mapping groups for the authenticated
-        org.
-      operationId: ListSpanMapperGroups
-      parameters:
-      - explode: true
-        in: query
-        name: category
-        schema:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCategory'
-        style: deepObject
-      - in: query
-        name: enabled
-        schema:
-          nullable: true
-          type: boolean
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableSpanMapperGroups'
-                  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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List span attribute mapping groups
-      tags:
-      - spanmapper
-    post:
-      deprecated: false
-      description: Creates a new span attribute mapping group for the org.
-      operationId: CreateSpanMapperGroup
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableSpanMapperGroup'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesSpanMapperGroup'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create a span attribute mapping group
-      tags:
-      - spanmapper
-  /api/v1/span_mapper_groups/{groupId}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapping group and cascades to all its mappers.
-      operationId: DeleteSpanMapperGroup
-      parameters:
-      - in: path
-        name: groupId
-        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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a span attribute mapping group
-      tags:
-      - spanmapper
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapping group's name, condition,
-        or enabled state.
-      operationId: UpdateSpanMapperGroup
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesUpdatableSpanMapperGroup'
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span attribute mapping group
-      tags:
-      - spanmapper
-  /api/v1/span_mapper_groups/{groupId}/span_mappers:
-    get:
-      deprecated: false
-      description: Returns all mappers belonging to a mapping group.
-      operationId: ListSpanMappers
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableSpanMapperGroups'
-                  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: List span mappers for a group
-      tags:
-      - spanmapper
-    post:
-      deprecated: false
-      description: Adds a new mapper to the specified mapping group.
-      operationId: CreateSpanMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableSpanMapper'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesSpanMapper'
-                  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
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create a span mapper
-      tags:
-      - spanmapper
-  /api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapper from a mapping group.
-      operationId: DeleteSpanMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      - in: path
-        name: mapperId
-        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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a span mapper
-      tags:
-      - spanmapper
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapper's field context, config, or
-        enabled state.
-      operationId: UpdateSpanMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      - in: path
-        name: mapperId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesUpdatableSpanMapper'
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span mapper
-      tags:
-      - spanmapper
  /api/v1/testChannel:
    post:
      deprecated: true
@@ -10879,7 +10337,9 @@ paths:
        five metrics, and pagination via offset/limit. The response type is ''list''
        for the default host.name grouping or ''grouped_list'' for custom groupBy
        keys. Also reports missing required metrics and whether the requested time
-        range falls before the data retention boundary.'
+        range falls before the data retention boundary. Numeric metric fields (cpu,
+        memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available
+        for that field; frontends should render ''—'' rather than the literal value.'
      operationId: ListHosts
      requestBody:
        content:
@@ -10933,6 +10393,80 @@ paths:
      summary: List Hosts for Infra Monitoring
      tags:
      - inframonitoring
+  /api/v2/infra_monitoring/pods:
+    post:
+      deprecated: false
+      description: 'Returns a paginated list of Kubernetes pods with key metrics:
+        CPU usage, CPU request/limit utilization, memory working set, memory request/limit
+        utilization, current pod phase (pending/running/succeeded/failed/unknown),
+        and pod age (ms since start time). Each pod includes metadata attributes (namespace,
+        node, workload owner such as deployment/statefulset/daemonset/job/cronjob,
+        cluster). Supports filtering via a filter expression, custom groupBy to aggregate
+        pods by any attribute, ordering by any of the six metrics (cpu, cpu_request,
+        cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit.
+        The response type is ''list'' for the default k8s.pod.uid grouping (each row
+        is one pod with its current phase) or ''grouped_list'' for custom groupBy
+        keys (each row aggregates pods in the group with per-phase counts: pendingPodCount,
+        runningPodCount, succeededPodCount, failedPodCount, unknownPodCount derived
+        from each pod''s latest phase in the window). Also reports missing required
+        metrics and whether the requested time range falls before the data retention
+        boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory,
+        podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no
+        data is available for that field; frontends should render ''—'' rather than
+        the literal value.'
+      operationId: ListPods
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/InframonitoringtypesPostablePods'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/InframonitoringtypesPods'
+                  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
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List Pods for Infra Monitoring
+      tags:
+      - inframonitoring
  /api/v2/livez:
    get:
      deprecated: false
--- a/ee/query-service/app/server.go
+++ b/ee/query-service/app/server.go
@@ -12,7 +12,6 @@ import (

 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper/implspanmapper"

 	"github.com/gorilla/handlers"

@@ -112,11 +111,9 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	}

 	// initiate agent config handler
-	spanAttrMappingFeature := implspanmapper.NewSpanAttrMappingFeature(signoz.Modules.SpanMapper)
-
 	agentConfMgr, err := agentConf.Initiate(&agentConf.ManagerOptions{
 		Store:         signoz.SQLStore,
-		AgentFeatures: []agentConf.AgentFeature{logParsingPipelineController, spanAttrMappingFeature},
+		AgentFeatures: []agentConf.AgentFeature{logParsingPipelineController},
 	})
 	if err != nil {
 		return nil, err
--- a/frontend/src/api/generated/services/inframonitoring/index.ts
+++ b/frontend/src/api/generated/services/inframonitoring/index.ts
@@ -13,7 +13,9 @@ import type {

 import type {
 	InframonitoringtypesPostableHostsDTO,
+	InframonitoringtypesPostablePodsDTO,
 	ListHosts200,
+	ListPods200,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';

@@ -21,7 +23,7 @@ import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';

 /**
- * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.
+ * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (cpu, memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.
 * @summary List Hosts for Infra Monitoring
 */
 export const listHosts = (
@@ -104,3 +106,87 @@ export const useListHosts = <

 	return useMutation(mutationOptions);
 };
+/**
+ * Returns a paginated list of Kubernetes pods with key metrics: CPU usage, CPU request/limit utilization, memory working set, memory request/limit utilization, current pod phase (pending/running/succeeded/failed/unknown), and pod age (ms since start time). Each pod includes metadata attributes (namespace, node, workload owner such as deployment/statefulset/daemonset/job/cronjob, cluster). Supports filtering via a filter expression, custom groupBy to aggregate pods by any attribute, ordering by any of the six metrics (cpu, cpu_request, cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit. The response type is 'list' for the default k8s.pod.uid grouping (each row is one pod with its current phase) or 'grouped_list' for custom groupBy keys (each row aggregates pods in the group with per-phase counts: pendingPodCount, runningPodCount, succeededPodCount, failedPodCount, unknownPodCount derived from each pod's latest phase in the window). Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory, podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.
+ * @summary List Pods for Infra Monitoring
+ */
+export const listPods = (
+	inframonitoringtypesPostablePodsDTO: BodyType<InframonitoringtypesPostablePodsDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListPods200>({
+		url: `/api/v2/infra_monitoring/pods`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: inframonitoringtypesPostablePodsDTO,
+		signal,
+	});
+};
+
+export const getListPodsMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listPods>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof listPods>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+	TContext
+> => {
+	const mutationKey = ['listPods'];
+	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 listPods>>,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return listPods(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type ListPodsMutationResult = NonNullable<
+	Awaited<ReturnType<typeof listPods>>
+>;
+export type ListPodsMutationBody =
+	BodyType<InframonitoringtypesPostablePodsDTO>;
+export type ListPodsMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List Pods for Infra Monitoring
+ */
+export const useListPods = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof listPods>>,
+		TError,
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof listPods>>,
+	TError,
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
+	TContext
+> => {
+	const mutationOptions = getListPodsMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -3238,6 +3238,108 @@ export interface InframonitoringtypesHostsDTO {
 	warning?: Querybuildertypesv5QueryWarnDataDTO;
 }

+export enum InframonitoringtypesPodPhaseDTO {
+	pending = 'pending',
+	running = 'running',
+	succeeded = 'succeeded',
+	failed = 'failed',
+	unknown = 'unknown',
+	'' = '',
+}
+/**
+ * @nullable
+ */
+export type InframonitoringtypesPodRecordDTOMeta = {
+	[key: string]: unknown;
+} | null;
+
+export interface InframonitoringtypesPodRecordDTO {
+	/**
+	 * @type integer
+	 */
+	failedPodCount: number;
+	/**
+	 * @type object
+	 * @nullable true
+	 */
+	meta: InframonitoringtypesPodRecordDTOMeta;
+	/**
+	 * @type integer
+	 */
+	pendingPodCount: number;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	podAge: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPU: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPULimit: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podCPURequest: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemory: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemoryLimit: number;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	podMemoryRequest: number;
+	podPhase: InframonitoringtypesPodPhaseDTO;
+	/**
+	 * @type string
+	 */
+	podUID: string;
+	/**
+	 * @type integer
+	 */
+	runningPodCount: number;
+	/**
+	 * @type integer
+	 */
+	succeededPodCount: number;
+	/**
+	 * @type integer
+	 */
+	unknownPodCount: number;
+}
+
+export interface InframonitoringtypesPodsDTO {
+	/**
+	 * @type boolean
+	 */
+	endTimeBeforeRetention: boolean;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	records: InframonitoringtypesPodRecordDTO[] | null;
+	requiredMetricsCheck: InframonitoringtypesRequiredMetricsCheckDTO;
+	/**
+	 * @type integer
+	 */
+	total: number;
+	type: InframonitoringtypesResponseTypeDTO;
+	warning?: Querybuildertypesv5QueryWarnDataDTO;
+}
+
 export interface InframonitoringtypesPostableHostsDTO {
 	/**
 	 * @type integer
@@ -3266,6 +3368,34 @@ export interface InframonitoringtypesPostableHostsDTO {
 	start: number;
 }

+export interface InframonitoringtypesPostablePodsDTO {
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	end: number;
+	filter?: Querybuildertypesv5FilterDTO;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
+	/**
+	 * @type integer
+	 */
+	limit: number;
+	/**
+	 * @type integer
+	 */
+	offset?: number;
+	orderBy?: Querybuildertypesv5OrderByDTO;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	start: number;
+}
+
 export interface InframonitoringtypesRequiredMetricsCheckDTO {
 	/**
 	 * @type array
@@ -5470,187 +5600,6 @@ export interface Sigv4SigV4ConfigDTO {
 	[key: string]: unknown;
 }

-export enum SpantypesFieldContextDTO {
-	attribute = 'attribute',
-	resource = 'resource',
-}
-export interface SpantypesGettableSpanMapperGroupsDTO {
-	/**
-	 * @type array
-	 */
-	items: SpantypesSpanMapperGroupDTO[];
-}
-
-export interface SpantypesPostableSpanMapperDTO {
-	config: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	field_context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpantypesPostableSpanMapperGroupDTO {
-	category: SpantypesSpanMapperGroupCategoryDTO;
-	condition: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpantypesSpanMapperDTO {
-	config: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	field_context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	group_id: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpantypesSpanMapperConfigDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	sources: SpantypesSpanMapperSourceDTO[] | null;
-}
-
-export interface SpantypesSpanMapperGroupDTO {
-	category: SpantypesSpanMapperGroupCategoryDTO;
-	condition: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpantypesSpanMapperGroupCategoryDTO {
-	[key: string]: unknown;
-}
-
-export interface SpantypesSpanMapperGroupConditionDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	attributes: string[] | null;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	resource: string[] | null;
-}
-
-export enum SpantypesSpanMapperOperationDTO {
-	move = 'move',
-	copy = 'copy',
-}
-export interface SpantypesSpanMapperSourceDTO {
-	context: SpantypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	key: string;
-	operation: SpantypesSpanMapperOperationDTO;
-	/**
-	 * @type integer
-	 */
-	priority: number;
-}
-
-export interface SpantypesUpdatableSpanMapperDTO {
-	config?: SpantypesSpanMapperConfigDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	field_context?: SpantypesFieldContextDTO;
-}
-
-export interface SpantypesUpdatableSpanMapperGroupDTO {
-	condition?: SpantypesSpanMapperGroupConditionDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	name?: string | null;
-}
-
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -7101,71 +7050,6 @@ export type GetMyServiceAccount200 = {
 	status: string;
 };

-export type ListSpanMapperGroupsParams = {
-	/**
-	 * @description undefined
-	 */
-	category?: SpantypesSpanMapperGroupCategoryDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 * @description undefined
-	 */
-	enabled?: boolean | null;
-};
-
-export type ListSpanMapperGroups200 = {
-	data: SpantypesGettableSpanMapperGroupsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateSpanMapperGroup201 = {
-	data: SpantypesSpanMapperGroupDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteSpanMapperGroupPathParameters = {
-	groupId: string;
-};
-export type UpdateSpanMapperGroupPathParameters = {
-	groupId: string;
-};
-export type ListSpanMappersPathParameters = {
-	groupId: string;
-};
-export type ListSpanMappers200 = {
-	data: SpantypesGettableSpanMapperGroupsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateSpanMapperPathParameters = {
-	groupId: string;
-};
-export type CreateSpanMapper201 = {
-	data: SpantypesSpanMapperDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteSpanMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
-export type UpdateSpanMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array
@@ -7348,6 +7232,14 @@ export type ListHosts200 = {
 	status: string;
 };

+export type ListPods200 = {
+	data: InframonitoringtypesPodsDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type Livez200 = {
 	data: FactoryResponseDTO;
 	/**
--- a/frontend/src/api/generated/services/spanmapper/index.ts
+++ b/frontend/src/api/generated/services/spanmapper/index.ts
@@ -1,787 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import { useMutation, useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type {
-	CreateSpanMapper201,
-	CreateSpanMapperGroup201,
-	CreateSpanMapperPathParameters,
-	DeleteSpanMapperGroupPathParameters,
-	DeleteSpanMapperPathParameters,
-	ListSpanMapperGroups200,
-	ListSpanMapperGroupsParams,
-	ListSpanMappers200,
-	ListSpanMappersPathParameters,
-	RenderErrorResponseDTO,
-	SpantypesPostableSpanMapperDTO,
-	SpantypesPostableSpanMapperGroupDTO,
-	SpantypesUpdatableSpanMapperDTO,
-	SpantypesUpdatableSpanMapperGroupDTO,
-	UpdateSpanMapperGroupPathParameters,
-	UpdateSpanMapperPathParameters,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * Returns all span attribute mapping groups for the authenticated org.
- * @summary List span attribute mapping groups
- */
-export const listSpanMapperGroups = (
-	params?: ListSpanMapperGroupsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanMapperGroups200>({
-		url: `/api/v1/span_mapper_groups`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListSpanMapperGroupsQueryKey = (
-	params?: ListSpanMapperGroupsParams,
-) => {
-	return [`/api/v1/span_mapper_groups`, ...(params ? [params] : [])] as const;
-};
-
-export const getListSpanMapperGroupsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanMapperGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanMapperGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMapperGroups>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanMapperGroupsQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listSpanMapperGroups>>
-	> = ({ signal }) => listSpanMapperGroups(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanMapperGroups>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanMapperGroupsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanMapperGroups>>
->;
-export type ListSpanMapperGroupsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mapping groups
- */
-
-export function useListSpanMapperGroups<
-	TData = Awaited<ReturnType<typeof listSpanMapperGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanMapperGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMapperGroups>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanMapperGroupsQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span attribute mapping groups
- */
-export const invalidateListSpanMapperGroups = async (
-	queryClient: QueryClient,
-	params?: ListSpanMapperGroupsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanMapperGroupsQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates a new span attribute mapping group for the org.
- * @summary Create a span attribute mapping group
- */
-export const createSpanMapperGroup = (
-	spantypesPostableSpanMapperGroupDTO: BodyType<SpantypesPostableSpanMapperGroupDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateSpanMapperGroup201>({
-		url: `/api/v1/span_mapper_groups`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableSpanMapperGroupDTO,
-		signal,
-	});
-};
-
-export const getCreateSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		TError,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>,
-	TError,
-	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-	TContext
-> => {
-	const mutationKey = ['createSpanMapperGroup'];
-	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 createSpanMapperGroup>>,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createSpanMapperGroup(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>
->;
-export type CreateSpanMapperGroupMutationBody =
-	BodyType<SpantypesPostableSpanMapperGroupDTO>;
-export type CreateSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapping group
- */
-export const useCreateSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		TError,
-		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createSpanMapperGroup>>,
-	TError,
-	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapping group and cascades to all its mappers.
- * @summary Delete a span attribute mapping group
- */
-export const deleteSpanMapperGroup = ({
-	groupId,
-}: DeleteSpanMapperGroupPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-		TError,
-		{ pathParams: DeleteSpanMapperGroupPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-	TError,
-	{ pathParams: DeleteSpanMapperGroupPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteSpanMapperGroup'];
-	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 deleteSpanMapperGroup>>,
-		{ pathParams: DeleteSpanMapperGroupPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteSpanMapperGroup(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>
->;
-
-export type DeleteSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapping group
- */
-export const useDeleteSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-		TError,
-		{ pathParams: DeleteSpanMapperGroupPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteSpanMapperGroup>>,
-	TError,
-	{ pathParams: DeleteSpanMapperGroupPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapping group's name, condition, or enabled state.
- * @summary Update a span attribute mapping group
- */
-export const updateSpanMapperGroup = (
-	{ groupId }: UpdateSpanMapperGroupPathParameters,
-	spantypesUpdatableSpanMapperGroupDTO: BodyType<SpantypesUpdatableSpanMapperGroupDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesUpdatableSpanMapperGroupDTO,
-	});
-};
-
-export const getUpdateSpanMapperGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperGroupPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateSpanMapperGroup'];
-	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 updateSpanMapperGroup>>,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateSpanMapperGroup(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateSpanMapperGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>
->;
-export type UpdateSpanMapperGroupMutationBody =
-	BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-export type UpdateSpanMapperGroupMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapping group
- */
-export const useUpdateSpanMapperGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperGroupPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateSpanMapperGroup>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperGroupPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateSpanMapperGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns all mappers belonging to a mapping group.
- * @summary List span mappers for a group
- */
-export const listSpanMappers = (
-	{ groupId }: ListSpanMappersPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanMappers200>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListSpanMappersQueryKey = ({
-	groupId,
-}: ListSpanMappersPathParameters) => {
-	return [`/api/v1/span_mapper_groups/${groupId}/span_mappers`] as const;
-};
-
-export const getListSpanMappersQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMappers>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanMappersQueryKey({ groupId });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listSpanMappers>>> = ({
-		signal,
-	}) => listSpanMappers({ groupId }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!groupId,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanMappers>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanMappersQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanMappers>>
->;
-export type ListSpanMappersQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span mappers for a group
- */
-
-export function useListSpanMappers<
-	TData = Awaited<ReturnType<typeof listSpanMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanMappers>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanMappersQueryOptions({ groupId }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span mappers for a group
- */
-export const invalidateListSpanMappers = async (
-	queryClient: QueryClient,
-	{ groupId }: ListSpanMappersPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanMappersQueryKey({ groupId }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Adds a new mapper to the specified mapping group.
- * @summary Create a span mapper
- */
-export const createSpanMapper = (
-	{ groupId }: CreateSpanMapperPathParameters,
-	spantypesPostableSpanMapperDTO: BodyType<SpantypesPostableSpanMapperDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateSpanMapper201>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableSpanMapperDTO,
-		signal,
-	});
-};
-
-export const getCreateSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapper>>,
-		TError,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createSpanMapper>>,
-	TError,
-	{
-		pathParams: CreateSpanMapperPathParameters;
-		data: BodyType<SpantypesPostableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['createSpanMapper'];
-	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 createSpanMapper>>,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return createSpanMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createSpanMapper>>
->;
-export type CreateSpanMapperMutationBody =
-	BodyType<SpantypesPostableSpanMapperDTO>;
-export type CreateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span mapper
- */
-export const useCreateSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createSpanMapper>>,
-		TError,
-		{
-			pathParams: CreateSpanMapperPathParameters;
-			data: BodyType<SpantypesPostableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createSpanMapper>>,
-	TError,
-	{
-		pathParams: CreateSpanMapperPathParameters;
-		data: BodyType<SpantypesPostableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getCreateSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapper from a mapping group.
- * @summary Delete a span mapper
- */
-export const deleteSpanMapper = ({
-	groupId,
-	mapperId,
-}: DeleteSpanMapperPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapper>>,
-		TError,
-		{ pathParams: DeleteSpanMapperPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteSpanMapper>>,
-	TError,
-	{ pathParams: DeleteSpanMapperPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteSpanMapper'];
-	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 deleteSpanMapper>>,
-		{ pathParams: DeleteSpanMapperPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteSpanMapper(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteSpanMapper>>
->;
-
-export type DeleteSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span mapper
- */
-export const useDeleteSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteSpanMapper>>,
-		TError,
-		{ pathParams: DeleteSpanMapperPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteSpanMapper>>,
-	TError,
-	{ pathParams: DeleteSpanMapperPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapper's field context, config, or enabled state.
- * @summary Update a span mapper
- */
-export const updateSpanMapper = (
-	{ groupId, mapperId }: UpdateSpanMapperPathParameters,
-	spantypesUpdatableSpanMapperDTO: BodyType<SpantypesUpdatableSpanMapperDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesUpdatableSpanMapperDTO,
-	});
-};
-
-export const getUpdateSpanMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapper>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateSpanMapper>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateSpanMapper'];
-	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 updateSpanMapper>>,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateSpanMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateSpanMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateSpanMapper>>
->;
-export type UpdateSpanMapperMutationBody =
-	BodyType<SpantypesUpdatableSpanMapperDTO>;
-export type UpdateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span mapper
- */
-export const useUpdateSpanMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateSpanMapper>>,
-		TError,
-		{
-			pathParams: UpdateSpanMapperPathParameters;
-			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateSpanMapper>>,
-	TError,
-	{
-		pathParams: UpdateSpanMapperPathParameters;
-		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateSpanMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
--- a/frontend/src/container/FormAlertRules/ChartPreview/index.tsx
+++ b/frontend/src/container/FormAlertRules/ChartPreview/index.tsx
@@ -123,10 +123,11 @@ function ChartPreview({
 	});
 	const { currentQuery } = useQueryBuilder();

-	const { minTime, maxTime, selectedTime: globalSelectedInterval } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
+	const {
+		minTime,
+		maxTime,
+		selectedTime: globalSelectedInterval,
+	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);

 	const { featureFlags } = useAppContext();

@@ -138,8 +139,8 @@ function ChartPreview({
 		if (startTime && endTime && startTime !== endTime) {
 			dispatch(
 				UpdateTimeInterval('custom', [
-					parseInt(getTimeString(startTime), 10),
-					parseInt(getTimeString(endTime), 10),
+					Number.parseInt(getTimeString(startTime), 10),
+					Number.parseInt(getTimeString(endTime), 10),
 				]),
 			);
 		}
@@ -221,12 +222,11 @@ function ChartPreview({
 	// Initialize graph visibility from localStorage
 	useEffect(() => {
 		if (queryResponse?.data?.payload?.data?.result) {
-			const {
-				graphVisibilityStates: localStoredVisibilityState,
-			} = getLocalStorageGraphVisibilityState({
-				apiResponse: queryResponse.data.payload.data.result,
-				name: 'alert-chart-preview',
-			});
+			const { graphVisibilityStates: localStoredVisibilityState } =
+				getLocalStorageGraphVisibilityState({
+					apiResponse: queryResponse.data.payload.data.result,
+					name: 'alert-chart-preview',
+				});
 			setGraphVisibility(localStoredVisibilityState);
 		}
 	}, [queryResponse?.data?.payload?.data?.result]);
--- a/frontend/src/container/FormAlertRules/index.tsx
+++ b/frontend/src/container/FormAlertRules/index.tsx
@@ -127,9 +127,8 @@ function FormAlertRules({
 		handleSetConfig,
 		redirectWithQueryBuilderData,
 	} = useQueryBuilder();
-	const { matchType, op, target, targetUnit } = usePrefillAlertConditions(
-		stagedQuery,
-	);
+	const { matchType, op, target, targetUnit } =
+		usePrefillAlertConditions(stagedQuery);

 	useEffect(() => {
 		handleSetConfig(panelType || PANEL_TYPES.TIME_SERIES, dataSource);
@@ -172,9 +171,10 @@ function FormAlertRules({
 	}, [currentQuery.unit]);

 	// initQuery contains initial query when component was mounted
-	const initQuery = useMemo(() => initialValue.condition.compositeQuery, [
-		initialValue,
-	]);
+	const initQuery = useMemo(
+		() => initialValue.condition.compositeQuery,
+		[initialValue],
+	);

 	const queryOptions = useMemo(() => {
 		const involvedQueriesInTraceOperator = getInvolvedQueriesInTraceOperator(
@@ -370,7 +370,7 @@ function FormAlertRules({
 	// onQueryCategoryChange handles changes to query category
 	// in state as well as sets additional defaults
 	const onQueryCategoryChange = (val: EQueryType): void => {
-		const element = document.getElementById('top');
+		const element = document.querySelector('#top');
 		if (element) {
 			element.scrollIntoView({ behavior: 'smooth' });
 		}
@@ -808,9 +808,10 @@ function FormAlertRules({
 		featureFlags?.find((flag) => flag.name === FeatureKeys.ANOMALY_DETECTION)
 			?.active || false;

-	const source = useMemo(() => urlQuery.get(QueryParams.source) as YAxisSource, [
-		urlQuery,
-	]);
+	const source = useMemo(
+		() => urlQuery.get(QueryParams.source) as YAxisSource,
+		[urlQuery],
+	);

 	// Only update automatically when creating a new metrics-based alert rule
 	const shouldUpdateYAxisUnit = useMemo(() => {
--- a/frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx
+++ b/frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx
@@ -108,9 +108,8 @@ function Explorer(): JSX.Element {
 	const [showOneChartPerQuery, toggleShowOneChartPerQuery] = useState(
 		isOneChartPerQueryEnabled,
 	);
-	const [disableOneChartPerQuery, toggleDisableOneChartPerQuery] = useState(
-		false,
-	);
+	const [disableOneChartPerQuery, toggleDisableOneChartPerQuery] =
+		useState(false);
 	const [yAxisUnit, setYAxisUnit] = useState<string | undefined>();

 	const unitsLength = useMemo(() => units.length, [units]);
@@ -280,7 +279,7 @@ function Explorer(): JSX.Element {
 		[],
 	);

-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();

 	const oneChartPerQueryDisabledTooltip = useMemo(() => {
 		if (splitedQueries.length <= 1) {
@@ -292,7 +291,7 @@ function Explorer(): JSX.Element {
 		if (disableOneChartPerQuery) {
 			return 'One chart per query cannot be disabled for multiple queries with different units.';
 		}
-		return undefined;
+		return;
 	}, [disableOneChartPerQuery, splitedQueries.length, units.length]);

 	// Show the y axis unit selector if -
--- a/frontend/src/container/MetricsExplorer/Inspect/Inspect.tsx
+++ b/frontend/src/container/MetricsExplorer/Inspect/Inspect.tsx
@@ -35,20 +35,14 @@ function Inspect({
 	onClose,
 }: InspectProps): JSX.Element {
 	const isDarkMode = useIsDarkMode();
-	const [currentMetricName, setCurrentMetricName] = useState<string>(
-		defaultMetricName,
-	);
-	const [appliedMetricName, setAppliedMetricName] = useState<string>(
-		defaultMetricName,
-	);
-	const [
-		popoverOptions,
-		setPopoverOptions,
-	] = useState<GraphPopoverOptions | null>(null);
-	const [
-		expandedViewOptions,
-		setExpandedViewOptions,
-	] = useState<GraphPopoverOptions | null>(null);
+	const [currentMetricName, setCurrentMetricName] =
+		useState<string>(defaultMetricName);
+	const [appliedMetricName, setAppliedMetricName] =
+		useState<string>(defaultMetricName);
+	const [popoverOptions, setPopoverOptions] =
+		useState<GraphPopoverOptions | null>(null);
+	const [expandedViewOptions, setExpandedViewOptions] =
+		useState<GraphPopoverOptions | null>(null);
 	const [showExpandedView, setShowExpandedView] = useState(false);

 	const { data: metricDetailsData } = useGetMetricMetadata(
@@ -144,13 +138,15 @@ function Inspect({
 		[dispatchMetricInspectionOptions],
 	);

-	const selectedMetricType = useMemo(() => metricDetailsData?.data?.type, [
-		metricDetailsData,
-	]);
+	const selectedMetricType = useMemo(
+		() => metricDetailsData?.data?.type,
+		[metricDetailsData],
+	);

-	const selectedMetricUnit = useMemo(() => metricDetailsData?.data?.unit, [
-		metricDetailsData,
-	]);
+	const selectedMetricUnit = useMemo(
+		() => metricDetailsData?.data?.unit,
+		[metricDetailsData],
+	);

 	const aggregateAttribute = useMemo(
 		() => ({
@@ -221,7 +217,7 @@ function Inspect({
 			);
 		}

-		if (!inspectMetricsTimeSeries.length) {
+		if (inspectMetricsTimeSeries.length === 0) {
 			return renderFallback(
 				'inspect-metrics-empty',
 				<Empty description="No time series found for this metric to inspect." />,
--- a/frontend/src/container/MetricsExplorer/Inspect/useInspectMetrics.ts
+++ b/frontend/src/container/MetricsExplorer/Inspect/useInspectMetrics.ts
@@ -256,10 +256,10 @@ export function useInspectMetrics(
 			const valuesMap = new Map<number, number>();

 			series.values.forEach(({ timestamp, value }) => {
-				valuesMap.set(timestamp, parseFloat(value));
+				valuesMap.set(timestamp, Number.parseFloat(value));
 			});

-			return timestamps.map((timestamp) => valuesMap.get(timestamp) ?? NaN);
+			return timestamps.map((timestamp) => valuesMap.get(timestamp) ?? Number.NaN);
 		});

 		const rawData = [timestamps, ...timeseriesArray];
@@ -273,7 +273,7 @@ export function useInspectMetrics(
 				labels.add(label);
 			});
 		});
-		return Array.from(labels);
+		return [...labels];
 	}, [inspectMetricsData]);

 	const reset = useCallback(() => {
--- a/frontend/src/container/QueryBuilder/components/RunQueryBtn/test/RunQueryBtn.test.tsx
+++ b/frontend/src/container/QueryBuilder/components/RunQueryBtn/test/RunQueryBtn.test.tsx
@@ -18,7 +18,7 @@ describe('RunQueryBtn', () => {
 		);
 	});

-	test('renders run state and triggers on click', async () => {
+	it('renders run state and triggers on click', async () => {
 		const user = userEvent.setup();
 		const onRun = jest.fn();
 		const onCancel = jest.fn();
@@ -35,7 +35,7 @@ describe('RunQueryBtn', () => {
 		expect(onRun).toHaveBeenCalledTimes(1);
 	});

-	test('shows cancel state and calls handleCancelQuery', async () => {
+	it('shows cancel state and calls handleCancelQuery', async () => {
 		const user = userEvent.setup();
 		const onRun = jest.fn();
 		const onCancel = jest.fn();
@@ -51,19 +51,19 @@ describe('RunQueryBtn', () => {
 		expect(onCancel).toHaveBeenCalledTimes(1);
 	});

-	test('disabled when disabled prop is true', () => {
+	it('disabled when disabled prop is true', () => {
 		render(<RunQueryBtn disabled />);
 		expect(screen.getByRole('button', { name: /run query/i })).toBeDisabled();
 	});

-	test('disabled when no props provided', () => {
+	it('disabled when no props provided', () => {
 		render(<RunQueryBtn />);
 		expect(
 			screen.getByRole('button', { name: /run query/i }),
 		).toBeInTheDocument();
 	});

-	test('shows Command + CornerDownLeft on mac', () => {
+	it('shows Command + CornerDownLeft on mac', () => {
 		const { container } = render(
 			<RunQueryBtn
 				onStageRunQuery={jest.fn()}
@@ -77,7 +77,7 @@ describe('RunQueryBtn', () => {
 		).toBeInTheDocument();
 	});

-	test('shows ChevronUp + CornerDownLeft on non-mac', () => {
+	it('shows ChevronUp + CornerDownLeft on non-mac', () => {
 		(getUserOperatingSystem as jest.Mock).mockReturnValue(
 			UserOperatingSystem.WINDOWS,
 		);
@@ -95,7 +95,7 @@ describe('RunQueryBtn', () => {
 		).toBeInTheDocument();
 	});

-	test('renders custom label when provided', () => {
+	it('renders custom label when provided', () => {
 		render(
 			<RunQueryBtn
 				onStageRunQuery={jest.fn()}
--- a/frontend/src/hooks/queryBuilder/useGetQueryRange.ts
+++ b/frontend/src/hooks/queryBuilder/useGetQueryRange.ts
@@ -115,8 +115,8 @@ export const useGetQueryRange: UseGetQueryRange = (

 			const updatedQuery = updateBarStepInterval(
 				requestData.query,
-				requestData.start ? requestData.start * 1e3 : parseInt(start, 10) * 1e3,
-				requestData.end ? requestData.end * 1e3 : parseInt(end, 10) * 1e3,
+				requestData.start ? requestData.start * 1e3 : Number.parseInt(start, 10) * 1e3,
+				requestData.end ? requestData.end * 1e3 : Number.parseInt(end, 10) * 1e3,
 			);

 			return {
--- a/frontend/src/pages/LogsExplorer/index.tsx
+++ b/frontend/src/pages/LogsExplorer/index.tsx
@@ -98,7 +98,7 @@ function LogsExplorer(): JSX.Element {
 		setIsLoadingQueries(false);
 	}, [queryClient]);

-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();

 	const handleChangeSelectedView = useCallback(
 		(view: ExplorerViews, querySearchParameters?: ICurrentQueryData): void => {
@@ -127,9 +127,8 @@ function LogsExplorer(): JSX.Element {
 		setShowFilters((prev) => !prev);
 	};

-	const {
-		redirectWithQuery: redirectWithOptionsData,
-	} = useUrlQueryData<OptionsQuery>(URL_OPTIONS, defaultOptionsQuery);
+	const { redirectWithQuery: redirectWithOptionsData } =
+		useUrlQueryData<OptionsQuery>(URL_OPTIONS, defaultOptionsQuery);

 	// Get and parse stored columns from localStorage
 	const logListOptionsFromLocalStorage = useMemo(() => {
--- a/frontend/src/pages/TracesExplorer/index.tsx
+++ b/frontend/src/pages/TracesExplorer/index.tsx
@@ -101,7 +101,7 @@ function TracesExplorer(): JSX.Element {
 		getExplorerViewFromUrl(searchParams, panelTypesFromUrl),
 	);

-	const [warning, setWarning] = useState<Warning | undefined>(undefined);
+	const [warning, setWarning] = useState<Warning | undefined>();
 	const [isOpen, setOpen] = useState<boolean>(true);

 	const defaultQuery = useMemo(
--- a/pkg/apiserver/signozapiserver/inframonitoring.go
+++ b/pkg/apiserver/signozapiserver/inframonitoring.go
@@ -16,7 +16,7 @@ func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
 			ID:                  "ListHosts",
 			Tags:                []string{"inframonitoring"},
 			Summary:             "List Hosts for Infra Monitoring",
-			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.",
+			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (cpu, memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.",
 			Request:             new(inframonitoringtypes.PostableHosts),
 			RequestContentType:  "application/json",
 			Response:            new(inframonitoringtypes.Hosts),
@@ -29,5 +29,24 @@ func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
 		return err
 	}

+	if err := router.Handle("/api/v2/infra_monitoring/pods", handler.New(
+		provider.authZ.ViewAccess(provider.infraMonitoringHandler.ListPods),
+		handler.OpenAPIDef{
+			ID:                  "ListPods",
+			Tags:                []string{"inframonitoring"},
+			Summary:             "List Pods for Infra Monitoring",
+			Description:         "Returns a paginated list of Kubernetes pods with key metrics: CPU usage, CPU request/limit utilization, memory working set, memory request/limit utilization, current pod phase (pending/running/succeeded/failed/unknown), and pod age (ms since start time). Each pod includes metadata attributes (namespace, node, workload owner such as deployment/statefulset/daemonset/job/cronjob, cluster). Supports filtering via a filter expression, custom groupBy to aggregate pods by any attribute, ordering by any of the six metrics (cpu, cpu_request, cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit. The response type is 'list' for the default k8s.pod.uid grouping (each row is one pod with its current phase) or 'grouped_list' for custom groupBy keys (each row aggregates pods in the group with per-phase counts: pendingPodCount, runningPodCount, succeededPodCount, failedPodCount, unknownPodCount derived from each pod's latest phase in the window). Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory, podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no data is available for that field; frontends should render '—' rather than the literal value.",
+			Request:             new(inframonitoringtypes.PostablePods),
+			RequestContentType:  "application/json",
+			Response:            new(inframonitoringtypes.Pods),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
 	return nil
 }
--- a/pkg/apiserver/signozapiserver/provider.go
+++ b/pkg/apiserver/signozapiserver/provider.go
@@ -16,8 +16,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -25,7 +25,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
@@ -63,7 +62,6 @@ type provider struct {
 	factoryHandler          factory.Handler
 	cloudIntegrationHandler cloudintegration.Handler
 	ruleStateHistoryHandler rulestatehistory.Handler
-	spanMapperHandler       spanmapper.Handler
 	alertmanagerHandler     alertmanager.Handler
 	traceDetailHandler      tracedetail.Handler
 	rulerHandler            ruler.Handler
@@ -94,7 +92,6 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanMapperHandler spanmapper.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
@@ -128,7 +125,6 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
-			spanMapperHandler,
 			alertmanagerHandler,
 			traceDetailHandler,
 			rulerHandler,
@@ -164,7 +160,6 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanMapperHandler spanmapper.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
@@ -198,7 +193,6 @@ func newProvider(
 		factoryHandler:          factoryHandler,
 		cloudIntegrationHandler: cloudIntegrationHandler,
 		ruleStateHistoryHandler: ruleStateHistoryHandler,
-		spanMapperHandler:       spanMapperHandler,
 		alertmanagerHandler:     alertmanagerHandler,
 		traceDetailHandler:      traceDetailHandler,
 		rulerHandler:            rulerHandler,
@@ -306,10 +300,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}

-	if err := provider.addSpanMapperRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addAlertmanagerRoutes(router); err != nil {
 		return err
 	}
--- a/pkg/apiserver/signozapiserver/spanmapper.go
+++ b/pkg/apiserver/signozapiserver/spanmapper.go
@@ -1,171 +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/spantypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addSpanMapperRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/span_mapper_groups", handler.New(
-		provider.authZ.ViewAccess(provider.spanMapperHandler.ListGroups),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanMapperGroups",
-			Tags:                []string{"spanmapper"},
-			Summary:             "List span attribute mapping groups",
-			Description:         "Returns all span attribute mapping groups for the authenticated org.",
-			Request:             nil,
-			RequestContentType:  "",
-			RequestQuery:        new(spantypes.ListSpanMapperGroupsQuery),
-			Response:            new(spantypes.GettableSpanMapperGroups),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.CreateGroup),
-		handler.OpenAPIDef{
-			ID:                  "CreateSpanMapperGroup",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Create a span attribute mapping group",
-			Description:         "Creates a new span attribute mapping group for the org.",
-			Request:             new(spantypes.PostableSpanMapperGroup),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableSpanMapperGroup),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.UpdateGroup),
-		handler.OpenAPIDef{
-			ID:                 "UpdateSpanMapperGroup",
-			Tags:               []string{"spanmapper"},
-			Summary:            "Update a span attribute mapping group",
-			Description:        "Partially updates an existing mapping group's name, condition, or enabled state.",
-			Request:            new(spantypes.UpdatableSpanMapperGroup),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.DeleteGroup),
-		handler.OpenAPIDef{
-			ID:                  "DeleteSpanMapperGroup",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Delete a span attribute mapping group",
-			Description:         "Hard-deletes a mapping group and cascades to all its mappers.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers", handler.New(
-		provider.authZ.ViewAccess(provider.spanMapperHandler.ListMappers),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanMappers",
-			Tags:                []string{"spanmapper"},
-			Summary:             "List span mappers for a group",
-			Description:         "Returns all mappers belonging to a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(spantypes.GettableSpanMapperGroups),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.CreateMapper),
-		handler.OpenAPIDef{
-			ID:                  "CreateSpanMapper",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Create a span mapper",
-			Description:         "Adds a new mapper to the specified mapping group.",
-			Request:             new(spantypes.PostableSpanMapper),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableSpanMapper),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.UpdateMapper),
-		handler.OpenAPIDef{
-			ID:                 "UpdateSpanMapper",
-			Tags:               []string{"spanmapper"},
-			Summary:            "Update a span mapper",
-			Description:        "Partially updates an existing mapper's field context, config, or enabled state.",
-			Request:            new(spantypes.UpdatableSpanMapper),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanMapperHandler.DeleteMapper),
-		handler.OpenAPIDef{
-			ID:                  "DeleteSpanMapper",
-			Tags:                []string{"spanmapper"},
-			Summary:             "Delete a span mapper",
-			Description:         "Hard-deletes a mapper from a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}
--- a/pkg/modules/inframonitoring/implinframonitoring/handler.go
+++ b/pkg/modules/inframonitoring/implinframonitoring/handler.go
@@ -45,3 +45,27 @@ func (h *handler) ListHosts(rw http.ResponseWriter, req *http.Request) {

 	render.Success(rw, http.StatusOK, result)
 }
+
+func (h *handler) ListPods(rw http.ResponseWriter, req *http.Request) {
+	claims, err := authtypes.ClaimsFromContext(req.Context())
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID := valuer.MustNewUUID(claims.OrgID)
+
+	var parsedReq inframonitoringtypes.PostablePods
+	if err := binding.JSON.BindBody(req.Body, &parsedReq); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.ListPods(req.Context(), orgID, &parsedReq)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
--- a/pkg/modules/inframonitoring/implinframonitoring/internaltypes.go
+++ b/pkg/modules/inframonitoring/implinframonitoring/internaltypes.go
@@ -14,3 +14,12 @@ type groupHostStatusCounts struct {
 	Active   int
 	Inactive int
 }
+
+// podPhaseCounts holds per-group pod counts bucketed by latest phase in window.
+type podPhaseCounts struct {
+	Pending   int
+	Running   int
+	Succeeded int
+	Failed    int
+	Unknown   int
+}
--- a/pkg/modules/inframonitoring/implinframonitoring/module.go
+++ b/pkg/modules/inframonitoring/implinframonitoring/module.go
@@ -159,3 +159,92 @@ func (m *module) ListHosts(ctx context.Context, orgID valuer.UUID, req *inframon

 	return resp, nil
 }
+
+func (m *module) ListPods(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostablePods) (*inframonitoringtypes.Pods, error) {
+	if err := req.Validate(); err != nil {
+		return nil, err
+	}
+
+	resp := &inframonitoringtypes.Pods{}
+
+	if req.OrderBy == nil {
+		req.OrderBy = &qbtypes.OrderBy{
+			Key: qbtypes.OrderByKey{
+				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+					Name: inframonitoringtypes.PodsOrderByCPU,
+				},
+			},
+			Direction: qbtypes.OrderDirectionDesc,
+		}
+	}
+
+	if len(req.GroupBy) == 0 {
+		req.GroupBy = []qbtypes.GroupByKey{podUIDGroupByKey}
+		resp.Type = inframonitoringtypes.ResponseTypeList
+	} else {
+		resp.Type = inframonitoringtypes.ResponseTypeGroupedList
+	}
+
+	missingMetrics, minFirstReportedUnixMilli, err := m.getMetricsExistenceAndEarliestTime(ctx, podsTableMetricNamesList)
+	if err != nil {
+		return nil, err
+	}
+	if len(missingMetrics) > 0 {
+		resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: missingMetrics}
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	if req.End < int64(minFirstReportedUnixMilli) {
+		resp.EndTimeBeforeRetention = true
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		resp.Total = 0
+		return resp, nil
+	}
+	resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: []string{}}
+
+	metadataMap, err := m.getPodsTableMetadata(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = len(metadataMap)
+
+	pageGroups, err := m.getTopPodGroups(ctx, orgID, req, metadataMap)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(pageGroups) == 0 {
+		resp.Records = []inframonitoringtypes.PodRecord{}
+		return resp, nil
+	}
+
+	filterExpr := ""
+	if req.Filter != nil {
+		filterExpr = req.Filter.Expression
+	}
+
+	// Query G (per-pod latest phase) is meaningful only under list mode (k8s.pod.uid in groupBy).
+	// Under custom groupBy we use getPerGroupPodPhaseCounts to bucket pods per group.
+	isPodUIDInGroupBy := isKeyInGroupByAttrs(req.GroupBy, podUIDAttrKey)
+
+	fullQueryReq := buildFullQueryRequest(req.Start, req.End, filterExpr, req.GroupBy, pageGroups, m.newPodsTableListQuery(isPodUIDInGroupBy))
+	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
+	if err != nil {
+		return nil, err
+	}
+
+	phaseCounts := make(map[string]podPhaseCounts)
+	if !isPodUIDInGroupBy {
+		phaseCounts, err = m.getPerGroupPodPhaseCounts(ctx, req, pageGroups)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resp.Records = buildPodRecords(isPodUIDInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, phaseCounts, req.End)
+	resp.Warning = queryResp.Warning
+
+	return resp, nil
+}
--- a/pkg/modules/inframonitoring/implinframonitoring/pods.go
+++ b/pkg/modules/inframonitoring/implinframonitoring/pods.go
@@ -0,0 +1,372 @@
+package implinframonitoring
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+func mapPhaseNumToString(podPhase int) inframonitoringtypes.PodPhase {
+	switch podPhase {
+	case 1:
+		return inframonitoringtypes.PodPhasePending
+	case 2:
+		return inframonitoringtypes.PodPhaseRunning
+	case 3:
+		return inframonitoringtypes.PodPhaseSucceeded
+	case 4:
+		return inframonitoringtypes.PodPhaseFailed
+	case 5:
+		return inframonitoringtypes.PodPhaseUnknown
+	default:
+		return inframonitoringtypes.PodPhaseNone
+	}
+}
+
+// buildPodRecords assembles the page records.
+//
+// isPodUIDInGroupBy=true (list mode): one row = one pod. PodPhase is read from
+// query G's result, and the matching *PodCount field is set to 1.
+//
+// isPodUIDInGroupBy=false (grouped_list mode): rows are groups. PodPhase stays
+// PodPhaseNone; *PodCount fields come from phaseCounts (zeros when group missing).
+func buildPodRecords(
+	isPodUIDInGroupBy bool,
+	resp *qbtypes.QueryRangeResponse,
+	pageGroups []map[string]string,
+	groupBy []qbtypes.GroupByKey,
+	metadataMap map[string]map[string]string,
+	phaseCounts map[string]podPhaseCounts,
+	reqEnd int64,
+) []inframonitoringtypes.PodRecord {
+	metricsMap := parseFullQueryResponse(resp, groupBy)
+
+	records := make([]inframonitoringtypes.PodRecord, 0, len(pageGroups))
+	for _, labels := range pageGroups {
+		compositeKey := compositeKeyFromLabels(labels, groupBy)
+		podUID := labels[podUIDAttrKey]
+
+		record := inframonitoringtypes.PodRecord{ // initialize with default values
+			PodUID:           podUID,
+			PodPhase:         inframonitoringtypes.PodPhaseNone,
+			PodCPU:           -1,
+			PodCPURequest:    -1,
+			PodCPULimit:      -1,
+			PodMemory:        -1,
+			PodMemoryRequest: -1,
+			PodMemoryLimit:   -1,
+			PodAge:           -1,
+			Meta:             map[string]any{},
+		}
+
+		if metrics, ok := metricsMap[compositeKey]; ok {
+			if v, exists := metrics["A"]; exists {
+				record.PodCPU = v
+			}
+			if v, exists := metrics["B"]; exists {
+				record.PodCPURequest = v
+			}
+			if v, exists := metrics["C"]; exists {
+				record.PodCPULimit = v
+			}
+			if v, exists := metrics["D"]; exists {
+				record.PodMemory = v
+			}
+			if v, exists := metrics["E"]; exists {
+				record.PodMemoryRequest = v
+			}
+			if v, exists := metrics["F"]; exists {
+				record.PodMemoryLimit = v
+			}
+		}
+
+		// set pod phase + counts based on whether pod uid is in group by (list vs grouped_list)
+		if isPodUIDInGroupBy { // derive phase + count=1 from query G
+			if metrics, ok := metricsMap[compositeKey]; ok {
+				if podPhaseFloatVal, exists := metrics["G"]; exists {
+					record.PodPhase = mapPhaseNumToString(int(podPhaseFloatVal))
+					switch record.PodPhase {
+					case inframonitoringtypes.PodPhasePending:
+						record.PendingPodCount = 1
+					case inframonitoringtypes.PodPhaseRunning:
+						record.RunningPodCount = 1
+					case inframonitoringtypes.PodPhaseSucceeded:
+						record.SucceededPodCount = 1
+					case inframonitoringtypes.PodPhaseFailed:
+						record.FailedPodCount = 1
+					case inframonitoringtypes.PodPhaseUnknown:
+						record.UnknownPodCount = 1
+					}
+				}
+			}
+		} else { // derive counts from phaseCounts; PodPhase stays PodPhaseNone because it doesn't make sense under groupBy other than pod uid
+			if c, ok := phaseCounts[compositeKey]; ok {
+				record.PendingPodCount = c.Pending
+				record.RunningPodCount = c.Running
+				record.SucceededPodCount = c.Succeeded
+				record.FailedPodCount = c.Failed
+				record.UnknownPodCount = c.Unknown
+			}
+		}
+
+		if attrs, ok := metadataMap[compositeKey]; ok && isPodUIDInGroupBy {
+			// the condition above ensures we deduce age only if pod uid is in group by because if
+			// it's not in group by then we might have multiple pod uids in the same group and hence then podAge wont make sense
+			if startTimeStr, exists := attrs[podStartTimeAttrKey]; exists && startTimeStr != "" {
+				if t, err := time.Parse(time.RFC3339, startTimeStr); err == nil {
+					startTimeMs := t.UnixMilli()
+					if startTimeMs > 0 {
+						record.PodAge = reqEnd - startTimeMs
+					}
+				}
+			}
+			for k, v := range attrs {
+				record.Meta[k] = v
+			}
+		}
+
+		records = append(records, record)
+	}
+	return records
+}
+
+func (m *module) getTopPodGroups(
+	ctx context.Context,
+	orgID valuer.UUID,
+	req *inframonitoringtypes.PostablePods,
+	metadataMap map[string]map[string]string,
+) ([]map[string]string, error) {
+	orderByKey := req.OrderBy.Key.Name
+	queryNamesForOrderBy := orderByToPodsQueryNames[orderByKey]
+	rankingQueryName := queryNamesForOrderBy[len(queryNamesForOrderBy)-1]
+
+	topReq := &qbtypes.QueryRangeRequest{
+		Start:       uint64(req.Start),
+		End:         uint64(req.End),
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: make([]qbtypes.QueryEnvelope, 0, len(queryNamesForOrderBy)),
+		},
+	}
+
+	// Ranking never needs query G (phase removed from valid orderBy keys).
+	for _, envelope := range m.newPodsTableListQuery(false).CompositeQuery.Queries {
+		if !slices.Contains(queryNamesForOrderBy, envelope.GetQueryName()) {
+			continue
+		}
+		copied := envelope
+		if copied.Type == qbtypes.QueryTypeBuilder {
+			existingExpr := ""
+			if f := copied.GetFilter(); f != nil {
+				existingExpr = f.Expression
+			}
+			reqFilterExpr := ""
+			if req.Filter != nil {
+				reqFilterExpr = req.Filter.Expression
+			}
+			merged := mergeFilterExpressions(existingExpr, reqFilterExpr)
+			copied.SetFilter(&qbtypes.Filter{Expression: merged})
+			copied.SetGroupBy(req.GroupBy)
+		}
+		topReq.CompositeQuery.Queries = append(topReq.CompositeQuery.Queries, copied)
+	}
+
+	resp, err := m.querier.QueryRange(ctx, orgID, topReq)
+	if err != nil {
+		return nil, err
+	}
+
+	allMetricGroups := parseAndSortGroups(resp, rankingQueryName, req.GroupBy, req.OrderBy.Direction)
+	return paginateWithBackfill(allMetricGroups, metadataMap, req.GroupBy, req.Offset, req.Limit), nil
+}
+
+func (m *module) getPodsTableMetadata(ctx context.Context, req *inframonitoringtypes.PostablePods) (map[string]map[string]string, error) {
+	var nonGroupByAttrs []string
+	for _, key := range podAttrKeysForMetadata {
+		if !isKeyInGroupByAttrs(req.GroupBy, key) {
+			nonGroupByAttrs = append(nonGroupByAttrs, key)
+		}
+	}
+	return m.getMetadata(ctx, podsTableMetricNamesList, req.GroupBy, nonGroupByAttrs, req.Filter, req.Start, req.End)
+}
+
+// getPerGroupPodPhaseCounts computes per-group pod counts bucketed by each
+// pod's latest phase in the requested window.
+// Pipeline:
+//
+//	timeSeriesFPs:      fp ↔ (pod_uid, groupBy cols) from the time_series table.
+//	                    User filter + page-groups filter applied here.
+//	latestPhasePerPod:  GLOBAL INNER JOIN samples × timeSeriesFPs, collapsed to
+//	                    the latest phase per pod via argMax(value, unix_milli).
+//	                    One step — the JOIN projects pod_uid + groupBy cols
+//	                    down to the sample row, so no fp-level intermediate.
+//	countPodsPerPhase:  per-group uniqExactIf into 5 phase buckets.
+//
+// Groups absent from the result map have implicit zero counts (caller default).
+func (m *module) getPerGroupPodPhaseCounts(
+	ctx context.Context,
+	req *inframonitoringtypes.PostablePods,
+	pageGroups []map[string]string,
+) (map[string]podPhaseCounts, error) {
+	if len(pageGroups) == 0 || len(req.GroupBy) == 0 {
+		return map[string]podPhaseCounts{}, nil
+	}
+
+	// Merged filter expression (user filter + page-groups IN clauses).
+	reqFilterExpr := ""
+	if req.Filter != nil {
+		reqFilterExpr = req.Filter.Expression
+	}
+	pageGroupsFilterExpr := buildPageGroupsFilterExpr(pageGroups)
+	filterExpr := mergeFilterExpressions(reqFilterExpr, pageGroupsFilterExpr)
+
+	// Resolve tables. Same convention as hosts (distributed names from helpers).
+	adjustedStart, adjustedEnd, _, localTimeSeriesTable := telemetrymetrics.WhichTSTableToUse(
+		uint64(req.Start), uint64(req.End), nil,
+	)
+	samplesTable := telemetrymetrics.WhichSamplesTableToUse(
+		uint64(req.Start), uint64(req.End),
+		metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, nil,
+	)
+	// Aggregated samples tables hold the latest value in `last`, not `value`.
+	valueCol := "value"
+	if samplesTable == telemetrymetrics.SamplesV4Agg5mTableName ||
+		samplesTable == telemetrymetrics.SamplesV4Agg30mTableName {
+		valueCol = "last"
+	}
+
+	// ----- timeSeriesFPs -----
+	timeSeriesFPs := sqlbuilder.NewSelectBuilder()
+	timeSeriesFPsSelectCols := []string{
+		"fingerprint",
+		fmt.Sprintf("JSONExtractString(labels, %s) AS pod_uid", timeSeriesFPs.Var(podUIDAttrKey)),
+	}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsSelectCols = append(timeSeriesFPsSelectCols,
+			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", timeSeriesFPs.Var(key.Name), quoteIdentifier(key.Name)),
+		)
+	}
+	timeSeriesFPs.Select(timeSeriesFPsSelectCols...)
+	timeSeriesFPs.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	timeSeriesFPs.Where(
+		timeSeriesFPs.E("metric_name", podPhaseMetricName),
+		timeSeriesFPs.GE("unix_milli", adjustedStart),
+		timeSeriesFPs.L("unix_milli", adjustedEnd),
+	)
+	if filterExpr != "" {
+		filterClause, err := m.buildFilterClause(ctx, &qbtypes.Filter{Expression: filterExpr}, req.Start, req.End)
+		if err != nil {
+			return nil, err
+		}
+		if filterClause != nil {
+			timeSeriesFPs.AddWhereClause(filterClause)
+		}
+	}
+	timeSeriesFPsGroupBy := []string{"fingerprint", "pod_uid"}
+	for _, key := range req.GroupBy {
+		timeSeriesFPsGroupBy = append(timeSeriesFPsGroupBy, quoteIdentifier(key.Name))
+	}
+	timeSeriesFPs.GroupBy(timeSeriesFPsGroupBy...)
+	timeSeriesFPsSQL, timeSeriesFPsArgs := timeSeriesFPs.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// ----- latestPhasePerPod -----
+	// GLOBAL INNER JOIN samples × timeSeriesFPs, collapsed to the latest phase
+	// per pod via argMax(value, unix_milli). Replaces a prior 2-CTE chain
+	// (fp → latest-per-fp, then fp → pod) — one step because the JOIN
+	// projects pod_uid + groupBy cols down to the sample row.
+	latestPhasePerPod := sqlbuilder.NewSelectBuilder()
+	latestPhasePerPodSelectCols := []string{"tsfp.pod_uid AS pod_uid"}
+	latestPhasePerPodGroupBy := []string{"pod_uid"}
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		latestPhasePerPodSelectCols = append(latestPhasePerPodSelectCols, fmt.Sprintf("tsfp.%s AS %s", col, col))
+		latestPhasePerPodGroupBy = append(latestPhasePerPodGroupBy, col)
+	}
+	latestPhasePerPodSelectCols = append(latestPhasePerPodSelectCols,
+		fmt.Sprintf("argMax(samples.%s, samples.unix_milli) AS phase_value", valueCol),
+	)
+	latestPhasePerPod.Select(latestPhasePerPodSelectCols...)
+	latestPhasePerPod.From(fmt.Sprintf(
+		"%s.%s AS samples INNER JOIN time_series_fps AS tsfp ON samples.fingerprint = tsfp.fingerprint",
+		telemetrymetrics.DBName, samplesTable,
+	))
+	latestPhasePerPod.Where(
+		latestPhasePerPod.E("samples.metric_name", podPhaseMetricName),
+		latestPhasePerPod.GE("samples.unix_milli", req.Start),
+		latestPhasePerPod.L("samples.unix_milli", req.End),
+		"tsfp.pod_uid != ''",
+	)
+	latestPhasePerPod.GroupBy(latestPhasePerPodGroupBy...)
+	latestPhasePerPodSQL, latestPhasePerPodArgs := latestPhasePerPod.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	// ----- countPodsPerPhase (outer SELECT) -----
+	countPodsPerPhaseSelectCols := make([]string, 0, len(req.GroupBy)+5)
+	countPodsPerPhaseGroupBy := make([]string, 0, len(req.GroupBy))
+	for _, key := range req.GroupBy {
+		col := quoteIdentifier(key.Name)
+		countPodsPerPhaseSelectCols = append(countPodsPerPhaseSelectCols, col)
+		countPodsPerPhaseGroupBy = append(countPodsPerPhaseGroupBy, col)
+	}
+	countPodsPerPhaseSelectCols = append(countPodsPerPhaseSelectCols,
+		"uniqExactIf(pod_uid, phase_value = 1) AS pending_count",
+		"uniqExactIf(pod_uid, phase_value = 2) AS running_count",
+		"uniqExactIf(pod_uid, phase_value = 3) AS succeeded_count",
+		"uniqExactIf(pod_uid, phase_value = 4) AS failed_count",
+		"uniqExactIf(pod_uid, phase_value = 5) AS unknown_count",
+	)
+	countPodsPerPhaseSQL := fmt.Sprintf(
+		"SELECT %s FROM latest_phase_per_pod GROUP BY %s",
+		strings.Join(countPodsPerPhaseSelectCols, ", "),
+		strings.Join(countPodsPerPhaseGroupBy, ", "),
+	)
+
+	// Combine CTEs + outer.
+	cteFragments := []string{
+		fmt.Sprintf("time_series_fps AS (%s)", timeSeriesFPsSQL),
+		fmt.Sprintf("latest_phase_per_pod AS (%s)", latestPhasePerPodSQL),
+	}
+	finalSQL := querybuilder.CombineCTEs(cteFragments) + countPodsPerPhaseSQL
+	finalArgs := querybuilder.PrependArgs([][]any{timeSeriesFPsArgs, latestPhasePerPodArgs}, nil)
+
+	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, finalSQL, finalArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	result := make(map[string]podPhaseCounts)
+	for rows.Next() {
+		groupVals := make([]string, len(req.GroupBy))
+		scanPtrs := make([]any, 0, len(req.GroupBy)+5)
+		for i := range groupVals {
+			scanPtrs = append(scanPtrs, &groupVals[i])
+		}
+		var pending, running, succeeded, failed, unknown uint64
+		scanPtrs = append(scanPtrs, &pending, &running, &succeeded, &failed, &unknown)
+
+		if err := rows.Scan(scanPtrs...); err != nil {
+			return nil, err
+		}
+		result[compositeKeyFromList(groupVals)] = podPhaseCounts{
+			Pending:   int(pending),
+			Running:   int(running),
+			Succeeded: int(succeeded),
+			Failed:    int(failed),
+			Unknown:   int(unknown),
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
--- a/pkg/modules/inframonitoring/implinframonitoring/pods_constants.go
+++ b/pkg/modules/inframonitoring/implinframonitoring/pods_constants.go
@@ -0,0 +1,208 @@
+package implinframonitoring
+
+import (
+	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+const (
+	podUIDAttrKey       = "k8s.pod.uid"
+	podStartTimeAttrKey = "k8s.pod.start_time"
+	podPhaseMetricName  = "k8s.pod.phase"
+)
+
+var podUIDGroupByKey = qbtypes.GroupByKey{
+	TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+		Name:          podUIDAttrKey,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	},
+}
+
+var podsTableMetricNamesList = []string{
+	"k8s.pod.cpu.usage",
+	"k8s.pod.cpu_request_utilization",
+	"k8s.pod.cpu_limit_utilization",
+	"k8s.pod.memory.working_set",
+	"k8s.pod.memory_request_utilization",
+	"k8s.pod.memory_limit_utilization",
+	"k8s.pod.phase",
+}
+
+var podAttrKeysForMetadata = []string{
+	"k8s.pod.uid",
+	"k8s.pod.name",
+	"k8s.namespace.name",
+	"k8s.node.name",
+	"k8s.deployment.name",
+	"k8s.statefulset.name",
+	"k8s.daemonset.name",
+	"k8s.job.name",
+	"k8s.cronjob.name",
+	"k8s.cluster.name",
+	"k8s.pod.start_time",
+}
+
+var orderByToPodsQueryNames = map[string][]string{
+	inframonitoringtypes.PodsOrderByCPU:           {"A"},
+	inframonitoringtypes.PodsOrderByCPURequest:    {"B"},
+	inframonitoringtypes.PodsOrderByCPULimit:      {"C"},
+	inframonitoringtypes.PodsOrderByMemory:        {"D"},
+	inframonitoringtypes.PodsOrderByMemoryRequest: {"E"},
+	inframonitoringtypes.PodsOrderByMemoryLimit:   {"F"},
+}
+
+// newPodsTableListQuery builds the composite QB v5 request for the pods list.
+// includePhaseQuery controls whether query G (per-pod latest phase) is appended.
+// G is meaningful only when k8s.pod.uid is in groupBy (one row = one pod);
+// under custom groupBy, per-group phase counts come from getPerGroupPodPhaseCounts.
+func (m *module) newPodsTableListQuery(includePhaseQuery bool) *qbtypes.QueryRangeRequest {
+	queries := []qbtypes.QueryEnvelope{
+		// Query A: CPU usage
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "A",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu.usage",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query B: CPU request utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "B",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu_request_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query C: CPU limit utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "C",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.cpu_limit_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query D: Memory working set
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "D",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory.working_set",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query E: Memory request utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "E",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory_request_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+		// Query F: Memory limit utilization
+		{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "F",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.memory_limit_utilization",
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+						ReduceTo:         qbtypes.ReduceToAvg,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		},
+	}
+
+	if includePhaseQuery {
+		// Query G: Pod phase (latest value per pod). Only meaningful when
+		// k8s.pod.uid is in groupBy — under custom groupBy this query is
+		// replaced by getPerGroupPodPhaseCounts which buckets pods per group.
+		// SpaceAggregationMax is a workaround: ideally we'd use a "last"
+		// space aggregation to pick the last-seen phase when multiple
+		// fingerprints exist for a single pod.uid. Max yields the correct
+		// phase in the common single-fingerprint case, and in the rare
+		// multi-fingerprint case returns the most-severe phase observed.
+		// TODO(nikhilmantri0902): switch to SpaceAggregationLast once supported by querier.
+		queries = append(queries, qbtypes.QueryEnvelope{
+			Type: qbtypes.QueryTypeBuilder,
+			Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Name:   "G",
+				Signal: telemetrytypes.SignalMetrics,
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "k8s.pod.phase",
+						TimeAggregation:  metrictypes.TimeAggregationLatest,
+						SpaceAggregation: metrictypes.SpaceAggregationMax,
+						ReduceTo:         qbtypes.ReduceToLast,
+					},
+				},
+				GroupBy:  []qbtypes.GroupByKey{podUIDGroupByKey},
+				Disabled: false,
+			},
+		})
+	}
+
+	return &qbtypes.QueryRangeRequest{
+		RequestType: qbtypes.RequestTypeScalar,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: queries,
+		},
+	}
+}
--- a/pkg/modules/inframonitoring/inframonitoring.go
+++ b/pkg/modules/inframonitoring/inframonitoring.go
@@ -10,8 +10,10 @@ import (

 type Handler interface {
 	ListHosts(http.ResponseWriter, *http.Request)
+	ListPods(http.ResponseWriter, *http.Request)
 }

 type Module interface {
 	ListHosts(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableHosts) (*inframonitoringtypes.Hosts, error)
+	ListPods(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostablePods) (*inframonitoringtypes.Pods, error)
 }
--- a/pkg/modules/spanmapper/implspanmapper/agent_feature.go
+++ b/pkg/modules/spanmapper/implspanmapper/agent_feature.go
@@ -1,85 +0,0 @@
-package implspanmapper
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
-	"github.com/SigNoz/signoz/pkg/types/opamptypes"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-const SpanAttrMappingFeatureType agentConf.AgentFeatureType = "span_attr_mapping"
-
-// SpanAttrMappingFeature implements agentConf.AgentFeature. It reads enabled
-// mapping groups and mappers from the module and generates the
-// signozspanmappingprocessor config for deployment via OpAMP.
-type SpanAttrMappingFeature struct {
-	module spanmapper.Module
-}
-
-func NewSpanAttrMappingFeature(module spanmapper.Module) *SpanAttrMappingFeature {
-	return &SpanAttrMappingFeature{module: module}
-}
-
-func (f *SpanAttrMappingFeature) AgentFeatureType() agentConf.AgentFeatureType {
-	return SpanAttrMappingFeatureType
-}
-
-func (f *SpanAttrMappingFeature) RecommendAgentConfig(
-	orgId valuer.UUID,
-	currentConfYaml []byte,
-	configVersion *opamptypes.AgentConfigVersion,
-) ([]byte, string, error) {
-	ctx := context.Background()
-
-	groups, err := f.getEnabled(ctx, orgId)
-	if err != nil {
-		return nil, "", err
-	}
-
-	updatedConf, err := generateCollectorConfigWithSpanMapping(currentConfYaml, groups)
-	if err != nil {
-		return nil, "", err
-	}
-
-	serialized, err := json.Marshal(groups)
-	if err != nil {
-		return nil, "", err
-	}
-
-	return updatedConf, string(serialized), nil
-}
-
-// getEnabled returns enabled groups alongside their enabled mappers. Groups
-// with no enabled mappers are still included so the collector sees the
-// exists_any condition, even if the attributes list is empty.
-func (f *SpanAttrMappingFeature) getEnabled(ctx context.Context, orgId valuer.UUID) ([]enabledGroup, error) {
-	if f.module == nil {
-		return nil, nil
-	}
-
-	enabled := true
-	groups, err := f.module.ListGroups(ctx, orgId, &spantypes.ListSpanMapperGroupsQuery{Enabled: &enabled})
-	if err != nil {
-		return nil, err
-	}
-
-	out := make([]enabledGroup, 0, len(groups))
-	for _, g := range groups {
-		mappers, err := f.module.ListMappers(ctx, orgId, g.ID)
-		if err != nil {
-			return nil, err
-		}
-		enabledMappers := make([]*spantypes.SpanMapper, 0, len(mappers))
-		for _, m := range mappers {
-			if m.Enabled {
-				enabledMappers = append(enabledMappers, m)
-			}
-		}
-		out = append(out, enabledGroup{group: g, mappers: enabledMappers})
-	}
-	return out, nil
-}
--- a/pkg/modules/spanmapper/implspanmapper/collector_config.go
+++ b/pkg/modules/spanmapper/implspanmapper/collector_config.go
@@ -1,137 +0,0 @@
-package implspanmapper
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"gopkg.in/yaml.v3"
-)
-
-const processorName = "signozspanmappingprocessor"
-
-const (
-	// Collector context values (see signozspanmappingprocessor.ContextAttributes/ContextResource).
-	ctxAttributes = "attributes"
-	ctxResource   = "resource"
-
-	// Collector action values.
-	actionCopy = "copy"
-	actionMove = "move"
-
-	// Source key prefix the collector treats as "read from resource".
-	resourcePrefix = "resource."
-)
-
-// enabledGroup pairs an enabled group with its enabled mappers.
-type enabledGroup struct {
-	group   *spantypes.SpanMapperGroup
-	mappers []*spantypes.SpanMapper
-}
-
-// buildProcessorConfig converts enabled groups + mappers into the
-// signozspanmappingprocessor config shape.
-func buildProcessorConfig(groups []enabledGroup) *spantypes.SpanMappingProcessorConfig {
-	out := make([]spantypes.SpanMappingGroup, 0, len(groups))
-
-	for _, eg := range groups {
-		rules := make([]spantypes.SpanMappingAttribute, 0, len(eg.mappers))
-		for _, m := range eg.mappers {
-			rules = append(rules, buildAttributeRule(m))
-		}
-
-		out = append(out, spantypes.SpanMappingGroup{
-			ID: eg.group.Name,
-			ExistsAny: spantypes.SpanMappingExistsAny{
-				Attributes: eg.group.Condition.Attributes,
-				Resource:   eg.group.Condition.Resource,
-			},
-			Attributes: rules,
-		})
-	}
-
-	return &spantypes.SpanMappingProcessorConfig{Groups: out}
-}
-
-// buildAttributeRule maps a single SpanMapper to a collector AttributeRule.
-// Sources are sorted by Priority DESC (highest-priority first), and read-from-
-// resource sources are encoded via the "resource." prefix. The rule-level
-// action is derived from the sources' operations (all sources within one
-// mapper are expected to share the same operation; the highest-priority
-// source's operation is used).
-func buildAttributeRule(m *spantypes.SpanMapper) spantypes.SpanMappingAttribute {
-	sources := make([]spantypes.SpanMapperSource, len(m.Config.Sources))
-	copy(sources, m.Config.Sources)
-	sort.SliceStable(sources, func(i, j int) bool { return sources[i].Priority > sources[j].Priority })
-
-	keys := make([]string, 0, len(sources))
-	for _, s := range sources {
-		if s.Context == spantypes.FieldContextResource {
-			keys = append(keys, resourcePrefix+s.Key)
-		} else {
-			keys = append(keys, s.Key)
-		}
-	}
-
-	action := actionCopy
-	if len(sources) > 0 && sources[0].Operation == spantypes.SpanMapperOperationMove {
-		action = actionMove
-	}
-
-	ctx := ctxAttributes
-	if m.FieldContext == spantypes.FieldContextResource {
-		ctx = ctxResource
-	}
-
-	return spantypes.SpanMappingAttribute{
-		Target:  m.Name,
-		Context: ctx,
-		Action:  action,
-		Sources: keys,
-	}
-}
-
-// generateCollectorConfigWithSpanMapping injects (or replaces) the
-// signozspanmappingprocessor block in the collector YAML. Pipeline wiring is
-// handled by the collector's baseline config, not here.
-func generateCollectorConfigWithSpanMapping(
-	currentConfYaml []byte,
-	groups []enabledGroup,
-) ([]byte, error) {
-	// Empty input: nothing to inject into. Pass through unchanged so we don't
-	// turn it into "null\n" or fail on yaml.v3's EOF.
-	if len(bytes.TrimSpace(currentConfYaml)) == 0 {
-		return currentConfYaml, nil
-	}
-
-	var collectorConf map[string]any
-	if err := yaml.Unmarshal(currentConfYaml, &collectorConf); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal collector config: %w", err)
-	}
-	if collectorConf == nil {
-		collectorConf = map[string]any{}
-	}
-
-	processors := map[string]any{}
-	if collectorConf["processors"] != nil {
-		if p, ok := collectorConf["processors"].(map[string]any); ok {
-			processors = p
-		}
-	}
-
-	procConfig := buildProcessorConfig(groups)
-	configBytes, err := yaml.Marshal(procConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal span attr mapping processor config: %w", err)
-	}
-	var configMap any
-	if err := yaml.Unmarshal(configBytes, &configMap); err != nil {
-		return nil, fmt.Errorf("failed to re-unmarshal span attr mapping processor config: %w", err)
-	}
-
-	processors[processorName] = configMap
-	collectorConf["processors"] = processors
-
-	return yaml.Marshal(collectorConf)
-}
--- a/pkg/modules/spanmapper/implspanmapper/handler.go
+++ b/pkg/modules/spanmapper/implspanmapper/handler.go
@@ -1,301 +0,0 @@
-package implspanmapper
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module           spanmapper.Module
-	providerSettings factory.ProviderSettings
-}
-
-func NewHandler(module spanmapper.Module, providerSettings factory.ProviderSettings) spanmapper.Handler {
-	return &handler{module: module, providerSettings: providerSettings}
-}
-
-// ListGroups handles GET /api/v1/span_mapper_groups.
-func (h *handler) ListGroups(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)
-
-	var q spantypes.ListSpanMapperGroupsQuery
-	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groups, err := h.module.ListGroups(ctx, orgID, &q)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spantypes.NewGettableSpanMapperGroups(groups))
-}
-
-// CreateGroup handles POST /api/v1/span_mapper_groups.
-func (h *handler) CreateGroup(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.PostableSpanMapperGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	group := spantypes.NewSpanMapperGroupFromPostable(req)
-
-	err = h.module.CreateGroup(ctx, orgID, claims.Email, group)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	render.Success(rw, http.StatusCreated, group)
-}
-
-// UpdateGroup handles PUT /api/v1/span_mapper_groups/{id}.
-func (h *handler) UpdateGroup(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)
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.UpdatableSpanMapperGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateGroup(ctx, orgID, id, claims.Email, spantypes.NewSpanMapperGroupFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteGroup handles DELETE /api/v1/span_mapper_groups/{id}.
-func (h *handler) DeleteGroup(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)
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteGroup(ctx, orgID, id); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// ListMappers handles GET /api/v1/span_mapper_groups/{id}/span_mappers.
-func (h *handler) ListMappers(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)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mappers, err := h.module.ListMappers(ctx, orgID, groupID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spantypes.NewGettableSpanMappers(mappers))
-}
-
-// CreateMapper handles POST /api/v1/span_mapper_groups/{id}/span_mappers.
-func (h *handler) CreateMapper(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)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.PostableSpanMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	mapper := spantypes.NewSpanMapperFromPostable(req)
-
-	err = h.module.CreateMapper(ctx, orgID, groupID, claims.Email, mapper)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, mapper)
-}
-
-// UpdateMapper handles PUT /api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}.
-func (h *handler) UpdateMapper(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)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spantypes.UpdatableSpanMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateMapper(ctx, orgID, groupID, mapperID, claims.Email, spantypes.NewSpanMapperFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteMapper handles DELETE /api/v1/span_mapper_groups/{groupId}/span_mappers/{mapperId}.
-func (h *handler) DeleteMapper(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)
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteMapper(ctx, orgID, groupID, mapperID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// groupIDFromPath extracts and validates the {id} or {groupId} path variable.
-func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
-	vars := mux.Vars(r)
-	raw := vars["groupId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "group id is not a valid uuid")
-	}
-	return id, nil
-}
-
-// mapperIDFromPath extracts and validates the {mapperId} path variable.
-func mapperIDFromPath(r *http.Request) (valuer.UUID, error) {
-	raw := mux.Vars(r)["mapperId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "mapper id is not a valid uuid")
-	}
-	return id, nil
-}
--- a/pkg/modules/spanmapper/implspanmapper/module.go
+++ b/pkg/modules/spanmapper/implspanmapper/module.go
@@ -1,179 +0,0 @@
-package implspanmapper
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct {
-	store spantypes.Store
-}
-
-func NewModule(store spantypes.Store) spanmapper.Module {
-	return &module{store: store}
-}
-
-func (m *module) ListGroups(ctx context.Context, orgID valuer.UUID, q *spantypes.ListSpanMapperGroupsQuery) ([]*spantypes.SpanMapperGroup, error) {
-	storables, err := m.store.ListSpanMapperGroups(ctx, orgID, q)
-	if err != nil {
-		return nil, err
-	}
-	return spantypes.NewSpanMapperGroupsFromStorableGroups(storables), nil
-}
-
-func (m *module) GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapperGroup, error) {
-	s, err := m.store.GetSpanMapperGroup(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	return spantypes.NewSpanMapperGroupFromStorable(s), nil
-}
-
-func (m *module) CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, group *spantypes.SpanMapperGroup) error {
-	now := time.Now()
-	group.ID = valuer.GenerateUUID()
-	group.OrgID = orgID
-	group.CreatedAt = now
-	group.UpdatedAt = now
-	group.CreatedBy = createdBy
-	group.UpdatedBy = createdBy
-
-	storable := &spantypes.StorableSpanMapperGroup{
-		Identifiable:  types.Identifiable{ID: group.ID},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable: types.UserAuditable{CreatedBy: createdBy, UpdatedBy: createdBy},
-		OrgID:         orgID,
-		Name:          group.Name,
-		Category:      group.Category,
-		Condition:     group.Condition,
-		Enabled:       group.Enabled,
-	}
-
-	if err := m.store.CreateSpanMapperGroup(ctx, storable); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
-
-func (m *module) UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, group *spantypes.SpanMapperGroup) error {
-	existing, err := m.store.GetSpanMapperGroup(ctx, orgID, id)
-	if err != nil {
-		return err
-	}
-
-	if group.Name != "" {
-		existing.Name = group.Name
-	}
-	if len(group.Condition.Attributes) > 0 || len(group.Condition.Resource) > 0 {
-		existing.Condition = group.Condition
-	}
-	existing.Enabled = group.Enabled
-	existing.UpdatedAt = time.Now()
-	existing.UpdatedBy = updatedBy
-
-	if err := m.store.UpdateSpanMapperGroup(ctx, existing); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
-
-func (m *module) DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	if err := m.store.DeleteSpanMapperGroup(ctx, orgID, id); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
-
-func (m *module) ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spantypes.SpanMapper, error) {
-	storables, err := m.store.ListSpanMappers(ctx, orgID, groupID)
-	if err != nil {
-		return nil, err
-	}
-	return spantypes.NewSpanMappersFromStorableSpanMappers(storables), nil
-}
-
-func (m *module) GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapper, error) {
-	s, err := m.store.GetSpanMapper(ctx, orgID, groupID, id)
-	if err != nil {
-		return nil, err
-	}
-	return spantypes.NewSpanMapperFromStorable(s), nil
-}
-
-func (m *module) CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, mapper *spantypes.SpanMapper) error {
-	// Ensure the group belongs to the org before inserting the child row.
-	if _, err := m.store.GetSpanMapperGroup(ctx, orgID, groupID); err != nil {
-		return err
-	}
-
-	now := time.Now()
-	mapper.ID = valuer.GenerateUUID()
-	mapper.GroupID = groupID
-	mapper.CreatedAt = now
-	mapper.UpdatedAt = now
-	mapper.CreatedBy = createdBy
-	mapper.UpdatedBy = createdBy
-
-	storable := &spantypes.StorableSpanMapper{
-		Identifiable:  types.Identifiable{ID: mapper.ID},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable: types.UserAuditable{CreatedBy: createdBy, UpdatedBy: createdBy},
-		GroupID:       groupID,
-		Name:          mapper.Name,
-		FieldContext:  mapper.FieldContext,
-		Config:        mapper.Config,
-		Enabled:       mapper.Enabled,
-	}
-
-	if err := m.store.CreateSpanMapper(ctx, storable); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
-
-func (m *module) UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, mapper *spantypes.SpanMapper) error {
-	existing, err := m.store.GetSpanMapper(ctx, orgID, groupID, id)
-	if err != nil {
-		return err
-	}
-
-	if mapper.FieldContext != (spantypes.FieldContext{}) {
-		existing.FieldContext = mapper.FieldContext
-	}
-	if mapper.Config.Sources != nil {
-		existing.Config = mapper.Config
-	}
-	existing.Enabled = mapper.Enabled
-	existing.UpdatedAt = time.Now()
-	existing.UpdatedBy = updatedBy
-
-	if err := m.store.UpdateSpanMapper(ctx, existing); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
-
-func (m *module) DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error {
-	if err := m.store.DeleteSpanMapper(ctx, orgID, groupID, id); err != nil {
-		return err
-	}
-
-	agentConf.NotifyConfigUpdate(ctx)
-	return nil
-}
--- a/pkg/modules/spanmapper/implspanmapper/store.go
+++ b/pkg/modules/spanmapper/implspanmapper/store.go
@@ -1,236 +0,0 @@
-package implspanmapper
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type store struct {
-	sqlstore sqlstore.SQLStore
-}
-
-func NewStore(sqlstore sqlstore.SQLStore) spantypes.Store {
-	return &store{sqlstore: sqlstore}
-}
-
-func (s *store) ListSpanMapperGroups(ctx context.Context, orgID valuer.UUID, q *spantypes.ListSpanMapperGroupsQuery) ([]*spantypes.StorableSpanMapperGroup, error) {
-	groups := make([]*spantypes.StorableSpanMapperGroup, 0)
-
-	sel := s.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&groups).
-		Where("org_id = ?", orgID)
-
-	if q != nil {
-		if q.Category != nil {
-			sel = sel.Where("category = ?", valuer.String(*q.Category).StringValue())
-		}
-		if q.Enabled != nil {
-			sel = sel.Where("enabled = ?", *q.Enabled)
-		}
-	}
-
-	if err := sel.Order("created_at DESC").Scan(ctx); err != nil {
-		return nil, err
-	}
-	return groups, nil
-}
-
-func (s *store) GetSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) (*spantypes.StorableSpanMapperGroup, error) {
-	group := new(spantypes.StorableSpanMapperGroup)
-
-	err := s.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(group).
-		Where("org_id = ?", orgID).
-		Where("id = ?", id).
-		Scan(ctx)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, s.sqlstore.WrapNotFoundErrf(err, spantypes.ErrCodeMappingGroupNotFound, "span mapper group %s not found", id)
-		}
-		return nil, err
-	}
-	return group, nil
-}
-
-func (s *store) CreateSpanMapperGroup(ctx context.Context, group *spantypes.StorableSpanMapperGroup) error {
-	_, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewInsert().
-		Model(group).
-		Exec(ctx)
-	if err != nil {
-		return s.sqlstore.WrapAlreadyExistsErrf(err, spantypes.ErrCodeMappingGroupAlreadyExists, "span mapper group %q already exists", group.Name)
-	}
-	return nil
-}
-
-func (s *store) UpdateSpanMapperGroup(ctx context.Context, group *spantypes.StorableSpanMapperGroup) error {
-	res, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model(group).
-		Where("org_id = ?", group.OrgID).
-		Where("id = ?", group.ID).
-		ExcludeColumn("id", "org_id", "created_at", "created_by").
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rowsAffected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rowsAffected == 0 {
-		return errors.Newf(errors.TypeNotFound, spantypes.ErrCodeMappingGroupNotFound, "span mapper group %s not found", group.ID)
-	}
-	return nil
-}
-
-func (s *store) DeleteSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) error {
-	tx, err := s.sqlstore.BunDBCtx(ctx).BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	// Cascade: remove mappers belonging to this group first.
-	if _, err := tx.NewDelete().
-		Model((*spantypes.StorableSpanMapper)(nil)).
-		Where("group_id = ?", id).
-		Exec(ctx); err != nil {
-		return err
-	}
-
-	res, err := tx.NewDelete().
-		Model((*spantypes.StorableSpanMapperGroup)(nil)).
-		Where("org_id = ?", orgID).
-		Where("id = ?", id).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rowsAffected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rowsAffected == 0 {
-		return errors.Newf(errors.TypeNotFound, spantypes.ErrCodeMappingGroupNotFound, "span mapper group %s not found", id)
-	}
-
-	return tx.Commit()
-}
-
-func (s *store) ListSpanMappers(ctx context.Context, orgID, groupID valuer.UUID) ([]*spantypes.StorableSpanMapper, error) {
-	mappers := make([]*spantypes.StorableSpanMapper, 0)
-
-	// Scope by org via the parent group's org_id.
-	if _, err := s.GetSpanMapperGroup(ctx, orgID, groupID); err != nil {
-		return nil, err
-	}
-
-	if err := s.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&mappers).
-		Where("group_id = ?", groupID).
-		Order("created_at DESC").
-		Scan(ctx); err != nil {
-		return nil, err
-	}
-	return mappers, nil
-}
-
-func (s *store) GetSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) (*spantypes.StorableSpanMapper, error) {
-	// Ensure the group belongs to the org.
-	if _, err := s.GetSpanMapperGroup(ctx, orgID, groupID); err != nil {
-		return nil, err
-	}
-
-	mapper := new(spantypes.StorableSpanMapper)
-	err := s.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(mapper).
-		Where("group_id = ?", groupID).
-		Where("id = ?", id).
-		Scan(ctx)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, s.sqlstore.WrapNotFoundErrf(err, spantypes.ErrCodeMapperNotFound, "span mapper %s not found", id)
-		}
-		return nil, err
-	}
-	return mapper, nil
-}
-
-func (s *store) CreateSpanMapper(ctx context.Context, mapper *spantypes.StorableSpanMapper) error {
-	_, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewInsert().
-		Model(mapper).
-		Exec(ctx)
-	if err != nil {
-		return s.sqlstore.WrapAlreadyExistsErrf(err, spantypes.ErrCodeMapperAlreadyExists, "span mapper %q already exists", mapper.Name)
-	}
-	return nil
-}
-
-func (s *store) UpdateSpanMapper(ctx context.Context, mapper *spantypes.StorableSpanMapper) error {
-	res, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model(mapper).
-		Where("group_id = ?", mapper.GroupID).
-		Where("id = ?", mapper.ID).
-		ExcludeColumn("id", "group_id", "created_at", "created_by").
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rowsAffected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rowsAffected == 0 {
-		return errors.Newf(errors.TypeNotFound, spantypes.ErrCodeMapperNotFound, "span mapper %s not found", mapper.ID)
-	}
-	return nil
-}
-
-func (s *store) DeleteSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) error {
-	if _, err := s.GetSpanMapperGroup(ctx, orgID, groupID); err != nil {
-		return err
-	}
-
-	res, err := s.sqlstore.
-		BunDBCtx(ctx).
-		NewDelete().
-		Model((*spantypes.StorableSpanMapper)(nil)).
-		Where("group_id = ?", groupID).
-		Where("id = ?", id).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	rowsAffected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rowsAffected == 0 {
-		return errors.Newf(errors.TypeNotFound, spantypes.ErrCodeMapperNotFound, "span mapper %s not found", id)
-	}
-	return nil
-}
--- a/pkg/modules/spanmapper/spanmapper.go
+++ b/pkg/modules/spanmapper/spanmapper.go
@@ -1,41 +0,0 @@
-package spanmapper
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Module defines the business logic for span attribute mapping groups and mappers.
-type Module interface {
-	// Group operations
-	ListGroups(ctx context.Context, orgID valuer.UUID, q *spantypes.ListSpanMapperGroupsQuery) ([]*spantypes.SpanMapperGroup, error)
-	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapperGroup, error)
-	CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, group *spantypes.SpanMapperGroup) error
-	UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, group *spantypes.SpanMapperGroup) error
-	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spantypes.SpanMapper, error)
-	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spantypes.SpanMapper, error)
-	CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, mapper *spantypes.SpanMapper) error
-	UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, mapper *spantypes.SpanMapper) error
-	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
-}
-
-// Handler defines the HTTP handler interface for mapping group and mapper endpoints.
-type Handler interface {
-	// Group handlers
-	ListGroups(rw http.ResponseWriter, r *http.Request)
-	CreateGroup(rw http.ResponseWriter, r *http.Request)
-	UpdateGroup(rw http.ResponseWriter, r *http.Request)
-	DeleteGroup(rw http.ResponseWriter, r *http.Request)
-
-	// Mapper handlers
-	ListMappers(rw http.ResponseWriter, r *http.Request)
-	CreateMapper(rw http.ResponseWriter, r *http.Request)
-	UpdateMapper(rw http.ResponseWriter, r *http.Request)
-	DeleteMapper(rw http.ResponseWriter, r *http.Request)
-}
--- a/pkg/query-service/app/server.go
+++ b/pkg/query-service/app/server.go
@@ -9,7 +9,6 @@ import (

 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper/implspanmapper"
 	"github.com/SigNoz/signoz/pkg/queryparser"

 	"github.com/gorilla/handlers"
@@ -130,14 +129,11 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {

 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)

-	spanAttrMappingFeature := implspanmapper.NewSpanAttrMappingFeature(signoz.Modules.SpanMapper)
-
 	agentConfMgr, err := agentConf.Initiate(
 		&agentConf.ManagerOptions{
 			Store: signoz.SQLStore,
 			AgentFeatures: []agentConf.AgentFeature{
 				logParsingPipelineController,
-				spanAttrMappingFeature,
 			},
 		},
 	)
--- a/pkg/signoz/handler.go
+++ b/pkg/signoz/handler.go
@@ -36,8 +36,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/services"
 	"github.com/SigNoz/signoz/pkg/modules/services/implservices"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper/implspanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
@@ -73,7 +71,6 @@ type Handlers struct {
 	RegistryHandler         factory.Handler
 	CloudIntegrationHandler cloudintegration.Handler
 	RuleStateHistory        rulestatehistory.Handler
-	SpanMapperHandler       spanmapper.Handler
 	AlertmanagerHandler     alertmanager.Handler
 	TraceDetail             tracedetail.Handler
 	RulerHandler            ruler.Handler
@@ -117,7 +114,6 @@ func NewHandlers(
 		RegistryHandler:         registryHandler,
 		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
 		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
-		SpanMapperHandler:       implspanmapper.NewHandler(modules.SpanMapper, providerSettings),
 		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
 		TraceDetail:             impltracedetail.NewHandler(modules.TraceDetail),
 		RulerHandler:            signozruler.NewHandler(rulerService),
--- a/pkg/signoz/module.go
+++ b/pkg/signoz/module.go
@@ -37,8 +37,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/services/implservices"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/session/implsession"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper/implspanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
@@ -81,7 +79,6 @@ type Modules struct {
 	CloudIntegration cloudintegration.Module
 	RuleStateHistory rulestatehistory.Module
 	TraceDetail      tracedetail.Module
-	SpanMapper       spanmapper.Module
 }

 func NewModules(
@@ -134,6 +131,5 @@ func NewModules(
 		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)),
 	}
 }
--- a/pkg/signoz/openapi.go
+++ b/pkg/signoz/openapi.go
@@ -21,8 +21,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -30,7 +30,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
@@ -75,7 +74,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
-		struct{ spanmapper.Handler }{},
 		struct{ alertmanager.Handler }{},
 		struct{ tracedetail.Handler }{},
 		struct{ ruler.Handler }{},
--- a/pkg/signoz/provider.go
+++ b/pkg/signoz/provider.go
@@ -195,7 +195,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewServiceAccountAuthzactory(sqlstore),
 		sqlmigration.NewDropUserDeletedAtFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateAWSAllRegionsFactory(sqlstore),
-		sqlmigration.NewAddSpanMapperFactory(sqlstore, sqlschema),
 	)
 }

@@ -282,7 +281,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
-			handlers.SpanMapperHandler,
 			handlers.AlertmanagerHandler,
 			handlers.TraceDetail,
 			handlers.RulerHandler,
--- a/pkg/sqlmigration/082_add_span_mapper.go
+++ b/pkg/sqlmigration/082_add_span_mapper.go
@@ -1,119 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addSpanMapper struct {
-	sqlschema sqlschema.SQLSchema
-	sqlstore  sqlstore.SQLStore
-}
-
-func NewAddSpanMapperFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_span_mapper"), func(_ context.Context, _ factory.ProviderSettings, _ Config) (SQLMigration, error) {
-		return &addSpanMapper{sqlschema: sqlschema, sqlstore: sqlstore}, nil
-	})
-}
-
-func (migration *addSpanMapper) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addSpanMapper) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	sqls := [][]byte{}
-
-	groupSQLs := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "span_mapper_group",
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "created_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "updated_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "category", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "condition", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "enabled", DataType: sqlschema.DataTypeBoolean, Nullable: false, Default: "true"},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
-			ColumnNames: []sqlschema.ColumnName{"id"},
-		},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-	sqls = append(sqls, groupSQLs...)
-
-	groupIdxSQLs := migration.sqlschema.Operator().CreateIndex(
-		&sqlschema.UniqueIndex{
-			TableName:   "span_mapper_group",
-			ColumnNames: []sqlschema.ColumnName{"org_id", "name"},
-		})
-	sqls = append(sqls, groupIdxSQLs...)
-
-	mapperSQLs := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "span_mapper",
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "created_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "updated_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "group_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "field_context", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "config", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "enabled", DataType: sqlschema.DataTypeBoolean, Nullable: false, Default: "true"},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
-			ColumnNames: []sqlschema.ColumnName{"id"},
-		},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("group_id"),
-				ReferencedTableName:   sqlschema.TableName("span_mapper_group"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-	sqls = append(sqls, mapperSQLs...)
-
-	mapperIdxSQLs := migration.sqlschema.Operator().CreateIndex(
-		&sqlschema.UniqueIndex{
-			TableName:   "span_mapper",
-			ColumnNames: []sqlschema.ColumnName{"group_id", "name"},
-		})
-	sqls = append(sqls, mapperIdxSQLs...)
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addSpanMapper) Down(context.Context, *bun.DB) error {
-	return nil
-}
--- a/pkg/types/inframonitoringtypes/hosts.go
+++ b/pkg/types/inframonitoringtypes/hosts.go
@@ -49,7 +49,7 @@ type HostFilter struct {
 	FilterByStatus HostStatus `json:"filterByStatus"`
 }

-// Validate ensures HostsListRequest contains acceptable values.
+// Validate ensures PostableHosts contains acceptable values.
 func (req *PostableHosts) Validate() error {
 	if req == nil {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
--- a/pkg/types/inframonitoringtypes/pods.go
+++ b/pkg/types/inframonitoringtypes/pods.go
@@ -0,0 +1,109 @@
+package inframonitoringtypes
+
+import (
+	"encoding/json"
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+)
+
+type Pods struct {
+	Type                   ResponseType           `json:"type" required:"true"`
+	Records                []PodRecord            `json:"records" required:"true"`
+	Total                  int                    `json:"total" required:"true"`
+	RequiredMetricsCheck   RequiredMetricsCheck   `json:"requiredMetricsCheck" required:"true"`
+	EndTimeBeforeRetention bool                   `json:"endTimeBeforeRetention" required:"true"`
+	Warning                *qbtypes.QueryWarnData `json:"warning,omitempty"`
+}
+
+type PodRecord struct {
+	PodUID            string                 `json:"podUID" required:"true"`
+	PodCPU            float64                `json:"podCPU" required:"true"`
+	PodCPURequest     float64                `json:"podCPURequest" required:"true"`
+	PodCPULimit       float64                `json:"podCPULimit" required:"true"`
+	PodMemory         float64                `json:"podMemory" required:"true"`
+	PodMemoryRequest  float64                `json:"podMemoryRequest" required:"true"`
+	PodMemoryLimit    float64                `json:"podMemoryLimit" required:"true"`
+	PodPhase          PodPhase               `json:"podPhase" required:"true"`
+	PendingPodCount   int                    `json:"pendingPodCount" required:"true"`
+	RunningPodCount   int                    `json:"runningPodCount" required:"true"`
+	SucceededPodCount int                    `json:"succeededPodCount" required:"true"`
+	FailedPodCount    int                    `json:"failedPodCount" required:"true"`
+	UnknownPodCount   int                    `json:"unknownPodCount" required:"true"`
+	PodAge            int64                  `json:"podAge" required:"true"`
+	Meta              map[string]interface{} `json:"meta" required:"true"`
+}
+
+// PostablePods is the request body for the v2 pods list API.
+type PostablePods struct {
+	Start   int64                `json:"start" required:"true"`
+	End     int64                `json:"end" required:"true"`
+	Filter  *qbtypes.Filter      `json:"filter"`
+	GroupBy []qbtypes.GroupByKey `json:"groupBy"`
+	OrderBy *qbtypes.OrderBy     `json:"orderBy"`
+	Offset  int                  `json:"offset"`
+	Limit   int                  `json:"limit" required:"true"`
+}
+
+// Validate ensures PostablePods contains acceptable values.
+func (req *PostablePods) Validate() error {
+	if req == nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
+	}
+
+	if req.Start <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid start time %d: start must be greater than 0",
+			req.Start,
+		)
+	}
+
+	if req.End <= 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid end time %d: end must be greater than 0",
+			req.End,
+		)
+	}
+
+	if req.Start >= req.End {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"invalid time range: start (%d) must be less than end (%d)",
+			req.Start,
+			req.End,
+		)
+	}
+
+	if req.Limit < 1 || req.Limit > 5000 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be between 1 and 5000")
+	}
+
+	if req.Offset < 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset cannot be negative")
+	}
+
+	if req.OrderBy != nil {
+		if !slices.Contains(PodsValidOrderByKeys, req.OrderBy.Key.Name) {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by key: %s", req.OrderBy.Key.Name)
+		}
+		if req.OrderBy.Direction != qbtypes.OrderDirectionAsc && req.OrderBy.Direction != qbtypes.OrderDirectionDesc {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by direction: %s", req.OrderBy.Direction)
+		}
+	}
+
+	return nil
+}
+
+// UnmarshalJSON validates input immediately after decoding.
+func (req *PostablePods) UnmarshalJSON(data []byte) error {
+	type raw PostablePods
+	var decoded raw
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return err
+	}
+	*req = PostablePods(decoded)
+	return req.Validate()
+}
--- a/pkg/types/inframonitoringtypes/pods_constants.go
+++ b/pkg/types/inframonitoringtypes/pods_constants.go
@@ -0,0 +1,45 @@
+package inframonitoringtypes
+
+import "github.com/SigNoz/signoz/pkg/valuer"
+
+type PodPhase struct {
+	valuer.String
+}
+
+var (
+	PodPhasePending   = PodPhase{valuer.NewString("pending")}
+	PodPhaseRunning   = PodPhase{valuer.NewString("running")}
+	PodPhaseSucceeded = PodPhase{valuer.NewString("succeeded")}
+	PodPhaseFailed    = PodPhase{valuer.NewString("failed")}
+	PodPhaseUnknown   = PodPhase{valuer.NewString("unknown")}
+	PodPhaseNone      = PodPhase{valuer.NewString("")}
+)
+
+func (PodPhase) Enum() []any {
+	return []any{
+		PodPhasePending,
+		PodPhaseRunning,
+		PodPhaseSucceeded,
+		PodPhaseFailed,
+		PodPhaseUnknown,
+		PodPhaseNone,
+	}
+}
+
+const (
+	PodsOrderByCPU           = "cpu"
+	PodsOrderByCPURequest    = "cpu_request"
+	PodsOrderByCPULimit      = "cpu_limit"
+	PodsOrderByMemory        = "memory"
+	PodsOrderByMemoryRequest = "memory_request"
+	PodsOrderByMemoryLimit   = "memory_limit"
+)
+
+var PodsValidOrderByKeys = []string{
+	PodsOrderByCPU,
+	PodsOrderByCPURequest,
+	PodsOrderByCPULimit,
+	PodsOrderByMemory,
+	PodsOrderByMemoryRequest,
+	PodsOrderByMemoryLimit,
+}
--- a/pkg/types/inframonitoringtypes/pods_test.go
+++ b/pkg/types/inframonitoringtypes/pods_test.go
@@ -0,0 +1,219 @@
+package inframonitoringtypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostablePods_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *PostablePods
+		wantErr bool
+	}{
+		{
+			name: "valid request",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name:    "nil request",
+			req:     nil,
+			wantErr: true,
+		},
+		{
+			name: "start time zero",
+			req: &PostablePods{
+				Start:  0,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time negative",
+			req: &PostablePods{
+				Start:  -1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "end time zero",
+			req: &PostablePods{
+				Start:  1000,
+				End:    0,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time greater than end time",
+			req: &PostablePods{
+				Start:  2000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "start time equal to end time",
+			req: &PostablePods{
+				Start:  1000,
+				End:    1000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit zero",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  0,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit negative",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  -10,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "limit exceeds max",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  5001,
+				Offset: 0,
+			},
+			wantErr: true,
+		},
+		{
+			name: "offset negative",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: -5,
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy nil is valid",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with valid key cpu and direction asc",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: PodsOrderByCPU,
+						},
+					},
+					Direction: qbtypes.OrderDirectionAsc,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "orderBy with phase key is rejected",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "phase",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with invalid key",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "unknown",
+						},
+					},
+					Direction: qbtypes.OrderDirectionDesc,
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "orderBy with valid key but invalid direction",
+			req: &PostablePods{
+				Start:  1000,
+				End:    2000,
+				Limit:  100,
+				Offset: 0,
+				OrderBy: &qbtypes.OrderBy{
+					Key: qbtypes.OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: PodsOrderByMemory,
+						},
+					},
+					Direction: qbtypes.OrderDirection{String: valuer.NewString("invalid")},
+				},
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.req.Validate()
+			if tt.wantErr {
+				require.Error(t, err)
+				require.True(t, errors.Ast(err, errors.TypeInvalidInput), "expected error to be of type InvalidInput")
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
--- a/pkg/types/spantypes/mapper.go
+++ b/pkg/types/spantypes/mapper.go
@@ -1,137 +0,0 @@
-package spantypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMapperNotFound      = errors.MustNewCode("span_attribute_mapper_not_found")
-	ErrCodeMapperAlreadyExists = errors.MustNewCode("span_attribute_mapper_already_exists")
-	ErrCodeMappingInvalidInput = errors.MustNewCode("span_attribute_mapping_invalid_input")
-)
-
-// FieldContext is where the target attribute is written.
-type FieldContext struct {
-	valuer.String
-}
-
-var (
-	FieldContextSpanAttribute = FieldContext{valuer.NewString("attribute")}
-	FieldContextResource      = FieldContext{valuer.NewString("resource")}
-)
-
-// MapperOperation determines whether the source attribute is moved (deleted) or copied.
-type SpanMapperOperation struct {
-	valuer.String
-}
-
-var (
-	SpanMapperOperationMove = SpanMapperOperation{valuer.NewString("move")}
-	SpanMapperOperationCopy = SpanMapperOperation{valuer.NewString("copy")}
-)
-
-// MapperSource describes one candidate source for a target attribute.
-type SpanMapperSource struct {
-	Key       string              `json:"key" required:"true"`
-	Context   FieldContext        `json:"context" required:"true"`
-	Operation SpanMapperOperation `json:"operation" required:"true"`
-	Priority  int                 `json:"priority" required:"true"`
-}
-
-// MapperConfig holds the mapping logic for a single target attribute.
-// It implements driver.Valuer and sql.Scanner for JSON text column storage.
-type SpanMapperConfig struct {
-	Sources []SpanMapperSource `json:"sources" required:"true" nullable:"true"`
-}
-
-// SpanMapper is the domain model for a span attribute mapper.
-type SpanMapper struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID           valuer.UUID      `json:"id"            required:"true"`
-	GroupID      valuer.UUID      `json:"group_id"      required:"true"`
-	Name         string           `json:"name"          required:"true"`
-	FieldContext FieldContext     `json:"field_context" required:"true"`
-	Config       SpanMapperConfig `json:"config"        required:"true"`
-	Enabled      bool             `json:"enabled"       required:"true"`
-}
-
-type PostableSpanMapper struct {
-	Name         string           `json:"name"          required:"true"`
-	FieldContext FieldContext     `json:"field_context" required:"true"`
-	Config       SpanMapperConfig `json:"config"        required:"true"`
-	Enabled      bool             `json:"enabled"`
-}
-
-// UpdatableSpanMapper is the HTTP request body for updating a span mapper.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableSpanMapper struct {
-	FieldContext FieldContext      `json:"field_context,omitempty"`
-	Config       *SpanMapperConfig `json:"config,omitempty"`
-	Enabled      *bool             `json:"enabled,omitempty"`
-}
-
-type GettableSpanMapper = SpanMapper
-
-type GettableSpanMappers struct {
-	Items []*GettableSpanMapper `json:"items" required:"true" nullable:"false"`
-}
-
-func (FieldContext) Enum() []any {
-	return []any{FieldContextSpanAttribute, FieldContextResource}
-}
-
-func (SpanMapperOperation) Enum() []any {
-	return []any{SpanMapperOperationMove, SpanMapperOperationCopy}
-}
-
-func NewSpanMapperFromStorable(s *StorableSpanMapper) *SpanMapper {
-	return &SpanMapper{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		GroupID:       s.GroupID,
-		Name:          s.Name,
-		FieldContext:  s.FieldContext,
-		Config:        s.Config,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewSpanMapperFromPostable(req *PostableSpanMapper) *SpanMapper {
-	return &SpanMapper{
-		Name:         req.Name,
-		FieldContext: req.FieldContext,
-		Config:       req.Config,
-		Enabled:      req.Enabled,
-	}
-}
-
-func NewSpanMapperFromUpdatable(req *UpdatableSpanMapper) *SpanMapper {
-	m := &SpanMapper{}
-	if req.FieldContext != (FieldContext{}) {
-		m.FieldContext = req.FieldContext
-	}
-	if req.Config != nil {
-		m.Config = *req.Config
-	}
-	if req.Enabled != nil {
-		m.Enabled = *req.Enabled
-	}
-	return m
-}
-
-func NewSpanMappersFromStorableSpanMappers(ss []*StorableSpanMapper) []*SpanMapper {
-	mappers := make([]*SpanMapper, len(ss))
-	for i, s := range ss {
-		mappers[i] = NewSpanMapperFromStorable(s)
-	}
-	return mappers
-}
-
-func NewGettableSpanMappers(m []*SpanMapper) *GettableSpanMappers {
-	return &GettableSpanMappers{Items: m}
-}
--- a/pkg/types/spantypes/mappergroup.go
+++ b/pkg/types/spantypes/mappergroup.go
@@ -1,109 +0,0 @@
-package spantypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMappingGroupNotFound      = errors.MustNewCode("span_attribute_mapping_group_not_found")
-	ErrCodeMappingGroupAlreadyExists = errors.MustNewCode("span_attribute_mapping_group_already_exists")
-)
-
-// SpanMapperGroupCategory defaults will be llm, tool, agent but user can configure more as they want.
-type SpanMapperGroupCategory valuer.String
-
-// A group runs when any of the listed attribute/resource key patterns match.
-type SpanMapperGroupCondition struct {
-	Attributes []string `json:"attributes" required:"true" nullable:"true"`
-	Resource   []string `json:"resource" required:"true" nullable:"true"`
-}
-
-// SpanMapperGroup is the domain model for a span attribute mapping group.
-type SpanMapperGroup struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID        valuer.UUID              `json:"id" required:"true"`
-	OrgID     valuer.UUID              `json:"orgId" required:"true"`
-	Name      string                   `json:"name" required:"true"`
-	Category  SpanMapperGroupCategory  `json:"category" required:"true"`
-	Condition SpanMapperGroupCondition `json:"condition" required:"true"`
-	Enabled   bool                     `json:"enabled" required:"true"`
-}
-
-// GettableSpanMapperGroup is the HTTP response representation of a mapping group.
-type GettableSpanMapperGroup = SpanMapperGroup
-
-type PostableSpanMapperGroup struct {
-	Name      string                   `json:"name"      required:"true"`
-	Category  SpanMapperGroupCategory  `json:"category"  required:"true"`
-	Condition SpanMapperGroupCondition `json:"condition" required:"true"`
-	Enabled   bool                     `json:"enabled"`
-}
-
-// UpdatableSpanMapperGroup is the HTTP request body for updating a mapping group.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableSpanMapperGroup struct {
-	Name      *string                   `json:"name,omitempty"`
-	Condition *SpanMapperGroupCondition `json:"condition,omitempty"`
-	Enabled   *bool                     `json:"enabled,omitempty"`
-}
-
-type ListSpanMapperGroupsQuery struct {
-	Category *SpanMapperGroupCategory `query:"category"`
-	Enabled  *bool                    `query:"enabled"`
-}
-
-type GettableSpanMapperGroups struct {
-	Items []*GettableSpanMapperGroup `json:"items" required:"true" nullable:"false"`
-}
-
-func NewSpanMapperGroupFromStorable(s *StorableSpanMapperGroup) *SpanMapperGroup {
-	return &SpanMapperGroup{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		OrgID:         s.OrgID,
-		Name:          s.Name,
-		Category:      s.Category,
-		Condition:     s.Condition,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewSpanMapperGroupFromPostable(p *PostableSpanMapperGroup) *SpanMapperGroup {
-	return &SpanMapperGroup{
-		Name:      p.Name,
-		Category:  p.Category,
-		Condition: p.Condition,
-		Enabled:   p.Enabled,
-	}
-}
-
-func NewSpanMapperGroupFromUpdatable(u *UpdatableSpanMapperGroup) *SpanMapperGroup {
-	g := &SpanMapperGroup{}
-	if u.Name != nil {
-		g.Name = *u.Name
-	}
-	if u.Condition != nil {
-		g.Condition = *u.Condition
-	}
-	if u.Enabled != nil {
-		g.Enabled = *u.Enabled
-	}
-	return g
-}
-
-func NewSpanMapperGroupsFromStorableGroups(ss []*StorableSpanMapperGroup) []*SpanMapperGroup {
-	groups := make([]*SpanMapperGroup, len(ss))
-	for i, s := range ss {
-		groups[i] = NewSpanMapperGroupFromStorable(s)
-	}
-	return groups
-}
-
-func NewGettableSpanMapperGroups(g []*SpanMapperGroup) *GettableSpanMapperGroups {
-	return &GettableSpanMapperGroups{Items: g}
-}
--- a/pkg/types/spantypes/processor_config.go
+++ b/pkg/types/spantypes/processor_config.go
@@ -1,23 +0,0 @@
-package spantypes
-
-type SpanMappingProcessorConfig struct {
-	Groups []SpanMappingGroup `yaml:"groups" json:"groups"`
-}
-
-type SpanMappingGroup struct {
-	ID         string                 `yaml:"id" json:"id"`
-	ExistsAny  SpanMappingExistsAny   `yaml:"exists_any" json:"exists_any"`
-	Attributes []SpanMappingAttribute `yaml:"attributes" json:"attributes"`
-}
-
-type SpanMappingExistsAny struct {
-	Attributes []string `yaml:"attributes,omitempty" json:"attributes,omitempty"`
-	Resource   []string `yaml:"resource,omitempty" json:"resource,omitempty"`
-}
-
-type SpanMappingAttribute struct {
-	Target  string   `yaml:"target" json:"target"`
-	Context string   `yaml:"context,omitempty" json:"context,omitempty"`
-	Action  string   `yaml:"action,omitempty" json:"action,omitempty"`
-	Sources []string `yaml:"sources" json:"sources"`
-}
--- a/pkg/types/spantypes/storable.go
+++ b/pkg/types/spantypes/storable.go
@@ -1,87 +0,0 @@
-package spantypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-type StorableSpanMapperGroup struct {
-	bun.BaseModel `bun:"table:span_mapper_group,alias:span_attribute_mapping_group"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID     valuer.UUID              `bun:"org_id,type:text,notnull"`
-	Name      string                   `bun:"name,type:text,notnull"`
-	Category  SpanMapperGroupCategory  `bun:"category,type:text,notnull"`
-	Condition SpanMapperGroupCondition `bun:"condition,type:jsonb,notnull"`
-	Enabled   bool                     `bun:"enabled,notnull,default:true"`
-}
-
-type StorableSpanMapper struct {
-	bun.BaseModel `bun:"table:span_mapper,alias:span_attribute_mapping"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	GroupID      valuer.UUID      `bun:"group_id,type:text,notnull"`
-	Name         string           `bun:"name,type:text,notnull"`
-	FieldContext FieldContext     `bun:"field_context,type:text,notnull"`
-	Config       SpanMapperConfig `bun:"config,type:jsonb,notnull"`
-	Enabled      bool             `bun:"enabled,notnull,default:true"`
-}
-
-func (c SpanMapperGroupCondition) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (c *SpanMapperGroupCondition) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*c = SpanMapperGroupCondition{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanmapper: cannot scan %T into Condition", src)
-	}
-	return json.Unmarshal(raw, c)
-}
-
-func (m SpanMapperConfig) Value() (driver.Value, error) {
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (m *SpanMapperConfig) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*m = SpanMapperConfig{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanmapper: cannot scan %T into MapperConfig", src)
-	}
-	return json.Unmarshal(raw, m)
-}
--- a/pkg/types/spantypes/store.go
+++ b/pkg/types/spantypes/store.go
@@ -1,23 +0,0 @@
-package spantypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	// Group operations
-	ListSpanMapperGroups(ctx context.Context, orgID valuer.UUID, q *ListSpanMapperGroupsQuery) ([]*StorableSpanMapperGroup, error)
-	GetSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) (*StorableSpanMapperGroup, error)
-	CreateSpanMapperGroup(ctx context.Context, group *StorableSpanMapperGroup) error
-	UpdateSpanMapperGroup(ctx context.Context, group *StorableSpanMapperGroup) error
-	DeleteSpanMapperGroup(ctx context.Context, orgID, id valuer.UUID) error
-
-	// Mapper operations
-	ListSpanMappers(ctx context.Context, orgID, groupID valuer.UUID) ([]*StorableSpanMapper, error)
-	GetSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) (*StorableSpanMapper, error)
-	CreateSpanMapper(ctx context.Context, mapper *StorableSpanMapper) error
-	UpdateSpanMapper(ctx context.Context, mapper *StorableSpanMapper) error
-	DeleteSpanMapper(ctx context.Context, orgID, groupID, id valuer.UUID) error
-}
Author	SHA1	Message	Date
nikhilmantri0902	55b2215025	chore: comment correction	2026-04-24 17:14:56 +05:30
nikhilmantri0902	e90378e618	Merge branch 'infraM/v2_pods_list_api' into feat/v2_pods_list_api_phase_counts	2026-04-24 16:47:15 +05:30
nikhilmantri0902	4592b78f48	chore: pod phase with local table of time series as counts	2026-04-24 15:27:38 +05:30
nikhilmantri0902	d81c99feae	chore: 3 cte --> 2 cte	2026-04-24 14:58:26 +05:30
nikhilmantri0902	65a456ff9e	fix: isPodUIDInGroupBy in buildPodRecords	2026-04-24 14:36:43 +05:30
nikhilmantri0902	264577b673	chore: added unknown phase count	2026-04-24 13:29:09 +05:30
Ashwin Bhatkal	b35c6676f9	fix: rebase fixes	2026-04-24 13:17:02 +05:30
nikhilmantri0902	c78c9a42db	chore: merged base	2026-04-24 13:03:21 +05:30
nikhilmantri0902	1095caa123	chore: improved api description to document -1 as no data in numeric fields	2026-04-24 12:11:45 +05:30
nikhilmantri0902	9043b49762	chore: removed pods - order by phase	2026-04-24 12:04:51 +05:30
nikhilmantri0902	d4084a7494	chore: added support for pod phase unknown	2026-04-24 11:46:26 +05:30
nikhilmantri0902	27c564b3bf	chore: added required tags	2026-04-24 11:21:20 +05:30
Nikhil Mantri	f02c491828	Merge branch 'main' into infraM/v2_pods_list_api	2026-04-24 10:47:13 +05:30
Nikhil Mantri	3d53b8f77f	Merge branch 'main' into infraM/v2_pods_list_api	2026-04-23 18:44:33 +05:30
nikhilmantri0902	dffe94fec4	chore: conflicts resolved	2026-04-23 18:39:39 +05:30
nikhilmantri0902	b7d4f18aae	chore: added queries for pod phase counts in custom group by	2026-04-23 18:01:26 +05:30
nikhilmantri0902	9ad2ec428a	chore: added phase counts feature	2026-04-23 16:50:39 +05:30
nikhilmantri0902	c9360fcf13	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-23 11:23:49 +05:30
nikhilmantri0902	b5ab45db20	chore: regen api client for inframonitoring Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-23 10:51:35 +05:30
Nikhil Mantri	08f76aca78	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-23 09:51:01 +05:30
nikhilmantri0902	983d4fe4f2	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-22 15:37:21 +05:30
nikhilmantri0902	833af794c3	chore: make sort stable in case of tiebreaker by comparing composite group by keys	2026-04-22 15:26:28 +05:30
nikhilmantri0902	21b51d1fcc	chore: cleanup and rename	2026-04-22 15:13:00 +05:30
nikhilmantri0902	56f22682c8	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-22 14:29:17 +05:30
nikhilmantri0902	9c8359940c	chore: remove a defensive nil map check, the function ensure non-nil map when err nil	2026-04-22 11:59:01 +05:30
Nikhil Mantri	4050880275	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-22 11:35:57 +05:30
nikhilmantri0902	5e775f64f2	chore: added status unauthorized	2026-04-21 21:30:44 +05:30
nikhilmantri0902	0189f23f46	chore: removed internal server error	2026-04-21 21:30:01 +05:30
nikhilmantri0902	49a36d4e3d	chore: removed pod metric temporalities	2026-04-21 21:24:49 +05:30
nikhilmantri0902	9407d658ab	chore: merge base hosts v2 branch	2026-04-21 21:17:28 +05:30
nikhilmantri0902	5035712485	chore: added json tag required: true	2026-04-21 18:50:25 +05:30
nikhilmantri0902	bab17c3615	chore: comments resolve	2026-04-21 18:33:56 +05:30
Nikhil Mantri	37b44f4db9	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-21 17:40:06 +05:30
nikhilmantri0902	99dd6e5f1e	chore: pods code restructuring	2026-04-21 17:03:13 +05:30
nikhilmantri0902	9c7131fa6a	chore: merge base branch	2026-04-21 16:22:55 +05:30
Nikhil Mantri	ad889a2e1d	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-21 13:48:53 +05:30
nikhilmantri0902	a4f6d0cbf5	chore: removed temporalities	2026-04-21 13:44:06 +05:30
nikhilmantri0902	589bed7c16	chore: comments correction	2026-04-21 12:50:51 +05:30
nikhilmantri0902	93843a1f48	chore: file structure further breakdown for clarity	2026-04-21 12:36:07 +05:30
nikhilmantri0902	88c43108fc	chore: added types package	2026-04-20 18:52:43 +05:30
nikhilmantri0902	ed4cf540e8	chore: inframonitoring types renaming	2026-04-20 18:47:28 +05:30
nikhilmantri0902	9e2dfa9033	chore: rearrangement	2026-04-20 17:51:03 +05:30
nikhilmantri0902	d98d5d68ee	chore: rename PodsList -> ListPods	2026-04-20 16:57:21 +05:30
nikhilmantri0902	2cb1c3b73b	chore: rename HostsList -> ListHosts	2026-04-20 16:42:19 +05:30
nikhilmantri0902	ae7ca497ad	chore: merged base hosts branch and reorganized code	2026-04-20 13:38:25 +05:30
Nikhil Mantri	a579916961	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-20 11:05:36 +05:30
Nikhil Mantri	4a16d56abf	feat(infra-monitoring): v2 hosts list - return counts of active & inactive hosts for custom group by attributes (#10956 ) * chore: add functionality for showing active and inactive counts in custom group by * chore: bug fix * chore: added subquery for active and total count * chore: ignore empty string hosts in get active hosts * fix: sinceUnixMilli for determining active hosts compute once per request * chore: refactor code	2026-04-20 10:41:15 +05:30
Nikhil Mantri	642b5ac3f0	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-16 16:32:39 +05:30
Nikhil Mantri	a12112619c	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-16 15:41:35 +05:30
nikhilmantri0902	014785f1bc	chore: ignore empty string hosts in get active hosts	2026-04-16 13:17:15 +05:30
Nikhil Mantri	58ee797b10	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-15 14:18:29 +05:30
Nikhil Mantri	82d236742f	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-15 11:21:33 +05:30
nikhilmantri0902	397e1ad5be	chore: added TODOs and made filterByStatus a part of filter struct	2026-04-14 18:32:48 +05:30
nikhilmantri0902	8d6b25ca9b	chore: resolved conflicts	2026-04-14 17:09:17 +05:30
nikhilmantri0902	5fa6bd8b8d	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-13 11:02:14 +05:30
nikhilmantri0902	bd9977483b	chore: improved description	2026-04-11 11:31:35 +05:30
nikhilmantri0902	50fbdfeeef	chore: validate order by to validate function	2026-04-10 19:01:45 +05:30
nikhilmantri0902	e2b1b73e87	chore: improvements	2026-04-10 13:23:33 +05:30
nikhilmantri0902	cb9f3fd3e5	chore: rearrage	2026-04-10 00:39:23 +05:30
nikhilmantri0902	232acc343d	chore: escape backtick to prevent sql injection	2026-04-10 00:01:01 +05:30
nikhilmantri0902	2025afdccc	chore: endpoint modification openapi	2026-04-09 23:25:59 +05:30
nikhilmantri0902	d2f4d4af93	chore: endpoint correction	2026-04-09 23:21:57 +05:30
Nikhil Mantri	47ff7bbb8e	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-09 23:20:39 +05:30
Nikhil Mantri	724071c5dc	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-09 18:30:15 +05:30
nikhilmantri0902	4d24979358	chore: frontend fix	2026-04-09 18:26:42 +05:30
nikhilmantri0902	042943b10a	chore: distributed samples table to local table change for get metadata	2026-04-09 18:24:45 +05:30
nikhilmantri0902	48a9be7ec8	chore: added required metrics check	2026-04-09 17:38:48 +05:30
nikhilmantri0902	a9504b2120	chore: added a TODO remark	2026-04-09 16:08:34 +05:30
nikhilmantri0902	8755887c4a	chore: added better metrics existence check	2026-04-09 16:01:35 +05:30
Nikhil Mantri	4cb4662b3a	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-09 15:14:25 +05:30
nikhilmantri0902	e6900dabc8	chore: warnings added passing from queryResponse warning to host lists response struct	2026-04-09 00:09:38 +05:30
nikhilmantri0902	c1ba389b63	chore: add type for response and files rearrange	2026-04-08 23:35:53 +05:30
nikhilmantri0902	3a1f40234f	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-08 23:03:50 +05:30
Nikhil Mantri	2e4891fa63	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-08 16:07:57 +05:30
Nikhil Mantri	04ebc0bec7	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-08 11:08:10 +05:30
nikhilmantri0902	271f9b81ed	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-07 21:55:47 +05:30
nikhilmantri0902	6fa815c294	chore: modified getMetadata query	2026-04-07 18:55:57 +05:30
nikhilmantri0902	63ec518efb	chore: added hostName logic	2026-04-07 17:36:15 +05:30
nikhilmantri0902	c4ca20dd90	chore: return errors from getMetadata and lint fix	2026-04-07 17:01:13 +05:30
nikhilmantri0902	e56cc4222b	chore: return errors from getMetadata and lint fix	2026-04-07 16:57:35 +05:30
nikhilmantri0902	07d2944d7c	chore: yarn generate api	2026-04-07 16:44:06 +05:30
nikhilmantri0902	dea01ae36a	chore: hostStatusNone added for clarity that this field can be left empty as well in payload	2026-04-07 16:32:25 +05:30
nikhilmantri0902	62ea5b54e2	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-07 14:09:48 +05:30
nikhilmantri0902	e549a7e42f	chore: added pods list api updates	2026-04-07 13:58:10 +05:30
nikhilmantri0902	90e2ebb11f	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-07 13:51:35 +05:30
nikhilmantri0902	61baa1be7a	chore: code improvements	2026-04-07 13:49:00 +05:30
nikhilmantri0902	b946fa665f	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-07 11:15:35 +05:30
nikhilmantri0902	2e049556e4	chore: unified composite key function	2026-04-07 11:15:03 +05:30
nikhilmantri0902	492a5e70d7	chore: added pods metrics temporality	2026-04-06 17:33:44 +05:30
nikhilmantri0902	ba1f2771e8	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-06 17:18:44 +05:30
nikhilmantri0902	7458fb4855	Merge branch 'main' into infraM/v2_hosts_list_api	2026-04-06 17:18:01 +05:30
nikhilmantri0902	5f55f3938b	chore: added temporalities of metrics	2026-04-06 17:17:15 +05:30
nikhilmantri0902	3e8102485c	Merge branch 'infraM/v2_hosts_list_api' into infraM/v2_pods_list_api	2026-04-04 20:52:50 +05:30
nikhilmantri0902	861c682ea5	chore: nil pointer dereference fix in req.Filter	2026-04-04 20:52:08 +05:30
nikhilmantri0902	c8e5895dff	chore: nil pointer check	2026-04-04 20:45:04 +05:30
nikhilmantri0902	82d72e7edb	chore: pods api meta start time	2026-04-04 17:18:04 +05:30
nikhilmantri0902	a3f8ecaaf1	chore: merged base branch	2026-04-04 16:47:10 +05:30
nikhilmantri0902	19aada656c	chore: updated spec	2026-04-04 16:44:15 +05:30
nikhilmantri0902	b21bb4280f	chore: updated openapi yml	2026-04-04 16:38:22 +05:30
nikhilmantri0902	bc0a4fdb5c	chore: added pods list logic	2026-04-04 13:24:46 +05:30
nikhilmantri0902	37fb0e9254	Merge branch 'infraM/base_dependencies' into infraM/v2_hosts_list_api	2026-04-03 17:49:00 +05:30
nikhilmantri0902	aecfa1a174	chore: added validation on order by	2026-04-02 20:13:30 +05:30
nikhilmantri0902	b869d23d94	chore: moved funcs	2026-04-02 20:02:22 +05:30
nikhilmantri0902	6ee3d44f76	chore: removed isSendingK8sAgentsMetricsCode	2026-04-02 19:58:30 +05:30
nikhilmantri0902	462e554107	chore: yarn generate api	2026-04-02 14:49:15 +05:30
nikhilmantri0902	66afa73e6f	chore: return status as a string	2026-04-02 14:39:02 +05:30
nikhilmantri0902	54c604bcf4	chore: added some unit tests	2026-04-02 14:20:27 +05:30
nikhilmantri0902	c1be02ba54	chore: added validate function	2026-04-02 14:14:34 +05:30
nikhilmantri0902	d3c7ba8f45	chore: disk usage	2026-04-02 14:01:18 +05:30
nikhilmantri0902	039c4a0496	fix: bug fix	2026-04-02 11:32:49 +05:30
nikhilmantri0902	51a94b6bbc	chore: added logic for hosts v3 api	2026-04-02 02:52:28 +05:30
nikhilmantri0902	bbfbb94f52	chore: merged main	2026-04-01 00:45:40 +05:30
nikhilmantri0902	d1eb9ef16f	chore: endpoint detail update	2026-03-31 16:16:31 +05:30
nikhilmantri0902	3db00f8bc3	chore: baseline setup	2026-03-31 15:27:18 +05:30