chore: address lint

docs/api/openapi.yml

@@ -7240,41 +7240,6 @@ components:
       - operation
       - priority
       type: object
-    SpantypesSpanMappingPreviewGroup:
-      properties:
-        group:
-          $ref: '#/components/schemas/SpantypesPostableSpanMapperGroup'
-        mappers:
-          items:
-            $ref: '#/components/schemas/SpantypesPostableSpanMapper'
-          nullable: true
-          type: array
-      required:
-      - group
-      - mappers
-      type: object
-    SpantypesSpanMappingPreviewRequest:
-      properties:
-        groupId:
-          nullable: true
-          type: string
-        groups:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanMappingPreviewGroup'
-          nullable: true
-          type: array
-        span:
-          additionalProperties: {}
-          nullable: true
-          type: object
-      type: object
-    SpantypesSpanMappingPreviewResponse:
-      properties:
-        span:
-          additionalProperties: {}
-          nullable: true
-          type: object
-      type: object
     SpantypesUpdatableSpanMapper:
       properties:
         config:
@@ -12832,69 +12797,6 @@ paths:
       summary: Update a span mapper
       tags:
       - spanmapper
-  /api/v1/span_mapper_groups/preview:
-    post:
-      deprecated: false
-      description: Previews how attribute mappings would transform a sample span.
-      operationId: PreviewSpanMapping
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesSpanMappingPreviewRequest'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesSpanMappingPreviewResponse'
-                  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: Preview span attribute mapping against a sample span
-      tags:
-      - spanmapper
   /api/v1/stats:
     get:
       deprecated: false

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

@@ -8492,56 +8492,6 @@ export interface SpantypesSpanMapperDTO {
 	updatedBy?: string;
 }
 
-export interface SpantypesSpanMappingPreviewGroupDTO {
-	group: SpantypesPostableSpanMapperGroupDTO;
-	/**
-	 * @type array,null
-	 */
-	mappers: SpantypesPostableSpanMapperDTO[] | null;
-}
-
-export type SpantypesSpanMappingPreviewRequestDTOSpanAnyOf = {
-	[key: string]: unknown;
-};
-
-/**
- * @nullable
- */
-export type SpantypesSpanMappingPreviewRequestDTOSpan =
-	SpantypesSpanMappingPreviewRequestDTOSpanAnyOf | null;
-
-export interface SpantypesSpanMappingPreviewRequestDTO {
-	/**
-	 * @type string,null
-	 */
-	groupId?: string | null;
-	/**
-	 * @type array,null
-	 */
-	groups?: SpantypesSpanMappingPreviewGroupDTO[] | null;
-	/**
-	 * @type object,null
-	 */
-	span?: SpantypesSpanMappingPreviewRequestDTOSpan;
-}
-
-export type SpantypesSpanMappingPreviewResponseDTOSpanAnyOf = {
-	[key: string]: unknown;
-};
-
-/**
- * @nullable
- */
-export type SpantypesSpanMappingPreviewResponseDTOSpan =
-	SpantypesSpanMappingPreviewResponseDTOSpanAnyOf | null;
-
-export interface SpantypesSpanMappingPreviewResponseDTO {
-	/**
-	 * @type object,null
-	 */
-	span?: SpantypesSpanMappingPreviewResponseDTOSpan;
-}
-
 export interface SpantypesUpdatableSpanMapperDTO {
 	config?: SpantypesSpanMapperConfigDTO;
 	/**
@@ -9848,14 +9798,6 @@ export type UpdateSpanMapperPathParameters = {
 	groupId: string;
 	mapperId: string;
 };
-export type PreviewSpanMapping200 = {
-	data: SpantypesSpanMappingPreviewResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetStats200Data = { [key: string]: unknown };
 
 export type GetStats200 = {

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

@@ -27,11 +27,9 @@ import type {
 	ListSpanMapperGroupsParams,
 	ListSpanMappers200,
 	ListSpanMappersPathParameters,
-	PreviewSpanMapping200,
 	RenderErrorResponseDTO,
 	SpantypesPostableSpanMapperDTO,
 	SpantypesPostableSpanMapperGroupDTO,
-	SpantypesSpanMappingPreviewRequestDTO,
 	SpantypesUpdatableSpanMapperDTO,
 	SpantypesUpdatableSpanMapperGroupDTO,
 	UpdateSpanMapperGroupPathParameters,
@@ -782,86 +780,3 @@ export const useUpdateSpanMapper = <
 > => {
 	return useMutation(getUpdateSpanMapperMutationOptions(options));
 };
-/**
- * Previews how attribute mappings would transform a sample span.
- * @summary Preview span attribute mapping against a sample span
- */
-export const previewSpanMapping = (
-	spantypesSpanMappingPreviewRequestDTO?: BodyType<SpantypesSpanMappingPreviewRequestDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PreviewSpanMapping200>({
-		url: `/api/v1/span_mapper_groups/preview`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesSpanMappingPreviewRequestDTO,
-		signal,
-	});
-};
-
-export const getPreviewSpanMappingMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof previewSpanMapping>>,
-		TError,
-		{ data?: BodyType<SpantypesSpanMappingPreviewRequestDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof previewSpanMapping>>,
-	TError,
-	{ data?: BodyType<SpantypesSpanMappingPreviewRequestDTO> },
-	TContext
-> => {
-	const mutationKey = ['previewSpanMapping'];
-	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 previewSpanMapping>>,
-		{ data?: BodyType<SpantypesSpanMappingPreviewRequestDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return previewSpanMapping(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PreviewSpanMappingMutationResult = NonNullable<
-	Awaited<ReturnType<typeof previewSpanMapping>>
->;
-export type PreviewSpanMappingMutationBody =
-	| BodyType<SpantypesSpanMappingPreviewRequestDTO>
-	| undefined;
-export type PreviewSpanMappingMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Preview span attribute mapping against a sample span
- */
-export const usePreviewSpanMapping = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof previewSpanMapping>>,
-		TError,
-		{ data?: BodyType<SpantypesSpanMappingPreviewRequestDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof previewSpanMapping>>,
-	TError,
-	{ data?: BodyType<SpantypesSpanMappingPreviewRequestDTO> },
-	TContext
-> => {
-	return useMutation(getPreviewSpanMappingMutationOptions(options));
-};

frontend/src/container/MetricsApplication/Tabs/Overview/ServiceOverview.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from 'react';
 import { useParams } from 'react-router-dom';
+import { Skeleton } from 'antd';
 import { ENTITY_VERSION_V4 } from 'constants/app';
 import { FeatureKeys } from 'constants/features';
 import { PANEL_TYPES } from 'constants/queryBuilder';
@@ -123,14 +124,24 @@ function ServiceOverview({
 			/>
 			<Card data-testid="service_latency">
 				<GraphContainer>
-					<Graph
-						onDragSelect={onDragSelect}
-						widget={latencyWidget}
-						onClickHandler={handleGraphClick('Service')}
-						isQueryEnabled={isQueryEnabled}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							onDragSelect={onDragSelect}
+							widget={latencyWidget}
+							onClickHandler={handleGraphClick('Service')}
+							isQueryEnabled={isQueryEnabled}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			</Card>
 		</>

frontend/src/container/MetricsApplication/Tabs/Overview/TopLevelOperations.tsx

@@ -1,3 +1,4 @@
+import { Skeleton } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import axios from 'axios';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
@@ -28,14 +29,24 @@ function TopLevelOperation({
 				</Typography>
 			) : (
 				<GraphContainer>
-					<Graph
-						widget={widget}
-						onClickHandler={handleGraphClick(opName)}
-						onDragSelect={onDragSelect}
-						isQueryEnabled={!topLevelOperationsIsLoading}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							widget={widget}
+							onClickHandler={handleGraphClick(opName)}
+							onDragSelect={onDragSelect}
+							isQueryEnabled={!topLevelOperationsIsLoading}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			)}
 		</Card>

pkg/apiserver/signozapiserver/spanmapper.go

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

pkg/modules/cloudintegration/config.go

@@ -22,7 +22,7 @@ func newConfig() factory.Config {
 		Agent: AgentConfig{
 			// we will maintain the latest version of cloud integration agent from here,
 			// till we automate it externally or figure out a way to validate it.
-			Version: "v0.0.13",
+			Version: "v0.0.12",
 		},
 	}
 }

pkg/modules/spanmapper/implspanmapper/handler.go

@@ -273,35 +273,6 @@ func (h *handler) DeleteMapper(rw http.ResponseWriter, r *http.Request) {
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-// PreviewMapping handles POST /api/v1/span_mapper_groups/preview.
-// used to get preview of attributes/resources after remapping.
-func (h *handler) PreviewMapping(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.SpanMappingPreviewRequest)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.PreviewMapping(ctx, orgID, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}
-
 // groupIDFromPath extracts and validates the {id} or {groupId} path variable.
 func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
 	vars := mux.Vars(r)

pkg/modules/spanmapper/implspanmapper/module.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/spanmapper"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/types/opamptypes"
@@ -103,97 +102,6 @@ func (module *module) DeleteMapper(ctx context.Context, orgID, groupID, id value
 	return nil
 }
 
-// PreviewMapping resolves the mappings to preview (from the request body, a
-// saved group, or all enabled saved mappings) and returns the input span with
-// its "attributes" and "resource" maps transformed.
-func (module *module) PreviewMapping(ctx context.Context, orgID valuer.UUID, req *spantypes.SpanMappingPreviewRequest) (*spantypes.SpanMappingPreviewResponse, error) {
-	groups, err := module.resolvePreviewGroups(ctx, orgID, req)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(req.Span) == 0 {
-		return nil, errors.New(errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "'span' must be provided")
-	}
-
-	outResource, outSpan := spantypes.SimulateMappingForAttributes(groups, spanAttrMap(req.Span["resource"]), spanAttrMap(req.Span["attributes"]))
-
-	result := make(map[string]any, len(req.Span))
-	for k, v := range req.Span {
-		result[k] = v
-	}
-	setAttrMap(result, "attributes", req.Span, outSpan)
-	setAttrMap(result, "resource", req.Span, outResource)
-
-	return &spantypes.SpanMappingPreviewResponse{Span: result}, nil
-}
-
-func spanAttrMap(v any) map[string]any {
-	if m, ok := v.(map[string]any); ok {
-		return m
-	}
-	return nil
-}
-
-func setAttrMap(dst map[string]any, key string, in map[string]any, transformed map[string]any) {
-	if _, present := in[key]; present || len(transformed) > 0 {
-		dst[key] = transformed
-	}
-}
-
-// resolvePreviewGroups picks the mappings to preview against: the groups in the
-// request body, else a specific saved group (GroupID), else all of the org's
-// enabled saved mappings.
-func (module *module) resolvePreviewGroups(ctx context.Context, orgID valuer.UUID, req *spantypes.SpanMappingPreviewRequest) ([]*spantypes.SpanMapperGroupWithMappers, error) {
-	hasGroups := len(req.Groups) > 0
-	hasGroupID := req.GroupID != nil && *req.GroupID != ""
-
-	if hasGroups && hasGroupID {
-		return nil, errors.New(errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "provide either 'groups' or 'groupId', not both")
-	}
-
-	if hasGroups {
-		groups := make([]*spantypes.SpanMapperGroupWithMappers, 0, len(req.Groups))
-		for _, spec := range req.Groups {
-			group := &spantypes.SpanMapperGroup{
-				OrgID:     orgID,
-				Name:      spec.Group.Name,
-				Condition: spec.Group.Condition,
-				Enabled:   spec.Group.Enabled,
-			}
-			mappers := make([]*spantypes.SpanMapper, 0, len(spec.Mappers))
-			for _, pm := range spec.Mappers {
-				mappers = append(mappers, &spantypes.SpanMapper{
-					Name:         pm.Name,
-					FieldContext: pm.FieldContext,
-					Config:       pm.Config,
-					Enabled:      pm.Enabled,
-				})
-			}
-			groups = append(groups, &spantypes.SpanMapperGroupWithMappers{Group: group, Mappers: mappers})
-		}
-		return groups, nil
-	}
-
-	if hasGroupID {
-		id, err := valuer.NewUUID(*req.GroupID)
-		if err != nil {
-			return nil, errors.Wrapf(err, errors.TypeInvalidInput, spantypes.ErrCodeMappingInvalidInput, "group id is not a valid uuid")
-		}
-		group, err := module.store.GetGroup(ctx, orgID, id)
-		if err != nil {
-			return nil, err
-		}
-		mappers, err := module.store.ListMappers(ctx, orgID, id)
-		if err != nil {
-			return nil, err
-		}
-		return []*spantypes.SpanMapperGroupWithMappers{{Group: group, Mappers: mappers}}, nil
-	}
-
-	return module.listEnabledGroupsWithMappers(ctx, orgID)
-}
-
 func (module *module) AgentFeatureType() agentConf.AgentFeatureType {
 	return spantypes.SpanAttrMappingFeatureType
 }

pkg/modules/spanmapper/spanmapper.go

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

pkg/types/ruletypes/api_params.go

@@ -338,6 +338,7 @@ func isValidLabelValue(v string) bool {
 // validate runs during UnmarshalJSON (read + write path).
 // Preserves the original pre-existing checks only so that stored rules
 // continue to load without errors.
+// TODO(srikanthccv): remove this once v1 is deprecated and removed.
 func (r *PostableRule) validate() error {
 	var errs []error
 
@@ -366,9 +367,13 @@ func (r *PostableRule) validate() error {
 
 	errs = append(errs, testTemplateParsing(r)...)
 
-	joined := errors.Join(errs...)
-	if joined != nil {
-		return errors.WrapInvalidInputf(joined, errors.CodeInvalidInput, "validation failed")
+	if len(errs) > 0 {
+		messages := make([]string, len(errs))
+		for i, e := range errs {
+			messages[i] = e.Error()
+		}
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "alert rule definition is not valid").
+			WithAdditional(messages...)
 	}
 	return nil
 }
@@ -466,9 +471,13 @@ func (r *PostableRule) Validate() error {
 
 	errs = append(errs, testTemplateParsing(r)...)
 
-	joined := errors.Join(errs...)
-	if joined != nil {
-		return errors.WrapInvalidInputf(joined, errors.CodeInvalidInput, "validation failed")
+	if len(errs) > 0 {
+		messages := make([]string, len(errs))
+		for i, e := range errs {
+			messages[i] = e.Error()
+		}
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "alert rule is not valid").
+			WithAdditional(messages...)
 	}
 	return nil
 }

pkg/types/ruletypes/validate_test.go

@@ -4,8 +4,23 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
 )
 
+func errorContains(err error, substr string) bool {
+	j := errors.AsJSON(err)
+	if strings.Contains(j.Message, substr) {
+		return true
+	}
+	for _, e := range j.Errors {
+		if strings.Contains(e.Message, substr) {
+			return true
+		}
+	}
+	return false
+}
+
 // validV1Builder returns a minimal valid v1 builder rule JSON.
 func validV1Builder() string {
 	return `{
@@ -494,7 +509,7 @@ func TestValidate_PostableRule_Common(t *testing.T) {
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("expected error containing %q, got nil", tt.errSubstr)
-				} else if tt.errSubstr != "" && !strings.Contains(err.Error(), tt.errSubstr) {
+				} else if tt.errSubstr != "" && !errorContains(err, tt.errSubstr) {
 					t.Errorf("expected error containing %q, got: %v", tt.errSubstr, err)
 				}
 			} else {
@@ -687,7 +702,7 @@ func TestValidate_V1_ConditionFields(t *testing.T) {
 			if tt.wantErr {
 				if validateErr == nil {
 					t.Errorf("expected Validate() error containing %q, got nil", tt.errSubstr)
-				} else if tt.errSubstr != "" && !strings.Contains(validateErr.Error(), tt.errSubstr) {
+				} else if tt.errSubstr != "" && !errorContains(validateErr, tt.errSubstr) {
 					t.Errorf("expected error containing %q, got: %v", tt.errSubstr, validateErr)
 				}
 			} else {
@@ -1029,7 +1044,7 @@ func TestValidate_V2Alpha1(t *testing.T) {
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("expected error containing %q, got nil", tt.errSubstr)
-				} else if tt.errSubstr != "" && !strings.Contains(err.Error(), tt.errSubstr) {
+				} else if tt.errSubstr != "" && !errorContains(err, tt.errSubstr) {
 					t.Errorf("expected error containing %q, got: %v", tt.errSubstr, err)
 				}
 			} else {
@@ -1337,7 +1352,7 @@ func TestValidate_MultipleErrors(t *testing.T) {
 			t.Fatal("expected unmarshal error for wrong version")
 		}
 		// The error should mention version
-		if !strings.Contains(err.Error(), "version") {
+		if !errorContains(err, "version") {
 			t.Errorf("expected error to mention version, got: %v", err)
 		}
 	})
@@ -1355,10 +1370,9 @@ func TestValidate_MultipleErrors(t *testing.T) {
 		if validateErr == nil {
 			t.Fatal("expected Validate() error")
 		}
-		errStr := validateErr.Error()
 		// Should contain errors for thresholds, evaluation, notificationSettings
 		for _, substr := range []string{"evaluation", "notificationSettings"} {
-			if !strings.Contains(errStr, substr) {
+			if !errorContains(validateErr, substr) {
 				t.Errorf("expected error to mention %q, got: %v", substr, validateErr)
 			}
 		}
@@ -1469,7 +1483,7 @@ func TestValidate_V2Alpha1_CumulativeEvaluation(t *testing.T) {
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("expected error containing %q, got nil", tt.errSubstr)
-				} else if !strings.Contains(err.Error(), tt.errSubstr) {
+				} else if !errorContains(err, tt.errSubstr) {
 					t.Errorf("expected error containing %q, got: %v", tt.errSubstr, err)
 				}
 			} else if err != nil {

pkg/types/spantypes/spanmappersimulator.go

@@ -1,117 +0,0 @@
-package spantypes
-
-import (
-	"strings"
-)
-
-// resourceSourcePrefix marks a source that reads from resource attributes:
-// buildAttributeRule prefixes those keys with "resource." (e.g. "resource.service.name").
-var resourceSourcePrefix = FieldContextResource.StringValue() + "."
-
-type SpanMappingPreviewGroup struct {
-	Group   PostableSpanMapperGroup `json:"group" required:"true"`
-	Mappers []PostableSpanMapper    `json:"mappers" required:"true" nullable:"true"`
-}
-
-type SpanMappingPreviewRequest struct {
-	Span    map[string]any            `json:"span" nullable:"true"`
-	Groups  []SpanMappingPreviewGroup `json:"groups" nullable:"true"`
-	GroupID *string                   `json:"groupId" nullable:"true"`
-}
-
-type SpanMappingPreviewResponse struct {
-	Span map[string]any `json:"span" nullable:"true"`
-}
-
-func SimulateMappingForAttributes(groups []*SpanMapperGroupWithMappers, resourceAttrs, spanAttrs map[string]any) (outResource, outSpan map[string]any) {
-	cfg := buildProcessorConfig(filterEnabledGroupsWithMappers(groups))
-
-	outResource = cloneAttrs(resourceAttrs)
-	outSpan = cloneAttrs(spanAttrs)
-
-	applyEnabledGroups(cfg, outSpan, outResource)
-	return outResource, outSpan
-}
-
-func filterEnabledGroupsWithMappers(groups []*SpanMapperGroupWithMappers) []*SpanMapperGroupWithMappers {
-	out := make([]*SpanMapperGroupWithMappers, 0, len(groups))
-	for _, gm := range groups {
-		if gm == nil || gm.Group == nil || !gm.Group.Enabled {
-			continue
-		}
-		enabled := make([]*SpanMapper, 0, len(gm.Mappers))
-		for _, m := range gm.Mappers {
-			if m != nil && m.Enabled {
-				enabled = append(enabled, m)
-			}
-		}
-		if len(enabled) > 0 {
-			out = append(out, &SpanMapperGroupWithMappers{Group: gm.Group, Mappers: enabled})
-		}
-	}
-	return out
-}
-
-func cloneAttrs(in map[string]any) map[string]any {
-	out := make(map[string]any, len(in))
-	for k, v := range in {
-		out[k] = v
-	}
-	return out
-}
-
-// The functions below are copied from signoz-otel-collector (processor/signozspanmappingprocessor, PR #796):
-// TODO(spanmapper-preview): delete them and call the real processor once that PR merges and the dependency is bumped.
-func applyEnabledGroups(cfg *spanMapperProcessorConfig, spanAttrs, resourceAttrs map[string]any) {
-	for i := range cfg.Groups {
-		g := &cfg.Groups[i]
-		if !spanMapperConditionMet(g.ExistsAny, spanAttrs, resourceAttrs) {
-			continue
-		}
-		for j := range g.Attributes {
-			applySpanMapperRule(&g.Attributes[j], spanAttrs, resourceAttrs)
-		}
-	}
-}
-
-func spanMapperConditionMet(cond spanMapperProcessorExistsAny, spanAttrs, resourceAttrs map[string]any) bool {
-	return anyKeyContains(spanAttrs, cond.Attributes) || anyKeyContains(resourceAttrs, cond.Resource)
-}
-
-func anyKeyContains(attrs map[string]any, patterns []string) bool {
-	for k := range attrs {
-		for _, p := range patterns {
-			if strings.Contains(k, p) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func applySpanMapperRule(rule *spanMapperProcessorAttribute, spanAttrs, resourceAttrs map[string]any) {
-	dst := spanAttrs
-	if rule.Context == FieldContextResource.StringValue() {
-		dst = resourceAttrs
-	}
-
-	for i := range rule.Sources {
-		src := &rule.Sources[i]
-		sourceKey, isResource := strings.CutPrefix(src.Key, resourceSourcePrefix)
-
-		from := spanAttrs
-		if isResource {
-			from = resourceAttrs
-		}
-		val, ok := from[sourceKey]
-		if !ok {
-			continue
-		}
-
-		dst[rule.Target] = val
-		if src.Action == SpanMapperOperationMove.StringValue() {
-			delete(from, sourceKey)
-		}
-		return
-	}
-}

pkg/types/spantypes/spanmappersimulator_test.go

@@ -1,159 +0,0 @@
-package spantypes
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func simGroup(name string, attrCond, resCond []string, mappers ...*SpanMapper) *SpanMapperGroupWithMappers {
-	return &SpanMapperGroupWithMappers{
-		Group: &SpanMapperGroup{
-			Name:      name,
-			Condition: SpanMapperGroupCondition{Attributes: attrCond, Resource: resCond},
-			Enabled:   true,
-		},
-		Mappers: mappers,
-	}
-}
-
-func simMapper(target string, ctx FieldContext, sources ...SpanMapperSource) *SpanMapper {
-	return &SpanMapper{
-		Name:         target,
-		FieldContext: ctx,
-		Config:       SpanMapperConfig{Sources: sources},
-		Enabled:      true,
-	}
-}
-
-func simAttrSrc(key string, op SpanMapperOperation, priority int) SpanMapperSource {
-	return SpanMapperSource{Key: key, Context: FieldContextSpanAttribute, Operation: op, Priority: priority}
-}
-
-func simResSrc(key string, op SpanMapperOperation, priority int) SpanMapperSource {
-	return SpanMapperSource{Key: key, Context: FieldContextResource, Operation: op, Priority: priority}
-}
-
-func TestSimulate_MatchInSpanAttrs(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("llm", []string{"model"}, nil,
-			simMapper("gen_ai.request.model", FieldContextSpanAttribute,
-				simAttrSrc("llm.model", SpanMapperOperationCopy, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"llm.model": "gpt-4", "gen_ai.llm.model": "gpt-40"})
-
-	assert.Equal(t, "gpt-4", outSpan["gen_ai.request.model"])
-}
-
-func TestSimulate_MatchInResourceAttrs(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("llm", nil, []string{"service.name"},
-			simMapper("gen_ai.request.model", FieldContextSpanAttribute,
-				simResSrc("service.name", SpanMapperOperationCopy, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, map[string]any{"service.name": "my-llm-service"}, nil)
-
-	assert.Equal(t, "my-llm-service", outSpan["gen_ai.request.model"])
-}
-
-func TestSimulate_NoMatchSkipsGroup(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("llm", []string{"model"}, nil,
-			simMapper("gen_ai.request.model", FieldContextSpanAttribute,
-				simAttrSrc("llm.model", SpanMapperOperationCopy, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"some.other.key": "value"})
-
-	_, ok := outSpan["gen_ai.request.model"]
-	assert.False(t, ok, "target must not be set when condition is not met")
-}
-
-func TestSimulate_SourceFirstMatchWins(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("tokens", []string{"llm"}, nil,
-			simMapper("gen_ai.request.tokens", FieldContextSpanAttribute,
-				simAttrSrc("gen_ai.request_tokens", SpanMapperOperationCopy, 2),
-				simAttrSrc("llm.tokens", SpanMapperOperationCopy, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"gen_ai.request_tokens": "100", "llm.tokens": "200"})
-
-	assert.Equal(t, "100", outSpan["gen_ai.request.tokens"])
-}
-
-func TestSimulate_SourceFallsBackToSecond(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("tokens", []string{"llm"}, nil,
-			simMapper("gen_ai.request.tokens", FieldContextSpanAttribute,
-				simAttrSrc("gen_ai.request_tokens", SpanMapperOperationCopy, 2),
-				simAttrSrc("llm.tokens", SpanMapperOperationCopy, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"llm.tokens": "200"})
-
-	assert.Equal(t, "200", outSpan["gen_ai.request.tokens"])
-}
-
-func TestSimulate_ActionMove(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("input", []string{"gen_ai"}, nil,
-			simMapper("gen_ai.request.input", FieldContextSpanAttribute,
-				simAttrSrc("gen_ai.input", SpanMapperOperationMove, 1)),
-		),
-	}
-	_, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"gen_ai.input": "hello"})
-
-	assert.Equal(t, "hello", outSpan["gen_ai.request.input"])
-	_, srcPresent := outSpan["gen_ai.input"]
-	assert.False(t, srcPresent, "source key must be deleted when action=move")
-}
-
-func TestSimulate_WriteToResourceContext(t *testing.T) {
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("llm", []string{"llm"}, nil,
-			simMapper("gen_ai.request.model", FieldContextResource,
-				simAttrSrc("llm.model", SpanMapperOperationCopy, 1)),
-		),
-	}
-	outResource, outSpan := SimulateMappingForAttributes(groups, nil, map[string]any{"llm.model": "gpt-4"})
-
-	assert.Equal(t, "gpt-4", outResource["gen_ai.request.model"], "target must be written to resource attributes")
-	_, inSpan := outSpan["gen_ai.request.model"]
-	assert.False(t, inSpan)
-}
-
-func TestSimulate_DisabledGroupsAndMappersSkipped(t *testing.T) {
-	disabledGroup := simGroup("g1", []string{"llm"}, nil,
-		simMapper("gen_ai.request.model", FieldContextSpanAttribute,
-			simAttrSrc("llm.model", SpanMapperOperationCopy, 1)))
-	disabledGroup.Group.Enabled = false
-
-	_, outSpan := SimulateMappingForAttributes([]*SpanMapperGroupWithMappers{disabledGroup}, nil, map[string]any{"llm.model": "gpt-4"})
-
-	_, ok := outSpan["gen_ai.request.model"]
-	assert.False(t, ok, "disabled groups must not be evaluated")
-}
-
-func TestSimulate_NoMappingsReturnsInputUnchanged(t *testing.T) {
-	outResource, outSpan := SimulateMappingForAttributes(nil, map[string]any{"host.name": "h1"}, map[string]any{"model": "gpt-5"})
-
-	assert.Equal(t, map[string]any{"host.name": "h1"}, outResource, "resource attributes returned unchanged")
-	assert.Equal(t, map[string]any{"model": "gpt-5"}, outSpan, "span attributes returned unchanged")
-}
-
-func TestSimulate_DoesNotMutateInput(t *testing.T) {
-	input := map[string]any{"gen_ai.input": "hi"}
-	groups := []*SpanMapperGroupWithMappers{
-		simGroup("input", []string{"gen_ai"}, nil,
-			simMapper("gen_ai.request.input", FieldContextSpanAttribute,
-				simAttrSrc("gen_ai.input", SpanMapperOperationMove, 1))),
-	}
-	_, _ = SimulateMappingForAttributes(groups, nil, input)
-
-	// Original input map must be untouched (move would have deleted the key).
-	_, ok := input["gen_ai.input"]
-	assert.True(t, ok, "input map must not be mutated by the preview")
-}