feat(base-path): migrate remaining pattern for window.location.origin + path

Restructure Validate nil check, rename expectErr to fail with
early-return, trim trailing newlines in test assertions, remove
t.Parallel from subtests, inline short config literals, restore
struct field comments in web.Config.

docs/api/openapi.yml

@@ -4268,183 +4268,6 @@ components:
       type: object
     Sigv4SigV4Config:
       type: object
-    SpanattributemappingtypesCondition:
-      properties:
-        attributes:
-          items:
-            type: string
-          nullable: true
-          type: array
-        resource:
-          items:
-            type: string
-          nullable: true
-          type: array
-      type: object
-    SpanattributemappingtypesFieldContext:
-      enum:
-      - attribute
-      - resource
-      type: string
-    SpanattributemappingtypesGroup:
-      properties:
-        category:
-          type: string
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        id:
-          type: string
-        name:
-          type: string
-        ordId:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - ordId
-      - name
-      - category
-      - condition
-      - enabled
-      type: object
-    SpanattributemappingtypesListGroupsResponse:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesGroup'
-          nullable: true
-          type: array
-      required:
-      - items
-      type: object
-    SpanattributemappingtypesListMappersResponse:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesMapper'
-          nullable: true
-          type: array
-      required:
-      - items
-      type: object
-    SpanattributemappingtypesMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        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
-    SpanattributemappingtypesMapperConfig:
-      properties:
-        sources:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesMapperSource'
-          nullable: true
-          type: array
-      type: object
-    SpanattributemappingtypesMapperOperation:
-      enum:
-      - move
-      - copy
-      type: string
-    SpanattributemappingtypesMapperSource:
-      properties:
-        context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        key:
-          type: string
-        operation:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperOperation'
-        priority:
-          type: integer
-      type: object
-    SpanattributemappingtypesPostableGroup:
-      properties:
-        category:
-          type: string
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        enabled:
-          type: boolean
-        name:
-          type: string
-      required:
-      - name
-      - category
-      - condition
-      type: object
-    SpanattributemappingtypesPostableMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        name:
-          type: string
-      required:
-      - name
-      - field_context
-      - config
-      type: object
-    SpanattributemappingtypesUpdatableGroup:
-      properties:
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        enabled:
-          nullable: true
-          type: boolean
-        name:
-          nullable: true
-          type: string
-      type: object
-    SpanattributemappingtypesUpdatableMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        enabled:
-          nullable: true
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-      type: object
     TelemetrytypesFieldContext:
       enum:
       - metric
@@ -9053,510 +8876,6 @@ paths:
       summary: Updates my service account
       tags:
       - serviceaccount
-  /api/v1/span_attribute_mapping_groups:
-    get:
-      deprecated: false
-      description: Returns all span attribute mapping groups for the authenticated
-        org.
-      operationId: ListSpanAttributeMappingGroups
-      parameters:
-      - in: query
-        name: category
-        schema:
-          nullable: true
-          type: string
-      - in: query
-        name: enabled
-        schema:
-          nullable: true
-          type: boolean
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesListGroupsResponse'
-                  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:
-      - span-attribute-mapping
-    post:
-      deprecated: false
-      description: Creates a new span attribute mapping group for the org.
-      operationId: CreateMappingGroup
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesPostableGroup'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesGroup'
-                  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:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapper from a mapping group.
-      operationId: DeleteMapper
-      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 attribute mapper
-      tags:
-      - span-attribute-mapping
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapper's field context, config, or
-        enabled state.
-      operationId: UpdateMapper
-      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/SpanattributemappingtypesUpdatableMapper'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesMapper'
-                  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:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span attribute mapper
-      tags:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{id}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapping group and cascades to all its mappers.
-      operationId: DeleteMappingGroup
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "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:
-      - span-attribute-mapping
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapping group's name, condition,
-        or enabled state.
-      operationId: UpdateMappingGroup
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesUpdatableGroup'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesGroup'
-                  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:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span attribute mapping group
-      tags:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{id}/mappers:
-    get:
-      deprecated: false
-      description: Returns all attribute mappers belonging to a mapping group.
-      operationId: ListMappers
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesListMappersResponse'
-                  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 attribute mappers for a group
-      tags:
-      - span-attribute-mapping
-    post:
-      deprecated: false
-      description: Adds a new attribute mapper to the specified mapping group.
-      operationId: CreateMapper
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesPostableMapper'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesMapper'
-                  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 attribute mapper
-      tags:
-      - span-attribute-mapping
   /api/v1/testChannel:
     post:
       deprecated: true

frontend/.eslintrc.cjs

@@ -66,6 +66,8 @@ module.exports = {
 	rules: {
 		// Asset migration — base-path safety
 		'rulesdir/no-unsupported-asset-pattern': 'error',
+		// Base-path safety — window.open and origin-concat patterns; upgrade to error coming PR
+		'rulesdir/no-raw-absolute-path': 'warn',
 
 		// Code quality rules
 		'prefer-const': 'error', // Enforces const for variables never reassigned

frontend/eslint-rules/no-raw-absolute-path.js

@@ -0,0 +1,153 @@
+'use strict';
+
+/**
+ * ESLint rule: no-raw-absolute-path
+ *
+ * Catches patterns that break at runtime when the app is served from a
+ * sub-path (e.g. /signoz/):
+ *
+ *   1. window.open(path, '_blank')
+ *      → use openInNewTab(path) which calls withBasePath internally
+ *
+ *   2. window.location.origin + path  /  `${window.location.origin}${path}`
+ *      → use getAbsoluteUrl(path)
+ *
+ *   3. frontendBaseUrl: window.location.origin  (bare origin usage)
+ *      → use getBaseUrl() to include the base path
+ *
+ *   4. window.location.href = path
+ *      → use withBasePath(path) or navigate() for internal navigation
+ *
+ * External URLs (first arg starts with "http") are explicitly allowed.
+ */
+
+function isOriginAccess(node) {
+	return (
+		node.type === 'MemberExpression' &&
+		!node.computed &&
+		node.property.name === 'origin' &&
+		node.object.type === 'MemberExpression' &&
+		!node.object.computed &&
+		node.object.property.name === 'location' &&
+		node.object.object.type === 'Identifier' &&
+		node.object.object.name === 'window'
+	);
+}
+
+function isHrefAccess(node) {
+	return (
+		node.type === 'MemberExpression' &&
+		!node.computed &&
+		node.property.name === 'href' &&
+		node.object.type === 'MemberExpression' &&
+		!node.object.computed &&
+		node.object.property.name === 'location' &&
+		node.object.object.type === 'Identifier' &&
+		node.object.object.name === 'window'
+	);
+}
+
+function isExternalUrl(node) {
+	if (node.type === 'Literal' && typeof node.value === 'string') {
+		return node.value.startsWith('http://') || node.value.startsWith('https://');
+	}
+	if (node.type === 'TemplateLiteral' && node.quasis.length > 0) {
+		const raw = node.quasis[0].value.raw;
+		return raw.startsWith('http://') || raw.startsWith('https://');
+	}
+	return false;
+}
+
+// window.open(withBasePath(x)) and window.open(getAbsoluteUrl(x)) are already safe.
+function isSafeHelperCall(node) {
+	return (
+		node.type === 'CallExpression' &&
+		node.callee.type === 'Identifier' &&
+		(node.callee.name === 'withBasePath' || node.callee.name === 'getAbsoluteUrl')
+	);
+}
+
+module.exports = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description:
+				'Disallow raw window.open and origin-concatenation patterns that miss the runtime base path',
+			category: 'Base Path Safety',
+		},
+		schema: [],
+		messages: {
+			windowOpen:
+				'Use openInNewTab(path) instead of window.open(path, "_blank") — openInNewTab prepends the base path automatically.',
+			originConcat:
+				'Use getAbsoluteUrl(path) instead of window.location.origin + path — getAbsoluteUrl prepends the base path automatically.',
+			originDirect:
+				'Use getBaseUrl() instead of window.location.origin — getBaseUrl includes the base path.',
+			hrefAssign:
+				'Use withBasePath(path) or navigate() instead of window.location.href = path — ensures the base path is included.',
+		},
+	},
+
+	create(context) {
+		return {
+			// window.open(path, ...) — allow only external first-arg URLs
+			CallExpression(node) {
+				const { callee, arguments: args } = node;
+				if (
+					callee.type !== 'MemberExpression' ||
+					callee.object.type !== 'Identifier' ||
+					callee.object.name !== 'window' ||
+					callee.property.name !== 'open'
+				)
+					return;
+				if (args.length < 1) return;
+				if (isExternalUrl(args[0])) return;
+				if (isSafeHelperCall(args[0])) return;
+
+				context.report({ node, messageId: 'windowOpen' });
+			},
+
+			// window.location.origin + path
+			BinaryExpression(node) {
+				if (node.operator !== '+') return;
+				if (isOriginAccess(node.left) || isOriginAccess(node.right)) {
+					context.report({ node, messageId: 'originConcat' });
+				}
+			},
+
+			// `${window.location.origin}${path}`
+			TemplateLiteral(node) {
+				if (node.expressions.some(isOriginAccess)) {
+					context.report({ node, messageId: 'originConcat' });
+				}
+			},
+
+			// window.location.origin used directly (not in concatenation)
+			// Catches: frontendBaseUrl: window.location.origin
+			MemberExpression(node) {
+				if (!isOriginAccess(node)) return;
+
+				const parent = node.parent;
+				// Skip if parent is BinaryExpression with + (handled by BinaryExpression visitor)
+				if (parent.type === 'BinaryExpression' && parent.operator === '+') return;
+				// Skip if inside TemplateLiteral (handled by TemplateLiteral visitor)
+				if (parent.type === 'TemplateLiteral') return;
+
+				context.report({ node, messageId: 'originDirect' });
+			},
+
+			// window.location.href = path
+			AssignmentExpression(node) {
+				if (node.operator !== '=') return;
+				if (!isHrefAccess(node.left)) return;
+
+				// Allow external URLs
+				if (isExternalUrl(node.right)) return;
+				// Allow safe helper calls
+				if (isSafeHelperCall(node.right)) return;
+
+				context.report({ node, messageId: 'hrefAssign' });
+			},
+		};
+	},
+};

frontend/index.html

@@ -2,6 +2,7 @@
 <html lang="en">
 	<head>
 		<meta charset="utf-8" />
+		<base href="[[.BaseHref]]" />
 		<meta
 			http-equiv="Cache-Control"
 			content="no-cache, no-store, must-revalidate, max-age: 0"
@@ -59,7 +60,7 @@
 		<meta data-react-helmet="true" name="docusaurus_locale" content="en" />
 		<meta data-react-helmet="true" name="docusaurus_tag" content="default" />
 		<meta name="robots" content="noindex" />
-		<link data-react-helmet="true" rel="shortcut icon" href="/favicon.ico" />
+		<link data-react-helmet="true" rel="shortcut icon" href="favicon.ico" />
 	</head>
 	<body data-theme="default">
 		<script>
@@ -136,7 +137,7 @@
 				})(document, 'script');
 			}
 		</script>
-		<link rel="stylesheet" href="/css/uPlot.min.css" />
+		<link rel="stylesheet" href="css/uPlot.min.css" />
 		<script type="module" src="./src/index.tsx"></script>
 	</body>
 </html>

frontend/src/ReactI18/index.tsx

@@ -2,6 +2,7 @@ import { initReactI18next } from 'react-i18next';
 import i18n from 'i18next';
 import LanguageDetector from 'i18next-browser-languagedetector';
 import Backend from 'i18next-http-backend';
+import { getBasePath } from 'utils/basePath';
 
 import cacheBursting from '../../i18n-translations-hash.json';
 
@@ -24,7 +25,7 @@ i18n
 				const ns = namespace[0];
 				const pathkey = `/${language}/${ns}`;
 				const hash = cacheBursting[pathkey as keyof typeof cacheBursting] || '';
-				return `/locales/${language}/${namespace}.json?h=${hash}`;
+				return `${getBasePath()}locales/${language}/${namespace}.json?h=${hash}`;
 			},
 		},
 		react: {

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

@@ -5243,198 +5243,6 @@ export interface Sigv4SigV4ConfigDTO {
 	[key: string]: unknown;
 }
 
-export interface SpanattributemappingtypesConditionDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	attributes?: string[] | null;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	resource?: string[] | null;
-}
-
-export enum SpanattributemappingtypesFieldContextDTO {
-	attribute = 'attribute',
-	resource = 'resource',
-}
-export interface SpanattributemappingtypesGroupDTO {
-	/**
-	 * @type string
-	 */
-	category: string;
-	condition: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @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
-	 */
-	ordId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpanattributemappingtypesListGroupsResponseDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: SpanattributemappingtypesGroupDTO[] | null;
-}
-
-export interface SpanattributemappingtypesListMappersResponseDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: SpanattributemappingtypesMapperDTO[] | null;
-}
-
-export interface SpanattributemappingtypesMapperDTO {
-	config: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	field_context: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @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 SpanattributemappingtypesMapperConfigDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	sources?: SpanattributemappingtypesMapperSourceDTO[] | null;
-}
-
-export enum SpanattributemappingtypesMapperOperationDTO {
-	move = 'move',
-	copy = 'copy',
-}
-export interface SpanattributemappingtypesMapperSourceDTO {
-	context?: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	key?: string;
-	operation?: SpanattributemappingtypesMapperOperationDTO;
-	/**
-	 * @type integer
-	 */
-	priority?: number;
-}
-
-export interface SpanattributemappingtypesPostableGroupDTO {
-	/**
-	 * @type string
-	 */
-	category: string;
-	condition: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpanattributemappingtypesPostableMapperDTO {
-	config: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	field_context: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpanattributemappingtypesUpdatableGroupDTO {
-	condition?: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	name?: string | null;
-}
-
-export interface SpanattributemappingtypesUpdatableMapperDTO {
-	config?: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	field_context?: SpanattributemappingtypesFieldContextDTO;
-}
-
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -6654,89 +6462,6 @@ export type GetMyServiceAccount200 = {
 	status: string;
 };
 
-export type ListSpanAttributeMappingGroupsParams = {
-	/**
-	 * @type string
-	 * @nullable true
-	 * @description undefined
-	 */
-	category?: string | null;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 * @description undefined
-	 */
-	enabled?: boolean | null;
-};
-
-export type ListSpanAttributeMappingGroups200 = {
-	data: SpanattributemappingtypesListGroupsResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateMappingGroup201 = {
-	data: SpanattributemappingtypesGroupDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
-export type UpdateMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
-export type UpdateMapper200 = {
-	data: SpanattributemappingtypesMapperDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteMappingGroupPathParameters = {
-	id: string;
-};
-export type UpdateMappingGroupPathParameters = {
-	id: string;
-};
-export type UpdateMappingGroup200 = {
-	data: SpanattributemappingtypesGroupDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type ListMappersPathParameters = {
-	id: string;
-};
-export type ListMappers200 = {
-	data: SpanattributemappingtypesListMappersResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateMapperPathParameters = {
-	id: string;
-};
-export type CreateMapper201 = {
-	data: SpanattributemappingtypesMapperDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array

frontend/src/api/generated/services/span-attribute-mapping/index.ts

@@ -1,784 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useMutation, useQuery } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	CreateMapper201,
-	CreateMapperPathParameters,
-	CreateMappingGroup201,
-	DeleteMapperPathParameters,
-	DeleteMappingGroupPathParameters,
-	ListMappers200,
-	ListMappersPathParameters,
-	ListSpanAttributeMappingGroups200,
-	ListSpanAttributeMappingGroupsParams,
-	RenderErrorResponseDTO,
-	SpanattributemappingtypesPostableGroupDTO,
-	SpanattributemappingtypesPostableMapperDTO,
-	SpanattributemappingtypesUpdatableGroupDTO,
-	SpanattributemappingtypesUpdatableMapperDTO,
-	UpdateMapper200,
-	UpdateMapperPathParameters,
-	UpdateMappingGroup200,
-	UpdateMappingGroupPathParameters,
-} from '../sigNoz.schemas';
-
-/**
- * Returns all span attribute mapping groups for the authenticated org.
- * @summary List span attribute mapping groups
- */
-export const listSpanAttributeMappingGroups = (
-	params?: ListSpanAttributeMappingGroupsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanAttributeMappingGroups200>({
-		url: `/api/v1/span_attribute_mapping_groups`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListSpanAttributeMappingGroupsQueryKey = (
-	params?: ListSpanAttributeMappingGroupsParams,
-) => {
-	return [
-		`/api/v1/span_attribute_mapping_groups`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getListSpanAttributeMappingGroupsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanAttributeMappingGroupsQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
-	> = ({ signal }) => listSpanAttributeMappingGroups(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanAttributeMappingGroupsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
->;
-export type ListSpanAttributeMappingGroupsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mapping groups
- */
-
-export function useListSpanAttributeMappingGroups<
-	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanAttributeMappingGroupsQueryOptions(
-		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 invalidateListSpanAttributeMappingGroups = async (
-	queryClient: QueryClient,
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanAttributeMappingGroupsQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates a new span attribute mapping group for the org.
- * @summary Create a span attribute mapping group
- */
-export const createMappingGroup = (
-	spanattributemappingtypesPostableGroupDTO: BodyType<SpanattributemappingtypesPostableGroupDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateMappingGroup201>({
-		url: `/api/v1/span_attribute_mapping_groups`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesPostableGroupDTO,
-		signal,
-	});
-};
-
-export const getCreateMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMappingGroup>>,
-		TError,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createMappingGroup>>,
-	TError,
-	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-	TContext
-> => {
-	const mutationKey = ['createMappingGroup'];
-	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 createMappingGroup>>,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createMappingGroup(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createMappingGroup>>
->;
-export type CreateMappingGroupMutationBody = BodyType<SpanattributemappingtypesPostableGroupDTO>;
-export type CreateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapping group
- */
-export const useCreateMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMappingGroup>>,
-		TError,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createMappingGroup>>,
-	TError,
-	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateMappingGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapper from a mapping group.
- * @summary Delete a span attribute mapper
- */
-export const deleteMapper = ({
-	groupId,
-	mapperId,
-}: DeleteMapperPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMapper>>,
-		TError,
-		{ pathParams: DeleteMapperPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMapper>>,
-	TError,
-	{ pathParams: DeleteMapperPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMapper'];
-	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 deleteMapper>>,
-		{ pathParams: DeleteMapperPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMapper(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMapper>>
->;
-
-export type DeleteMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapper
- */
-export const useDeleteMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMapper>>,
-		TError,
-		{ pathParams: DeleteMapperPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMapper>>,
-	TError,
-	{ pathParams: DeleteMapperPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapper's field context, config, or enabled state.
- * @summary Update a span attribute mapper
- */
-export const updateMapper = (
-	{ groupId, mapperId }: UpdateMapperPathParameters,
-	spanattributemappingtypesUpdatableMapperDTO: BodyType<SpanattributemappingtypesUpdatableMapperDTO>,
-) => {
-	return GeneratedAPIInstance<UpdateMapper200>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesUpdatableMapperDTO,
-	});
-};
-
-export const getUpdateMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMapper>>,
-		TError,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMapper>>,
-	TError,
-	{
-		pathParams: UpdateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateMapper'];
-	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 updateMapper>>,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMapper>>
->;
-export type UpdateMapperMutationBody = BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-export type UpdateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapper
- */
-export const useUpdateMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMapper>>,
-		TError,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMapper>>,
-	TError,
-	{
-		pathParams: UpdateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapping group and cascades to all its mappers.
- * @summary Delete a span attribute mapping group
- */
-export const deleteMappingGroup = ({
-	id,
-}: DeleteMappingGroupPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMappingGroup>>,
-		TError,
-		{ pathParams: DeleteMappingGroupPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMappingGroup>>,
-	TError,
-	{ pathParams: DeleteMappingGroupPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMappingGroup'];
-	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 deleteMappingGroup>>,
-		{ pathParams: DeleteMappingGroupPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMappingGroup(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMappingGroup>>
->;
-
-export type DeleteMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapping group
- */
-export const useDeleteMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMappingGroup>>,
-		TError,
-		{ pathParams: DeleteMappingGroupPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMappingGroup>>,
-	TError,
-	{ pathParams: DeleteMappingGroupPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteMappingGroupMutationOptions(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 updateMappingGroup = (
-	{ id }: UpdateMappingGroupPathParameters,
-	spanattributemappingtypesUpdatableGroupDTO: BodyType<SpanattributemappingtypesUpdatableGroupDTO>,
-) => {
-	return GeneratedAPIInstance<UpdateMappingGroup200>({
-		url: `/api/v1/span_attribute_mapping_groups/${id}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesUpdatableGroupDTO,
-	});
-};
-
-export const getUpdateMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMappingGroup>>,
-		TError,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMappingGroup>>,
-	TError,
-	{
-		pathParams: UpdateMappingGroupPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateMappingGroup'];
-	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 updateMappingGroup>>,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateMappingGroup(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMappingGroup>>
->;
-export type UpdateMappingGroupMutationBody = BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-export type UpdateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapping group
- */
-export const useUpdateMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMappingGroup>>,
-		TError,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMappingGroup>>,
-	TError,
-	{
-		pathParams: UpdateMappingGroupPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateMappingGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns all attribute mappers belonging to a mapping group.
- * @summary List span attribute mappers for a group
- */
-export const listMappers = (
-	{ id }: ListMappersPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListMappers200>({
-		url: `/api/v1/span_attribute_mapping_groups/${id}/mappers`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListMappersQueryKey = ({ id }: ListMappersPathParameters) => {
-	return [`/api/v1/span_attribute_mapping_groups/${id}/mappers`] as const;
-};
-
-export const getListMappersQueryOptions = <
-	TData = Awaited<ReturnType<typeof listMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: ListMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMappers>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListMappersQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listMappers>>> = ({
-		signal,
-	}) => listMappers({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof listMappers>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListMappersQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listMappers>>
->;
-export type ListMappersQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mappers for a group
- */
-
-export function useListMappers<
-	TData = Awaited<ReturnType<typeof listMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: ListMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMappers>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListMappersQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span attribute mappers for a group
- */
-export const invalidateListMappers = async (
-	queryClient: QueryClient,
-	{ id }: ListMappersPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListMappersQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Adds a new attribute mapper to the specified mapping group.
- * @summary Create a span attribute mapper
- */
-export const createMapper = (
-	{ id }: CreateMapperPathParameters,
-	spanattributemappingtypesPostableMapperDTO: BodyType<SpanattributemappingtypesPostableMapperDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateMapper201>({
-		url: `/api/v1/span_attribute_mapping_groups/${id}/mappers`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesPostableMapperDTO,
-		signal,
-	});
-};
-
-export const getCreateMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMapper>>,
-		TError,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createMapper>>,
-	TError,
-	{
-		pathParams: CreateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['createMapper'];
-	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 createMapper>>,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return createMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createMapper>>
->;
-export type CreateMapperMutationBody = BodyType<SpanattributemappingtypesPostableMapperDTO>;
-export type CreateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapper
- */
-export const useCreateMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMapper>>,
-		TError,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createMapper>>,
-	TError,
-	{
-		pathParams: CreateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getCreateMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

frontend/src/api/generatedAPIInstance.ts

@@ -1,5 +1,6 @@
 import {
 	interceptorRejected,
+	interceptorsRequestBasePath,
 	interceptorsRequestResponse,
 	interceptorsResponse,
 } from 'api';
@@ -17,6 +18,7 @@ export const GeneratedAPIInstance = <T>(
 	return generatedAPIAxiosInstance({ ...config }).then(({ data }) => data);
 };
 
+generatedAPIAxiosInstance.interceptors.request.use(interceptorsRequestBasePath);
 generatedAPIAxiosInstance.interceptors.request.use(interceptorsRequestResponse);
 generatedAPIAxiosInstance.interceptors.response.use(
 	interceptorsResponse,

frontend/src/api/index.ts

@@ -11,6 +11,7 @@ import axios, {
 import { ENVIRONMENT } from 'constants/env';
 import { Events } from 'constants/events';
 import { LOCALSTORAGE } from 'constants/localStorage';
+import { getBasePath } from 'utils/basePath';
 import { eventEmitter } from 'utils/getEventEmitter';
 
 import apiV1, { apiAlertManager, apiV2, apiV3, apiV4, apiV5 } from './apiV1';
@@ -67,6 +68,39 @@ export const interceptorsRequestResponse = (
 	return value;
 };
 
+// Strips the leading '/' from path and joins with base — idempotent if already prefixed.
+// e.g. prependBase('/signoz/', '/api/v1/') → '/signoz/api/v1/'
+function prependBase(base: string, path: string): string {
+	return path.startsWith(base) ? path : base + path.slice(1);
+}
+
+// Prepends the runtime base path to outgoing requests so API calls work under
+// a URL prefix (e.g. /signoz/api/v1/…). No-op for root deployments and dev
+// (dev baseURL is a full http:// URL, not an absolute path).
+export const interceptorsRequestBasePath = (
+	value: InternalAxiosRequestConfig,
+): InternalAxiosRequestConfig => {
+	const basePath = getBasePath();
+	if (basePath === '/') {
+		return value;
+	}
+
+	if (value.baseURL?.startsWith('/')) {
+		// Production relative baseURL: '/api/v1/' → '/signoz/api/v1/'
+		value.baseURL = prependBase(basePath, value.baseURL);
+	} else if (value.baseURL?.startsWith('http')) {
+		// Dev absolute baseURL (VITE_FRONTEND_API_ENDPOINT): 'https://host/api/v1/' → 'https://host/signoz/api/v1/'
+		const url = new URL(value.baseURL);
+		url.pathname = prependBase(basePath, url.pathname);
+		value.baseURL = url.toString();
+	} else if (!value.baseURL && value.url?.startsWith('/')) {
+		// Orval-generated client (empty baseURL, path in url): '/api/signoz/v1/rules' → '/signoz/api/signoz/v1/rules'
+		value.url = prependBase(basePath, value.url);
+	}
+
+	return value;
+};
+
 export const interceptorRejected = async (
 	value: AxiosResponse<any>,
 ): Promise<AxiosResponse<any>> => {
@@ -133,6 +167,7 @@ const instance = axios.create({
 });
 
 instance.interceptors.request.use(interceptorsRequestResponse);
+instance.interceptors.request.use(interceptorsRequestBasePath);
 instance.interceptors.response.use(interceptorsResponse, interceptorRejected);
 
 export const AxiosAlertManagerInstance = axios.create({
@@ -147,6 +182,7 @@ ApiV2Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV2Instance.interceptors.request.use(interceptorsRequestResponse);
+ApiV2Instance.interceptors.request.use(interceptorsRequestBasePath);
 
 // axios V3
 export const ApiV3Instance = axios.create({
@@ -158,6 +194,7 @@ ApiV3Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV3Instance.interceptors.request.use(interceptorsRequestResponse);
+ApiV3Instance.interceptors.request.use(interceptorsRequestBasePath);
 //
 
 // axios V4
@@ -170,6 +207,7 @@ ApiV4Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV4Instance.interceptors.request.use(interceptorsRequestResponse);
+ApiV4Instance.interceptors.request.use(interceptorsRequestBasePath);
 //
 
 // axios V5
@@ -182,6 +220,7 @@ ApiV5Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV5Instance.interceptors.request.use(interceptorsRequestResponse);
+ApiV5Instance.interceptors.request.use(interceptorsRequestBasePath);
 //
 
 // axios Base
@@ -194,6 +233,7 @@ LogEventAxiosInstance.interceptors.response.use(
 	interceptorRejectedBase,
 );
 LogEventAxiosInstance.interceptors.request.use(interceptorsRequestResponse);
+LogEventAxiosInstance.interceptors.request.use(interceptorsRequestBasePath);
 //
 
 AxiosAlertManagerInstance.interceptors.response.use(
@@ -201,6 +241,7 @@ AxiosAlertManagerInstance.interceptors.response.use(
 	interceptorRejected,
 );
 AxiosAlertManagerInstance.interceptors.request.use(interceptorsRequestResponse);
+AxiosAlertManagerInstance.interceptors.request.use(interceptorsRequestBasePath);
 
 export { apiV1 };
 export default instance;

frontend/src/components/CeleryTask/useNavigateToExplorer.ts

@@ -12,6 +12,7 @@ import { AppState } from 'store/reducers';
 import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, MetricAggregateOperator } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { withBasePath } from 'utils/basePath';
 
 export interface NavigateToExplorerProps {
 	filters: TagFilterItem[];
@@ -133,7 +134,7 @@ export function useNavigateToExplorer(): (
 				QueryParams.compositeQuery
 			}=${JSONCompositeQuery}`;
 
-			window.open(newExplorerPath, sameTab ? '_self' : '_blank');
+			window.open(withBasePath(newExplorerPath), sameTab ? '_self' : '_blank');
 		},
 		[
 			prepareQuery,

frontend/src/components/HeaderRightSection/ShareURLModal.tsx

@@ -13,6 +13,7 @@ import GetMinMax from 'lib/getMinMax';
 import { Check, Info, Link2 } from 'lucide-react';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { getAbsoluteUrl } from 'utils/basePath';
 
 const routesToBeSharedWithTime = [
 	ROUTES.LOGS_EXPLORER,
@@ -80,17 +81,13 @@ function ShareURLModal(): JSX.Element {
 
 				urlQuery.delete(QueryParams.relativeTime);
 
-				currentUrl = `${window.location.origin}${
-					location.pathname
-				}?${urlQuery.toString()}`;
+				currentUrl = getAbsoluteUrl(`${location.pathname}?${urlQuery.toString()}`);
 			} else {
 				urlQuery.delete(QueryParams.startTime);
 				urlQuery.delete(QueryParams.endTime);
 
 				urlQuery.set(QueryParams.relativeTime, selectedTime);
-				currentUrl = `${window.location.origin}${
-					location.pathname
-				}?${urlQuery.toString()}`;
+				currentUrl = getAbsoluteUrl(`${location.pathname}?${urlQuery.toString()}`);
 			}
 		}
 

frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import { VIEW_TYPES, VIEWS } from './constants';
@@ -330,10 +331,7 @@ function HostMetricsDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -352,10 +350,7 @@ function HostMetricsDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/DependentServices.tsx

@@ -9,6 +9,7 @@ import {
 } from 'container/ApiMonitoring/utils';
 import { UnfoldVertical } from 'lucide-react';
 import { SuccessResponse } from 'types/api';
+import { openInNewTab } from 'utils/navigation';
 
 import emptyStateUrl from '@/assets/Icons/emptyState.svg';
 
@@ -94,20 +95,14 @@ function DependentServices({
 					}}
 					onRow={(record): { onClick: () => void; className: string } => ({
 						onClick: (): void => {
-							const url = new URL(
-								`/services/${
-									record.serviceData.serviceName &&
-									record.serviceData.serviceName !== '-'
-										? record.serviceData.serviceName
-										: ''
-								}`,
-								window.location.origin,
-							);
+							const serviceName =
+								record.serviceData.serviceName && record.serviceData.serviceName !== '-'
+									? record.serviceData.serviceName
+									: '';
 							const urlQuery = new URLSearchParams();
 							urlQuery.set(QueryParams.startTime, timeRange.startTime.toString());
 							urlQuery.set(QueryParams.endTime, timeRange.endTime.toString());
-							url.search = urlQuery.toString();
-							window.open(url.toString(), '_blank');
+							openInNewTab(`/services/${serviceName}?${urlQuery.toString()}`);
 						},
 						className: 'clickable-row',
 					})}

frontend/src/container/CreateAlertV2/AlertCondition/utils.tsx

@@ -14,6 +14,7 @@ import { IUser } from 'providers/App/types';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { USER_ROLES } from 'types/roles';
+import { openInNewTab } from 'utils/navigation';
 
 import { ROUTING_POLICIES_ROUTE } from './constants';
 import { RoutingPolicyBannerProps } from './types';
@@ -387,7 +388,7 @@ export function NotificationChannelsNotFoundContent({
 							style={{ padding: '0 4px' }}
 							type="link"
 							onClick={(): void => {
-								window.open(ROUTES.CHANNELS_NEW, '_blank');
+								openInNewTab(ROUTES.CHANNELS_NEW);
 							}}
 						>
 							here.

frontend/src/container/FormAlertRules/BasicInfo.tsx

@@ -15,6 +15,7 @@ import { AlertDef, Labels } from 'types/api/alerts/def';
 import { Channels } from 'types/api/channels/getAll';
 import APIError from 'types/api/error';
 import { requireErrorMessage } from 'utils/form/requireErrorMessage';
+import { openInNewTab } from 'utils/navigation';
 import { popupContainer } from 'utils/selectPopupContainer';
 
 import ChannelSelect from './ChannelSelect';
@@ -87,7 +88,7 @@ function BasicInfo({
 			dataSource: ALERTS_DATA_SOURCE_MAP[alertDef?.alertType as AlertTypes],
 			ruleId: isNewRule ? 0 : alertDef?.id,
 		});
-		window.open(ROUTES.CHANNELS_NEW, '_blank');
+		openInNewTab(ROUTES.CHANNELS_NEW);
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, []);
 	const hasLoggedEvent = useRef(false);

frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.tsx

@@ -49,6 +49,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import ClusterEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -414,10 +415,7 @@ function ClusterDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -436,10 +434,7 @@ function ClusterDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/DaemonSetDetails.tsx

@@ -48,6 +48,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import DaemonSetEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -429,10 +430,7 @@ function DaemonSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -451,10 +449,7 @@ function DaemonSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Deployments/DeploymentDetails/DeploymentDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import DeploymentEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -433,10 +434,7 @@ function DeploymentDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -455,10 +453,7 @@ function DeploymentDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Jobs/JobDetails/JobDetails.tsx

@@ -48,6 +48,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import JobEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -427,10 +428,7 @@ function JobDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -449,10 +447,7 @@ function JobDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import NamespaceEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -419,10 +420,7 @@ function NamespaceDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -441,10 +439,7 @@ function NamespaceDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import NodeLogs from '../../EntityDetailsUtils/EntityLogs';
@@ -416,10 +417,7 @@ function NodeDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -438,10 +436,7 @@ function NodeDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import PodEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -435,10 +436,7 @@ function PodDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -457,10 +455,7 @@ function PodDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/StatefulSetDetails.tsx

@@ -53,6 +53,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import {
@@ -431,10 +432,7 @@ function StatefulSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -453,10 +451,7 @@ function StatefulSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/ListOfDashboard/DashboardsList.tsx

@@ -83,6 +83,8 @@ import {
 } from 'types/api/dashboard/getAll';
 import APIError from 'types/api/error';
 import { isModifierKeyPressed } from 'utils/app';
+import { getAbsoluteUrl } from 'utils/basePath';
+import { openInNewTab } from 'utils/navigation';
 
 import awwSnapUrl from '@/assets/Icons/awwSnap.svg';
 import dashboardsUrl from '@/assets/Icons/dashboards.svg';
@@ -457,7 +459,7 @@ function DashboardsList(): JSX.Element {
 													onClick={(e): void => {
 														e.stopPropagation();
 														e.preventDefault();
-														window.open(getLink(), '_blank');
+														openInNewTab(getLink());
 													}}
 												>
 													Open in New Tab
@@ -469,7 +471,7 @@ function DashboardsList(): JSX.Element {
 													onClick={(e): void => {
 														e.stopPropagation();
 														e.preventDefault();
-														setCopy(`${window.location.origin}${getLink()}`);
+														setCopy(getAbsoluteUrl(getLink()));
 													}}
 												>
 													Copy Link

frontend/src/container/ListOfDashboard/TableComponents/Name.tsx

@@ -1,6 +1,7 @@
 import { LockFilled } from '@ant-design/icons';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
+import { openInNewTab } from 'utils/navigation';
 
 import { Data } from '../DashboardsList';
 import { TableLinkText } from './styles';
@@ -12,7 +13,7 @@ function Name(name: Data['name'], data: Data): JSX.Element {
 
 	const onClickHandler = (event: React.MouseEvent<HTMLElement>): void => {
 		if (event.metaKey || event.ctrlKey) {
-			window.open(getLink(), '_blank');
+			openInNewTab(getLink());
 		} else {
 			history.push(getLink());
 		}

frontend/src/container/LogDetailedView/ContextView/ContextLogRenderer.tsx

@@ -17,6 +17,7 @@ import useUrlQuery from 'hooks/useUrlQuery';
 import { ILog } from 'types/api/logs/log';
 import { Query, TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, StringOperators } from 'types/common/queryBuilder';
+import { withBasePath } from 'utils/basePath';
 
 import { useContextLogData } from './useContextLogData';
 
@@ -116,7 +117,7 @@ function ContextLogRenderer({
 			);
 
 			const link = `${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`;
-			window.open(link, '_blank', 'noopener,noreferrer');
+			window.open(withBasePath(link), '_blank', 'noopener,noreferrer');
 		},
 		[query, urlQuery],
 	);

frontend/src/container/LogDetailedView/TableView.tsx

@@ -34,6 +34,7 @@ import { SET_DETAILED_LOG_DATA } from 'types/actions/logs';
 import { IField } from 'types/api/logs/fields';
 import { ILog } from 'types/api/logs/log';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { openInNewTab } from 'utils/navigation';
 
 import { ActionItemProps } from './ActionItem';
 import FieldRenderer from './FieldRenderer';
@@ -191,7 +192,7 @@ function TableView({
 
 			if (event.ctrlKey || event.metaKey) {
 				// open the trace in new tab
-				window.open(route, '_blank');
+				openInNewTab(route);
 			} else {
 				history.push(route);
 			}

frontend/src/container/LogsExplorerList/TanStackTableView/index.tsx

@@ -34,6 +34,7 @@ import ROUTES from 'constants/routes';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import useDragColumns from 'hooks/useDragColumns';
+import { getAbsoluteUrl } from 'utils/basePath';
 
 import { infinityDefaultStyles } from '../InfinityTableView/config';
 import { TanStackTableStyled } from '../InfinityTableView/styles';
@@ -239,7 +240,7 @@ const TanStackTableView = forwardRef<TableVirtuosoHandle, InfinityTableProps>(
 				urlQuery.delete(QueryParams.activeLogId);
 				urlQuery.delete(QueryParams.relativeTime);
 				urlQuery.set(QueryParams.activeLogId, `"${logId}"`);
-				const link = `${window.location.origin}${pathname}?${urlQuery.toString()}`;
+				const link = getAbsoluteUrl(`${pathname}?${urlQuery.toString()}`);
 
 				setCopy(link);
 				toast.success('Copied to clipboard', { position: 'top-right' });

frontend/src/container/MetricsApplication/utils.ts

@@ -1,5 +1,6 @@
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
+import { withBasePath } from 'utils/basePath';
 
 import { TopOperationList } from './TopOperationsTable';
 import { NavigateToTraceProps } from './types';
@@ -37,7 +38,7 @@ export const navigateToTrace = ({
 	}=${JSONCompositeQuery}`;
 
 	if (openInNewTab) {
-		window.open(newTraceExplorerPath, '_blank');
+		window.open(withBasePath(newTraceExplorerPath), '_blank');
 	} else {
 		safeNavigate(newTraceExplorerPath);
 	}

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

@@ -14,6 +14,7 @@ import ContextMenu from 'periscope/components/ContextMenu';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { openInNewTab } from 'utils/navigation';
 
 import { ContextMenuItem } from './contextConfig';
 import { getDataLinks } from './dataLinksUtils';
@@ -115,7 +116,7 @@ const useBaseAggregateOptions = ({
 					key={id}
 					icon={<LinkOutlined />}
 					onClick={(): void => {
-						window.open(url, '_blank');
+						openInNewTab(url);
 						onClose?.();
 					}}
 				>

frontend/src/container/RoutingPolicies/RoutingPolicyDetails.tsx

@@ -14,6 +14,7 @@ import { ModalTitle } from 'container/PipelinePage/PipelineListsView/styles';
 import { Check, Loader, X } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { USER_ROLES } from 'types/roles';
+import { openInNewTab } from 'utils/navigation';
 
 import { INITIAL_ROUTING_POLICY_DETAILS_FORM_STATE } from './constants';
 import {
@@ -76,7 +77,7 @@ function RoutingPolicyDetails({
 							style={{ padding: '0 4px' }}
 							type="link"
 							onClick={(): void => {
-								window.open(ROUTES.CHANNELS_NEW, '_blank');
+								openInNewTab(ROUTES.CHANNELS_NEW);
 							}}
 						>
 							here.

frontend/src/container/SpanDetailsDrawer/SpanLogs/SpanLogs.tsx

@@ -28,6 +28,7 @@ import {
 } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuid } from 'uuid';
 
 import noDataUrl from '@/assets/Icons/no-data.svg';
@@ -143,7 +144,7 @@ function SpanLogs({
 
 			const url = `${ROUTES.LOGS_EXPLORER}?${createQueryParams(queryParams)}`;
 
-			window.open(url, '_blank');
+			openInNewTab(url);
 		},
 		[
 			isLogSpanRelated,

frontend/src/container/SpanDetailsDrawer/SpanRelatedSignals/SpanRelatedSignals.tsx

@@ -17,6 +17,7 @@ import { BarChart2, Compass, X } from 'lucide-react';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Span } from 'types/api/trace/getTraceV2';
 import { DataSource, LogsAggregatorOperator } from 'types/common/queryBuilder';
+import { getAbsoluteUrl } from 'utils/basePath';
 
 import { RelatedSignalsViews } from '../constants';
 import SpanLogs from '../SpanLogs/SpanLogs';
@@ -158,9 +159,7 @@ function SpanRelatedSignals({
 		searchParams.set(QueryParams.endTime, endTimeMs.toString());
 
 		window.open(
-			`${window.location.origin}${
-				ROUTES.LOGS_EXPLORER
-			}?${searchParams.toString()}`,
+			getAbsoluteUrl(`${ROUTES.LOGS_EXPLORER}?${searchParams.toString()}`),
 			'_blank',
 			'noopener,noreferrer',
 		);

frontend/src/container/Trace/TraceTable/index.tsx

@@ -31,6 +31,7 @@ import {
 	UPDATE_SPANS_AGGREGATE_PAGE_SIZE,
 } from 'types/actions/trace';
 import { TraceReducer } from 'types/reducer/trace';
+import { openInNewTab } from 'utils/navigation';
 import { v4 } from 'uuid';
 
 dayjs.extend(duration);
@@ -214,7 +215,7 @@ function TraceTable(): JSX.Element {
 					event.preventDefault();
 					event.stopPropagation();
 					if (event.metaKey || event.ctrlKey) {
-						window.open(getLink(record), '_blank');
+						openInNewTab(getLink(record));
 					} else {
 						history.push(getLink(record));
 					}

frontend/src/container/TracesTableComponent/TracesTableComponent.tsx

@@ -28,6 +28,7 @@ import { useTimezone } from 'providers/Timezone';
 import { SuccessResponse } from 'types/api';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+import { openInNewTab } from 'utils/navigation';
 
 import './TracesTableComponent.styles.scss';
 
@@ -86,7 +87,7 @@ function TracesTableComponent({
 				event.preventDefault();
 				event.stopPropagation();
 				if (event.metaKey || event.ctrlKey) {
-					window.open(getTraceLink(record), '_blank');
+					openInNewTab(getTraceLink(record));
 				} else {
 					history.push(getTraceLink(record));
 				}

frontend/src/hooks/logs/useCopyLogLink.ts

@@ -17,6 +17,7 @@ import useUrlQuery from 'hooks/useUrlQuery';
 import useUrlQueryData from 'hooks/useUrlQueryData';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { getAbsoluteUrl } from 'utils/basePath';
 
 import { HIGHLIGHTED_DELAY } from './configs';
 import { UseCopyLogLink } from './types';
@@ -60,7 +61,7 @@ export const useCopyLogLink = (logId?: string): UseCopyLogLink => {
 			urlQuery.set(QueryParams.startTime, minTime?.toString() || '');
 			urlQuery.set(QueryParams.endTime, maxTime?.toString() || '');
 
-			const link = `${window.location.origin}${pathname}?${urlQuery.toString()}`;
+			const link = getAbsoluteUrl(`${pathname}?${urlQuery.toString()}`);
 
 			setCopy(link);
 

frontend/src/hooks/trace/useCopySpanLink.ts

@@ -4,6 +4,7 @@ import { useCopyToClipboard } from 'react-use';
 import { useNotifications } from 'hooks/useNotifications';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { Span } from 'types/api/trace/getTraceV2';
+import { getAbsoluteUrl } from 'utils/basePath';
 
 export const useCopySpanLink = (
 	span?: Span,
@@ -28,7 +29,7 @@ export const useCopySpanLink = (
 				urlQuery.set('spanId', span?.spanId);
 			}
 
-			const link = `${window.location.origin}${pathname}?${urlQuery.toString()}`;
+			const link = getAbsoluteUrl(`${pathname}?${urlQuery.toString()}`);
 
 			setCopy(link);
 			notifications.success({

frontend/src/hooks/useSafeNavigate.ts

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom-v5-compat';
 import { cloneDeep, isEqual } from 'lodash-es';
+import { withBasePath } from 'utils/basePath';
 
 interface NavigateOptions {
 	replace?: boolean;
@@ -130,7 +131,7 @@ export const useSafeNavigate = (
 					typeof to === 'string'
 						? to
 						: `${to.pathname || location.pathname}${to.search || ''}`;
-				window.open(targetPath, '_blank');
+				window.open(withBasePath(targetPath), '_blank');
 				return;
 			}
 

frontend/src/lib/history.ts

@@ -1,3 +1,4 @@
 import { createBrowserHistory } from 'history';
+import { getBasePath } from 'utils/basePath';
 
-export default createBrowserHistory();
+export default createBrowserHistory({ basename: getBasePath() });

frontend/src/pages/ErrorBoundaryFallback/ErrorBoundaryFallback.tsx

@@ -4,6 +4,7 @@ import ROUTES from 'constants/routes';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Home, LifeBuoy } from 'lucide-react';
 import { handleContactSupport } from 'pages/Integrations/utils';
+import { withBasePath } from 'utils/basePath';
 
 import cloudUrl from '@/assets/Images/cloud.svg';
 
@@ -11,8 +12,8 @@ import './ErrorBoundaryFallback.styles.scss';
 
 function ErrorBoundaryFallback(): JSX.Element {
 	const handleReload = (): void => {
-		// Go to home page
-		window.location.href = ROUTES.HOME;
+		// Hard reload resets Sentry.ErrorBoundary state; withBasePath preserves any /signoz/ prefix.
+		window.location.href = withBasePath(ROUTES.HOME);
 	};
 
 	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();

frontend/src/pages/MessagingQueues/MQDetails/DropRateView/DropRateView.tsx

@@ -19,6 +19,7 @@ import {
 } from 'pages/MessagingQueues/MessagingQueuesUtils';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 
 import {
 	convertToMilliseconds,
@@ -93,7 +94,7 @@ export function getColumns(
 											key={item}
 											className="traceid-text"
 											onClick={(): void => {
-												window.open(`${ROUTES.TRACE}/${item}`, '_blank');
+												openInNewTab(`${ROUTES.TRACE}/${item}`);
 												logEvent(`MQ Kafka: Drop Rate - traceid navigation`, {
 													item,
 												});
@@ -123,7 +124,7 @@ export function getColumns(
 						onClick={(e): void => {
 							e.preventDefault();
 							e.stopPropagation();
-							window.open(`/services/${encodeURIComponent(text)}`, '_blank');
+							openInNewTab(`/services/${encodeURIComponent(text)}`);
 						}}
 					>
 						{text}

frontend/src/utils/__tests__/basePath.test.ts

@@ -0,0 +1,118 @@
+/**
+ * basePath is memoized at module init, so each describe block isolates the
+ * module with a fresh DOM state using jest.isolateModules + require.
+ */
+
+type BasePath = typeof import('../basePath');
+
+function loadModule(href?: string): BasePath {
+	if (href !== undefined) {
+		const base = document.createElement('base');
+		base.setAttribute('href', href);
+		document.head.appendChild(base);
+	}
+
+	let mod!: BasePath;
+	jest.isolateModules(() => {
+		// eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+		mod = require('../basePath');
+	});
+	return mod;
+}
+
+afterEach(() => {
+	document.head.querySelectorAll('base').forEach((el) => el.remove());
+});
+
+describe('at basePath="/"', () => {
+	let m: BasePath;
+	beforeEach(() => {
+		m = loadModule('/');
+	});
+
+	it('getBasePath returns "/"', () => {
+		expect(m.getBasePath()).toBe('/');
+	});
+
+	it('withBasePath is a no-op for any internal path', () => {
+		expect(m.withBasePath('/logs')).toBe('/logs');
+		expect(m.withBasePath('/logs/explorer')).toBe('/logs/explorer');
+	});
+
+	it('withBasePath passes through external URLs', () => {
+		expect(m.withBasePath('https://example.com/foo')).toBe(
+			'https://example.com/foo',
+		);
+	});
+
+	it('getAbsoluteUrl returns origin + path', () => {
+		expect(m.getAbsoluteUrl('/logs')).toBe(`${window.location.origin}/logs`);
+	});
+
+	it('getBaseUrl returns bare origin', () => {
+		expect(m.getBaseUrl()).toBe(window.location.origin);
+	});
+});
+
+describe('at basePath="/signoz/"', () => {
+	let m: BasePath;
+	beforeEach(() => {
+		m = loadModule('/signoz/');
+	});
+
+	it('getBasePath returns "/signoz/"', () => {
+		expect(m.getBasePath()).toBe('/signoz/');
+	});
+
+	it('withBasePath prepends the prefix', () => {
+		expect(m.withBasePath('/logs')).toBe('/signoz/logs');
+		expect(m.withBasePath('/logs/explorer')).toBe('/signoz/logs/explorer');
+	});
+
+	it('withBasePath is idempotent — safe to call twice', () => {
+		expect(m.withBasePath('/signoz/logs')).toBe('/signoz/logs');
+	});
+
+	it('withBasePath is idempotent when path equals the prefix without trailing slash', () => {
+		expect(m.withBasePath('/signoz')).toBe('/signoz');
+	});
+
+	it('withBasePath passes through external URLs', () => {
+		expect(m.withBasePath('https://example.com/foo')).toBe(
+			'https://example.com/foo',
+		);
+	});
+
+	it('getAbsoluteUrl returns origin + prefixed path', () => {
+		expect(m.getAbsoluteUrl('/logs')).toBe(
+			`${window.location.origin}/signoz/logs`,
+		);
+	});
+
+	it('getBaseUrl returns origin + prefix without trailing slash', () => {
+		expect(m.getBaseUrl()).toBe(`${window.location.origin}/signoz`);
+	});
+});
+
+describe('no <base> tag', () => {
+	it('getBasePath falls back to "/"', () => {
+		const m = loadModule();
+		expect(m.getBasePath()).toBe('/');
+	});
+});
+
+describe('href without trailing slash', () => {
+	it('normalises to trailing slash', () => {
+		const m = loadModule('/signoz');
+		expect(m.getBasePath()).toBe('/signoz/');
+		expect(m.withBasePath('/logs')).toBe('/signoz/logs');
+	});
+});
+
+describe('nested prefix "/a/b/prefix/"', () => {
+	it('withBasePath handles arbitrary depth', () => {
+		const m = loadModule('/a/b/prefix/');
+		expect(m.withBasePath('/logs')).toBe('/a/b/prefix/logs');
+		expect(m.withBasePath('/a/b/prefix/logs')).toBe('/a/b/prefix/logs');
+	});
+});

frontend/src/utils/__tests__/navigation.test.ts

@@ -1,15 +1,27 @@
 import { isModifierKeyPressed } from '../app';
-import { openInNewTab } from '../navigation';
+
+type NavigationModule = typeof import('../navigation');
+
+function loadNavigationModule(href?: string): NavigationModule {
+	if (href !== undefined) {
+		const base = document.createElement('base');
+		base.setAttribute('href', href);
+		document.head.appendChild(base);
+	}
+	let mod!: NavigationModule;
+	jest.isolateModules(() => {
+		// eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+		mod = require('../navigation');
+	});
+	return mod;
+}
 
 describe('navigation utilities', () => {
 	const originalWindowOpen = window.open;
 
-	beforeEach(() => {
-		window.open = jest.fn();
-	});
-
 	afterEach(() => {
 		window.open = originalWindowOpen;
+		document.head.querySelectorAll('base').forEach((el) => el.remove());
 	});
 
 	describe('isModifierKeyPressed', () => {
@@ -56,25 +68,59 @@ describe('navigation utilities', () => {
 	});
 
 	describe('openInNewTab', () => {
-		it('calls window.open with the given path and _blank target', () => {
-			openInNewTab('/dashboard');
-			expect(window.open).toHaveBeenCalledWith('/dashboard', '_blank');
+		describe('at basePath="/"', () => {
+			let m: NavigationModule;
+			beforeEach(() => {
+				window.open = jest.fn();
+				m = loadNavigationModule('/');
+			});
+
+			it('passes internal path through unchanged', () => {
+				m.openInNewTab('/dashboard');
+				expect(window.open).toHaveBeenCalledWith('/dashboard', '_blank');
+			});
+
+			it('passes through external URLs unchanged', () => {
+				m.openInNewTab('https://example.com/page');
+				expect(window.open).toHaveBeenCalledWith(
+					'https://example.com/page',
+					'_blank',
+				);
+			});
+
+			it('handles paths with query strings', () => {
+				m.openInNewTab('/alerts?tab=AlertRules&relativeTime=30m');
+				expect(window.open).toHaveBeenCalledWith(
+					'/alerts?tab=AlertRules&relativeTime=30m',
+					'_blank',
+				);
+			});
 		});
 
-		it('handles full URLs', () => {
-			openInNewTab('https://example.com/page');
-			expect(window.open).toHaveBeenCalledWith(
-				'https://example.com/page',
-				'_blank',
-			);
-		});
+		describe('at basePath="/signoz/"', () => {
+			let m: NavigationModule;
+			beforeEach(() => {
+				window.open = jest.fn();
+				m = loadNavigationModule('/signoz/');
+			});
 
-		it('handles paths with query strings', () => {
-			openInNewTab('/alerts?tab=AlertRules&relativeTime=30m');
-			expect(window.open).toHaveBeenCalledWith(
-				'/alerts?tab=AlertRules&relativeTime=30m',
-				'_blank',
-			);
+			it('prepends base path to internal paths', () => {
+				m.openInNewTab('/dashboard');
+				expect(window.open).toHaveBeenCalledWith('/signoz/dashboard', '_blank');
+			});
+
+			it('passes through external URLs unchanged', () => {
+				m.openInNewTab('https://example.com/page');
+				expect(window.open).toHaveBeenCalledWith(
+					'https://example.com/page',
+					'_blank',
+				);
+			});
+
+			it('is idempotent — does not double-prefix an already-prefixed path', () => {
+				m.openInNewTab('/signoz/dashboard');
+				expect(window.open).toHaveBeenCalledWith('/signoz/dashboard', '_blank');
+			});
 		});
 	});
 });

frontend/src/utils/basePath.ts

@@ -0,0 +1,50 @@
+// Read once at module init — avoids a DOM query on every axios request.
+const _basePath: string = ((): string => {
+	const href = document.querySelector('base')?.getAttribute('href') ?? '/';
+	return href.endsWith('/') ? href : `${href}/`;
+})();
+
+/** Returns the runtime base path — always trailing-slashed. e.g. "/" or "/signoz/" */
+export function getBasePath(): string {
+	return _basePath;
+}
+
+/**
+ * Prepends the base path to an internal absolute path.
+ * Idempotent and safe to call on any value.
+ *
+ *   withBasePath('/logs')         → '/signoz/logs'
+ *   withBasePath('/signoz/logs')  → '/signoz/logs'  (already prefixed)
+ *   withBasePath('https://x.com') → 'https://x.com' (external, passthrough)
+ */
+export function withBasePath(path: string): string {
+	if (!path.startsWith('/')) {
+		return path;
+	}
+	if (_basePath === '/') {
+		return path;
+	}
+	if (path.startsWith(_basePath) || path === _basePath.slice(0, -1)) {
+		return path;
+	}
+	return _basePath + path.slice(1);
+}
+
+/**
+ * Full absolute URL — for copy-to-clipboard and window.open calls.
+ * getAbsoluteUrl(ROUTES.LOGS_EXPLORER) → 'https://host/signoz/logs/logs-explorer'
+ */
+export function getAbsoluteUrl(path: string): string {
+	return window.location.origin + withBasePath(path);
+}
+
+/**
+ * Origin + base path without trailing slash — for sending to the backend
+ * as frontendBaseUrl in invite / password-reset email flows.
+ * getBaseUrl() → 'https://host/signoz'
+ */
+export function getBaseUrl(): string {
+	return (
+		window.location.origin + (_basePath === '/' ? '' : _basePath.slice(0, -1))
+	);
+}

frontend/src/utils/navigation.ts

@@ -1,6 +1,5 @@
-/**
- * Opens the given path in a new browser tab.
- */
+import { withBasePath } from 'utils/basePath';
+
 export const openInNewTab = (path: string): void => {
-	window.open(path, '_blank');
+	window.open(withBasePath(path), '_blank');
 };

frontend/vite.config.ts

@@ -10,6 +10,18 @@ import { createHtmlPlugin } from 'vite-plugin-html';
 import { ViteImageOptimizer } from 'vite-plugin-image-optimizer';
 import tsconfigPaths from 'vite-tsconfig-paths';
 
+// In dev the Go backend is not involved, so replace the [[.BaseHref]] placeholder
+// with "/" so relative assets resolve correctly from the Vite dev server.
+function devBasePathPlugin(): Plugin {
+	return {
+		name: 'dev-base-path',
+		apply: 'serve',
+		transformIndexHtml(html): string {
+			return html.replaceAll('[[.BaseHref]]', '/');
+		},
+	};
+}
+
 function rawMarkdownPlugin(): Plugin {
 	return {
 		name: 'raw-markdown',
@@ -32,6 +44,7 @@ export default defineConfig(
 		const plugins = [
 			tsconfigPaths(),
 			rawMarkdownPlugin(),
+			devBasePathPlugin(),
 			react(),
 			createHtmlPlugin({
 				inject: {
@@ -124,6 +137,7 @@ export default defineConfig(
 				'process.env.TUNNEL_DOMAIN': JSON.stringify(env.VITE_TUNNEL_DOMAIN),
 				'process.env.DOCS_BASE_URL': JSON.stringify(env.VITE_DOCS_BASE_URL),
 			},
+			base: './',
 			build: {
 				sourcemap: true,
 				outDir: 'build',

go.mod

@@ -1,6 +1,6 @@
 module github.com/SigNoz/signoz
 
-go 1.25.7
+go 1.25.0
 
 require (
 	dario.cat/mergo v1.0.2
@@ -20,7 +20,6 @@ require (
 	github.com/go-co-op/gocron v1.30.1
 	github.com/go-openapi/runtime v0.29.2
 	github.com/go-openapi/strfmt v0.25.0
-	github.com/go-playground/validator/v10 v10.27.0
 	github.com/go-redis/redismock/v9 v9.2.0
 	github.com/go-viper/mapstructure/v2 v2.5.0
 	github.com/gojek/heimdall/v7 v7.0.3
@@ -29,8 +28,8 @@ require (
 	github.com/gorilla/handlers v1.5.1
 	github.com/gorilla/mux v1.8.1
 	github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674
-	github.com/huandu/go-sqlbuilder v1.39.1
-	github.com/jackc/pgx/v5 v5.8.0
+	github.com/huandu/go-sqlbuilder v1.35.0
+	github.com/jackc/pgx/v5 v5.7.6
 	github.com/json-iterator/go v1.1.13-0.20220915233716-71ac16282d12
 	github.com/knadh/koanf v1.5.0
 	github.com/knadh/koanf/v2 v2.3.2
@@ -40,7 +39,6 @@ require (
 	github.com/openfga/api/proto v0.0.0-20250909172242-b4b2a12f5c67
 	github.com/openfga/language/pkg/go v0.2.0-beta.2.0.20251027165255-0f8f255e5f6c
 	github.com/opentracing/opentracing-go v1.2.0
-	github.com/perses/perses v0.53.1
 	github.com/pkg/errors v0.9.1
 	github.com/prometheus/alertmanager v0.31.0
 	github.com/prometheus/client_golang v1.23.2
@@ -89,7 +87,7 @@ require (
 	google.golang.org/protobuf v1.36.11
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
-	k8s.io/apimachinery v0.35.2
+	k8s.io/apimachinery v0.35.0
 	modernc.org/sqlite v1.40.1
 )
 
@@ -129,14 +127,12 @@ require (
 	github.com/go-openapi/swag/yamlutils v0.25.4 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.27.0 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
 	github.com/hashicorp/go-metrics v0.5.4 // indirect
-	github.com/huandu/go-clone v1.7.3 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/muhlemmer/gu v0.3.1 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
-	github.com/perses/common v0.30.2 // indirect
 	github.com/prometheus/client_golang/exp v0.0.0-20260108101519-fb0838f53562 // indirect
 	github.com/redis/go-redis/extra/rediscmd/v9 v9.15.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
@@ -145,8 +141,6 @@ require (
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 // indirect
-	github.com/zitadel/oidc/v3 v3.45.4 // indirect
-	github.com/zitadel/schema v1.3.2 // indirect
 	go.opentelemetry.io/collector/client v1.50.0 // indirect
 	go.opentelemetry.io/collector/config/configoptional v1.50.0 // indirect
 	go.opentelemetry.io/collector/config/configretry v1.50.0 // indirect
@@ -216,7 +210,7 @@ require (
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/btree v1.1.3 // indirect
-	github.com/google/cel-go v0.27.0 // indirect
+	github.com/google/cel-go v0.26.1 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.11 // indirect
 	github.com/googleapis/gax-go/v2 v2.16.0 // indirect
@@ -234,7 +228,7 @@ require (
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/hashicorp/memberlist v0.5.4 // indirect
-	github.com/huandu/xstrings v1.5.0 // indirect
+	github.com/huandu/xstrings v1.4.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
@@ -306,6 +300,7 @@ require (
 	github.com/spf13/cast v1.10.0 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/spf13/viper v1.20.1 // indirect
+	github.com/stoewer/go-strcase v1.3.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/swaggest/openapi-go v0.2.60
@@ -391,7 +386,7 @@ require (
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9
 	google.golang.org/grpc v1.80.0 // indirect
 	gopkg.in/telebot.v3 v3.3.8 // indirect
-	k8s.io/client-go v0.35.2 // indirect
+	k8s.io/client-go v0.35.0 // indirect
 	k8s.io/klog/v2 v2.130.1 // indirect
 	k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 // indirect
 )

go.sum

@@ -489,8 +489,8 @@ github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Z
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
 github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
-github.com/google/cel-go v0.27.0 h1:e7ih85+4qVrBuqQWTW4FKSqZYokVuc3HnhH5keboFTo=
-github.com/google/cel-go v0.27.0/go.mod h1:tTJ11FWqnhw5KKpnWpvW9CJC3Y9GK4EIS0WXnBbebzw=
+github.com/google/cel-go v0.26.1 h1:iPbVVEdkhTX++hpe3lzSk7D3G3QSYqLGoHOcEio+UXQ=
+github.com/google/cel-go v0.26.1/go.mod h1:A9O8OU9rdvrK5MQyrqfIxo1a0u4g3sF8KB6PUIaryMM=
 github.com/google/gnostic-models v0.7.0 h1:qwTtogB15McXDaNqTZdzPJRHvaVJlAl+HVQnLmJEJxo=
 github.com/google/gnostic-models v0.7.0/go.mod h1:whL5G0m6dmc5cPxKc5bdKdEN3UjI7OUGxBlw57miDrQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -654,15 +654,12 @@ github.com/hetznercloud/hcloud-go/v2 v2.36.0 h1:HlLL/aaVXUulqe+rsjoJmrxKhPi1MflL
 github.com/hetznercloud/hcloud-go/v2 v2.36.0/go.mod h1:MnN/QJEa/RYNQiiVoJjNHPntM7Z1wlYPgJ2HA40/cDE=
 github.com/hjson/hjson-go/v4 v4.0.0 h1:wlm6IYYqHjOdXH1gHev4VoXCaW20HdQAGCxdOEEg2cs=
 github.com/hjson/hjson-go/v4 v4.0.0/go.mod h1:KaYt3bTw3zhBjYqnXkYywcYctk0A2nxeEFTse3rH13E=
-github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
 github.com/huandu/go-assert v1.1.6 h1:oaAfYxq9KNDi9qswn/6aE0EydfxSa+tWZC1KabNitYs=
 github.com/huandu/go-assert v1.1.6/go.mod h1:JuIfbmYG9ykwvuxoJ3V8TB5QP+3+ajIA54Y44TmkMxs=
-github.com/huandu/go-clone v1.7.3 h1:rtQODA+ABThEn6J5LBTppJfKmZy/FwfpMUWa8d01TTQ=
-github.com/huandu/go-clone v1.7.3/go.mod h1:ReGivhG6op3GYr+UY3lS6mxjKp7MIGTknuU5TbTVaXE=
-github.com/huandu/go-sqlbuilder v1.39.1 h1:uUaj41yLNTQBe7ojNF6Im1RPbHCN4zCjMRySTEC2ooI=
-github.com/huandu/go-sqlbuilder v1.39.1/go.mod h1:zdONH67liL+/TvoUMwnZP/sUYGSSvHh9psLe/HpXn8E=
-github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
-github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/huandu/go-sqlbuilder v1.35.0 h1:ESvxFHN8vxCTudY1Vq63zYpU5yJBESn19sf6k4v2T5Q=
+github.com/huandu/go-sqlbuilder v1.35.0/go.mod h1:mS0GAtrtW+XL6nM2/gXHRJax2RwSW1TraavWDFAc1JA=
+github.com/huandu/xstrings v1.4.0 h1:D17IlohoQq4UcpqD7fDk80P7l+lwAmlFaBHgOipl2FU=
+github.com/huandu/xstrings v1.4.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
 github.com/iancoleman/orderedmap v0.3.0 h1:5cbR2grmZR/DiVt+VJopEhtVs9YGInGIxAoMJn+Ichc=
 github.com/iancoleman/orderedmap v0.3.0/go.mod h1:XuLcCUkdL5owUCQeF2Ue9uuw1EptkJDkXXS7VoV7XGE=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
@@ -675,8 +672,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.8.0 h1:TYPDoleBBme0xGSAX3/+NujXXtpZn9HBONkQC7IEZSo=
-github.com/jackc/pgx/v5 v5.8.0/go.mod h1:QVeDInX2m9VyzvNeiCJVjCkNFqzsNb43204HshNSZKw=
+github.com/jackc/pgx/v5 v5.7.6 h1:rWQc5FwZSPX58r1OQmkuaNicxdmExaEz5A2DO2hUuTk=
+github.com/jackc/pgx/v5 v5.7.6/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4=
@@ -821,8 +818,6 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY
 github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8=
 github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
-github.com/muhlemmer/gu v0.3.1 h1:7EAqmFrW7n3hETvuAdmFmn4hS8W+z3LgKtrnow+YzNM=
-github.com/muhlemmer/gu v0.3.1/go.mod h1:YHtHR+gxM+bKEIIs7Hmi9sPT3ZDUvTN/i88wQpZkrdM=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -832,11 +827,9 @@ github.com/natefinch/wrap v0.2.0 h1:IXzc/pw5KqxJv55gV0lSOcKHYuEZPGbQrOOXr/bamRk=
 github.com/natefinch/wrap v0.2.0/go.mod h1:6gMHlAl12DwYEfKP3TkuykYUfLSEAvHw67itm4/KAS8=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nexucis/lamenv v0.5.2 h1:tK/u3XGhCq9qIoVNcXsK9LZb8fKopm0A5weqSRvHd7M=
-github.com/nexucis/lamenv v0.5.2/go.mod h1:HusJm6ltmmT7FMG8A750mOLuME6SHCsr2iFYxp5fFi0=
 github.com/npillmayer/nestext v0.1.3/go.mod h1:h2lrijH8jpicr25dFY+oAJLyzlya6jhnuG+zWp9L0Uk=
-github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
-github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
 github.com/oklog/run v1.2.0 h1:O8x3yXwah4A73hJdlrwo/2X6J62gE5qTMusH0dvz60E=
 github.com/oklog/run v1.2.0/go.mod h1:mgDbKRSwPhJfesJ4PntqFUbKQRZ50NgmZTSPlFA0YFk=
@@ -898,10 +891,6 @@ github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCko
 github.com/pelletier/go-toml/v2 v2.0.5/go.mod h1:OMHamSCAODeSsVrwwvcJOaoN0LIUIaFVNZzmWyNfXas=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
-github.com/perses/common v0.30.2 h1:RAiVxUpX76lTCb4X7pfcXSvYdXQmZwKi4oDKAEO//u0=
-github.com/perses/common v0.30.2/go.mod h1:DFtur1QPah2/ChXbKKhw7djYdwNgz27s5fPKpiK0Xao=
-github.com/perses/perses v0.53.1 h1:9VY/6p9QWrZwPSV7qiwTMSOsgcB37Lb1AXKT0ORXc6I=
-github.com/perses/perses v0.53.1/go.mod h1:ro8fsgBkHYOdrL/MV+fdP9mflKzYCy/+gcbxiaReI/A=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pierrec/lz4/v4 v4.1.23 h1:oJE7T90aYBGtFNrI8+KbETnPymobAhzRrR8Mu8n1yfU=
 github.com/pierrec/lz4/v4 v4.1.23/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
@@ -1060,6 +1049,8 @@ github.com/srikanthccv/ClickHouse-go-mock v0.13.0 h1:/b7DQphGkh29ocNtLh4DGmQxQYA
 github.com/srikanthccv/ClickHouse-go-mock v0.13.0/go.mod h1:LiiyBUdXNwB/1DE9rgK/8q9qjVYsTzg6WXQ/3mU3TeY=
 github.com/stackitcloud/stackit-sdk-go/core v0.21.1 h1:Y/PcAgM7DPYMNqum0MLv4n1mF9ieuevzcCIZYQfm3Ts=
 github.com/stackitcloud/stackit-sdk-go/core v0.21.1/go.mod h1:osMglDby4csGZ5sIfhNyYq1bS1TxIdPY88+skE/kkmI=
+github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs=
+github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
@@ -1159,10 +1150,6 @@ github.com/zeebo/assert v1.3.1 h1:vukIABvugfNMZMQO1ABsyQDJDTVQbn+LWSMy1ol1h6A=
 github.com/zeebo/assert v1.3.1/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-github.com/zitadel/oidc/v3 v3.45.4 h1:GKyWaPRVQ8sCu9XgJ3NgNGtG52FzwVJpzXjIUG2+YrI=
-github.com/zitadel/oidc/v3 v3.45.4/go.mod h1:XALmFXS9/kSom9B6uWin1yJ2WTI/E4Ti5aXJdewAVEs=
-github.com/zitadel/schema v1.3.2 h1:gfJvt7dOMfTmxzhscZ9KkapKo3Nei3B6cAxjav+lyjI=
-github.com/zitadel/schema v1.3.2/go.mod h1:IZmdfF9Wu62Zu6tJJTH3UsArevs3Y4smfJIj3L8fzxw=
 go.etcd.io/etcd/api/v3 v3.5.4/go.mod h1:5GB2vv4A4AOn3yk7MftYGHkUfGtDHnEraIjym4dYz5A=
 go.etcd.io/etcd/client/pkg/v3 v3.5.4/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g=
 go.etcd.io/etcd/client/v2 v2.305.4/go.mod h1:Ud+VUwIi9/uQHOMA+4ekToJ12lTxlv0zB/+DHwTGEbU=
@@ -1928,12 +1915,12 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-k8s.io/api v0.35.2 h1:tW7mWc2RpxW7HS4CoRXhtYHSzme1PN1UjGHJ1bdrtdw=
-k8s.io/api v0.35.2/go.mod h1:7AJfqGoAZcwSFhOjcGM7WV05QxMMgUaChNfLTXDRE60=
-k8s.io/apimachinery v0.35.2 h1:NqsM/mmZA7sHW02JZ9RTtk3wInRgbVxL8MPfzSANAK8=
-k8s.io/apimachinery v0.35.2/go.mod h1:jQCgFZFR1F4Ik7hvr2g84RTJSZegBc8yHgFWKn//hns=
-k8s.io/client-go v0.35.2 h1:YUfPefdGJA4aljDdayAXkc98DnPkIetMl4PrKX97W9o=
-k8s.io/client-go v0.35.2/go.mod h1:4QqEwh4oQpeK8AaefZ0jwTFJw/9kIjdQi0jpKeYvz7g=
+k8s.io/api v0.35.0 h1:iBAU5LTyBI9vw3L5glmat1njFK34srdLmktWwLTprlY=
+k8s.io/api v0.35.0/go.mod h1:AQ0SNTzm4ZAczM03QH42c7l3bih1TbAXYo0DkF8ktnA=
+k8s.io/apimachinery v0.35.0 h1:Z2L3IHvPVv/MJ7xRxHEtk6GoJElaAqDCCU0S6ncYok8=
+k8s.io/apimachinery v0.35.0/go.mod h1:jQCgFZFR1F4Ik7hvr2g84RTJSZegBc8yHgFWKn//hns=
+k8s.io/client-go v0.35.0 h1:IAW0ifFbfQQwQmga0UdoH0yvdqrbwMdq9vIFEhRpxBE=
+k8s.io/client-go v0.35.0/go.mod h1:q2E5AAyqcbeLGPdoRB+Nxe3KYTfPce1Dnu1myQdqz9o=
 k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk=
 k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=
 k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912 h1:Y3gxNAuB0OBLImH611+UDZcmKS3g6CthxToOb37KgwE=

pkg/apiserver/signozapiserver/provider.go

@@ -24,7 +24,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/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -35,34 +34,33 @@ import (
 )
 
 type provider struct {
-	config                      apiserver.Config
-	settings                    factory.ScopedProviderSettings
-	router                      *mux.Router
-	authZ                       *middleware.AuthZ
-	orgHandler                  organization.Handler
-	userHandler                 user.Handler
-	sessionHandler              session.Handler
-	authDomainHandler           authdomain.Handler
-	preferenceHandler           preference.Handler
-	globalHandler               global.Handler
-	promoteHandler              promote.Handler
-	flaggerHandler              flagger.Handler
-	dashboardModule             dashboard.Module
-	dashboardHandler            dashboard.Handler
-	metricsExplorerHandler      metricsexplorer.Handler
-	gatewayHandler              gateway.Handler
-	fieldsHandler               fields.Handler
-	authzHandler                authz.Handler
-	rawDataExportHandler        rawdataexport.Handler
-	zeusHandler                 zeus.Handler
-	querierHandler              querier.Handler
-	serviceAccountHandler       serviceaccount.Handler
-	factoryHandler              factory.Handler
-	cloudIntegrationHandler     cloudintegration.Handler
-	ruleStateHistoryHandler     rulestatehistory.Handler
-	spanAttributeMappingHandler spanattributemapping.Handler
-	alertmanagerHandler         alertmanager.Handler
-	rulerHandler                ruler.Handler
+	config                  apiserver.Config
+	settings                factory.ScopedProviderSettings
+	router                  *mux.Router
+	authZ                   *middleware.AuthZ
+	orgHandler              organization.Handler
+	userHandler             user.Handler
+	sessionHandler          session.Handler
+	authDomainHandler       authdomain.Handler
+	preferenceHandler       preference.Handler
+	globalHandler           global.Handler
+	promoteHandler          promote.Handler
+	flaggerHandler          flagger.Handler
+	dashboardModule         dashboard.Module
+	dashboardHandler        dashboard.Handler
+	metricsExplorerHandler  metricsexplorer.Handler
+	gatewayHandler          gateway.Handler
+	fieldsHandler           fields.Handler
+	authzHandler            authz.Handler
+	rawDataExportHandler    rawdataexport.Handler
+	zeusHandler             zeus.Handler
+	querierHandler          querier.Handler
+	serviceAccountHandler   serviceaccount.Handler
+	factoryHandler          factory.Handler
+	cloudIntegrationHandler cloudintegration.Handler
+	ruleStateHistoryHandler rulestatehistory.Handler
+	alertmanagerHandler     alertmanager.Handler
+	rulerHandler            ruler.Handler
 }
 
 func NewFactory(
@@ -89,7 +87,6 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
@@ -121,7 +118,6 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
-			spanAttributeMappingHandler,
 			alertmanagerHandler,
 			rulerHandler,
 		)
@@ -155,7 +151,6 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) (apiserver.APIServer, error) {
@@ -163,33 +158,32 @@ func newProvider(
 	router := mux.NewRouter().UseEncodedPath()
 
 	provider := &provider{
-		config:                      config,
-		settings:                    settings,
-		router:                      router,
-		orgHandler:                  orgHandler,
-		userHandler:                 userHandler,
-		sessionHandler:              sessionHandler,
-		authDomainHandler:           authDomainHandler,
-		preferenceHandler:           preferenceHandler,
-		globalHandler:               globalHandler,
-		promoteHandler:              promoteHandler,
-		flaggerHandler:              flaggerHandler,
-		dashboardModule:             dashboardModule,
-		dashboardHandler:            dashboardHandler,
-		metricsExplorerHandler:      metricsExplorerHandler,
-		gatewayHandler:              gatewayHandler,
-		fieldsHandler:               fieldsHandler,
-		authzHandler:                authzHandler,
-		rawDataExportHandler:        rawDataExportHandler,
-		zeusHandler:                 zeusHandler,
-		querierHandler:              querierHandler,
-		serviceAccountHandler:       serviceAccountHandler,
-		factoryHandler:              factoryHandler,
-		cloudIntegrationHandler:     cloudIntegrationHandler,
-		ruleStateHistoryHandler:     ruleStateHistoryHandler,
-		spanAttributeMappingHandler: spanAttributeMappingHandler,
-		alertmanagerHandler:         alertmanagerHandler,
-		rulerHandler:                rulerHandler,
+		config:                  config,
+		settings:                settings,
+		router:                  router,
+		orgHandler:              orgHandler,
+		userHandler:             userHandler,
+		sessionHandler:          sessionHandler,
+		authDomainHandler:       authDomainHandler,
+		preferenceHandler:       preferenceHandler,
+		globalHandler:           globalHandler,
+		promoteHandler:          promoteHandler,
+		flaggerHandler:          flaggerHandler,
+		dashboardModule:         dashboardModule,
+		dashboardHandler:        dashboardHandler,
+		metricsExplorerHandler:  metricsExplorerHandler,
+		gatewayHandler:          gatewayHandler,
+		fieldsHandler:           fieldsHandler,
+		authzHandler:            authzHandler,
+		rawDataExportHandler:    rawDataExportHandler,
+		zeusHandler:             zeusHandler,
+		querierHandler:          querierHandler,
+		serviceAccountHandler:   serviceAccountHandler,
+		factoryHandler:          factoryHandler,
+		cloudIntegrationHandler: cloudIntegrationHandler,
+		ruleStateHistoryHandler: ruleStateHistoryHandler,
+		alertmanagerHandler:     alertmanagerHandler,
+		rulerHandler:            rulerHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -290,10 +284,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addSpanAttributeMappingRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addAlertmanagerRoutes(router); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/spanattributemapping.go

@@ -1,175 +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/spanattributemappingtypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addSpanAttributeMappingRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups", handler.New(
-		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListGroups),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanAttributeMappingGroups",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "List span attribute mapping groups",
-			Description:         "Returns all span attribute mapping groups for the authenticated org.",
-			Request:             nil,
-			RequestContentType:  "",
-			RequestQuery:        new(spanattributemappingtypes.ListGroupsQuery),
-			Response:            new(spanattributemappingtypes.ListGroupsResponse),
-			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_attribute_mapping_groups", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateGroup),
-		handler.OpenAPIDef{
-			ID:                  "CreateMappingGroup",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Create a span attribute mapping group",
-			Description:         "Creates a new span attribute mapping group for the org.",
-			Request:             new(spanattributemappingtypes.PostableGroup),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableGroup),
-			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_attribute_mapping_groups/{id}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateGroup),
-		handler.OpenAPIDef{
-			ID:                  "UpdateMappingGroup",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Update a span attribute mapping group",
-			Description:         "Partially updates an existing mapping group's name, condition, or enabled state.",
-			Request:             new(spanattributemappingtypes.UpdatableGroup),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableGroup),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			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_attribute_mapping_groups/{id}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteGroup),
-		handler.OpenAPIDef{
-			ID:                  "DeleteMappingGroup",
-			Tags:                []string{"span-attribute-mapping"},
-			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_attribute_mapping_groups/{id}/mappers", handler.New(
-		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListMappers),
-		handler.OpenAPIDef{
-			ID:                  "ListMappers",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "List span attribute mappers for a group",
-			Description:         "Returns all attribute mappers belonging to a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(spanattributemappingtypes.ListMappersResponse),
-			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_attribute_mapping_groups/{id}/mappers", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateMapper),
-		handler.OpenAPIDef{
-			ID:                  "CreateMapper",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Create a span attribute mapper",
-			Description:         "Adds a new attribute mapper to the specified mapping group.",
-			Request:             new(spanattributemappingtypes.PostableMapper),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableMapper),
-			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_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateMapper),
-		handler.OpenAPIDef{
-			ID:                  "UpdateMapper",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Update a span attribute mapper",
-			Description:         "Partially updates an existing mapper's field context, config, or enabled state.",
-			Request:             new(spanattributemappingtypes.UpdatableMapper),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableMapper),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			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_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteMapper),
-		handler.OpenAPIDef{
-			ID:                  "DeleteMapper",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Delete a span attribute 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/metricsexplorer/implmetricsexplorer/module.go

@@ -1122,7 +1122,7 @@ func (m *module) computeTimeseriesTreemap(ctx context.Context, req *metricsexplo
 	)
 	finalSB.From("__metric_totals mt")
 	finalSB.Join("__total_time_series tts", "1=1")
-	finalSB.OrderByDesc("percentage")
+	finalSB.OrderBy("percentage").Desc()
 	finalSB.Limit(req.Limit)
 
 	query, args := finalSB.BuildWithFlavor(sqlbuilder.ClickHouse)

pkg/modules/spanattributemapping/implspanattributemapping/handler.go

@@ -1,350 +0,0 @@
-package implspanattributemapping
-
-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/spanattributemapping"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module           spanattributemapping.Module
-	providerSettings factory.ProviderSettings
-}
-
-func NewHandler(module spanattributemapping.Module, providerSettings factory.ProviderSettings) spanattributemapping.Handler {
-	return &handler{module: module, providerSettings: providerSettings}
-}
-
-// ListGroups handles GET /api/v1/ai-o11y/mapping/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var q spanattributemappingtypes.ListGroupsQuery
-	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
-	}
-
-	items := make([]*spanattributemappingtypes.GettableGroup, len(groups))
-	for i, g := range groups {
-		items[i] = spanattributemappingtypes.NewGettableGroup(g)
-	}
-
-	render.Success(rw, http.StatusOK, &spanattributemappingtypes.ListGroupsResponse{Items: items})
-}
-
-// CreateGroup handles POST /api/v1/ai-o11y/mapping/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.PostableGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	group, err := h.module.CreateGroup(ctx, orgID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, spanattributemappingtypes.NewGettableGroup(group))
-}
-
-// UpdateGroup handles PUT /api/v1/ai-o11y/mapping/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.UpdatableGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	group, err := h.module.UpdateGroup(ctx, orgID, id, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableGroup(group))
-}
-
-// DeleteGroup handles DELETE /api/v1/ai-o11y/mapping/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	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/ai-o11y/mapping/groups/{id}/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	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
-	}
-
-	items := make([]*spanattributemappingtypes.GettableMapper, len(mappers))
-	for i, m := range mappers {
-		items[i] = spanattributemappingtypes.NewGettableMapper(m)
-	}
-
-	render.Success(rw, http.StatusOK, &spanattributemappingtypes.ListMappersResponse{Items: items})
-}
-
-// CreateMapper handles POST /api/v1/ai-o11y/mapping/groups/{id}/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.PostableMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapper, err := h.module.CreateMapper(ctx, orgID, groupID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, spanattributemappingtypes.NewGettableMapper(mapper))
-}
-
-// UpdateMapper handles PUT /api/v1/ai-o11y/mapping/groups/{groupId}/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	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(spanattributemappingtypes.UpdatableMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapper, err := h.module.UpdateMapper(ctx, orgID, groupID, mapperID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableMapper(mapper))
-}
-
-// DeleteMapper handles DELETE /api/v1/ai-o11y/mapping/groups/{groupId}/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, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	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"]
-	if raw == "" {
-		raw = vars["id"]
-	}
-	if raw == "" {
-		return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "group id is missing from the path")
-	}
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "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"]
-	if raw == "" {
-		return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "mapper id is missing from the path")
-	}
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "mapper id is not a valid uuid")
-	}
-	return id, nil
-}

pkg/modules/spanattributemapping/spanattributemapping.go

@@ -1,41 +0,0 @@
-package spanattributemapping
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
-	"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 *spanattributemappingtypes.ListGroupsQuery) ([]*spanattributemappingtypes.Group, error)
-	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Group, error)
-	CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, req *spanattributemappingtypes.PostableGroup) (*spanattributemappingtypes.Group, error)
-	UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, req *spanattributemappingtypes.UpdatableGroup) (*spanattributemappingtypes.Group, error)
-	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spanattributemappingtypes.Mapper, error)
-	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Mapper, error)
-	CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, req *spanattributemappingtypes.PostableMapper) (*spanattributemappingtypes.Mapper, error)
-	UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, req *spanattributemappingtypes.UpdatableMapper) (*spanattributemappingtypes.Mapper, 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/signoz/handler.go

@@ -3,6 +3,8 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/signozauthzapi"
@@ -34,43 +36,38 @@ 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/spanattributemapping"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping/implspanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
 
 type Handlers struct {
-	SavedView                  savedview.Handler
-	Apdex                      apdex.Handler
-	Dashboard                  dashboard.Handler
-	QuickFilter                quickfilter.Handler
-	TraceFunnel                tracefunnel.Handler
-	RawDataExport              rawdataexport.Handler
-	SpanPercentile             spanpercentile.Handler
-	Services                   services.Handler
-	MetricsExplorer            metricsexplorer.Handler
-	Global                     global.Handler
-	FlaggerHandler             flagger.Handler
-	GatewayHandler             gateway.Handler
-	Fields                     fields.Handler
-	AuthzHandler               authz.Handler
-	ZeusHandler                zeus.Handler
-	QuerierHandler             querier.Handler
-	ServiceAccountHandler      serviceaccount.Handler
-	RegistryHandler            factory.Handler
-	CloudIntegrationHandler    cloudintegration.Handler
-	RuleStateHistory           rulestatehistory.Handler
-	SpanAttributeMappingHander spanattributemapping.Handler
-	AlertmanagerHandler        alertmanager.Handler
-	RulerHandler               ruler.Handler
+	SavedView               savedview.Handler
+	Apdex                   apdex.Handler
+	Dashboard               dashboard.Handler
+	QuickFilter             quickfilter.Handler
+	TraceFunnel             tracefunnel.Handler
+	RawDataExport           rawdataexport.Handler
+	SpanPercentile          spanpercentile.Handler
+	Services                services.Handler
+	MetricsExplorer         metricsexplorer.Handler
+	Global                  global.Handler
+	FlaggerHandler          flagger.Handler
+	GatewayHandler          gateway.Handler
+	Fields                  fields.Handler
+	AuthzHandler            authz.Handler
+	ZeusHandler             zeus.Handler
+	QuerierHandler          querier.Handler
+	ServiceAccountHandler   serviceaccount.Handler
+	RegistryHandler         factory.Handler
+	CloudIntegrationHandler cloudintegration.Handler
+	RuleStateHistory        rulestatehistory.Handler
+	AlertmanagerHandler     alertmanager.Handler
+	RulerHandler            ruler.Handler
 }
 
 func NewHandlers(
@@ -90,28 +87,27 @@ func NewHandlers(
 	rulerService ruler.Ruler,
 ) Handlers {
 	return Handlers{
-		SavedView:                  implsavedview.NewHandler(modules.SavedView),
-		Apdex:                      implapdex.NewHandler(modules.Apdex),
-		Dashboard:                  impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
-		QuickFilter:                implquickfilter.NewHandler(modules.QuickFilter),
-		TraceFunnel:                impltracefunnel.NewHandler(modules.TraceFunnel),
-		RawDataExport:              implrawdataexport.NewHandler(modules.RawDataExport),
-		Services:                   implservices.NewHandler(modules.Services),
-		MetricsExplorer:            implmetricsexplorer.NewHandler(modules.MetricsExplorer),
-		SpanPercentile:             implspanpercentile.NewHandler(modules.SpanPercentile),
-		Global:                     signozglobal.NewHandler(global),
-		FlaggerHandler:             flagger.NewHandler(flaggerService),
-		GatewayHandler:             gateway.NewHandler(gatewayService),
-		Fields:                     implfields.NewHandler(providerSettings, telemetryMetadataStore),
-		AuthzHandler:               signozauthzapi.NewHandler(authz),
-		ZeusHandler:                zeus.NewHandler(zeusService, licensing),
-		QuerierHandler:             querierHandler,
-		ServiceAccountHandler:      implserviceaccount.NewHandler(modules.ServiceAccount),
-		RegistryHandler:            registryHandler,
-		RuleStateHistory:           implrulestatehistory.NewHandler(modules.RuleStateHistory),
-		CloudIntegrationHandler:    implcloudintegration.NewHandler(modules.CloudIntegration),
-		SpanAttributeMappingHander: implspanattributemapping.NewHandler(nil, providerSettings), // todo(nitya): will update this in future PR
-		AlertmanagerHandler:        signozalertmanager.NewHandler(alertmanagerService),
-		RulerHandler:               signozruler.NewHandler(rulerService),
+		SavedView:               implsavedview.NewHandler(modules.SavedView),
+		Apdex:                   implapdex.NewHandler(modules.Apdex),
+		Dashboard:               impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
+		QuickFilter:             implquickfilter.NewHandler(modules.QuickFilter),
+		TraceFunnel:             impltracefunnel.NewHandler(modules.TraceFunnel),
+		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
+		Services:                implservices.NewHandler(modules.Services),
+		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
+		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
+		Global:                  signozglobal.NewHandler(global),
+		FlaggerHandler:          flagger.NewHandler(flaggerService),
+		GatewayHandler:          gateway.NewHandler(gatewayService),
+		Fields:                  implfields.NewHandler(providerSettings, telemetryMetadataStore),
+		AuthzHandler:            signozauthzapi.NewHandler(authz),
+		ZeusHandler:             zeus.NewHandler(zeusService, licensing),
+		QuerierHandler:          querierHandler,
+		ServiceAccountHandler:   implserviceaccount.NewHandler(modules.ServiceAccount),
+		RegistryHandler:         registryHandler,
+		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
+		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
+		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
+		RulerHandler:            signozruler.NewHandler(rulerService),
 	}
 }

pkg/signoz/openapi.go

@@ -29,7 +29,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/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -72,7 +71,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
-		struct{ spanattributemapping.Handler }{},
 		struct{ alertmanager.Handler }{},
 		struct{ ruler.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})

pkg/signoz/provider.go

@@ -3,6 +3,8 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
+	"github.com/SigNoz/signoz/pkg/auditor"
+	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/rulebasednotification"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
@@ -10,8 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/analytics/segmentanalytics"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
@@ -226,6 +226,8 @@ func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter orga
 	)
 }
 
+
+
 func NewEmailingProviderFactories() factory.NamedMap[factory.ProviderFactory[emailing.Emailing, emailing.Config]] {
 	return factory.MustNewNamedMap(
 		noopemailing.NewFactory(),
@@ -279,7 +281,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
-			handlers.SpanAttributeMappingHander,
 			handlers.AlertmanagerHandler,
 			handlers.RulerHandler,
 		),

pkg/types/dashboardtypes/dashboard_v2.go

@@ -1,262 +0,0 @@
-package dashboardtypes
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"slices"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/go-playground/validator/v10"
-	v1 "github.com/perses/perses/pkg/model/api/v1"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-	"github.com/perses/perses/pkg/model/api/v1/dashboard"
-)
-
-// StorableDashboardDataV2 wraps v1.DashboardSpec (Perses) with additional SigNoz-specific fields.
-//
-// We embed DashboardSpec (not v1.Dashboard) to avoid carrying Perses's Metadata
-// (Name, Project, CreatedAt, UpdatedAt, Tags, Version) and Kind field. SigNoz
-// manages identity (ID), timestamps (TimeAuditable), and multi-tenancy (OrgID)
-// separately on StorableDashboardV2/DashboardV2.
-//
-// The following v1 request fields map to locations inside v1.DashboardSpec:
-//   - title       → Display.Name          (common.Display)
-//   - description → Display.Description   (common.Display)
-//
-// Fields that have no Perses equivalent will be added in this wrapper (like image, uploadGrafana, etc.)
-type StorableDashboardDataV2 = v1.DashboardSpec
-
-// UnmarshalAndValidateDashboardV2JSON unmarshals the JSON into a StorableDashboardDataV2
-// (= PostableDashboardV2 = UpdatableDashboardV2) and validates plugin kinds and specs.
-func UnmarshalAndValidateDashboardV2JSON(data []byte) (*StorableDashboardDataV2, error) {
-	var d StorableDashboardDataV2
-	// Note: DashboardSpec has a custom UnmarshalJSON which prevents
-	// DisallowUnknownFields from working at the top level. Unknown
-	// fields in plugin specs are still rejected by validateAndNormalizePluginSpec.
-	if err := json.Unmarshal(data, &d); err != nil {
-		return nil, err
-	}
-	if err := validateDashboardV2(d); err != nil {
-		return nil, err
-	}
-	return &d, nil
-}
-
-// Plugin kind → spec type factory. Each value is a pointer to the zero value of the
-// expected spec struct. validatePluginSpec marshals plugin.Spec back to JSON and
-// unmarshals into the typed struct to catch field-level errors.
-var (
-	panelPluginSpecs = map[PanelPluginKind]func() any{
-		PanelKindTimeSeries: func() any { return new(TimeSeriesPanelSpec) },
-		PanelKindBarChart:   func() any { return new(BarChartPanelSpec) },
-		PanelKindNumber:     func() any { return new(NumberPanelSpec) },
-		PanelKindPieChart:   func() any { return new(PieChartPanelSpec) },
-		PanelKindTable:      func() any { return new(TablePanelSpec) },
-		PanelKindHistogram:  func() any { return new(HistogramPanelSpec) },
-		PanelKindList:       func() any { return new(ListPanelSpec) },
-	}
-	queryPluginSpecs = map[QueryPluginKind]func() any{
-		QueryKindBuilder:       func() any { return new(BuilderQuerySpec) },
-		QueryKindComposite:     func() any { return new(CompositeQuerySpec) },
-		QueryKindFormula:       func() any { return new(FormulaSpec) },
-		QueryKindPromQL:        func() any { return new(PromQLQuerySpec) },
-		QueryKindClickHouseSQL: func() any { return new(ClickHouseSQLQuerySpec) },
-		QueryKindTraceOperator: func() any { return new(TraceOperatorSpec) },
-	}
-	variablePluginSpecs = map[VariablePluginKind]func() any{
-		VariableKindDynamic: func() any { return new(DynamicVariableSpec) },
-		VariableKindQuery:   func() any { return new(QueryVariableSpec) },
-		VariableKindCustom:  func() any { return new(CustomVariableSpec) },
-		VariableKindTextbox: func() any { return new(TextboxVariableSpec) },
-	}
-	datasourcePluginSpecs = map[DatasourcePluginKind]func() any{
-		DatasourceKindSigNoz: func() any { return new(struct{}) },
-	}
-
-	// allowedQueryKinds maps each panel plugin kind to the query plugin
-	// kinds it supports. Composite sub-query types are mapped to these
-	// same kind strings via compositeSubQueryTypeToPluginKind.
-	allowedQueryKinds = map[PanelPluginKind][]QueryPluginKind{
-		PanelKindTimeSeries: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindBarChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindNumber:     {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindHistogram:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindTable:      {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindList:       {QueryKindBuilder},
-	}
-
-	// compositeSubQueryTypeToPluginKind maps CompositeQuery sub-query type
-	// strings to the equivalent top-level query plugin kind for validation.
-	compositeSubQueryTypeToPluginKind = map[qb.QueryType]QueryPluginKind{
-		qb.QueryTypeBuilder:       QueryKindBuilder,
-		qb.QueryTypeFormula:       QueryKindFormula,
-		qb.QueryTypeTraceOperator: QueryKindTraceOperator,
-		qb.QueryTypePromQL:        QueryKindPromQL,
-		qb.QueryTypeClickHouseSQL: QueryKindClickHouseSQL,
-	}
-)
-
-func validateDashboardV2(d StorableDashboardDataV2) error {
-	for name, ds := range d.Datasources {
-		if err := validateDatasourcePlugin(&ds.Plugin, fmt.Sprintf("spec.datasources.%s.plugin", name)); err != nil {
-			return err
-		}
-	}
-
-	for i, v := range d.Variables {
-		if err := validateVariablePlugin(v, fmt.Sprintf("spec.variables[%d]", i)); err != nil {
-			return err
-		}
-	}
-
-	for key, panel := range d.Panels {
-		if panel == nil {
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.panels.%s: panel must not be null", key)
-		}
-		path := fmt.Sprintf("spec.panels.%s", key)
-		if err := validatePanelPlugin(&panel.Spec.Plugin, path+".spec.plugin"); err != nil {
-			return err
-		}
-		panelKind := PanelPluginKind(panel.Spec.Plugin.Kind)
-		allowed := allowedQueryKinds[panelKind]
-		for qi := range panel.Spec.Queries {
-			queryPath := fmt.Sprintf("%s.spec.queries[%d].spec.plugin", path, qi)
-			if err := validateQueryPlugin(&panel.Spec.Queries[qi].Spec.Plugin, queryPath); err != nil {
-				return err
-			}
-			if err := validateQueryAllowedForPanel(panel.Spec.Queries[qi].Spec.Plugin, allowed, panelKind, queryPath); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func validateDatasourcePlugin(plugin *common.Plugin, path string) error {
-	kind := DatasourcePluginKind(plugin.Kind)
-	factory, ok := datasourcePluginSpecs[kind]
-	if !ok {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-			"%s: unknown datasource plugin kind %q; allowed values: %s", path, kind, formatEnum(kind.Enum()))
-	}
-	return validateAndNormalizePluginSpec(plugin, factory, path)
-}
-
-func validateVariablePlugin(v dashboard.Variable, path string) error {
-	switch spec := v.Spec.(type) {
-	case *dashboard.ListVariableSpec:
-		pluginPath := path + ".spec.plugin"
-		kind := VariablePluginKind(spec.Plugin.Kind)
-		factory, ok := variablePluginSpecs[kind]
-		if !ok {
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-				"%s: unknown variable plugin kind %q; allowed values: %s", pluginPath, kind, formatEnum(kind.Enum()))
-		}
-		return validateAndNormalizePluginSpec(&spec.Plugin, factory, pluginPath)
-	case *dashboard.TextVariableSpec:
-		// TextVariables have no plugin, nothing to validate.
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: unsupported variable kind %q", path, v.Kind)
-	}
-}
-
-func validatePanelPlugin(plugin *common.Plugin, path string) error {
-	kind := PanelPluginKind(plugin.Kind)
-	factory, ok := panelPluginSpecs[kind]
-	if !ok {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-			"%s: unknown panel plugin kind %q; allowed values: %s", path, kind, formatEnum(kind.Enum()))
-	}
-	return validateAndNormalizePluginSpec(plugin, factory, path)
-}
-
-func validateQueryPlugin(plugin *common.Plugin, path string) error {
-	kind := QueryPluginKind(plugin.Kind)
-	factory, ok := queryPluginSpecs[kind]
-	if !ok {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-			"%s: unknown query plugin kind %q; allowed values: %s", path, kind, formatEnum(kind.Enum()))
-	}
-	return validateAndNormalizePluginSpec(plugin, factory, path)
-}
-
-func formatEnum(values []any) string {
-	parts := make([]string, len(values))
-	for i, v := range values {
-		parts[i] = fmt.Sprintf("`%v`", v)
-	}
-	return strings.Join(parts, ", ")
-}
-
-// validateAndNormalizePluginSpec validates the plugin spec and writes the typed
-// struct (with defaults) back into plugin.Spec so that DB storage and API
-// responses contain normalized values.
-func validateAndNormalizePluginSpec(plugin *common.Plugin, factory func() any, path string) error {
-	if plugin.Kind == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: plugin kind is required", path)
-	}
-	if plugin.Spec == nil {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: plugin spec is required", path)
-	}
-	// Re-marshal the spec and unmarshal into the typed struct.
-	specJSON, err := json.Marshal(plugin.Spec)
-	if err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.spec", path)
-	}
-	target := factory()
-	decoder := json.NewDecoder(bytes.NewReader(specJSON))
-	decoder.DisallowUnknownFields()
-	if err := decoder.Decode(target); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.spec", path)
-	}
-	if err := validator.New().Struct(target); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.spec", path)
-	}
-	// Write the typed struct back so defaults are included.
-	plugin.Spec = target
-	return nil
-}
-
-// validateQueryAllowedForPanel checks that the query plugin kind is permitted
-// for the given panel. For composite queries it recurses into sub-queries.
-func validateQueryAllowedForPanel(plugin common.Plugin, allowed []QueryPluginKind, panelKind PanelPluginKind, path string) error {
-	queryKind := QueryPluginKind(plugin.Kind)
-	if !slices.Contains(allowed, queryKind) {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-			"%s: query kind %q is not supported by panel kind %q", path, queryKind, panelKind)
-	}
-
-	// For composite queries, validate each sub-query type.
-	if queryKind == QueryKindComposite && plugin.Spec != nil {
-		specJSON, err := json.Marshal(plugin.Spec)
-		if err != nil {
-			return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.spec", path)
-		}
-		var composite struct {
-			Queries []struct {
-				Type qb.QueryType `json:"type"`
-			} `json:"queries"`
-		}
-		if err := json.Unmarshal(specJSON, &composite); err != nil {
-			return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.spec", path)
-		}
-		for si, sub := range composite.Queries {
-			pluginKind, ok := compositeSubQueryTypeToPluginKind[sub.Type]
-			if !ok {
-				continue
-			}
-			if !slices.Contains(allowed, pluginKind) {
-				return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-					"%s.spec.queries[%d]: sub-query type %q is not supported by panel kind %q",
-					path, si, sub.Type, panelKind)
-			}
-		}
-	}
-	return nil
-}

pkg/types/dashboardtypes/dashboard_v2_test.go

@@ -1,889 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestValidateBigExample(t *testing.T) {
-	data, err := os.ReadFile("testdata/perses.json")
-	require.NoError(t, err, "reading example file")
-	_, err = UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "expected valid dashboard")
-}
-
-func TestValidateDashboardWithSections(t *testing.T) {
-	data, err := os.ReadFile("testdata/perses_with_sections.json")
-	require.NoError(t, err, "reading example file")
-	_, err = UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "expected valid dashboard")
-}
-
-func TestInvalidateNotAJSON(t *testing.T) {
-	_, err := UnmarshalAndValidateDashboardV2JSON([]byte("not json"))
-	require.Error(t, err, "expected error for invalid JSON")
-}
-
-func TestValidateEmptySpec(t *testing.T) {
-	// no variables no panels
-	data := []byte(`{}`)
-	_, err := UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "expected valid")
-}
-
-func TestValidateOnlyVariables(t *testing.T) {
-	data := []byte(`{
-		"variables": [
-			{
-				"kind": "ListVariable",
-				"spec": {
-					"name": "service",
-					"allowAllValue": true,
-					"allowMultiple": false,
-					"plugin": {
-						"kind": "signoz/DynamicVariable",
-						"spec": {
-							"name": "service.name",
-							"signal": "metrics"
-						}
-					}
-				}
-			},
-			{
-				"kind": "TextVariable",
-				"spec": {
-					"name": "mytext",
-					"value": "default",
-					"plugin": {
-						"kind": "signoz/TextboxVariable",
-						"spec": {}
-					}
-				}
-			}
-		],
-		"layouts": []
-	}`)
-	_, err := UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "expected valid")
-}
-
-func TestInvalidateUnknownPluginKind(t *testing.T) {
-	tests := []struct {
-		name        string
-		data        string
-		wantContain string
-	}{
-		{
-			name: "unknown panel plugin",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {"kind": "NonExistentPanel", "spec": {}}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "NonExistentPanel",
-		},
-		{
-			name: "unknown query plugin",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-							"queries": [{
-								"kind": "TimeSeriesQuery",
-								"spec": {
-									"plugin": {"kind": "FakeQueryPlugin", "spec": {}}
-								}
-							}]
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "FakeQueryPlugin",
-		},
-		{
-			name: "unknown variable plugin",
-			data: `{
-				"variables": [{
-					"kind": "ListVariable",
-					"spec": {
-						"name": "v1",
-						"allowAllValue": false,
-						"allowMultiple": false,
-						"plugin": {"kind": "FakeVariable", "spec": {}}
-					}
-				}],
-				"layouts": []
-			}`,
-			wantContain: "FakeVariable",
-		},
-		{
-			name: "unknown datasource plugin",
-			data: `{
-				"datasources": {
-					"ds1": {
-						"default": true,
-						"plugin": {"kind": "FakeDatasource", "spec": {}}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "FakeDatasource",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON([]byte(tt.data))
-			require.Error(t, err, "expected error containing %q, got nil", tt.wantContain)
-			require.Contains(t, err.Error(), tt.wantContain, "error should mention %q", tt.wantContain)
-		})
-	}
-}
-
-func TestInvalidateOneInvalidPanel(t *testing.T) {
-	data := []byte(`{
-		"panels": {
-			"good": {
-				"kind": "Panel",
-				"spec": {"plugin": {"kind": "signoz/NumberPanel", "spec": {}}}
-			},
-			"bad": {
-				"kind": "Panel",
-				"spec": {"plugin": {"kind": "FakePanel", "spec": {}}}
-			}
-		},
-		"layouts": []
-	}`)
-	_, err := UnmarshalAndValidateDashboardV2JSON(data)
-	require.Error(t, err, "expected error for invalid panel plugin kind")
-	require.Contains(t, err.Error(), "FakePanel", "error should mention FakePanel")
-}
-
-func TestRejectUnknownFieldsInPluginSpec(t *testing.T) {
-	tests := []struct {
-		name        string
-		data        string
-		wantContain string
-	}{
-		{
-			name: "unknown field in panel spec",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"bogusField": true}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "bogusField",
-		},
-		{
-			name: "unknown field in query spec",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-							"queries": [{
-								"kind": "TimeSeriesQuery",
-								"spec": {
-									"plugin": {
-										"kind": "signoz/PromQLQuery",
-										"spec": {"name": "A", "query": "up", "unknownThing": 42}
-									}
-								}
-							}]
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "unknownThing",
-		},
-		{
-			name: "unknown field in variable spec",
-			data: `{
-				"variables": [{
-					"kind": "ListVariable",
-					"spec": {
-						"name": "v",
-						"allowAllValue": false,
-						"allowMultiple": false,
-						"plugin": {
-							"kind": "signoz/DynamicVariable",
-							"spec": {"name": "service.name", "signal": "metrics", "extraField": "bad"}
-						}
-					}
-				}],
-				"layouts": []
-			}`,
-			wantContain: "extraField",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON([]byte(tt.data))
-			require.Error(t, err, "expected error for unknown field")
-			require.Contains(t, err.Error(), tt.wantContain, "error should mention %q", tt.wantContain)
-		})
-	}
-}
-
-func TestInvalidateWrongFieldTypeInPluginSpec(t *testing.T) {
-	tests := []struct {
-		name        string
-		data        string
-		wantContain string
-	}{
-		{
-			name: "wrong type on panel plugin field",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"visualization": {"fillSpans": "notabool"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "fillSpans",
-		},
-		{
-			name: "wrong type on query plugin field",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-							"queries": [{
-								"kind": "TimeSeriesQuery",
-								"spec": {
-									"plugin": {
-										"kind": "signoz/PromQLQuery",
-										"spec": {"name": "A", "query": 123}
-									}
-								}
-							}]
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "",
-		},
-		{
-			name: "wrong type on variable plugin field",
-			data: `{
-				"variables": [{
-					"kind": "ListVariable",
-					"spec": {
-						"name": "v",
-						"allowAllValue": false,
-						"allowMultiple": false,
-						"plugin": {
-							"kind": "signoz/DynamicVariable",
-							"spec": {"name": 123, "signal": "metrics"}
-						}
-					}
-				}],
-				"layouts": []
-			}`,
-			wantContain: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON([]byte(tt.data))
-			require.Error(t, err, "expected validation error")
-			if tt.wantContain != "" {
-				require.Contains(t, err.Error(), tt.wantContain, "error should mention %q", tt.wantContain)
-			}
-		})
-	}
-}
-
-func TestInvalidateBadPanelSpecValues(t *testing.T) {
-	tests := []struct {
-		name        string
-		data        string
-		wantContain string
-	}{
-		{
-			name: "bad signal in builder query",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {}
-							},
-							"queries": [{
-								"kind": "TimeSeriesQuery",
-								"spec": {
-									"plugin": {
-										"kind": "signoz/BuilderQuery",
-										"spec": {"signal": "foo"}
-									}
-								}
-							}]
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "signal",
-		},
-		{
-			name: "bad line interpolation",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"chartAppearance": {"lineInterpolation": "cubic"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "line interpolation",
-		},
-		{
-			name: "bad line style",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"chartAppearance": {"lineStyle": "dotted"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "line style",
-		},
-		{
-			name: "bad fill mode",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"chartAppearance": {"fillMode": "striped"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "fill mode",
-		},
-		{
-			name: "bad spanGaps fillLessThan",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"chartAppearance": {"spanGaps": {"fillLessThan": "notaduration"}}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "duration",
-		},
-		{
-			name: "bad time preference",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"visualization": {"timePreference": "last2Hr"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "timePreference",
-		},
-		{
-			name: "bad legend position",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/BarChartPanel",
-								"spec": {"legend": {"position": "top"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "legend position",
-		},
-		{
-			name: "bad threshold format",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/NumberPanel",
-								"spec": {"thresholds": [{"value": 100, "operator": ">", "color": "Red", "format": "Color"}]}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "threshold format",
-		},
-		{
-			name: "bad comparison operator",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/NumberPanel",
-								"spec": {"thresholds": [{"value": 100, "operator": "!=", "color": "Red", "format": "text"}]}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "comparison operator",
-		},
-		{
-			name: "bad precision",
-			data: `{
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"plugin": {
-								"kind": "signoz/TimeSeriesPanel",
-								"spec": {"formatting": {"decimalPrecision": "9"}}
-							}
-						}
-					}
-				},
-				"layouts": []
-			}`,
-			wantContain: "precision",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON([]byte(tt.data))
-			require.Error(t, err, "expected error containing %q, got nil", tt.wantContain)
-			require.Contains(t, err.Error(), tt.wantContain, "error should mention %q", tt.wantContain)
-		})
-	}
-}
-
-func TestValidateRequiredFields(t *testing.T) {
-	wrapVariable := func(pluginKind, pluginSpec string) string {
-		return `{
-			"variables": [{
-				"kind": "ListVariable",
-				"spec": {
-					"name": "v",
-					"allowAllValue": false,
-					"allowMultiple": false,
-					"plugin": {"kind": "` + pluginKind + `", "spec": ` + pluginSpec + `}
-				}
-			}],
-			"layouts": []
-		}`
-	}
-	wrapPanel := func(panelKind, panelSpec string) string {
-		return `{
-			"panels": {
-				"p1": {
-					"kind": "Panel",
-					"spec": {
-						"plugin": {"kind": "` + panelKind + `", "spec": ` + panelSpec + `}
-					}
-				}
-			},
-			"layouts": []
-		}`
-	}
-
-	tests := []struct {
-		name        string
-		data        string
-		wantContain string
-	}{
-		{
-			name:        "DynamicVariable missing name",
-			data:        wrapVariable("signoz/DynamicVariable", `{"signal": "metrics"}`),
-			wantContain: "Name",
-		},
-		{
-			name:        "QueryVariable missing queryValue",
-			data:        wrapVariable("signoz/QueryVariable", `{}`),
-			wantContain: "QueryValue",
-		},
-		{
-			name:        "CustomVariable missing customValue",
-			data:        wrapVariable("signoz/CustomVariable", `{}`),
-			wantContain: "CustomValue",
-		},
-		{
-			name:        "ThresholdWithLabel missing value",
-			data:        wrapPanel("signoz/TimeSeriesPanel", `{"thresholds": [{"color": "Red", "label": "high"}]}`),
-			wantContain: "Value",
-		},
-		{
-			name:        "ThresholdWithLabel missing color",
-			data:        wrapPanel("signoz/TimeSeriesPanel", `{"thresholds": [{"value": 100, "label": "high", "color": ""}]}`),
-			wantContain: "Color",
-		},
-		{
-			name:        "ThresholdWithLabel missing label",
-			data:        wrapPanel("signoz/TimeSeriesPanel", `{"thresholds": [{"value": 100, "color": "Red", "label": ""}]}`),
-			wantContain: "Label",
-		},
-		{
-			name:        "ComparisonThreshold missing value",
-			data:        wrapPanel("signoz/NumberPanel", `{"thresholds": [{"operator": ">", "format": "text", "color": "Red"}]}`),
-			wantContain: "Value",
-		},
-		{
-			name:        "ComparisonThreshold missing color",
-			data:        wrapPanel("signoz/NumberPanel", `{"thresholds": [{"value": 100, "operator": ">", "format": "text", "color": ""}]}`),
-			wantContain: "Color",
-		},
-		{
-			name:        "TableThreshold missing columnName",
-			data:        wrapPanel("signoz/TablePanel", `{"thresholds": [{"value": 100, "operator": ">", "format": "text", "color": "Red", "columnName": ""}]}`),
-			wantContain: "ColumnName",
-		},
-		{
-			name:        "SelectField missing name",
-			data:        wrapPanel("signoz/ListPanel", `{"selectFields": [{"name": ""}]}`),
-			wantContain: "Name",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON([]byte(tt.data))
-			require.Error(t, err, "expected error containing %q, got nil", tt.wantContain)
-			require.Contains(t, err.Error(), tt.wantContain, "error should mention %q", tt.wantContain)
-		})
-	}
-}
-
-func TestTimeSeriesPanelDefaults(t *testing.T) {
-	data := []byte(`{
-		"panels": {
-			"p1": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {
-						"kind": "signoz/TimeSeriesPanel",
-						"spec": {}
-					}
-				}
-			}
-		},
-		"layouts": []
-	}`)
-	d, err := UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "unmarshal and validate failed")
-
-	// After validation+normalization, the plugin spec should be a typed struct.
-	require.IsType(t, &TimeSeriesPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)
-	spec := d.Panels["p1"].Spec.Plugin.Spec.(*TimeSeriesPanelSpec)
-
-	require.Equal(t, "2", spec.Formatting.DecimalPrecision.ValueOrDefault(), "expected DecimalPrecision default 2")
-	require.Equal(t, "spline", spec.ChartAppearance.LineInterpolation.ValueOrDefault(), "expected LineInterpolation default spline")
-	require.Equal(t, "solid", spec.ChartAppearance.LineStyle.ValueOrDefault(), "expected LineStyle default solid")
-	require.Equal(t, "solid", spec.ChartAppearance.FillMode.ValueOrDefault(), "expected FillMode default solid")
-	require.False(t, spec.ChartAppearance.SpanGaps.FillOnlyBelow, "expected SpanGaps.FillOnlyBelow default false")
-	require.Equal(t, "global_time", spec.Visualization.TimePreference.ValueOrDefault(), "expected TimePreference default global_time")
-	require.Equal(t, "bottom", spec.Legend.Position.ValueOrDefault(), "expected LegendPosition default bottom")
-
-	// Re-marshal the full dashboard (what we'd store in DB / return in API response)
-	// and verify the output contains the default values.
-	output, err := json.Marshal(d)
-	require.NoError(t, err, "marshal dashboard failed")
-	outputStr := string(output)
-	for field, want := range map[string]string{
-		"decimalPrecision":  `"2"`,
-		"lineInterpolation": `"spline"`,
-		"lineStyle":         `"solid"`,
-		"fillMode":          `"solid"`,
-		"timePreference":    `"global_time"`,
-		"position":          `"bottom"`,
-	} {
-		assert.Contains(t, outputStr, `"`+field+`":`+want, "expected stored/response JSON to contain %s:%s", field, want)
-	}
-}
-
-func TestNumberPanelDefaults(t *testing.T) {
-	data := []byte(`{
-		"panels": {
-			"p1": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {
-						"kind": "signoz/NumberPanel",
-						"spec": {"thresholds": [{"value": 100, "color": "Red"}]}
-					}
-				}
-			}
-		},
-		"layouts": []
-	}`)
-	d, err := UnmarshalAndValidateDashboardV2JSON(data)
-	require.NoError(t, err, "unmarshal and validate failed")
-
-	require.IsType(t, &NumberPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)
-	spec := d.Panels["p1"].Spec.Plugin.Spec.(*NumberPanelSpec)
-
-	require.Len(t, spec.Thresholds, 1, "expected 1 threshold")
-	require.Equal(t, ">", spec.Thresholds[0].Operator.ValueOrDefault(), "expected ComparisonOperator default >")
-	require.Equal(t, "text", spec.Thresholds[0].Format.ValueOrDefault(), "expected ThresholdFormat default text")
-
-	// Marshal back and verify defaults in JSON output.
-	output, err := json.Marshal(d)
-	require.NoError(t, err, "marshal dashboard failed")
-	outputStr := string(output)
-	assert.Contains(t, outputStr, `"format":"text"`, "expected stored/response JSON to contain format:text")
-	// Go's json.Marshal escapes ">" as "\u003e", so check for both forms.
-	assert.True(t,
-		strings.Contains(outputStr, `"operator":">"`) || strings.Contains(outputStr, `"operator":"\u003e"`),
-		"expected stored/response JSON to contain operator:>, got: %s", outputStr)
-}
-
-// TestStorageRoundTrip simulates the future DB store/load cycle:
-// marshal the normalized dashboard to JSON (what would be written to DB),
-// then unmarshal it back (what would be read from DB), and verify defaults survive.
-func TestStorageRoundTrip(t *testing.T) {
-	input := []byte(`{
-		"panels": {
-			"p1": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {
-						"kind": "signoz/TimeSeriesPanel",
-						"spec": {}
-					}
-				}
-			},
-			"p2": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {
-						"kind": "signoz/NumberPanel",
-						"spec": {"thresholds": [{"value": 100, "color": "Red"}]}
-					}
-				}
-			}
-		},
-		"layouts": []
-	}`)
-
-	// Step 1: Unmarshal + validate + normalize (what the API handler does).
-	d, err := UnmarshalAndValidateDashboardV2JSON(input)
-	require.NoError(t, err, "unmarshal and validate failed")
-
-	// Step 1.5: Verify struct fields have correct defaults (extra validation before storing).
-	tsSpec := d.Panels["p1"].Spec.Plugin.Spec.(*TimeSeriesPanelSpec)
-	assert.Equal(t, "2", tsSpec.Formatting.DecimalPrecision.ValueOrDefault())
-	assert.Equal(t, "spline", tsSpec.ChartAppearance.LineInterpolation.ValueOrDefault())
-	assert.Equal(t, "solid", tsSpec.ChartAppearance.LineStyle.ValueOrDefault())
-	assert.Equal(t, "solid", tsSpec.ChartAppearance.FillMode.ValueOrDefault())
-	assert.Equal(t, "global_time", tsSpec.Visualization.TimePreference.ValueOrDefault())
-	assert.Equal(t, "bottom", tsSpec.Legend.Position.ValueOrDefault())
-	numSpec := d.Panels["p2"].Spec.Plugin.Spec.(*NumberPanelSpec)
-	assert.Equal(t, ">", numSpec.Thresholds[0].Operator.ValueOrDefault())
-	assert.Equal(t, "text", numSpec.Thresholds[0].Format.ValueOrDefault())
-
-	// Step 2: Marshal to JSON (simulates writing to DB).
-	stored, err := json.Marshal(d)
-	require.NoError(t, err, "marshal for storage failed")
-
-	// Step 3: Unmarshal from JSON (simulates reading from DB).
-	loaded, err := UnmarshalAndValidateDashboardV2JSON(stored)
-	require.NoError(t, err, "unmarshal from storage failed")
-
-	// Step 3.5: Verify struct fields have correct defaults after loading (before returning in API).
-	tsLoaded := loaded.Panels["p1"].Spec.Plugin.Spec.(*TimeSeriesPanelSpec)
-	assert.Equal(t, "2", tsLoaded.Formatting.DecimalPrecision.ValueOrDefault(), "after load")
-	assert.Equal(t, "spline", tsLoaded.ChartAppearance.LineInterpolation.ValueOrDefault(), "after load")
-	assert.Equal(t, "solid", tsLoaded.ChartAppearance.LineStyle.ValueOrDefault(), "after load")
-	assert.Equal(t, "solid", tsLoaded.ChartAppearance.FillMode.ValueOrDefault(), "after load")
-	assert.Equal(t, "global_time", tsLoaded.Visualization.TimePreference.ValueOrDefault(), "after load")
-	assert.Equal(t, "bottom", tsLoaded.Legend.Position.ValueOrDefault(), "after load")
-	numLoaded := loaded.Panels["p2"].Spec.Plugin.Spec.(*NumberPanelSpec)
-	assert.Equal(t, ">", numLoaded.Thresholds[0].Operator.ValueOrDefault(), "after load")
-	assert.Equal(t, "text", numLoaded.Thresholds[0].Format.ValueOrDefault(), "after load")
-
-	// Step 4: Marshal again (simulates API response) and verify defaults.
-	response, err := json.Marshal(loaded)
-	require.NoError(t, err, "marshal for response failed")
-	responseStr := string(response)
-
-	for field, want := range map[string]string{
-		"decimalPrecision":  `"2"`,
-		"lineInterpolation": `"spline"`,
-		"lineStyle":         `"solid"`,
-		"fillMode":          `"solid"`,
-		"timePreference":    `"global_time"`,
-		"position":          `"bottom"`,
-		"format":            `"text"`,
-	} {
-		assert.Contains(t, responseStr, `"`+field+`":`+want, "expected %s:%s after storage round-trip", field, want)
-	}
-
-	// Verify operator default (Go escapes ">" as "\u003e").
-	assert.True(t,
-		strings.Contains(responseStr, `"operator":">"`) || strings.Contains(responseStr, `"operator":"\u003e"`),
-		"expected operator:> after storage round-trip")
-}
-
-func TestSpanGaps(t *testing.T) {
-	unmarshal := func(t *testing.T, val string) SpanGaps {
-		t.Helper()
-		var sg SpanGaps
-		require.NoError(t, json.Unmarshal([]byte(val), &sg))
-		return sg
-	}
-
-	t.Run("defaults", func(t *testing.T) {
-		var sg SpanGaps
-		assert.False(t, sg.FillOnlyBelow, "expected FillOnlyBelow default false")
-		assert.True(t, sg.FillLessThan.IsZero(), "expected FillLessThan default zero")
-	})
-
-	t.Run("fillOnlyBelow true", func(t *testing.T) {
-		sg := unmarshal(t, `{"fillOnlyBelow": true}`)
-		assert.True(t, sg.FillOnlyBelow)
-	})
-
-	t.Run("fillLessThan duration", func(t *testing.T) {
-		sg := unmarshal(t, `{"fillOnlyBelow": false, "fillLessThan": "5m"}`)
-		assert.False(t, sg.FillOnlyBelow)
-		assert.Equal(t, 5*time.Minute, sg.FillLessThan.Duration())
-	})
-
-	t.Run("fillLessThan compound duration", func(t *testing.T) {
-		sg := unmarshal(t, `{"fillLessThan": "1h30m"}`)
-		assert.Equal(t, 90*time.Minute, sg.FillLessThan.Duration())
-	})
-}
-
-func TestPanelTypeQueryTypeCompatibility(t *testing.T) {
-	mkQuery := func(panelKind, queryKind, querySpec string) []byte {
-		return []byte(`{
-			"panels": {"p1": {"kind": "Panel", "spec": {
-				"plugin": {"kind": "` + panelKind + `", "spec": {}},
-				"queries": [{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "` + queryKind + `", "spec": ` + querySpec + `}}}]
-			}}},
-			"layouts": []
-		}`)
-	}
-	mkComposite := func(panelKind, subType, subSpec string) []byte {
-		return []byte(`{
-			"panels": {"p1": {"kind": "Panel", "spec": {
-				"plugin": {"kind": "` + panelKind + `", "spec": {}},
-				"queries": [{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/CompositeQuery", "spec": {
-					"queries": [{"type": "` + subType + `", "spec": ` + subSpec + `}]
-				}}}}]
-			}}},
-			"layouts": []
-		}`)
-	}
-
-	cases := []struct {
-		name    string
-		data    []byte
-		wantErr bool
-	}{
-		// Top-level: allowed
-		{"TimeSeries+PromQL", mkQuery("signoz/TimeSeriesPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), false},
-		{"Table+ClickHouse", mkQuery("signoz/TablePanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), false},
-		{"List+Builder", mkQuery("signoz/ListPanel", "signoz/BuilderQuery", `{"name":"A","signal":"logs"}`), false},
-		// Top-level: rejected
-		{"Table+PromQL", mkQuery("signoz/TablePanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},
-		{"List+ClickHouse", mkQuery("signoz/ListPanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), true},
-		{"List+PromQL", mkQuery("signoz/ListPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},
-		{"List+Composite", mkQuery("signoz/ListPanel", "signoz/CompositeQuery", `{"queries":[]}`), true},
-		{"List+Formula", mkQuery("signoz/ListPanel", "signoz/Formula", `{"name":"F1","expression":"A+B"}`), true},
-		// Composite sub-queries
-		{"Table+Composite(promql)", mkComposite("signoz/TablePanel", "promql", `{"name":"A","query":"up"}`), true},
-		{"Table+Composite(clickhouse)", mkComposite("signoz/TablePanel", "clickhouse_sql", `{"name":"A","query":"SELECT 1"}`), false},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := UnmarshalAndValidateDashboardV2JSON(tc.data)
-			if tc.wantErr {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}

pkg/types/dashboardtypes/perses_plugin_types.go

@@ -1,615 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"strconv"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// ══════════════════════════════════════════════
-// SigNoz variable plugin specs
-// ══════════════════════════════════════════════
-
-type VariablePluginKind string
-
-const (
-	VariableKindDynamic VariablePluginKind = "signoz/DynamicVariable"
-	VariableKindQuery   VariablePluginKind = "signoz/QueryVariable"
-	VariableKindCustom  VariablePluginKind = "signoz/CustomVariable"
-	VariableKindTextbox VariablePluginKind = "signoz/TextboxVariable"
-)
-
-func (VariablePluginKind) Enum() []any {
-	return []any{VariableKindDynamic, VariableKindQuery, VariableKindCustom, VariableKindTextbox}
-}
-
-type DynamicVariableSpec struct {
-	// Name is the name of the attribute being fetched dynamically from the
-	// signal. This could be extended to a richer selector in the future.
-	Name   string                `json:"name" validate:"required" required:"true"`
-	Signal telemetrytypes.Signal `json:"signal"`
-}
-
-type QueryVariableSpec struct {
-	QueryValue string `json:"queryValue" validate:"required" required:"true"`
-}
-
-type CustomVariableSpec struct {
-	CustomValue string `json:"customValue" validate:"required" required:"true"`
-}
-
-type TextboxVariableSpec struct{}
-
-// ══════════════════════════════════════════════
-// SigNoz query plugin specs — aliased from querybuildertypesv5
-// ══════════════════════════════════════════════
-
-type QueryPluginKind string
-
-const (
-	QueryKindBuilder       QueryPluginKind = "signoz/BuilderQuery"
-	QueryKindComposite     QueryPluginKind = "signoz/CompositeQuery"
-	QueryKindFormula       QueryPluginKind = "signoz/Formula"
-	QueryKindPromQL        QueryPluginKind = "signoz/PromQLQuery"
-	QueryKindClickHouseSQL QueryPluginKind = "signoz/ClickHouseSQL"
-	QueryKindTraceOperator QueryPluginKind = "signoz/TraceOperator"
-)
-
-func (QueryPluginKind) Enum() []any {
-	return []any{QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL, QueryKindTraceOperator}
-}
-
-type (
-	CompositeQuerySpec     = qb.CompositeQuery
-	QueryEnvelope          = qb.QueryEnvelope
-	FormulaSpec            = qb.QueryBuilderFormula
-	PromQLQuerySpec        = qb.PromQuery
-	ClickHouseSQLQuerySpec = qb.ClickHouseQuery
-	TraceOperatorSpec      = qb.QueryBuilderTraceOperator
-)
-
-// BuilderQuerySpec dispatches to the correct generic QueryBuilderQuery type
-// based on the signal field, reusing the shared dispatch logic.
-type BuilderQuerySpec struct {
-	Spec any
-}
-
-func (b *BuilderQuerySpec) UnmarshalJSON(data []byte) error {
-	spec, err := qb.UnmarshalBuilderQueryBySignal(data)
-	if err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid builder query spec")
-	}
-	b.Spec = spec
-	return nil
-}
-
-// ══════════════════════════════════════════════
-// SigNoz panel plugin specs
-// ══════════════════════════════════════════════
-
-type PanelPluginKind string
-
-const (
-	PanelKindTimeSeries PanelPluginKind = "signoz/TimeSeriesPanel"
-	PanelKindBarChart   PanelPluginKind = "signoz/BarChartPanel"
-	PanelKindNumber     PanelPluginKind = "signoz/NumberPanel"
-	PanelKindPieChart   PanelPluginKind = "signoz/PieChartPanel"
-	PanelKindTable      PanelPluginKind = "signoz/TablePanel"
-	PanelKindHistogram  PanelPluginKind = "signoz/HistogramPanel"
-	PanelKindList       PanelPluginKind = "signoz/ListPanel"
-)
-
-func (PanelPluginKind) Enum() []any {
-	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList}
-}
-
-type DatasourcePluginKind string
-
-const (
-	DatasourceKindSigNoz DatasourcePluginKind = "signoz/Datasource"
-)
-
-func (DatasourcePluginKind) Enum() []any {
-	return []any{DatasourceKindSigNoz}
-}
-
-type TimeSeriesPanelSpec struct {
-	Visualization   TimeSeriesVisualization   `json:"visualization"`
-	Formatting      PanelFormatting           `json:"formatting"`
-	ChartAppearance TimeSeriesChartAppearance `json:"chartAppearance"`
-	Axes            Axes                      `json:"axes"`
-	Legend          Legend                    `json:"legend"`
-	Thresholds      []ThresholdWithLabel      `json:"thresholds" validate:"dive"`
-}
-
-type TimeSeriesChartAppearance struct {
-	LineInterpolation LineInterpolation `json:"lineInterpolation"`
-	ShowPoints        bool              `json:"showPoints"`
-	LineStyle         LineStyle         `json:"lineStyle"`
-	FillMode          FillMode          `json:"fillMode"`
-	SpanGaps          SpanGaps          `json:"spanGaps"`
-}
-
-type BarChartPanelSpec struct {
-	Visualization BarChartVisualization `json:"visualization"`
-	Formatting    PanelFormatting       `json:"formatting"`
-	Axes          Axes                  `json:"axes"`
-	Legend        Legend                `json:"legend"`
-	Thresholds    []ThresholdWithLabel  `json:"thresholds" validate:"dive"`
-}
-
-type NumberPanelSpec struct {
-	Visualization BasicVisualization    `json:"visualization"`
-	Formatting    PanelFormatting       `json:"formatting"`
-	Thresholds    []ComparisonThreshold `json:"thresholds" validate:"dive"`
-}
-
-type PieChartPanelSpec struct {
-	Visualization BasicVisualization `json:"visualization"`
-	Formatting    PanelFormatting    `json:"formatting"`
-	Legend        Legend             `json:"legend"`
-}
-
-type TablePanelSpec struct {
-	Visualization BasicVisualization `json:"visualization"`
-	Formatting    TableFormatting    `json:"formatting"`
-	Thresholds    []TableThreshold   `json:"thresholds" validate:"dive"`
-}
-
-type HistogramPanelSpec struct {
-	HistogramBuckets HistogramBuckets `json:"histogramBuckets"`
-	Legend           Legend           `json:"legend"`
-}
-
-type HistogramBuckets struct {
-	BucketCount           *float64 `json:"bucketCount"`
-	BucketWidth           *float64 `json:"bucketWidth"`
-	MergeAllActiveQueries bool     `json:"mergeAllActiveQueries"`
-}
-
-type ListPanelSpec struct {
-	SelectFields []telemetrytypes.TelemetryFieldKey `json:"selectFields,omitempty" validate:"dive"`
-}
-
-// ══════════════════════════════════════════════
-// Panel common types
-// ══════════════════════════════════════════════
-
-type Axes struct {
-	SoftMin    *float64 `json:"softMin"`
-	SoftMax    *float64 `json:"softMax"`
-	IsLogScale bool     `json:"isLogScale"`
-}
-
-type BasicVisualization struct {
-	TimePreference TimePreference `json:"timePreference"`
-}
-
-type TimeSeriesVisualization struct {
-	BasicVisualization
-	FillSpans bool `json:"fillSpans"`
-}
-
-type BarChartVisualization struct {
-	BasicVisualization
-	FillSpans       bool `json:"fillSpans"`
-	StackedBarChart bool `json:"stackedBarChart"`
-}
-
-type PanelFormatting struct {
-	Unit             string          `json:"unit"`
-	DecimalPrecision PrecisionOption `json:"decimalPrecision"`
-}
-
-type TableFormatting struct {
-	ColumnUnits      map[string]string `json:"columnUnits"`
-	DecimalPrecision PrecisionOption   `json:"decimalPrecision"`
-}
-
-type Legend struct {
-	Position     LegendPosition    `json:"position"`
-	CustomColors map[string]string `json:"customColors"`
-}
-
-type ThresholdWithLabel struct {
-	Value float64 `json:"value" validate:"required" required:"true"`
-	Unit  string  `json:"unit"`
-	Color string  `json:"color" validate:"required" required:"true"`
-	Label string  `json:"label" validate:"required" required:"true"`
-}
-
-type ComparisonThreshold struct {
-	Value    float64            `json:"value" validate:"required" required:"true"`
-	Operator ComparisonOperator `json:"operator"`
-	Unit     string             `json:"unit"`
-	Color    string             `json:"color" validate:"required" required:"true"`
-	Format   ThresholdFormat    `json:"format"`
-}
-
-type TableThreshold struct {
-	ComparisonThreshold
-	ColumnName string `json:"columnName" validate:"required" required:"true"`
-}
-
-// ══════════════════════════════════════════════
-// Constrained scalar types — with default value
-// ══════════════════════════════════════════════
-
-type TimePreference struct{ valuer.String }
-
-var (
-	TimePreferenceGlobalTime = TimePreference{valuer.NewString("global_time")} // default
-	TimePreferenceLast5Min   = TimePreference{valuer.NewString("last_5_min")}
-	TimePreferenceLast15Min  = TimePreference{valuer.NewString("last_15_min")}
-	TimePreferenceLast30Min  = TimePreference{valuer.NewString("last_30_min")}
-	TimePreferenceLast1Hr    = TimePreference{valuer.NewString("last_1_hr")}
-	TimePreferenceLast6Hr    = TimePreference{valuer.NewString("last_6_hr")}
-	TimePreferenceLast1Day   = TimePreference{valuer.NewString("last_1_day")}
-	TimePreferenceLast3Days  = TimePreference{valuer.NewString("last_3_days")}
-	TimePreferenceLast1Week  = TimePreference{valuer.NewString("last_1_week")}
-	TimePreferenceLast1Month = TimePreference{valuer.NewString("last_1_month")}
-)
-
-func (TimePreference) Enum() []any {
-	return []any{TimePreferenceGlobalTime, TimePreferenceLast5Min, TimePreferenceLast15Min, TimePreferenceLast30Min, TimePreferenceLast1Hr, TimePreferenceLast6Hr, TimePreferenceLast1Day, TimePreferenceLast3Days, TimePreferenceLast1Week, TimePreferenceLast1Month}
-}
-
-func (t TimePreference) ValueOrDefault() string {
-	if t.IsZero() {
-		return TimePreferenceGlobalTime.StringValue()
-	}
-	return t.StringValue()
-}
-
-func (t TimePreference) MarshalJSON() ([]byte, error) {
-	return json.Marshal(t.ValueOrDefault())
-}
-
-func (t *TimePreference) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid timePreference: must be a string, one of `global_time`, `last_5_min`, `last_15_min`, `last_30_min`, `last_1_hr`, `last_6_hr`, `last_1_day`, `last_3_days`, `last_1_week`, or `last_1_month`")
-	}
-	if v == "" {
-		*t = TimePreferenceGlobalTime
-		return nil
-	}
-	tp := TimePreference{valuer.NewString(v)}
-	switch tp {
-	case TimePreferenceGlobalTime, TimePreferenceLast5Min, TimePreferenceLast15Min, TimePreferenceLast30Min, TimePreferenceLast1Hr, TimePreferenceLast6Hr, TimePreferenceLast1Day, TimePreferenceLast3Days, TimePreferenceLast1Week, TimePreferenceLast1Month:
-		*t = tp
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid timePreference %q: must be `global_time`, `last_5_min`, `last_15_min`, `last_30_min`, `last_1_hr`, `last_6_hr`, `last_1_day`, `last_3_days`, `last_1_week`, or `last_1_month`", v)
-	}
-}
-
-type LegendPosition struct{ valuer.String }
-
-var (
-	LegendPositionBottom = LegendPosition{valuer.NewString("bottom")} // default
-	LegendPositionRight  = LegendPosition{valuer.NewString("right")}
-)
-
-func (LegendPosition) Enum() []any {
-	return []any{LegendPositionBottom, LegendPositionRight}
-}
-
-func (l LegendPosition) ValueOrDefault() string {
-	if l.IsZero() {
-		return LegendPositionBottom.StringValue()
-	}
-	return l.StringValue()
-}
-
-func (l LegendPosition) MarshalJSON() ([]byte, error) {
-	return json.Marshal(l.ValueOrDefault())
-}
-
-func (l *LegendPosition) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid legend position: must be a string, one of `bottom` or `right`")
-	}
-	if v == "" {
-		*l = LegendPositionBottom
-		return nil
-	}
-	lp := LegendPosition{valuer.NewString(v)}
-	switch lp {
-	case LegendPositionBottom, LegendPositionRight:
-		*l = lp
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid legend position %q: must be `bottom` or `right`", v)
-	}
-}
-
-type ThresholdFormat struct{ valuer.String }
-
-var (
-	ThresholdFormatText       = ThresholdFormat{valuer.NewString("text")} // default
-	ThresholdFormatBackground = ThresholdFormat{valuer.NewString("background")}
-)
-
-func (ThresholdFormat) Enum() []any {
-	return []any{ThresholdFormatText, ThresholdFormatBackground}
-}
-
-func (f ThresholdFormat) ValueOrDefault() string {
-	if f.IsZero() {
-		return ThresholdFormatText.StringValue()
-	}
-	return f.StringValue()
-}
-
-func (f ThresholdFormat) MarshalJSON() ([]byte, error) {
-	return json.Marshal(f.ValueOrDefault())
-}
-
-func (f *ThresholdFormat) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid threshold format: must be a string, one of `text` or `background`")
-	}
-	if v == "" {
-		*f = ThresholdFormatText
-		return nil
-	}
-	tf := ThresholdFormat{valuer.NewString(v)}
-	switch tf {
-	case ThresholdFormatText, ThresholdFormatBackground:
-		*f = tf
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid threshold format %q: must be `text` or `background`", v)
-	}
-}
-
-// Uses valuer.String with custom UnmarshalJSON for validation, rather than
-// ruletypes.CompareOperator which accepts any string at unmarshal time.
-type ComparisonOperator struct{ valuer.String }
-
-var (
-	ComparisonOperatorGT           = ComparisonOperator{valuer.NewString(">")} // default
-	ComparisonOperatorLT           = ComparisonOperator{valuer.NewString("<")}
-	ComparisonOperatorGTE          = ComparisonOperator{valuer.NewString(">=")}
-	ComparisonOperatorLTE          = ComparisonOperator{valuer.NewString("<=")}
-	ComparisonOperatorEQ           = ComparisonOperator{valuer.NewString("=")}
-	ComparisonOperatorAbove        = ComparisonOperator{valuer.NewString("above")}
-	ComparisonOperatorBelow        = ComparisonOperator{valuer.NewString("below")}
-	ComparisonOperatorAboveOrEqual = ComparisonOperator{valuer.NewString("above_or_equal")}
-	ComparisonOperatorBelowOrEqual = ComparisonOperator{valuer.NewString("below_or_equal")}
-	ComparisonOperatorEqual        = ComparisonOperator{valuer.NewString("equal")}
-	ComparisonOperatorNotEqual     = ComparisonOperator{valuer.NewString("not_equal")}
-)
-
-func (ComparisonOperator) Enum() []any {
-	return []any{ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ, ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual, ComparisonOperatorEqual, ComparisonOperatorNotEqual}
-}
-
-func (o ComparisonOperator) ValueOrDefault() string {
-	if o.IsZero() {
-		return ComparisonOperatorGT.StringValue()
-	}
-	return o.StringValue()
-}
-
-func (o ComparisonOperator) MarshalJSON() ([]byte, error) {
-	return json.Marshal(o.ValueOrDefault())
-}
-
-func (o *ComparisonOperator) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid comparison operator: must be a string, one of `>`, `<`, `>=`, `<=`, `=`, `above`, `below`, `above_or_equal`, `below_or_equal`, `equal`, or `not_equal`")
-	}
-	if v == "" {
-		*o = ComparisonOperatorGT
-		return nil
-	}
-	co := ComparisonOperator{valuer.NewString(v)}
-	switch co {
-	case ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ,
-		ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual,
-		ComparisonOperatorEqual, ComparisonOperatorNotEqual:
-		*o = co
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid comparison operator %q: must be `>`, `<`, `>=`, `<=`, `=`, `above`, `below`, `above_or_equal`, `below_or_equal`, `equal`, or `not_equal`", v)
-	}
-}
-
-type LineInterpolation struct{ valuer.String }
-
-var (
-	LineInterpolationLinear     = LineInterpolation{valuer.NewString("linear")}
-	LineInterpolationSpline     = LineInterpolation{valuer.NewString("spline")} // default
-	LineInterpolationStepAfter  = LineInterpolation{valuer.NewString("step_after")}
-	LineInterpolationStepBefore = LineInterpolation{valuer.NewString("step_before")}
-)
-
-func (LineInterpolation) Enum() []any {
-	return []any{LineInterpolationLinear, LineInterpolationSpline, LineInterpolationStepAfter, LineInterpolationStepBefore}
-}
-
-func (li LineInterpolation) ValueOrDefault() string {
-	if li.IsZero() {
-		return LineInterpolationSpline.StringValue()
-	}
-	return li.StringValue()
-}
-
-func (li LineInterpolation) MarshalJSON() ([]byte, error) {
-	return json.Marshal(li.ValueOrDefault())
-}
-
-func (li *LineInterpolation) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid line interpolation: must be a string, one of `linear`, `spline`, `step_after`, or `step_before`")
-	}
-	if v == "" {
-		*li = LineInterpolationSpline
-		return nil
-	}
-	val := LineInterpolation{valuer.NewString(v)}
-	switch val {
-	case LineInterpolationLinear, LineInterpolationSpline, LineInterpolationStepAfter, LineInterpolationStepBefore:
-		*li = val
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid line interpolation %q: must be `linear`, `spline`, `step_after`, or `step_before`", v)
-	}
-}
-
-type LineStyle struct{ valuer.String }
-
-var (
-	LineStyleSolid  = LineStyle{valuer.NewString("solid")} // default
-	LineStyleDashed = LineStyle{valuer.NewString("dashed")}
-)
-
-func (LineStyle) Enum() []any {
-	return []any{LineStyleSolid, LineStyleDashed}
-}
-
-func (ls LineStyle) ValueOrDefault() string {
-	if ls.IsZero() {
-		return LineStyleSolid.StringValue()
-	}
-	return ls.StringValue()
-}
-
-func (ls LineStyle) MarshalJSON() ([]byte, error) {
-	return json.Marshal(ls.ValueOrDefault())
-}
-
-func (ls *LineStyle) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid line style: must be a string, one of `solid` or `dashed`")
-	}
-	if v == "" {
-		*ls = LineStyleSolid
-		return nil
-	}
-	val := LineStyle{valuer.NewString(v)}
-	switch val {
-	case LineStyleSolid, LineStyleDashed:
-		*ls = val
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid line style %q: must be `solid` or `dashed`", v)
-	}
-}
-
-type FillMode struct{ valuer.String }
-
-var (
-	FillModeSolid    = FillMode{valuer.NewString("solid")} // default
-	FillModeGradient = FillMode{valuer.NewString("gradient")}
-	FillModeNone     = FillMode{valuer.NewString("none")}
-)
-
-func (FillMode) Enum() []any {
-	return []any{FillModeSolid, FillModeGradient, FillModeNone}
-}
-
-func (fm FillMode) ValueOrDefault() string {
-	if fm.IsZero() {
-		return FillModeSolid.StringValue()
-	}
-	return fm.StringValue()
-}
-
-func (fm FillMode) MarshalJSON() ([]byte, error) {
-	return json.Marshal(fm.ValueOrDefault())
-}
-
-func (fm *FillMode) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid fill mode: must be a string, one of `solid`, `gradient`, or `none`")
-	}
-	if v == "" {
-		*fm = FillModeSolid
-		return nil
-	}
-	val := FillMode{valuer.NewString(v)}
-	switch val {
-	case FillModeSolid, FillModeGradient, FillModeNone:
-		*fm = val
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid fill mode %q: must be `solid`, `gradient`, or `none`", v)
-	}
-}
-
-// SpanGaps controls whether lines connect across null values.
-// When FillOnlyBelow is false (default), all gaps are connected.
-// When FillOnlyBelow is true, only gaps smaller than FillLessThan are connected.
-type SpanGaps struct {
-	FillOnlyBelow bool                `json:"fillOnlyBelow"`
-	FillLessThan  valuer.TextDuration `json:"fillLessThan"`
-}
-
-type PrecisionOption struct{ valuer.String }
-
-var (
-	PrecisionOption0    = PrecisionOption{valuer.NewString("0")}
-	PrecisionOption1    = PrecisionOption{valuer.NewString("1")}
-	PrecisionOption2    = PrecisionOption{valuer.NewString("2")} // default
-	PrecisionOption3    = PrecisionOption{valuer.NewString("3")}
-	PrecisionOption4    = PrecisionOption{valuer.NewString("4")}
-	PrecisionOptionFull = PrecisionOption{valuer.NewString("full")}
-)
-
-func (PrecisionOption) Enum() []any {
-	return []any{PrecisionOption0, PrecisionOption1, PrecisionOption2, PrecisionOption3, PrecisionOption4, PrecisionOptionFull}
-}
-
-func (p PrecisionOption) ValueOrDefault() string {
-	if p.IsZero() {
-		return PrecisionOption2.StringValue()
-	}
-	return p.StringValue()
-}
-
-func (p PrecisionOption) MarshalJSON() ([]byte, error) {
-	return json.Marshal(p.ValueOrDefault())
-}
-
-func (p *PrecisionOption) UnmarshalJSON(data []byte) error {
-	// Accept int values 0-4 and store as string.
-	var n int
-	if err := json.Unmarshal(data, &n); err == nil {
-		switch n {
-		case 0, 1, 2, 3, 4:
-			p.String = valuer.NewString(strconv.Itoa(n))
-			return nil
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid precision option %d: must be `0`, `1`, `2`, `3`, `4`, or `full`", n)
-		}
-	}
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid precision option: must be `0`, `1`, `2`, `3`, `4`, or `full`")
-	}
-	if v == "" {
-		*p = PrecisionOption2
-		return nil
-	}
-	val := PrecisionOption{valuer.NewString(v)}
-	switch val {
-	case PrecisionOption0, PrecisionOption1, PrecisionOption2, PrecisionOption3, PrecisionOption4, PrecisionOptionFull:
-		*p = val
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid precision option %q: must be `0`, `1`, `2`, `3`, `4`, or `full`", v)
-	}
-}

pkg/types/dashboardtypes/testdata/perses.json

@@ -1,861 +0,0 @@
-{
-    "display": {
-        "name": "The everything dashboard",
-        "description": "Trying to cover as many concepts here as possible"
-    },
-    "duration": "1h",
-    "datasources": {
-        "SigNozDatasource": {
-            "default": true,
-            "plugin": {
-                "kind": "signoz/Datasource",
-                "spec": {}
-            }
-        }
-    },
-    "variables": [
-        {
-            "kind": "ListVariable",
-            "spec": {
-                "name": "serviceName",
-                "display": {
-                    "name": "serviceName"
-                },
-                "allowAllValue": true,
-                "allowMultiple": false,
-                "sort": "none",
-                "plugin": {
-                    "kind": "signoz/DynamicVariable",
-                    "spec": {
-                        "name": "service.name",
-                        "signal": "metrics"
-                    }
-                }
-            }
-        },
-        {
-            "kind": "ListVariable",
-            "spec": {
-                "name": "statusCodesFromQuery",
-                "display": {
-                    "name": "statusCodesFromQuery"
-                },
-                "allowAllValue": true,
-                "allowMultiple": true,
-                "sort": "alphabetical-asc",
-                "plugin": {
-                    "kind": "signoz/QueryVariable",
-                    "spec": {
-                        "queryValue": "SELECT JSONExtractString(labels, 'http.status_code') AS status_code FROM signoz_metrics.distributed_time_series_v4_1day WHERE status_code != '' GROUP BY status_code"
-                    }
-                }
-            }
-        },
-        {
-            "kind": "ListVariable",
-            "spec": {
-                "name": "limit",
-                "display": {
-                    "name": "limit"
-                },
-                "allowAllValue": false,
-                "allowMultiple": false,
-                "sort": "none",
-                "plugin": {
-                    "kind": "signoz/CustomVariable",
-                    "spec": {
-                        "customValue": "1,10,20,40,80,160,200"
-                    }
-                }
-            }
-        },
-        {
-            "kind": "TextVariable",
-            "spec": {
-                "name": "textboxvar",
-                "display": {
-                    "name": "textboxvar"
-                },
-                "value": "defaultvaluegoeshere",
-                "plugin": {
-                    "kind": "signoz/TextboxVariable",
-                    "spec": {}
-                }
-            }
-        }
-    ],
-    "panels": {
-        "24e2697b": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "total resp size",
-                    "description": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {
-                        "visualization": {
-                            "fillSpans": true
-                        },
-                        "formatting": {
-                            "unit": "By",
-                            "decimalPrecision": "3"
-                        },
-                        "axes": {
-                            "softMax": 800,
-                            "isLogScale": true
-                        },
-                        "legend": {
-                            "position": "right",
-                            "customColors": {
-                                "{service.name=\"sampleapp-gateway\"}": "#9ea5f7"
-                            }
-                        },
-                        "thresholds": [
-                            {
-                                "value": 1024,
-                                "unit": "By",
-                                "color": "Red",
-                                "label": "upper limit"
-                            },
-                            {
-                                "value": 100,
-                                "unit": "By",
-                                "color": "Orange",
-                                "label": "kinda bad"
-                            }
-                        ]
-                    }
-                },
-                "links": [
-                    {
-                        "name": "View service details",
-                        "url": "http://localhost:8080/{{_service.name}}?dfddf=%7B%7Blimit%7D%7D"
-                    }
-                ],
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "metrics",
-                                    "aggregations": [
-                                        {
-                                            "metricName": "http.server.response.body.size.sum",
-                                            "reduceTo": "sum",
-                                            "spaceAggregation": "sum",
-                                            "timeAggregation": "rate"
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "http.response.status_code IN $statusCodesFromQuery"
-                                    },
-                                    "groupBy": [
-                                        {
-                                            "name": "service.name",
-                                            "fieldDataType": "string",
-                                            "fieldContext": "tag"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "ff2f72f1": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "fraction of calls",
-                    "description": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {
-                        "visualization": {
-                            "fillSpans": true
-                        },
-                        "formatting": {
-                            "decimalPrecision": "1"
-                        },
-                        "thresholds": [
-                            {
-                                "value": 1,
-                                "color": "Blue",
-                                "label": "max possible"
-                            }
-                        ]
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/CompositeQuery",
-                                "spec": {
-                                    "queries": [
-                                        {
-                                            "type": "builder_query",
-                                            "spec": {
-                                                "name": "A",
-                                                "signal": "metrics",
-                                                "disabled": true,
-                                                "aggregations": [
-                                                    {
-                                                        "metricName": "signoz_calls_total",
-                                                        "reduceTo": "sum",
-                                                        "spaceAggregation": "sum",
-                                                        "timeAggregation": "rate"
-                                                    }
-                                                ],
-                                                "filter": {
-                                                    "expression": "service.name IN $serviceName  AND http.status_code IN $statusCodesFromQuery"
-                                                }
-                                            }
-                                        },
-                                        {
-                                            "type": "builder_query",
-                                            "spec": {
-                                                "name": "B",
-                                                "signal": "metrics",
-                                                "disabled": true,
-                                                "aggregations": [
-                                                    {
-                                                        "metricName": "signoz_calls_total",
-                                                        "reduceTo": "sum",
-                                                        "spaceAggregation": "sum",
-                                                        "timeAggregation": "rate"
-                                                    }
-                                                ],
-                                                "filter": {
-                                                    "expression": "service.name in $serviceName"
-                                                }
-                                            }
-                                        },
-                                        {
-                                            "type": "builder_formula",
-                                            "spec": {
-                                                "name": "F1",
-                                                "expression": "A / B"
-                                            }
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "011605e7": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "total resp size"
-                },
-                "plugin": {
-                    "kind": "signoz/BarChartPanel",
-                    "spec": {
-                        "visualization": {
-                            "stackedBarChart": false
-                        },
-                        "formatting": {
-                            "unit": "By"
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "metrics",
-                                    "aggregations": [
-                                        {
-                                            "metricName": "http.server.response.body.size.sum",
-                                            "reduceTo": "sum",
-                                            "spaceAggregation": "sum",
-                                            "timeAggregation": "rate"
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "http.response.status_code IN $statusCodesFromQuery"
-                                    },
-                                    "groupBy": [
-                                        {
-                                            "name": "service.name",
-                                            "fieldDataType": "string",
-                                            "fieldContext": "tag"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "e23516fc": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "num traces for service"
-                },
-                "plugin": {
-                    "kind": "signoz/NumberPanel",
-                    "spec": {
-                        "formatting": {
-                            "unit": "none",
-                            "decimalPrecision": "1"
-                        },
-                        "thresholds": [
-                            {
-                                "value": 1200000,
-                                "operator": ">",
-                                "unit": "none",
-                                "color": "Red",
-                                "format": "text"
-                            },
-                            {
-                                "value": 1200000,
-                                "operator": "<=",
-                                "unit": "none",
-                                "color": "Green",
-                                "format": "text"
-                            }
-                        ]
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "traces",
-                                    "aggregations": [
-                                        {
-                                            "expression": "count() "
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "service.name = $serviceName "
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "130c8d6b": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "num logs for service"
-                },
-                "plugin": {
-                    "kind": "signoz/NumberPanel",
-                    "spec": {
-                        "formatting": {
-                            "unit": "none",
-                            "decimalPrecision": "1"
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "logs",
-                                    "aggregations": [
-                                        {
-                                            "expression": "count() "
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "service.name = $serviceName "
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "246f7c6d": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "num traces for service per resp code"
-                },
-                "plugin": {
-                    "kind": "signoz/PieChartPanel",
-                    "spec": {
-                        "formatting": {
-                            "decimalPrecision": "1"
-                        },
-                        "legend": {
-                            "customColors": {
-                                "\"201\"": "#2bc051",
-                                "\"400\"": "#cc462e",
-                                "\"500\"": "#ff0000"
-                            }
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "traces",
-                                    "aggregations": [
-                                        {
-                                            "expression": "count() "
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "service.name = $serviceName isEntryPoint = 'true'"
-                                    },
-                                    "groupBy": [
-                                        {
-                                            "name": "http.response.status_code",
-                                            "fieldDataType": "float64",
-                                            "fieldContext": "tag"
-                                        }
-                                    ],
-                                    "legend": "\"{{http.response.status_code}}\""
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "21f7d4d0": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "average latency per service"
-                },
-                "plugin": {
-                    "kind": "signoz/TablePanel",
-                    "spec": {
-                        "formatting": {
-                            "columnUnits": {
-                                "A": "s"
-                            }
-                        },
-                        "thresholds": [
-                            {
-                                "value": 1,
-                                "operator": ">",
-                                "unit": "min",
-                                "color": "Red",
-                                "format": "text",
-                                "columnName": "A"
-                            }
-                        ]
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/ClickHouseSQL",
-                                "spec": {
-                                    "name": "A",
-                                    "query": "WITH\n    __spatial_aggregation_cte AS\n    (\n        SELECT\n            toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts,\n            `service.name`,\n            le,\n            sum(value) / 60 AS value\n        FROM signoz_metrics.distributed_samples_v4 AS points\n        INNER JOIN\n        (\n            SELECT\n                fingerprint,\n                JSONExtractString(labels, 'service.name') AS `service.name`,\n                JSONExtractString(labels, 'le') AS le\n            FROM signoz_metrics.time_series_v4\n            WHERE (metric_name IN ('signoz_latency.bucket')) AND (LOWER(temporality) LIKE LOWER('delta')) AND (__normalized = 0)\n            GROUP BY\n                fingerprint,\n                `service.name`,\n                le\n        ) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint\n        WHERE metric_name IN ('signoz_latency.bucket')\n        GROUP BY\n            ts,\n            `service.name`,\n            le\n    ),\n    __histogramCTE AS\n    (\n        SELECT\n            ts,\n            `service.name`,\n            histogramQuantile(arrayMap(x -> toFloat64(x), groupArray(le)), groupArray(value), 0.9) AS value\n        FROM __spatial_aggregation_cte\n        GROUP BY\n            `service.name`,\n            ts\n        ORDER BY\n            `service.name` ASC,\n            ts ASC\n    )\nSELECT\n    `service.name` AS service,\n    avg(value) AS A\nFROM __histogramCTE\nGROUP BY `service.name`"
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "ad5fd556": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "logs from service"
-                },
-                "plugin": {
-                    "kind": "signoz/ListPanel",
-                    "spec": {
-                        "selectFields": [
-                            {
-                                "name": "timestamp",
-                                "signal": "logs"
-                            },
-                            {
-                                "name": "body",
-                                "signal": "logs"
-                            },
-                            {
-                                "name": "error",
-                                "fieldDataType": "string"
-                            }
-                        ]
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "LogQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "logs",
-                                    "aggregations": [
-                                        {
-                                            "expression": "count() "
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": "service.name = $serviceName"
-                                    },
-                                    "groupBy": [],
-                                    "order": [
-                                        {
-                                            "key": {
-                                                "name": "timestamp"
-                                            },
-                                            "direction": "desc"
-                                        },
-                                        {
-                                            "key": {
-                                                "name": "id"
-                                            },
-                                            "direction": "desc"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "f07b59ee": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "response size buckets"
-                },
-                "plugin": {
-                    "kind": "signoz/HistogramPanel",
-                    "spec": {
-                        "histogramBuckets": {
-                            "bucketCount": 60,
-                            "mergeAllActiveQueries": true
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "metrics",
-                                    "aggregations": [
-                                        {
-                                            "metricName": "http.server.response.body.size.bucket",
-                                            "reduceTo": "avg",
-                                            "spaceAggregation": "p90",
-                                            "timeAggregation": "rate"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "e1a41831": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "trace operator",
-                    "description": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {
-                        "legend": {
-                            "position": "right"
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/CompositeQuery",
-                                "spec": {
-                                    "queries": [
-                                        {
-                                            "type": "builder_query",
-                                            "spec": {
-                                                "name": "A",
-                                                "signal": "traces",
-                                                "aggregations": [
-                                                    {
-                                                        "expression": "count() "
-                                                    }
-                                                ],
-                                                "filter": {
-                                                    "expression": "service.name = 'sampleapp-gateway' "
-                                                },
-                                                "legend": "Gateway"
-                                            }
-                                        },
-                                        {
-                                            "type": "builder_query",
-                                            "spec": {
-                                                "name": "B",
-                                                "signal": "traces",
-                                                "aggregations": [
-                                                    {
-                                                        "expression": "count() "
-                                                    }
-                                                ],
-                                                "filter": {
-                                                    "expression": "http.response.status_code = 200"
-                                                },
-                                                "legend": "$serviceName"
-                                            }
-                                        },
-                                        {
-                                            "type": "builder_trace_operator",
-                                            "spec": {
-                                                "name": "T1",
-                                                "aggregations": [
-                                                    {
-                                                        "expression": "count()",
-                                                        "alias": "request_count"
-                                                    }
-                                                ]
-                                            }
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "f0d70491": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "no results in this promql",
-                    "description": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {}
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/CompositeQuery",
-                                "spec": {
-                                    "queries": [
-                                        {
-                                            "type": "promql",
-                                            "spec": {
-                                                "name": "A",
-                                                "query": "sum(rate(flask_exporter_info[5m]))"
-                                            }
-                                        },
-                                        {
-                                            "type": "promql",
-                                            "spec": {
-                                                "name": "B",
-                                                "query": "sum(increase(flask_exporter_info[5m]))"
-                                            }
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "0e6eb4ca": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": "no results in this promql",
-                    "description": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {}
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/PromQLQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "query": "sum(rate(flask_exporter_info[5m]))"
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        }
-    },
-    "layouts": [
-        {
-            "kind": "Grid",
-            "spec": {
-                "items": [
-                    {
-                        "x": 0,
-                        "y": 0,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/24e2697b"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 0,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/ff2f72f1"
-                        }
-                    },
-                    {
-                        "x": 0,
-                        "y": 6,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/011605e7"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 6,
-                        "width": 6,
-                        "height": 3,
-                        "content": {
-                            "$ref": "#/spec/panels/e23516fc"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 9,
-                        "width": 6,
-                        "height": 3,
-                        "content": {
-                            "$ref": "#/spec/panels/130c8d6b"
-                        }
-                    },
-                    {
-                        "x": 0,
-                        "y": 12,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/246f7c6d"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 12,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/21f7d4d0"
-                        }
-                    },
-                    {
-                        "x": 0,
-                        "y": 18,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/ad5fd556"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 18,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/f07b59ee"
-                        }
-                    },
-                    {
-                        "x": 0,
-                        "y": 24,
-                        "width": 12,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/e1a41831"
-                        }
-                    },
-                    {
-                        "x": 0,
-                        "y": 30,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/f0d70491"
-                        }
-                    },
-                    {
-                        "x": 6,
-                        "y": 30,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/0e6eb4ca"
-                        }
-                    }
-                ]
-            }
-        }
-    ]
-}

pkg/types/dashboardtypes/testdata/perses_with_sections.json

@@ -1,154 +0,0 @@
-{
-    "display": {
-        "name": "NV dashboard with sections",
-        "description": ""
-    },
-    "datasources": {
-        "SigNozDatasource": {
-            "default": true,
-            "plugin": {
-                "kind": "signoz/Datasource",
-                "spec": {}
-            }
-        }
-    },
-    "panels": {
-        "b424e23b": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": ""
-                },
-                "plugin": {
-                    "kind": "signoz/NumberPanel",
-                    "spec": {
-                        "formatting": {
-                            "unit": "s",
-                            "decimalPrecision": "2"
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "metrics",
-                                    "aggregations": [
-                                        {
-                                            "metricName": "container.cpu.time",
-                                            "reduceTo": "sum",
-                                            "spaceAggregation": "sum",
-                                            "timeAggregation": "rate"
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": ""
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        "251df4d5": {
-            "kind": "Panel",
-            "spec": {
-                "display": {
-                    "name": ""
-                },
-                "plugin": {
-                    "kind": "signoz/TimeSeriesPanel",
-                    "spec": {
-                        "visualization": {
-                            "fillSpans": false
-                        },
-                        "formatting": {
-                            "unit": "recommendations",
-                            "decimalPrecision": "2"
-                        },
-                        "chartAppearance": {
-                            "lineInterpolation": "spline",
-                            "showPoints": false,
-                            "lineStyle": "solid",
-                            "fillMode": "none",
-                            "spanGaps": {"fillOnlyBelow": true}
-                        },
-                        "legend": {
-                            "position": "bottom"
-                        }
-                    }
-                },
-                "queries": [
-                    {
-                        "kind": "TimeSeriesQuery",
-                        "spec": {
-                            "plugin": {
-                                "kind": "signoz/BuilderQuery",
-                                "spec": {
-                                    "name": "A",
-                                    "signal": "metrics",
-                                    "aggregations": [
-                                        {
-                                            "metricName": "app_recommendations_counter",
-                                            "reduceTo": "sum",
-                                            "spaceAggregation": "sum",
-                                            "timeAggregation": "rate"
-                                        }
-                                    ],
-                                    "filter": {
-                                        "expression": ""
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        }
-    },
-    "layouts": [
-        {
-            "kind": "Grid",
-            "spec": {
-                "display": {
-                    "title": "Bravo"
-                },
-                "items": [
-                    {
-                        "x": 0,
-                        "y": 0,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/b424e23b"
-                        }
-                    }
-                ]
-            }
-        },
-        {
-            "kind": "Grid",
-            "spec": {
-                "display": {
-                    "title": "Alpha"
-                },
-                "items": [
-                    {
-                        "x": 0,
-                        "y": 0,
-                        "width": 6,
-                        "height": 6,
-                        "content": {
-                            "$ref": "#/spec/panels/251df4d5"
-                        }
-                    }
-                ]
-            }
-        }
-    ]
-}

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -99,11 +99,45 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 	// 2. Decode the spec based on the Type.
 	switch shadow.Type {
 	case QueryTypeBuilder, QueryTypeSubQuery:
-		spec, err := UnmarshalBuilderQueryBySignal(shadow.Spec)
-		if err != nil {
-			return err
+		var header struct {
+			Signal telemetrytypes.Signal `json:"signal"`
+		}
+		if err := json.Unmarshal(shadow.Spec, &header); err != nil {
+			return errors.NewInvalidInputf(
+				errors.CodeInvalidInput,
+				"cannot detect builder signal: %v",
+				err,
+			)
+		}
+
+		switch header.Signal {
+		case telemetrytypes.SignalTraces:
+			var spec QueryBuilderQuery[TraceAggregation]
+			if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
+				return wrapUnmarshalError(err, "invalid trace builder query spec: %v", err)
+			}
+			q.Spec = spec
+		case telemetrytypes.SignalLogs:
+			var spec QueryBuilderQuery[LogAggregation]
+			if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
+				return wrapUnmarshalError(err, "invalid log builder query spec: %v", err)
+			}
+			q.Spec = spec
+		case telemetrytypes.SignalMetrics:
+			var spec QueryBuilderQuery[MetricAggregation]
+			if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
+				return wrapUnmarshalError(err, "invalid metric builder query spec: %v", err)
+			}
+			q.Spec = spec
+		default:
+			return errors.NewInvalidInputf(
+				errors.CodeInvalidInput,
+				"unknown builder signal %q",
+				header.Signal,
+			).WithAdditional(
+				"Valid signals are: traces, logs, metrics",
+			)
 		}
-		q.Spec = spec
 
 	case QueryTypeFormula:
 		var spec QueryBuilderFormula
@@ -157,49 +191,6 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// UnmarshalBuilderQueryBySignal peeks at the "signal" field in the JSON data and
-// unmarshals into the correct generic QueryBuilderQuery type. Returns the typed spec.
-func UnmarshalBuilderQueryBySignal(data []byte) (any, error) {
-	var header struct {
-		Signal telemetrytypes.Signal `json:"signal"`
-	}
-	if err := json.Unmarshal(data, &header); err != nil {
-		return nil, errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"cannot detect builder signal: %v",
-			err,
-		)
-	}
-
-	switch header.Signal {
-	case telemetrytypes.SignalTraces:
-		var spec QueryBuilderQuery[TraceAggregation]
-		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, wrapUnmarshalError(err, "invalid trace builder query spec: %v", err)
-		}
-		return spec, nil
-	case telemetrytypes.SignalLogs:
-		var spec QueryBuilderQuery[LogAggregation]
-		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, wrapUnmarshalError(err, "invalid log builder query spec: %v", err)
-		}
-		return spec, nil
-	case telemetrytypes.SignalMetrics:
-		var spec QueryBuilderQuery[MetricAggregation]
-		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, wrapUnmarshalError(err, "invalid metric builder query spec: %v", err)
-		}
-		return spec, nil
-	default:
-		return nil, errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid signal %q; allowed values: %v",
-			header.Signal.StringValue(),
-			telemetrytypes.Signal{}.Enum(),
-		)
-	}
-}
-
 type CompositeQuery struct {
 	// Queries is the queries to use for the request.
 	Queries []QueryEnvelope `json:"queries"`

pkg/types/spanattributemappingtypes/errors.go

@@ -1,11 +0,0 @@
-package spanattributemappingtypes
-
-import "github.com/SigNoz/signoz/pkg/errors"
-
-var (
-	ErrCodeSpanAttributeMappingGroupNotFound      = errors.MustNewCode("span_attribute_mapping_group_not_found")
-	ErrCodeSpanAttributeMappingGroupAlreadyExists = errors.MustNewCode("span_attribute_mapping_group_already_exists")
-	ErrCodeSpanAttributeMapperNotFound            = errors.MustNewCode("span_attribute_mapper_not_found")
-	ErrCodeSpanAttributeMapperAlreadyExists       = errors.MustNewCode("span_attribute_mapper_already_exists")
-	ErrCodeSpanAttributeMappingInvalidInput       = errors.MustNewCode("span_attribute_mapping_invalid_input")
-)

pkg/types/spanattributemappingtypes/group.go

@@ -1,108 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// as of now it can be llm, tool, agent but can extend to more things in future.
-type GroupCategory string
-
-// A group runs when any of the listed attribute/resource key patterns match.
-type Condition struct {
-	Attributes []string `json:"attributes"`
-	Resource   []string `json:"resource"`
-}
-
-func (c Condition) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (c *Condition) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*c = Condition{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanattributemappingtypes: cannot scan %T into Condition", src)
-	}
-	return json.Unmarshal(raw, c)
-}
-
-// Group is the domain model for a span attribute mapping group.
-type Group struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID        valuer.UUID   `json:"id" required:"true"`
-	OrgID     valuer.UUID   `json:"ordId" required:"true"`
-	Name      string        `json:"name" required:"true"`
-	Category  GroupCategory `json:"category" required:"true"`
-	Condition Condition     `json:"condition" required:"true"`
-	Enabled   bool          `json:"enabled" required:"true"`
-}
-
-func NewGroupFromStorable(s *StorableGroup) *Group {
-	return &Group{
-		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 NewGroupsFromStorable(ss []*StorableGroup) []*Group {
-	groups := make([]*Group, len(ss))
-	for i, s := range ss {
-		groups[i] = NewGroupFromStorable(s)
-	}
-	return groups
-}
-
-// GettableGroup is the HTTP response representation of a mapping group.
-type GettableGroup = Group
-
-func NewGettableGroup(g *Group) *GettableGroup {
-	return g
-}
-
-type PostableGroup struct {
-	Name      string        `json:"name"      required:"true"`
-	Category  GroupCategory `json:"category"  required:"true"`
-	Condition Condition     `json:"condition" required:"true"`
-	Enabled   bool          `json:"enabled"`
-}
-
-// UpdatableGroup is the HTTP request body for updating a mapping group.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableGroup struct {
-	Name      *string    `json:"name,omitempty"`
-	Condition *Condition `json:"condition,omitempty"`
-	Enabled   *bool      `json:"enabled,omitempty"`
-}
-
-type ListGroupsQuery struct {
-	Category *GroupCategory `query:"category"`
-	Enabled  *bool          `query:"enabled"`
-}
-
-type ListGroupsResponse struct {
-	Items []*GettableGroup `json:"items" required:"true" nullable:"true"`
-}

pkg/types/spanattributemappingtypes/mapper.go

@@ -1,131 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// FieldContext is where the target attribute is written.
-type FieldContext string
-
-const (
-	FieldContextSpanAttribute FieldContext = "attribute"
-	FieldContextResource      FieldContext = "resource"
-)
-
-func (FieldContext) Enum() []any {
-	return []any{FieldContextSpanAttribute, FieldContextResource}
-}
-
-// MapperOperation determines whether the source attribute is moved (deleted) or copied.
-type MapperOperation string
-
-const (
-	MapperOperationMove MapperOperation = "move"
-	MapperOperationCopy MapperOperation = "copy"
-)
-
-func (MapperOperation) Enum() []any {
-	return []any{MapperOperationMove, MapperOperationCopy}
-}
-
-// MapperSource describes one candidate source for a target attribute.
-type MapperSource struct {
-	Key       string          `json:"key"`
-	Context   FieldContext    `json:"context"`
-	Operation MapperOperation `json:"operation"`
-	Priority  int             `json:"priority"`
-}
-
-// MapperConfig holds the mapping logic for a single target attribute.
-// It implements driver.Valuer and sql.Scanner for JSON text column storage.
-type MapperConfig struct {
-	Sources []MapperSource `json:"sources"`
-}
-
-func (m MapperConfig) Value() (driver.Value, error) {
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (m *MapperConfig) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*m = MapperConfig{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanattributemapping: cannot scan %T into MapperConfig", src)
-	}
-	return json.Unmarshal(raw, m)
-}
-
-// Mapper is the domain model for a span attribute mapper.
-type Mapper 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       MapperConfig `json:"config"        required:"true"`
-	Enabled      bool         `json:"enabled"       required:"true"`
-}
-
-func NewMapperFromStorable(s *StorableMapper) *Mapper {
-	return &Mapper{
-		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 NewMappersFromStorable(ss []*StorableMapper) []*Mapper {
-	mappers := make([]*Mapper, len(ss))
-	for i, s := range ss {
-		mappers[i] = NewMapperFromStorable(s)
-	}
-	return mappers
-}
-
-type GettableMapper = Mapper
-
-func NewGettableMapper(m *Mapper) *GettableMapper {
-	return m
-}
-
-type PostableMapper struct {
-	Name         string       `json:"name"          required:"true"`
-	FieldContext FieldContext `json:"field_context" required:"true"`
-	Config       MapperConfig `json:"config"        required:"true"`
-	Enabled      bool         `json:"enabled"`
-}
-
-// UpdatableMapper is the HTTP request body for updating a mapper.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableMapper struct {
-	FieldContext FieldContext  `json:"field_context,omitempty"`
-	Config       *MapperConfig `json:"config,omitempty"`
-	Enabled      *bool         `json:"enabled,omitempty"`
-}
-
-type ListMappersResponse struct {
-	Items []*GettableMapper `json:"items" required:"true" nullable:"true"`
-}

pkg/types/spanattributemappingtypes/storable.go

@@ -1,35 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-type StorableGroup struct {
-	bun.BaseModel `bun:"table:span_attribute_mapping_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  GroupCategory `bun:"category,type:text,notnull"`
-	Condition Condition     `bun:"condition,type:text,notnull"`
-	Enabled   bool          `bun:"enabled,notnull,default:true"`
-}
-
-type StorableMapper struct {
-	bun.BaseModel `bun:"table:span_attribute_mapping,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       MapperConfig `bun:"config,type:text,notnull"`
-	Enabled      bool         `bun:"enabled,notnull,default:true"`
-}

pkg/types/spanattributemappingtypes/store.go

@@ -1,23 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	// Group operations
-	ListGroups(ctx context.Context, orgID valuer.UUID, q *ListGroupsQuery) ([]*StorableGroup, error)
-	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*StorableGroup, error)
-	CreateGroup(ctx context.Context, group *StorableGroup) error
-	UpdateGroup(ctx context.Context, group *StorableGroup) error
-	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*StorableMapper, error)
-	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*StorableMapper, error)
-	CreateMapper(ctx context.Context, mapper *StorableMapper) error
-	UpdateMapper(ctx context.Context, mapper *StorableMapper) error
-	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
-}

pkg/types/telemetrytypes/field.go

@@ -30,7 +30,7 @@ const (
 )
 
 type TelemetryFieldKey struct {
-	Name          string        `json:"name" validate:"required" required:"true"`
+	Name          string        `json:"name" required:"true"`
 	Description   string        `json:"description,omitempty"`
 	Unit          string        `json:"unit,omitempty"`
 	Signal        Signal        `json:"signal,omitzero"`