fix: fixed drilldown menu ui

docs/api/openapi.yml

@@ -4489,184 +4489,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 +9231,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

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

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

@@ -5470,187 +5470,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 +6920,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

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

frontend/src/container/DashboardContainer/visualization/hooks/usePanelContextMenu.ts

@@ -104,7 +104,12 @@ export const usePanelContextMenu = ({
 			}
 
 			if (data && data?.record?.queryName) {
-				onClick(data.coord, { ...data.record, label: data.label, timeRange });
+				onClick(data.coord, {
+					...data.record,
+					label: data.label,
+					seriesColor: data.seriesColor,
+					timeRange,
+				});
 			}
 		},
 		[onClick, queryResponse],

frontend/src/container/QueryTable/Drilldown/__tests__/useBaseDrilldownNavigate.test.ts

@@ -0,0 +1,282 @@
+import { renderHook } from '@testing-library/react';
+import ROUTES from 'constants/routes';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import { getViewQuery } from '../drilldownUtils';
+import { AggregateData } from '../useAggregateDrilldown';
+import useBaseDrilldownNavigate, {
+	buildDrilldownUrl,
+	getRoute,
+} from '../useBaseDrilldownNavigate';
+
+const mockSafeNavigate = jest.fn();
+
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: typeof mockSafeNavigate } => ({ safeNavigate: mockSafeNavigate }),
+}));
+
+jest.mock('../drilldownUtils', () => ({
+	...jest.requireActual('../drilldownUtils'),
+	getViewQuery: jest.fn(),
+}));
+
+const mockGetViewQuery = getViewQuery as jest.Mock;
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const MOCK_QUERY: Query = {
+	id: 'q1',
+	queryType: 'builder' as any,
+	builder: {
+		queryData: [
+			{
+				queryName: 'A',
+				dataSource: 'metrics' as any,
+				groupBy: [],
+				expression: '',
+				disabled: false,
+				functions: [],
+				legend: '',
+				having: [],
+				limit: null,
+				stepInterval: undefined,
+				orderBy: [],
+			},
+		],
+		queryFormulas: [],
+		queryTraceOperator: [],
+	},
+	promql: [],
+	clickhouse_sql: [],
+};
+
+const MOCK_VIEW_QUERY: Query = {
+	...MOCK_QUERY,
+	builder: {
+		...MOCK_QUERY.builder,
+		queryData: [
+			{
+				...MOCK_QUERY.builder.queryData[0],
+				filters: { items: [], op: 'AND' },
+			},
+		],
+	},
+};
+
+const MOCK_AGGREGATE_DATA: AggregateData = {
+	queryName: 'A',
+	filters: [{ filterKey: 'service_name', filterValue: 'auth', operator: '=' }],
+	timeRange: { startTime: 1000000, endTime: 2000000 },
+};
+
+// ─── getRoute ─────────────────────────────────────────────────────────────────
+
+describe('getRoute', () => {
+	it.each([
+		['view_logs', ROUTES.LOGS_EXPLORER],
+		['view_metrics', ROUTES.METRICS_EXPLORER],
+		['view_traces', ROUTES.TRACES_EXPLORER],
+	])('maps %s to the correct explorer route', (key, expected) => {
+		expect(getRoute(key)).toBe(expected);
+	});
+
+	it('returns empty string for an unknown key', () => {
+		expect(getRoute('view_dashboard')).toBe('');
+	});
+});
+
+// ─── buildDrilldownUrl ────────────────────────────────────────────────────────
+
+describe('buildDrilldownUrl', () => {
+	beforeEach(() => {
+		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('returns null for an unknown drilldown key', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_dashboard');
+		expect(url).toBeNull();
+	});
+
+	it('returns null when getViewQuery returns null', () => {
+		mockGetViewQuery.mockReturnValue(null);
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toBeNull();
+	});
+
+	it('returns a URL starting with the logs explorer route for view_logs', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).not.toBeNull();
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+	});
+
+	it('returns a URL starting with the traces explorer route for view_traces', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_traces');
+		expect(url).toContain(ROUTES.TRACES_EXPLORER);
+	});
+
+	it('includes compositeQuery param in the URL', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toContain('compositeQuery=');
+	});
+
+	it('includes startTime and endTime when aggregateData has a timeRange', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toContain('startTime=1000000');
+		expect(url).toContain('endTime=2000000');
+	});
+
+	it('omits startTime and endTime when aggregateData has no timeRange', () => {
+		const { timeRange: _, ...withoutTimeRange } = MOCK_AGGREGATE_DATA;
+		const url = buildDrilldownUrl(MOCK_QUERY, withoutTimeRange, 'view_logs');
+		expect(url).not.toContain('startTime=');
+		expect(url).not.toContain('endTime=');
+	});
+
+	it('includes summaryFilters param for view_metrics', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_metrics');
+		expect(url).toContain(ROUTES.METRICS_EXPLORER);
+		expect(url).toContain('summaryFilters=');
+	});
+
+	it('does not include summaryFilters param for non-metrics routes', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).not.toContain('summaryFilters=');
+	});
+
+	it('handles null aggregateData by passing empty filters and empty queryName', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, null, 'view_logs');
+		expect(url).not.toBeNull();
+		expect(mockGetViewQuery).toHaveBeenCalledWith(MOCK_QUERY, [], 'view_logs', '');
+	});
+
+	it('passes aggregateData filters and queryName to getViewQuery', () => {
+		buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(mockGetViewQuery).toHaveBeenCalledWith(
+			MOCK_QUERY,
+			MOCK_AGGREGATE_DATA.filters,
+			'view_logs',
+			MOCK_AGGREGATE_DATA.queryName,
+		);
+	});
+});
+
+// ─── useBaseDrilldownNavigate ─────────────────────────────────────────────────
+
+describe('useBaseDrilldownNavigate', () => {
+	beforeEach(() => {
+		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('calls safeNavigate with the built URL on a valid key', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
+		const [url] = mockSafeNavigate.mock.calls[0];
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+		expect(url).toContain('compositeQuery=');
+	});
+
+	it('opens the explorer in a new tab', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_traces');
+
+		expect(mockSafeNavigate).toHaveBeenCalledWith(
+			expect.any(String),
+			{ newTab: true },
+		);
+	});
+
+	it('calls callback after successful navigation', () => {
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
+	it('does not call safeNavigate for an unknown key', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_dashboard');
+
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('still calls callback when the key is unknown', () => {
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_dashboard');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('still calls callback when getViewQuery returns null', () => {
+		mockGetViewQuery.mockReturnValue(null);
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('handles null aggregateData without throwing', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: null,
+			}),
+		);
+
+		expect(() => result.current('view_logs')).not.toThrow();
+		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
+	});
+});

frontend/src/container/QueryTable/Drilldown/drilldownUtils.tsx

@@ -166,7 +166,7 @@ export const getAggregateColumnHeader = (
 	};
 };
 
-const getFiltersFromMetric = (metric: any): FilterData[] =>
+export const getFiltersFromMetric = (metric: any): FilterData[] =>
 	Object.keys(metric).map((key) => ({
 		filterKey: key,
 		filterValue: metric[key],
@@ -196,6 +196,7 @@ export const getUplotClickData = ({
 	coord: { x: number; y: number };
 	record: { queryName: string; filters: FilterData[] };
 	label: string | React.ReactNode;
+	seriesColor?: string;
 } | null => {
 	if (!queryData?.queryName || !metric) {
 		return null;
@@ -208,6 +209,7 @@ export const getUplotClickData = ({
 
 	// Generate label from focusedSeries data
 	let label: string | React.ReactNode = '';
+	const seriesColor = focusedSeries?.color;
 	if (focusedSeries && focusedSeries.seriesName) {
 		label = (
 			<span style={{ color: focusedSeries.color }}>
@@ -223,6 +225,7 @@ export const getUplotClickData = ({
 		},
 		record,
 		label,
+		seriesColor,
 	};
 };
 
@@ -237,6 +240,7 @@ export const getPieChartClickData = (
 	queryName: string;
 	filters: FilterData[];
 	label: string | React.ReactNode;
+	seriesColor?: string;
 } | null => {
 	const { metric, queryName } = arc.data.record;
 	if (!queryName || !metric) {
@@ -248,6 +252,7 @@ export const getPieChartClickData = (
 		queryName,
 		filters: getFiltersFromMetric(metric), // TODO: add where clause query as well.
 		label,
+		seriesColor: arc.data.color,
 	};
 };
 

frontend/src/container/QueryTable/Drilldown/useAggregateDrilldown.tsx

@@ -22,6 +22,7 @@ export interface AggregateData {
 		endTime: number;
 	};
 	label?: string | React.ReactNode;
+	seriesColor?: string;
 }
 
 const useAggregateDrilldown = ({

frontend/src/container/QueryTable/Drilldown/useBaseAggregateOptions.tsx

@@ -2,14 +2,10 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { LinkOutlined, LoadingOutlined } from '@ant-design/icons';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
-import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { processContextLinks } from 'container/NewWidget/RightContainer/ContextLinks/utils';
 import useContextVariables from 'hooks/dashboard/useContextVariables';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import createQueryParams from 'lib/createQueryParams';
 import ContextMenu from 'periscope/components/ContextMenu';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
@@ -18,9 +14,10 @@ import { openInNewTab } from 'utils/navigation';
 
 import { ContextMenuItem } from './contextConfig';
 import { getDataLinks } from './dataLinksUtils';
-import { getAggregateColumnHeader, getViewQuery } from './drilldownUtils';
+import { getAggregateColumnHeader } from './drilldownUtils';
 import { getBaseContextConfig } from './menuOptions';
 import { AggregateData } from './useAggregateDrilldown';
+import useBaseDrilldownNavigate from './useBaseDrilldownNavigate';
 
 interface UseBaseAggregateOptionsProps {
 	query: Query;
@@ -38,19 +35,6 @@ interface BaseAggregateOptionsConfig {
 	items?: ContextMenuItem;
 }
 
-const getRoute = (key: string): string => {
-	switch (key) {
-		case 'view_logs':
-			return ROUTES.LOGS_EXPLORER;
-		case 'view_metrics':
-			return ROUTES.METRICS_EXPLORER;
-		case 'view_traces':
-			return ROUTES.TRACES_EXPLORER;
-		default:
-			return '';
-	}
-};
-
 const useBaseAggregateOptions = ({
 	query,
 	onClose,
@@ -63,10 +47,8 @@ const useBaseAggregateOptions = ({
 	baseAggregateOptionsConfig: BaseAggregateOptionsConfig;
 } => {
 	const [resolvedQuery, setResolvedQuery] = useState<Query>(query);
-	const {
-		getUpdatedQuery,
-		isLoading: isResolveQueryLoading,
-	} = useUpdatedQuery();
+	const { getUpdatedQuery, isLoading: isResolveQueryLoading } =
+		useUpdatedQuery();
 	const { dashboardData } = useDashboardStore();
 
 	useEffect(() => {
@@ -88,8 +70,6 @@ const useBaseAggregateOptions = ({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [query, aggregateData, panelType]);
 
-	const { safeNavigate } = useSafeNavigate();
-
 	// Use the new useContextVariables hook
 	const { processedVariables } = useContextVariables({
 		maxValues: 2,
@@ -123,50 +103,16 @@ const useBaseAggregateOptions = ({
 					{label}
 				</ContextMenu.Item>
 			));
-		} catch (error) {
+		} catch {
 			return [];
 		}
 	}, [contextLinks, processedVariables, onClose, aggregateData, query]);
 
-	const handleBaseDrilldown = useCallback(
-		(key: string): void => {
-			const route = getRoute(key);
-			const timeRange = aggregateData?.timeRange;
-			const filtersToAdd = aggregateData?.filters || [];
-			const viewQuery = getViewQuery(
-				resolvedQuery,
-				filtersToAdd,
-				key,
-				aggregateData?.queryName || '',
-			);
-
-			let queryParams = {
-				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-				...(timeRange && {
-					[QueryParams.startTime]: timeRange?.startTime.toString(),
-					[QueryParams.endTime]: timeRange?.endTime.toString(),
-				}),
-			} as Record<string, string>;
-
-			if (route === ROUTES.METRICS_EXPLORER) {
-				queryParams = {
-					...queryParams,
-					[QueryParams.summaryFilters]: JSON.stringify(
-						viewQuery?.builder.queryData[0].filters,
-					),
-				};
-			}
-
-			if (route) {
-				safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
-					newTab: true,
-				});
-			}
-
-			onClose();
-		},
-		[resolvedQuery, safeNavigate, onClose, aggregateData],
-	);
+	const handleBaseDrilldown = useBaseDrilldownNavigate({
+		resolvedQuery,
+		aggregateData,
+		callback: onClose,
+	});
 
 	const { pathname } = useLocation();
 
@@ -230,7 +176,15 @@ const useBaseAggregateOptions = ({
 									return (
 										<ContextMenu.Item
 											key={key}
-											icon={isLoading ? <LoadingOutlined spin /> : icon}
+											icon={
+												isLoading ? (
+													<LoadingOutlined spin />
+												) : (
+													<span style={{ color: aggregateData?.seriesColor }}>
+														{icon}
+													</span>
+												)
+											}
 											onClick={(): void => onClick()}
 											disabled={isLoading}
 										>

frontend/src/container/QueryTable/Drilldown/useBaseDrilldownNavigate.ts

@@ -0,0 +1,117 @@
+import { useCallback } from 'react';
+import { QueryParams } from 'constants/query';
+import ROUTES from 'constants/routes';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import createQueryParams from 'lib/createQueryParams';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import { getViewQuery } from './drilldownUtils';
+import { AggregateData } from './useAggregateDrilldown';
+
+type DrilldownKey = 'view_logs' | 'view_metrics' | 'view_traces';
+
+const DRILLDOWN_ROUTE_MAP: Record<DrilldownKey, string> = {
+	view_logs: ROUTES.LOGS_EXPLORER,
+	view_metrics: ROUTES.METRICS_EXPLORER,
+	view_traces: ROUTES.TRACES_EXPLORER,
+};
+
+const getRoute = (key: string): string =>
+	DRILLDOWN_ROUTE_MAP[key as DrilldownKey] ?? '';
+
+interface UseBaseDrilldownNavigateProps {
+	resolvedQuery: Query;
+	aggregateData: AggregateData | null;
+	callback?: () => void;
+}
+
+const useBaseDrilldownNavigate = ({
+	resolvedQuery,
+	aggregateData,
+	callback,
+}: UseBaseDrilldownNavigateProps): ((key: string) => void) => {
+	const { safeNavigate } = useSafeNavigate();
+
+	return useCallback(
+		(key: string): void => {
+			const route = getRoute(key);
+			const viewQuery = getViewQuery(
+				resolvedQuery,
+				aggregateData?.filters ?? [],
+				key,
+				aggregateData?.queryName ?? '',
+			);
+
+			if (!viewQuery || !route) {
+				callback?.();
+				return;
+			}
+
+			const timeRange = aggregateData?.timeRange;
+			let queryParams: Record<string, string> = {
+				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+				...(timeRange && {
+					[QueryParams.startTime]: timeRange.startTime.toString(),
+					[QueryParams.endTime]: timeRange.endTime.toString(),
+				}),
+			};
+
+			if (route === ROUTES.METRICS_EXPLORER) {
+				queryParams = {
+					...queryParams,
+					[QueryParams.summaryFilters]: JSON.stringify(
+						viewQuery.builder.queryData[0].filters,
+					),
+				};
+			}
+
+			safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
+				newTab: true,
+			});
+
+			callback?.();
+		},
+		[resolvedQuery, safeNavigate, callback, aggregateData],
+	);
+};
+
+export function buildDrilldownUrl(
+	resolvedQuery: Query,
+	aggregateData: AggregateData | null,
+	key: string,
+): string | null {
+	const route = getRoute(key);
+	const viewQuery = getViewQuery(
+		resolvedQuery,
+		aggregateData?.filters ?? [],
+		key,
+		aggregateData?.queryName ?? '',
+	);
+
+	if (!viewQuery || !route) {
+		return null;
+	}
+
+	const timeRange = aggregateData?.timeRange;
+	let queryParams: Record<string, string> = {
+		[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+		...(timeRange && {
+			[QueryParams.startTime]: timeRange.startTime.toString(),
+			[QueryParams.endTime]: timeRange.endTime.toString(),
+		}),
+	};
+
+	if (route === ROUTES.METRICS_EXPLORER) {
+		queryParams = {
+			...queryParams,
+			[QueryParams.summaryFilters]: JSON.stringify(
+				viewQuery.builder.queryData[0].filters,
+			),
+		};
+	}
+
+	return `${route}?${createQueryParams(queryParams)}`;
+}
+
+export { getRoute };
+export default useBaseDrilldownNavigate;

frontend/src/periscope/components/ContextMenu/styles.scss

@@ -4,7 +4,7 @@
 	gap: 8px;
 	padding: 8px;
 	cursor: pointer;
-	color: var(--foreground);
+	color: var(--muted-foreground);
 	font-family: Inter;
 	font-size: var(--font-size-sm);
 	font-weight: 600;
@@ -20,13 +20,10 @@
 	overflow: hidden;
 	text-overflow: ellipsis;
 
-	&:hover {
-		background-color: var(--l1-background);
-	}
-
+	&:hover,
 	&:focus {
 		outline: none;
-		background-color: var(--l1-background);
+		background-color: var(--l2-background-hover);
 	}
 
 	&.disabled {
@@ -47,7 +44,8 @@
 		}
 
 		&:hover {
-			background-color: var(--bg-cherry-100);
+			background-color: var(--danger-background);
+			color: var(--l1-foreground);
 		}
 	}
 
@@ -74,73 +72,24 @@
 }
 
 .context-menu-header {
-	padding-bottom: 4px;
-	border-bottom: 1px solid var(--l1-border);
+	padding: 8px 12px;
+	border-bottom: 1px solid var(--l2-border);
 	color: var(--muted-foreground);
 }
 
-// Target the popover inner specifically for context menu
 .context-menu .ant-popover-inner {
-	padding: 12px 8px !important;
-	// max-height: 254px !important;
-	max-width: 300px !important;
+	padding: 0;
+	border-radius: 6px;
+	max-width: 300px;
+	background: var(--l2-background) !important;
+	border: 1px solid var(--l2-border) !important;
 }
 
-// Dark mode support
-.darkMode {
-	.context-menu-item {
-		color: var(--muted-foreground);
-
-		&:hover,
-		&:focus {
-			background-color: var(--l2-background);
-		}
-
-		&.danger {
-			color: var(--bg-cherry-400);
-
-			.icon {
-				color: var(--bg-cherry-400);
-			}
-
-			&:hover {
-				background-color: var(--danger-background);
-				color: var(--l1-foreground);
-			}
-		}
-
-		.icon {
-			color: var(--bg-robin-400);
-		}
-	}
-
-	.context-menu-header {
-		border-bottom: 1px solid var(--l1-border);
-		color: var(--muted-foreground);
-	}
-
-	// Set the menu popover background
-	.context-menu .ant-popover-inner {
-		background: var(--l1-background) !important;
-		border: 1px solid var(--border) !important;
-	}
-}
-
-// Context menu backdrop overlay
 .context-menu-backdrop {
 	position: fixed;
-	top: 0;
-	left: 0;
-	width: 100vw;
-	height: 100vh;
+	inset: 0;
 	z-index: 9999;
 	background: transparent;
 	cursor: default;
-
-	// Prevent any pointer events from reaching elements behind
 	pointer-events: auto;
-
-	// Ensure it covers the entire viewport including any scrollable areas
-	position: fixed !important;
-	inset: 0;
 }

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
 	}

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

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

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

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

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

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

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

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

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

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

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

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,

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

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

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

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

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

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