fix: remove overlapping time from duration aggregation

* feat(global): add mcp_url to global config

Adds an optional mcp_url field to the global config so the frontend can
gate the MCP settings page on its presence. When unset the API returns
"mcp_url": null (pointer + nullable:"true"); when set it emits the
parsed URL as a string.

* feat(global): surface mcp_url in frontend types

Adds mcp_url to the manual GlobalConfigData type and refreshes the
generated OpenAPI client so consumers can read the new field.

* docs(global): use <unset> placeholder for mcp_url example

Matches the style of external_url and ingestion_url above it.

* style(global): separate mcp_url prep from return in GetConfig

Adds a blank line between the nullable-conversion block and the return
statement so the two logical phases read as distinct blocks.

* feat(global): mark endpoint fields as required in the API schema

The backend always emits external_url, ingestion_url and mcp_url on
GET /api/v1/global/config (mcp_url as literal null when unset), so the
JSON keys are always present. Add required:"true" to all three and
regenerate the OpenAPI + frontend client so consumers get non-optional
types.

* revert(global): drop mcp_url from legacy GlobalConfigData type

The legacy hand-written type for the non-Orval getGlobalConfig client
should be left alone; consumers that need mcp_url go through the
generated Orval client.

conf/example.yaml

@@ -11,6 +11,8 @@ global:
   external_url: <unset>
   # the url where the SigNoz backend receives telemetry data (traces, metrics, logs) from instrumented applications.
   ingestion_url: <unset>
+  # the url of the SigNoz MCP server. when unset, the MCP settings page is hidden in the frontend.
+  # mcp_url: <unset>
 
 ##################### Version #####################
 version:

docs/api/openapi.yml

@@ -2369,6 +2369,13 @@ components:
           $ref: '#/components/schemas/GlobaltypesIdentNConfig'
         ingestion_url:
           type: string
+        mcp_url:
+          nullable: true
+          type: string
+      required:
+      - external_url
+      - ingestion_url
+      - mcp_url
       type: object
     GlobaltypesIdentNConfig:
       properties:
@@ -2508,155 +2515,6 @@ components:
       - list
       - grouped_list
       type: string
-    LlmpricingruletypesGettablePricingRules:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRule'
-          nullable: true
-          type: array
-        limit:
-          type: integer
-        offset:
-          type: integer
-        total:
-          type: integer
-      required:
-      - items
-      - total
-      - offset
-      - limit
-      type: object
-    LlmpricingruletypesLLMPricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRuleCacheMode'
-        costCacheRead:
-          format: double
-          type: number
-        costCacheWrite:
-          format: double
-          type: number
-        costInput:
-          format: double
-          type: number
-        costOutput:
-          format: double
-          type: number
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        id:
-          type: string
-        isOverride:
-          type: boolean
-        modelName:
-          type: string
-        modelPattern:
-          items:
-            type: string
-          nullable: true
-          type: array
-        orgId:
-          type: string
-        sourceId:
-          type: string
-        syncedAt:
-          format: date-time
-          nullable: true
-          type: string
-        unit:
-          $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRuleUnit'
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - modelName
-      - modelPattern
-      - unit
-      - cacheMode
-      - costInput
-      - costOutput
-      - costCacheRead
-      - costCacheWrite
-      - isOverride
-      - enabled
-      type: object
-    LlmpricingruletypesLLMPricingRuleCacheMode:
-      enum:
-      - subtract
-      - additive
-      - unknown
-      type: string
-    LlmpricingruletypesLLMPricingRuleUnit:
-      enum:
-      - per_million_tokens
-      type: string
-    LlmpricingruletypesUpdatableLLMPricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRuleCacheMode'
-        costCacheRead:
-          format: double
-          type: number
-        costCacheWrite:
-          format: double
-          type: number
-        costInput:
-          format: double
-          type: number
-        costOutput:
-          format: double
-          type: number
-        enabled:
-          type: boolean
-        id:
-          nullable: true
-          type: string
-        isOverride:
-          nullable: true
-          type: boolean
-        modelName:
-          type: string
-        modelPattern:
-          items:
-            type: string
-          nullable: true
-          type: array
-        sourceId:
-          nullable: true
-          type: string
-        unit:
-          $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRuleUnit'
-      required:
-      - modelName
-      - modelPattern
-      - unit
-      - cacheMode
-      - costInput
-      - costOutput
-      - costCacheRead
-      - costCacheWrite
-      - enabled
-      type: object
-    LlmpricingruletypesUpdatableLLMPricingRules:
-      properties:
-        rules:
-          items:
-            $ref: '#/components/schemas/LlmpricingruletypesUpdatableLLMPricingRule'
-          nullable: true
-          type: array
-      required:
-      - rules
-      type: object
     MetricsexplorertypesInspectMetricsRequest:
       properties:
         end:
@@ -4745,6 +4603,11 @@ components:
       type: object
     TracedetailtypesGettableWaterfallTrace:
       properties:
+        aggregations:
+          items:
+            $ref: '#/components/schemas/TracedetailtypesSpanAggregationResult'
+          nullable: true
+          type: array
         endTimestampMillis:
           minimum: 0
           type: integer
@@ -4784,6 +4647,11 @@ components:
       type: object
     TracedetailtypesPostableWaterfall:
       properties:
+        aggregations:
+          items:
+            $ref: '#/components/schemas/TracedetailtypesSpanAggregation'
+          nullable: true
+          type: array
         limit:
           minimum: 0
           type: integer
@@ -4795,6 +4663,32 @@ components:
           nullable: true
           type: array
       type: object
+    TracedetailtypesSpanAggregation:
+      properties:
+        aggregation:
+          $ref: '#/components/schemas/TracedetailtypesSpanAggregationType'
+        field:
+          $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
+      type: object
+    TracedetailtypesSpanAggregationResult:
+      properties:
+        aggregation:
+          $ref: '#/components/schemas/TracedetailtypesSpanAggregationType'
+        field:
+          $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
+        value:
+          additionalProperties:
+            minimum: 0
+            type: integer
+          nullable: true
+          type: object
+      type: object
+    TracedetailtypesSpanAggregationType:
+      enum:
+      - spanCount
+      - executionTimePercentage
+      - duration
+      type: string
     TracedetailtypesWaterfallSpan:
       properties:
         attributes:
@@ -7481,218 +7375,6 @@ paths:
       summary: Create bulk invite
       tags:
       - users
-  /api/v1/llm_pricing_rules:
-    get:
-      deprecated: false
-      description: Returns all LLM pricing rules for the authenticated org, with pagination.
-      operationId: ListLLMPricingRules
-      parameters:
-      - in: query
-        name: offset
-        schema:
-          type: integer
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/LlmpricingruletypesGettablePricingRules'
-                  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 pricing rules
-      tags:
-      - llmpricingrules
-    put:
-      deprecated: false
-      description: Single write endpoint used by both the user and the Zeus sync job.
-        Per-rule match is by id, then sourceId, then insert. Override rows (is_override=true)
-        are fully preserved when the request does not provide isOverride; only synced_at
-        is stamped.
-      operationId: UpdateLLMPricingRules
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/LlmpricingruletypesUpdatableLLMPricingRules'
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Bulk update pricing rules
-      tags:
-      - llmpricingrules
-  /api/v1/llm_pricing_rules/{id}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a pricing rule. If auto-synced, it will be recreated
-        on the next sync cycle.
-      operationId: DeleteLLMPricingRule
-      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 pricing rule
-      tags:
-      - llmpricingrules
-    get:
-      deprecated: false
-      description: Returns a single LLM pricing rule by ID.
-      operationId: GetLLMPricingRule
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/LlmpricingruletypesLLMPricingRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get a pricing rule
-      tags:
-      - llmpricingrules
   /api/v1/logs/promote_paths:
     get:
       deprecated: false

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

@@ -1,398 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import { useMutation, useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type {
-	DeleteLLMPricingRulePathParameters,
-	GetLLMPricingRule200,
-	GetLLMPricingRulePathParameters,
-	ListLLMPricingRules200,
-	ListLLMPricingRulesParams,
-	LlmpricingruletypesUpdatableLLMPricingRulesDTO,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * Returns all LLM pricing rules for the authenticated org, with pagination.
- * @summary List pricing rules
- */
-export const listLLMPricingRules = (
-	params?: ListLLMPricingRulesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListLLMPricingRules200>({
-		url: `/api/v1/llm_pricing_rules`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListLLMPricingRulesQueryKey = (
-	params?: ListLLMPricingRulesParams,
-) => {
-	return [`/api/v1/llm_pricing_rules`, ...(params ? [params] : [])] as const;
-};
-
-export const getListLLMPricingRulesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listLLMPricingRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListLLMPricingRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listLLMPricingRules>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListLLMPricingRulesQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listLLMPricingRules>>
-	> = ({ signal }) => listLLMPricingRules(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listLLMPricingRules>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListLLMPricingRulesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listLLMPricingRules>>
->;
-export type ListLLMPricingRulesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List pricing rules
- */
-
-export function useListLLMPricingRules<
-	TData = Awaited<ReturnType<typeof listLLMPricingRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListLLMPricingRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listLLMPricingRules>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListLLMPricingRulesQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List pricing rules
- */
-export const invalidateListLLMPricingRules = async (
-	queryClient: QueryClient,
-	params?: ListLLMPricingRulesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListLLMPricingRulesQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Single write endpoint used by both the user and the Zeus sync job. Per-rule match is by id, then sourceId, then insert. Override rows (is_override=true) are fully preserved when the request does not provide isOverride; only synced_at is stamped.
- * @summary Bulk update pricing rules
- */
-export const updateLLMPricingRules = (
-	llmpricingruletypesUpdatableLLMPricingRulesDTO: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/llm_pricing_rules`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: llmpricingruletypesUpdatableLLMPricingRulesDTO,
-	});
-};
-
-export const getUpdateLLMPricingRulesMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateLLMPricingRules>>,
-		TError,
-		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateLLMPricingRules>>,
-	TError,
-	{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
-	TContext
-> => {
-	const mutationKey = ['updateLLMPricingRules'];
-	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 updateLLMPricingRules>>,
-		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return updateLLMPricingRules(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateLLMPricingRulesMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateLLMPricingRules>>
->;
-export type UpdateLLMPricingRulesMutationBody =
-	BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>;
-export type UpdateLLMPricingRulesMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Bulk update pricing rules
- */
-export const useUpdateLLMPricingRules = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateLLMPricingRules>>,
-		TError,
-		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateLLMPricingRules>>,
-	TError,
-	{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
-	TContext
-> => {
-	const mutationOptions = getUpdateLLMPricingRulesMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a pricing rule. If auto-synced, it will be recreated on the next sync cycle.
- * @summary Delete a pricing rule
- */
-export const deleteLLMPricingRule = ({
-	id,
-}: DeleteLLMPricingRulePathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/llm_pricing_rules/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteLLMPricingRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLLMPricingRule>>,
-		TError,
-		{ pathParams: DeleteLLMPricingRulePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteLLMPricingRule>>,
-	TError,
-	{ pathParams: DeleteLLMPricingRulePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteLLMPricingRule'];
-	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 deleteLLMPricingRule>>,
-		{ pathParams: DeleteLLMPricingRulePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteLLMPricingRule(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteLLMPricingRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteLLMPricingRule>>
->;
-
-export type DeleteLLMPricingRuleMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a pricing rule
- */
-export const useDeleteLLMPricingRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLLMPricingRule>>,
-		TError,
-		{ pathParams: DeleteLLMPricingRulePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteLLMPricingRule>>,
-	TError,
-	{ pathParams: DeleteLLMPricingRulePathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteLLMPricingRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns a single LLM pricing rule by ID.
- * @summary Get a pricing rule
- */
-export const getLLMPricingRule = (
-	{ id }: GetLLMPricingRulePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetLLMPricingRule200>({
-		url: `/api/v1/llm_pricing_rules/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetLLMPricingRuleQueryKey = ({
-	id,
-}: GetLLMPricingRulePathParameters) => {
-	return [`/api/v1/llm_pricing_rules/${id}`] as const;
-};
-
-export const getGetLLMPricingRuleQueryOptions = <
-	TData = Awaited<ReturnType<typeof getLLMPricingRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLLMPricingRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLLMPricingRule>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetLLMPricingRuleQueryKey({ id });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getLLMPricingRule>>
-	> = ({ signal }) => getLLMPricingRule({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getLLMPricingRule>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetLLMPricingRuleQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getLLMPricingRule>>
->;
-export type GetLLMPricingRuleQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a pricing rule
- */
-
-export function useGetLLMPricingRule<
-	TData = Awaited<ReturnType<typeof getLLMPricingRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLLMPricingRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLLMPricingRule>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetLLMPricingRuleQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get a pricing rule
- */
-export const invalidateGetLLMPricingRule = async (
-	queryClient: QueryClient,
-	{ id }: GetLLMPricingRulePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetLLMPricingRuleQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -3125,12 +3125,17 @@ export interface GlobaltypesConfigDTO {
 	/**
 	 * @type string
 	 */
-	external_url?: string;
+	external_url: string;
 	identN?: GlobaltypesIdentNConfigDTO;
 	/**
 	 * @type string
 	 */
-	ingestion_url?: string;
+	ingestion_url: string;
+	/**
+	 * @type string
+	 * @nullable true
+	 */
+	mcp_url: string | null;
 }
 
 export interface GlobaltypesIdentNConfigDTO {
@@ -3278,173 +3283,6 @@ export enum InframonitoringtypesResponseTypeDTO {
 	list = 'list',
 	grouped_list = 'grouped_list',
 }
-export interface LlmpricingruletypesGettablePricingRulesDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: LlmpricingruletypesLLMPricingRuleDTO[] | null;
-	/**
-	 * @type integer
-	 */
-	limit: number;
-	/**
-	 * @type integer
-	 */
-	offset: number;
-	/**
-	 * @type integer
-	 */
-	total: number;
-}
-
-export interface LlmpricingruletypesLLMPricingRuleDTO {
-	cacheMode: LlmpricingruletypesLLMPricingRuleCacheModeDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheRead: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheWrite: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costInput: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costOutput: number;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type boolean
-	 */
-	isOverride: boolean;
-	/**
-	 * @type string
-	 */
-	modelName: string;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	modelPattern: string[] | null;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 */
-	sourceId?: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 * @nullable true
-	 */
-	syncedAt?: Date | null;
-	unit: LlmpricingruletypesLLMPricingRuleUnitDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export enum LlmpricingruletypesLLMPricingRuleCacheModeDTO {
-	subtract = 'subtract',
-	additive = 'additive',
-	unknown = 'unknown',
-}
-export enum LlmpricingruletypesLLMPricingRuleUnitDTO {
-	per_million_tokens = 'per_million_tokens',
-}
-export interface LlmpricingruletypesUpdatableLLMPricingRuleDTO {
-	cacheMode: LlmpricingruletypesLLMPricingRuleCacheModeDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheRead: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheWrite: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costInput: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costOutput: number;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	id?: string | null;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	isOverride?: boolean | null;
-	/**
-	 * @type string
-	 */
-	modelName: string;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	modelPattern: string[] | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	sourceId?: string | null;
-	unit: LlmpricingruletypesLLMPricingRuleUnitDTO;
-}
-
-export interface LlmpricingruletypesUpdatableLLMPricingRulesDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	rules: LlmpricingruletypesUpdatableLLMPricingRuleDTO[] | null;
-}
-
 export interface MetricsexplorertypesInspectMetricsRequestDTO {
 	/**
 	 * @type integer
@@ -5755,6 +5593,11 @@ export type TracedetailtypesGettableWaterfallTraceDTOServiceNameToTotalDurationM
 	{ [key: string]: number } | null;
 
 export interface TracedetailtypesGettableWaterfallTraceDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	aggregations?: TracedetailtypesSpanAggregationResultDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -5809,6 +5652,11 @@ export interface TracedetailtypesGettableWaterfallTraceDTO {
 }
 
 export interface TracedetailtypesPostableWaterfallDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	aggregations?: TracedetailtypesSpanAggregationDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -5825,6 +5673,33 @@ export interface TracedetailtypesPostableWaterfallDTO {
 	uncollapsedSpans?: string[] | null;
 }
 
+export interface TracedetailtypesSpanAggregationDTO {
+	aggregation?: TracedetailtypesSpanAggregationTypeDTO;
+	field?: TelemetrytypesTelemetryFieldKeyDTO;
+}
+
+/**
+ * @nullable
+ */
+export type TracedetailtypesSpanAggregationResultDTOValue = {
+	[key: string]: number;
+} | null;
+
+export interface TracedetailtypesSpanAggregationResultDTO {
+	aggregation?: TracedetailtypesSpanAggregationTypeDTO;
+	field?: TelemetrytypesTelemetryFieldKeyDTO;
+	/**
+	 * @type object
+	 * @nullable true
+	 */
+	value?: TracedetailtypesSpanAggregationResultDTOValue;
+}
+
+export enum TracedetailtypesSpanAggregationTypeDTO {
+	spanCount = 'spanCount',
+	executionTimePercentage = 'executionTimePercentage',
+	duration = 'duration',
+}
 /**
  * @nullable
  */
@@ -6821,41 +6696,6 @@ export type CreateInvite201 = {
 	status: string;
 };
 
-export type ListLLMPricingRulesParams = {
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-};
-
-export type ListLLMPricingRules200 = {
-	data: LlmpricingruletypesGettablePricingRulesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteLLMPricingRulePathParameters = {
-	id: string;
-};
-export type GetLLMPricingRulePathParameters = {
-	id: string;
-};
-export type GetLLMPricingRule200 = {
-	data: LlmpricingruletypesLLMPricingRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListPromotedAndIndexedPaths200 = {
 	/**
 	 * @type array

pkg/apiserver/signozapiserver/llmpricingrule.go

@@ -1,93 +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/llmpricingruletypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addLLMPricingRuleRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/llm_pricing_rules", handler.New(
-		provider.authZ.ViewAccess(provider.llmPricingRuleHandler.List),
-		handler.OpenAPIDef{
-			ID:                  "ListLLMPricingRules",
-			Tags:                []string{"llmpricingrules"},
-			Summary:             "List pricing rules",
-			Description:         "Returns all LLM pricing rules for the authenticated org, with pagination.",
-			Request:             nil,
-			RequestContentType:  "",
-			RequestQuery:        new(llmpricingruletypes.ListPricingRulesQuery),
-			Response:            new(llmpricingruletypes.GettablePricingRules),
-			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/llm_pricing_rules", handler.New(
-		provider.authZ.AdminAccess(provider.llmPricingRuleHandler.Update),
-		handler.OpenAPIDef{
-			ID:                 "UpdateLLMPricingRules",
-			Tags:               []string{"llmpricingrules"},
-			Summary:            "Bulk update pricing rules",
-			Description:        "Single write endpoint used by both the user and the Zeus sync job. Per-rule match is by id, then sourceId, then insert. Override rows (is_override=true) are fully preserved when the request does not provide isOverride; only synced_at is stamped.",
-			Request:            new(llmpricingruletypes.UpdatableLLMPricingRules),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/llm_pricing_rules/{id}", handler.New(
-		provider.authZ.ViewAccess(provider.llmPricingRuleHandler.Get),
-		handler.OpenAPIDef{
-			ID:                  "GetLLMPricingRule",
-			Tags:                []string{"llmpricingrules"},
-			Summary:             "Get a pricing rule",
-			Description:         "Returns a single LLM pricing rule by ID.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(llmpricingruletypes.GettableLLMPricingRule),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/llm_pricing_rules/{id}", handler.New(
-		provider.authZ.AdminAccess(provider.llmPricingRuleHandler.Delete),
-		handler.OpenAPIDef{
-			ID:                  "DeleteLLMPricingRule",
-			Tags:                []string{"llmpricingrules"},
-			Summary:             "Delete a pricing rule",
-			Description:         "Hard-deletes a pricing rule. If auto-synced, it will be recreated on the next sync cycle.",
-			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/apiserver/signozapiserver/provider.go

@@ -16,9 +16,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -66,7 +65,6 @@ type provider struct {
 	alertmanagerHandler     alertmanager.Handler
 	traceDetailHandler      tracedetail.Handler
 	rulerHandler            ruler.Handler
-	llmPricingRuleHandler   llmpricingrule.Handler
 }
 
 func NewFactory(
@@ -95,7 +93,6 @@ func NewFactory(
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
 	alertmanagerHandler alertmanager.Handler,
-	llmPricingRuleHandler llmpricingrule.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
@@ -129,7 +126,6 @@ func NewFactory(
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
 			alertmanagerHandler,
-			llmPricingRuleHandler,
 			traceDetailHandler,
 			rulerHandler,
 		)
@@ -165,7 +161,6 @@ func newProvider(
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
 	alertmanagerHandler alertmanager.Handler,
-	llmPricingRuleHandler llmpricingrule.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
 ) (apiserver.APIServer, error) {
@@ -201,7 +196,6 @@ func newProvider(
 		alertmanagerHandler:     alertmanagerHandler,
 		traceDetailHandler:      traceDetailHandler,
 		rulerHandler:            rulerHandler,
-		llmPricingRuleHandler:   llmPricingRuleHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -310,10 +304,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addLLMPricingRuleRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addTraceDetailRoutes(router); err != nil {
 		return err
 	}

pkg/global/config.go

@@ -17,6 +17,7 @@ var (
 type Config struct {
 	ExternalURL  *url.URL `mapstructure:"external_url"`
 	IngestionURL *url.URL `mapstructure:"ingestion_url"`
+	MCPURL       *url.URL `mapstructure:"mcp_url"`
 }
 
 func NewConfigFactory() factory.ConfigFactory {

pkg/global/signozglobal/provider.go

@@ -31,8 +31,14 @@ func newProvider(_ context.Context, providerSettings factory.ProviderSettings, c
 }
 
 func (provider *provider) GetConfig(context.Context) *globaltypes.Config {
+	var mcpURL *string
+	if provider.config.MCPURL != nil {
+		s := provider.config.MCPURL.String()
+		mcpURL = &s
+	}
+
 	return globaltypes.NewConfig(
-		globaltypes.NewEndpoint(provider.config.ExternalURL.String(), provider.config.IngestionURL.String()),
+		globaltypes.NewEndpoint(provider.config.ExternalURL.String(), provider.config.IngestionURL.String(), mcpURL),
 		globaltypes.NewIdentNConfig(
 			globaltypes.TokenizerConfig{Enabled: provider.identNConfig.Tokenizer.Enabled},
 			globaltypes.APIKeyConfig{Enabled: provider.identNConfig.APIKeyConfig.Enabled},

pkg/modules/llmpricingrule/impllmpricingrule/handler.go

@@ -1,158 +0,0 @@
-package impllmpricingrule
-
-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/llmpricingrule"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/llmpricingruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-const maxLimit = 100
-
-type handler struct {
-	module           llmpricingrule.Module
-	providerSettings factory.ProviderSettings
-}
-
-func NewHandler(module llmpricingrule.Module, providerSettings factory.ProviderSettings) llmpricingrule.Handler {
-	return &handler{module: module, providerSettings: providerSettings}
-}
-
-// List handles GET /api/v1/llm_pricing_rules.
-func (h *handler) List(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	var q llmpricingruletypes.ListPricingRulesQuery
-	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if q.Limit <= 0 {
-		q.Limit = 20
-	} else if q.Limit > maxLimit {
-		q.Limit = maxLimit
-	}
-	if q.Offset < 0 {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, llmpricingruletypes.ErrCodePricingRuleInvalidInput, "offset must be a non-negative integer"))
-		return
-	}
-
-	rules, total, err := h.module.List(ctx, orgID, q.Offset, q.Limit)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, llmpricingruletypes.NewGettableLLMPricingRulesFromLLMPricingRules(rules, total, q.Offset, q.Limit))
-}
-
-// Get handles GET /api/v1/llm_pricing_rules/{id}.
-func (h *handler) Get(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	id, err := ruleIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	rule, err := h.module.Get(ctx, orgID, id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, rule)
-}
-
-func (h *handler) Update(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	req := new(llmpricingruletypes.UpdatableLLMPricingRules)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.Update(ctx, orgID, claims.Email, req.Rules)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// Delete handles DELETE /api/v1/llm_pricing_rules/{id}.
-func (h *handler) Delete(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	id, err := ruleIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.Delete(ctx, orgID, id); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// ruleIDFromPath extracts and validates the {id} path variable.
-func ruleIDFromPath(r *http.Request) (valuer.UUID, error) {
-	raw := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, llmpricingruletypes.ErrCodePricingRuleInvalidInput, "id is not a valid uuid")
-	}
-	return id, nil
-}

pkg/modules/llmpricingrule/llmpricingrule.go

@@ -1,24 +0,0 @@
-package llmpricingrule
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/llmpricingruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Module interface {
-	List(ctx context.Context, orgID valuer.UUID, offset, limit int) ([]*llmpricingruletypes.LLMPricingRule, int, error)
-	Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*llmpricingruletypes.LLMPricingRule, error)
-	Update(ctx context.Context, orgID valuer.UUID, userEmail string, rules []llmpricingruletypes.UpdatableLLMPricingRule) (err error)
-	Delete(ctx context.Context, orgID, id valuer.UUID) error
-}
-
-// Handler defines the HTTP handler interface for pricing rule endpoints.
-type Handler interface {
-	List(rw http.ResponseWriter, r *http.Request)
-	Get(rw http.ResponseWriter, r *http.Request)
-	Update(rw http.ResponseWriter, r *http.Request)
-	Delete(rw http.ResponseWriter, r *http.Request)
-}

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -25,6 +25,11 @@ func (h *handler) GetWaterfall(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if err := req.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
 	result, err := h.module.GetWaterfall(r.Context(), mux.Vars(r)["traceID"], req)
 	if err != nil {
 		render.Error(rw, err)

pkg/modules/tracedetail/impltracedetail/module.go

@@ -37,7 +37,12 @@ func (m *module) GetWaterfall(ctx context.Context, traceID string, req *tracedet
 		m.config.Waterfall.MaxDepthToAutoExpand,
 	)
 
-	return tracedetailtypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans), nil
+	aggregationResults := make([]tracedetailtypes.SpanAggregationResult, 0, len(req.Aggregations))
+	for _, a := range req.Aggregations {
+		aggregationResults = append(aggregationResults, waterfallTrace.GetSpanAggregation(a.Aggregation, a.Field))
+	}
+
+	return tracedetailtypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans, aggregationResults), nil
 }
 
 // getTraceData returns the waterfall cache for the given traceID with fallback on DB.

pkg/modules/tracedetail/impltracedetail/waterfall_test.go

@@ -260,7 +260,7 @@ func TestGetSelectedSpans_MultipleRoots(t *testing.T) {
 	trace := getWaterfallTrace([]*tracedetailtypes.WaterfallSpan{root1, root2}, spanMap)
 	spans, _ := trace.GetSelectedSpans([]string{"root1", "root2"}, "root1", 500, 5)
 
-	traceRespnose := tracedetailtypes.NewGettableWaterfallTrace(trace, spans, nil, false)
+	traceRespnose := tracedetailtypes.NewGettableWaterfallTrace(trace, spans, nil, false, nil)
 
 	assert.Equal(t, []string{"root1", "child1", "root2", "child2"}, spanIDs(spans), "root1 subtree must precede root2 subtree")
 	assert.Equal(t, "svc-a", traceRespnose.RootServiceName, "metadata comes from first root")
@@ -567,7 +567,7 @@ func TestGetAllSpans(t *testing.T) {
 	)
 	trace := getWaterfallTrace([]*tracedetailtypes.WaterfallSpan{root}, nil)
 	spans := trace.GetAllSpans()
-	traceResponse := tracedetailtypes.NewGettableWaterfallTrace(trace, spans, nil, true)
+	traceResponse := tracedetailtypes.NewGettableWaterfallTrace(trace, spans, nil, true, nil)
 	assert.ElementsMatch(t, spanIDs(spans), []string{"root", "childA", "grandchildA", "leafA", "childB", "grandchildB", "leafB"})
 	assert.Equal(t, "svc", traceResponse.RootServiceName)
 	assert.Equal(t, "root-op", traceResponse.RootServiceEntryPoint)

pkg/query-service/app/clickhouseReader/reader.go

@@ -1154,7 +1154,13 @@ func (r *ClickHouseReader) GetFlamegraphSpansForTrace(ctx context.Context, orgID
 	if err != nil {
 		r.logger.Info("cache miss for getFlamegraphSpansForTrace", "traceID", traceID)
 
-		searchScanResponses, err := r.GetSpansForTrace(ctx, traceID, fmt.Sprintf("SELECT timestamp, duration_nano, span_id, trace_id, has_error,links as references, resource_string_service$$name, name, events FROM %s.%s WHERE trace_id=$1 and ts_bucket_start>=$2 and ts_bucket_start<=$3 ORDER BY timestamp ASC, name ASC", r.TraceDB, r.traceTableName))
+		selectCols := "timestamp, duration_nano, span_id, trace_id, has_error, links as references, resource_string_service$$name, name, events"
+		if len(req.RequiredFields) > 0 {
+			selectCols += ", attributes_string, attributes_number, attributes_bool, resources_string"
+		}
+		flamegraphQuery := fmt.Sprintf("SELECT %s FROM %s.%s WHERE trace_id=$1 and ts_bucket_start>=$2 and ts_bucket_start<=$3 ORDER BY timestamp ASC, name ASC", selectCols, r.TraceDB, r.traceTableName)
+
+		searchScanResponses, err := r.GetSpansForTrace(ctx, traceID, flamegraphQuery)
 		if err != nil {
 			return nil, err
 		}
@@ -1193,6 +1199,10 @@ func (r *ClickHouseReader) GetFlamegraphSpansForTrace(ctx context.Context, orgID
 				Children:     make([]*model.FlamegraphSpan, 0),
 			}
 
+			if len(req.RequiredFields) > 0 {
+				jsonItem.SetRequestedFields(item, req.RequiredFields)
+			}
+
 			// metadata calculation
 			startTimeUnixNano := uint64(item.TimeUnixNano.UnixNano())
 			if startTime == 0 || startTimeUnixNano < startTime {

pkg/query-service/model/queryParams.go

@@ -2,6 +2,8 @@ package model
 
 import (
 	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 type InstantQueryMetricsParams struct {
@@ -337,10 +339,11 @@ type GetWaterfallSpansForTraceWithMetadataParams struct {
 }
 
 type GetFlamegraphSpansForTraceParams struct {
-	SelectedSpanID  string `json:"selectedSpanId"`
-	Limit           uint   `json:"limit"`
-	BoundaryStartTS uint64 `json:"boundaryStartTsMilli"`
-	BoundaryEndTS   uint64 `json:"boundarEndTsMilli"`
+	SelectedSpanID  string                             `json:"selectedSpanId"`
+	Limit           uint                               `json:"limit"`
+	BoundaryStartTS uint64                             `json:"boundaryStartTsMilli"`
+	BoundaryEndTS   uint64                             `json:"boundarEndTsMilli"`
+	RequiredFields  []telemetrytypes.TelemetryFieldKey `json:"requiredFields"`
 }
 
 type SpanFilterParams struct {

pkg/query-service/model/response.go

@@ -7,6 +7,7 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/pkg/errors"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/util/stats"
@@ -314,6 +315,30 @@ type FlamegraphSpan struct {
 	Events       []Event           `json:"event"`
 	References   []OtelSpanRef     `json:"references,omitempty"`
 	Children     []*FlamegraphSpan `json:"children"`
+	Attributes   map[string]any    `json:"attributes,omitempty"`
+	Resource     map[string]string `json:"resource,omitempty"`
+}
+
+// SetRequestedFields extracts the requested attribute/resource fields from item into s.
+func (s *FlamegraphSpan) SetRequestedFields(item SpanItemV2, fields []telemetrytypes.TelemetryFieldKey) {
+	for _, field := range fields {
+		switch field.FieldContext {
+		case telemetrytypes.FieldContextResource:
+			if v, ok := item.Resources_string[field.Name]; ok && v != "" {
+				if s.Resource == nil {
+					s.Resource = make(map[string]string)
+				}
+				s.Resource[field.Name] = v
+			}
+		case telemetrytypes.FieldContextAttribute:
+			if v := item.AttributeValue(field.Name); v != nil {
+				if s.Attributes == nil {
+					s.Attributes = make(map[string]any)
+				}
+				s.Attributes[field.Name] = v
+			}
+		}
+	}
 }
 
 type GetWaterfallSpansForTraceWithMetadataResponse struct {

pkg/query-service/model/trace.go

@@ -29,3 +29,17 @@ type TraceSummary struct {
 	End      time.Time `ch:"end"`
 	NumSpans uint64    `ch:"num_spans"`
 }
+
+// AttributeValue looks up an attribute across string, number, and bool maps in priority order.
+func (s SpanItemV2) AttributeValue(name string) any {
+	if v, ok := s.Attributes_string[name]; ok && v != "" {
+		return v
+	}
+	if v, ok := s.Attributes_number[name]; ok {
+		return v
+	}
+	if v, ok := s.Attributes_bool[name]; ok {
+		return v
+	}
+	return nil
+}

pkg/signoz/handler.go

@@ -22,8 +22,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/fields/implfields"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
-	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule/impllmpricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
@@ -76,7 +74,6 @@ type Handlers struct {
 	AlertmanagerHandler     alertmanager.Handler
 	TraceDetail             tracedetail.Handler
 	RulerHandler            ruler.Handler
-	LLMPricingRuleHandler   llmpricingrule.Handler
 }
 
 func NewHandlers(
@@ -120,6 +117,5 @@ func NewHandlers(
 		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
 		TraceDetail:             impltracedetail.NewHandler(modules.TraceDetail),
 		RulerHandler:            signozruler.NewHandler(rulerService),
-		LLMPricingRuleHandler:   impllmpricingrule.NewHandler(nil, providerSettings),
 	}
 }

pkg/signoz/openapi.go

@@ -21,9 +21,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/llmpricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
+	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -76,7 +75,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
 		struct{ alertmanager.Handler }{},
-		struct{ llmpricingrule.Handler }{},
 		struct{ tracedetail.Handler }{},
 		struct{ ruler.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})

pkg/signoz/provider.go

@@ -282,7 +282,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
 			handlers.AlertmanagerHandler,
-			handlers.LLMPricingRuleHandler,
 			handlers.TraceDetail,
 			handlers.RulerHandler,
 		),

pkg/types/globaltypes/endpoint.go

@@ -1,13 +1,15 @@
 package globaltypes
 
 type Endpoint struct {
-	ExternalURL  string `json:"external_url"`
-	IngestionURL string `json:"ingestion_url"`
+	ExternalURL  string  `json:"external_url" required:"true"`
+	IngestionURL string  `json:"ingestion_url" required:"true"`
+	MCPURL       *string `json:"mcp_url" required:"true" nullable:"true"`
 }
 
-func NewEndpoint(externalURL, ingestionURL string) Endpoint {
+func NewEndpoint(externalURL, ingestionURL string, mcpURL *string) Endpoint {
 	return Endpoint{
 		ExternalURL:  externalURL,
 		IngestionURL: ingestionURL,
+		MCPURL:       mcpURL,
 	}
 }

pkg/types/llmpricingruletypes/pricing.go

@@ -1,144 +0,0 @@
-package llmpricingruletypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodePricingRuleNotFound     = errors.MustNewCode("pricing_rule_not_found")
-	ErrCodePricingRuleInvalidInput = errors.MustNewCode("pricing_rule_invalid_input")
-)
-
-type LLMPricingRuleUnit struct {
-	valuer.String
-}
-
-var (
-	UnitPerMillionTokens = LLMPricingRuleUnit{valuer.NewString("per_million_tokens")}
-)
-
-type LLMPricingRuleCacheMode struct {
-	valuer.String
-}
-
-var (
-	// LLMPricingRuleCacheModeSubtract: cached tokens are inside input_tokens (OpenAI-style).
-	LLMPricingRuleCacheModeSubtract = LLMPricingRuleCacheMode{valuer.NewString("subtract")}
-	// LLMPricingRuleCacheModeAdditive: cached tokens are reported separately (Anthropic-style).
-	LLMPricingRuleCacheModeAdditive = LLMPricingRuleCacheMode{valuer.NewString("additive")}
-	// LLMPricingRuleCacheModeUnknown: provider behaviour is unknown; falls back to subtract.
-	LLMPricingRuleCacheModeUnknown = LLMPricingRuleCacheMode{valuer.NewString("unknown")}
-)
-
-// LLMPricingRule is the domain model for an LLM pricing rule.
-// It also doubles as the HTTP response shape; see GettablePricingRule.
-type LLMPricingRule struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID             valuer.UUID             `json:"id" required:"true"`
-	OrgID          valuer.UUID             `json:"orgId" required:"true"`
-	SourceID       *valuer.UUID            `json:"sourceId,omitempty"`
-	Model          string                  `json:"modelName" required:"true"`
-	ModelPattern   []string                `json:"modelPattern" required:"true"`
-	Unit           LLMPricingRuleUnit      `json:"unit" required:"true"`
-	CacheMode      LLMPricingRuleCacheMode `json:"cacheMode" required:"true"`
-	CostInput      float64                 `json:"costInput" required:"true"`
-	CostOutput     float64                 `json:"costOutput" required:"true"`
-	CostCacheRead  float64                 `json:"costCacheRead" required:"true"`
-	CostCacheWrite float64                 `json:"costCacheWrite" required:"true"`
-	IsOverride     bool                    `json:"isOverride" required:"true"`
-	SyncedAt       *time.Time              `json:"syncedAt,omitempty"`
-	Enabled        bool                    `json:"enabled" required:"true"`
-}
-
-// GettablePricingRule is a type alias for PricingRule — the response shape is
-// identical to the core type, so per pkg/types conventions we do not mint a
-// separate flavor.
-type GettableLLMPricingRule = LLMPricingRule
-
-// UpdatablePricingRule is one entry in the bulk upsert batch.
-//
-// Identification:
-//   - ID set       → match by id (user editing a known row).
-//   - SourceID set → match by source_id (Zeus sync, or user editing a Zeus-synced row).
-//   - neither set  → insert a new row with source_id = NULL (user-created custom rule).
-//
-// IsOverride is a pointer so the caller can distinguish "not sent" from "set to false".
-// When IsOverride is nil AND the matched row has is_override = true, the row is fully
-// preserved — only synced_at is stamped.
-type UpdatableLLMPricingRule struct {
-	ID             *valuer.UUID            `json:"id,omitempty"`
-	SourceID       *valuer.UUID            `json:"sourceId,omitempty"`
-	Model          string                  `json:"modelName" required:"true"`
-	ModelPattern   []string                `json:"modelPattern" required:"true"`
-	Unit           LLMPricingRuleUnit      `json:"unit" required:"true"`
-	CacheMode      LLMPricingRuleCacheMode `json:"cacheMode" required:"true"`
-	CostInput      float64                 `json:"costInput" required:"true"`
-	CostOutput     float64                 `json:"costOutput" required:"true"`
-	CostCacheRead  float64                 `json:"costCacheRead" required:"true"`
-	CostCacheWrite float64                 `json:"costCacheWrite" required:"true"`
-	IsOverride     *bool                   `json:"isOverride,omitempty"`
-	Enabled        bool                    `json:"enabled" required:"true"`
-}
-
-type UpdatableLLMPricingRules struct {
-	Rules []UpdatableLLMPricingRule `json:"rules" required:"true"`
-}
-
-type ListPricingRulesQuery struct {
-	Offset int `query:"offset" json:"offset"`
-	Limit  int `query:"limit"  json:"limit"`
-}
-
-type GettablePricingRules struct {
-	Items  []*GettableLLMPricingRule `json:"items"  required:"true"`
-	Total  int                       `json:"total"  required:"true"`
-	Offset int                       `json:"offset" required:"true"`
-	Limit  int                       `json:"limit"  required:"true"`
-}
-
-func (LLMPricingRuleUnit) Enum() []any {
-	return []any{UnitPerMillionTokens}
-}
-
-func (LLMPricingRuleCacheMode) Enum() []any {
-	return []any{LLMPricingRuleCacheModeSubtract, LLMPricingRuleCacheModeAdditive, LLMPricingRuleCacheModeUnknown}
-}
-
-func NewLLMPricingRuleFromStorable(s *StorableLLMPricingRule) *LLMPricingRule {
-	pattern := make([]string, len(s.ModelPattern))
-	copy(pattern, s.ModelPattern)
-
-	return &LLMPricingRule{
-		TimeAuditable:  s.TimeAuditable,
-		UserAuditable:  s.UserAuditable,
-		ID:             s.ID,
-		OrgID:          s.OrgID,
-		SourceID:       s.SourceID,
-		Model:          s.Model,
-		ModelPattern:   pattern,
-		Unit:           s.Unit,
-		CacheMode:      s.CacheMode,
-		CostInput:      s.CostInput,
-		CostOutput:     s.CostOutput,
-		CostCacheRead:  s.CostCacheRead,
-		CostCacheWrite: s.CostCacheWrite,
-		IsOverride:     s.IsOverride,
-		SyncedAt:       s.SyncedAt,
-		Enabled:        s.Enabled,
-	}
-}
-
-func NewGettableLLMPricingRulesFromLLMPricingRules(items []*LLMPricingRule, total, offset, limit int) *GettablePricingRules {
-	return &GettablePricingRules{
-		Items:  items,
-		Total:  total,
-		Offset: offset,
-		Limit:  limit,
-	}
-}

pkg/types/llmpricingruletypes/storable.go

@@ -1,67 +0,0 @@
-package llmpricingruletypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-// StringSlice is a []string that is stored as a JSON text column.
-// It is compatible with both SQLite and PostgreSQL.
-type StringSlice []string
-
-// StorableLLMPricingRule is the bun/DB representation of an LLM pricing rule.
-type StorableLLMPricingRule struct {
-	bun.BaseModel `bun:"table:llm_pricing_rule,alias:llm_pricing_rule"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID          valuer.UUID             `bun:"org_id,type:text,notnull"`
-	SourceID       *valuer.UUID            `bun:"source_id,type:text"`
-	Model          string                  `bun:"model,type:text,notnull"`
-	ModelPattern   StringSlice             `bun:"model_pattern,type:text,notnull"`
-	Unit           LLMPricingRuleUnit      `bun:"unit,type:text,notnull"`
-	CacheMode      LLMPricingRuleCacheMode `bun:"cache_mode,type:text,notnull"`
-	CostInput      float64                 `bun:"cost_input,notnull"`
-	CostOutput     float64                 `bun:"cost_output,notnull"`
-	CostCacheRead  float64                 `bun:"cost_cache_read,notnull"`
-	CostCacheWrite float64                 `bun:"cost_cache_write,notnull"`
-	// IsOverride marks the row as user-pinned. When true, Zeus skips it entirely.
-	IsOverride bool       `bun:"is_override,notnull,default:false"`
-	SyncedAt   *time.Time `bun:"synced_at"`
-	Enabled    bool       `bun:"enabled,notnull,default:true"`
-}
-
-func (s StringSlice) Value() (driver.Value, error) {
-	if s == nil {
-		return "[]", nil
-	}
-	b, err := json.Marshal(s)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (s *StringSlice) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*s = nil
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "llmpricingruletypes: cannot scan %T into StringSlice", src)
-	}
-	return json.Unmarshal(raw, s)
-}

pkg/types/llmpricingruletypes/store.go

@@ -1,16 +0,0 @@
-package llmpricingruletypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	List(ctx context.Context, orgID valuer.UUID, offset, limit int) ([]*StorableLLMPricingRule, int, error)
-	Get(ctx context.Context, orgID, id valuer.UUID) (*StorableLLMPricingRule, error)
-	GetBySourceID(ctx context.Context, orgID, sourceID valuer.UUID) (*StorableLLMPricingRule, error)
-	Create(ctx context.Context, rule *StorableLLMPricingRule) error
-	Update(ctx context.Context, rule *StorableLLMPricingRule) error
-	Delete(ctx context.Context, orgID, id valuer.UUID) error
-}

pkg/types/tracedetailtypes/aggregation.go

@@ -0,0 +1,50 @@
+package tracedetailtypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+const maxAggregationItems = 10
+
+var ErrTooManyAggregationItems = errors.NewInvalidInputf(errors.CodeInvalidInput, "aggregations request exceeds maximum of %d items", maxAggregationItems)
+
+// SpanAggregationType defines the aggregation to compute over spans grouped by a field.
+type SpanAggregationType string
+
+const (
+	SpanAggregationSpanCount               SpanAggregationType = "spanCount"
+	SpanAggregationExecutionTimePercentage SpanAggregationType = "executionTimePercentage"
+	SpanAggregationDuration                SpanAggregationType = "duration"
+)
+
+// SpanAggregation is a single aggregation request item: which field to group by and how.
+type SpanAggregation struct {
+	Field       telemetrytypes.TelemetryFieldKey `json:"field"`
+	Aggregation SpanAggregationType              `json:"aggregation"`
+}
+
+// SpanAggregationResult is the computed result for one aggregation request item.
+// Duration values are in milliseconds.
+type SpanAggregationResult struct {
+	Field       telemetrytypes.TelemetryFieldKey `json:"field"`
+	Aggregation SpanAggregationType              `json:"aggregation"`
+	Value       map[string]uint64                `json:"value" nullable:"true"`
+}
+
+func (s SpanAggregationType) Enum() []any {
+	return []any{
+		SpanAggregationSpanCount,
+		SpanAggregationExecutionTimePercentage,
+		SpanAggregationDuration,
+	}
+}
+
+func (s SpanAggregationType) isValid() bool {
+	for _, v := range s.Enum() {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}

pkg/types/tracedetailtypes/aggregation_test.go

@@ -0,0 +1,240 @@
+package tracedetailtypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+// mkASpan builds a WaterfallSpan with timing and field data for analytics tests.
+func mkASpan(id string, resource map[string]string, attributes map[string]any, startNs, durationNs uint64) *WaterfallSpan {
+	return &WaterfallSpan{
+		SpanID:       id,
+		Resource:     resource,
+		Attributes:   attributes,
+		TimeUnixNano: startNs,
+		DurationNano: durationNs,
+		Children:     make([]*WaterfallSpan, 0),
+	}
+}
+
+func buildTraceFromSpans(spans ...*WaterfallSpan) *WaterfallTrace {
+	spanMap := make(map[string]*WaterfallSpan, len(spans))
+	var startTime, endTime uint64
+	initialized := false
+	for _, s := range spans {
+		spanMap[s.SpanID] = s
+		if !initialized || s.TimeUnixNano < startTime {
+			startTime = s.TimeUnixNano
+			initialized = true
+		}
+		if end := s.TimeUnixNano + s.DurationNano; end > endTime {
+			endTime = end
+		}
+	}
+	return NewWaterfallTrace(startTime, endTime, uint64(len(spanMap)), 0, spanMap, nil, nil, false)
+}
+
+var (
+	fieldServiceName = telemetrytypes.TelemetryFieldKey{
+		Name:         "service.name",
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+	fieldHTTPMethod = telemetrytypes.TelemetryFieldKey{
+		Name:         "http.method",
+		FieldContext: telemetrytypes.FieldContextAttribute,
+	}
+	fieldCached = telemetrytypes.TelemetryFieldKey{
+		Name:         "db.cached",
+		FieldContext: telemetrytypes.FieldContextAttribute,
+	}
+)
+
+func TestGetSpanAggregation_SpanCount(t *testing.T) {
+	tests := []struct {
+		name  string
+		trace *WaterfallTrace
+		field telemetrytypes.TelemetryFieldKey
+		want  map[string]uint64
+	}{
+		{
+			name: "counts by resource field",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{"service.name": "frontend"}, nil, 10, 5),
+				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 20, 8),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"frontend": 2, "backend": 1},
+		},
+		{
+			name: "counts by string attribute field",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", nil, map[string]any{"http.method": "GET"}, 0, 10),
+				mkASpan("s2", nil, map[string]any{"http.method": "POST"}, 10, 5),
+				mkASpan("s3", nil, map[string]any{"http.method": "GET"}, 20, 8),
+			),
+			field: fieldHTTPMethod,
+			want:  map[string]uint64{"GET": 2, "POST": 1},
+		},
+		{
+			name: "counts by boolean attribute field",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", nil, map[string]any{"db.cached": true}, 0, 10),
+				mkASpan("s2", nil, map[string]any{"db.cached": false}, 10, 5),
+				mkASpan("s3", nil, map[string]any{"db.cached": true}, 20, 8),
+			),
+			field: fieldCached,
+			want:  map[string]uint64{"true": 2, "false": 1},
+		},
+		{
+			name: "spans missing the field are excluded",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{}, nil, 10, 5), // no service.name
+				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 20, 8),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"frontend": 1, "backend": 1},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := tc.trace.GetSpanAggregation(SpanAggregationSpanCount, tc.field)
+			assert.Equal(t, tc.field, result.Field)
+			assert.Equal(t, SpanAggregationSpanCount, result.Aggregation)
+			assert.Equal(t, tc.want, result.Value)
+		})
+	}
+}
+
+func TestGetSpanAggregation_Duration(t *testing.T) {
+	tests := []struct {
+		name  string
+		trace *WaterfallTrace
+		field telemetrytypes.TelemetryFieldKey
+		want  map[string]uint64
+	}{
+		{
+			name: "non-overlapping spans — merged equals sum",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 100),
+				mkASpan("s2", map[string]string{"service.name": "frontend"}, nil, 100, 50),
+				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 0, 80),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"frontend": 150, "backend": 80},
+		},
+		{
+			name: "non-overlapping attribute groups — merged equals sum",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", nil, map[string]any{"http.method": "GET"}, 0, 30),
+				mkASpan("s2", nil, map[string]any{"http.method": "GET"}, 50, 20),
+				mkASpan("s3", nil, map[string]any{"http.method": "POST"}, 0, 70),
+			),
+			field: fieldHTTPMethod,
+			want:  map[string]uint64{"GET": 50, "POST": 70},
+		},
+		{
+			name: "overlapping spans — non-overlapping interval merge",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 15}, // [0,10] ∪ [5,15] = [0,15]
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := tc.trace.GetSpanAggregation(SpanAggregationDuration, tc.field)
+			assert.Equal(t, tc.field, result.Field)
+			assert.Equal(t, SpanAggregationDuration, result.Aggregation)
+			assert.Equal(t, tc.want, result.Value)
+		})
+	}
+}
+
+func TestGetSpanAggregation_ExecutionTimePercentage(t *testing.T) {
+	tests := []struct {
+		name  string
+		trace *WaterfallTrace
+		field telemetrytypes.TelemetryFieldKey
+		want  map[string]uint64
+	}{
+		{
+			// trace [0,30]: svc occupies [0,10]+[20,30]=20 → 20*100/30 = 66%
+			name: "non-overlapping spans",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 20, 10),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 66},
+		},
+		{
+			// trace [0,15]: svc [0,15]=15 → 100%
+			name: "partially overlapping spans",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 100},
+		},
+		{
+			// trace [0,20]: outer absorbs inner → 100%
+			name: "fully contained span",
+			trace: buildTraceFromSpans(
+				mkASpan("outer", map[string]string{"service.name": "svc"}, nil, 0, 20),
+				mkASpan("inner", map[string]string{"service.name": "svc"}, nil, 5, 5),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 100},
+		},
+		{
+			// trace [0,30]: svc [0,15]+[20,30]=25 → 25*100/30 = 83%
+			name: "three spans with two merges",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
+				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
+				mkASpan("s3", map[string]string{"service.name": "svc"}, nil, 20, 10),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 83},
+		},
+		{
+			// trace [0,28]: frontend [0,15]=15 → 53%, backend [0,5]+[20,28]=13 → 46%
+			name: "independent groups are computed separately",
+			trace: buildTraceFromSpans(
+				mkASpan("a1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
+				mkASpan("a2", map[string]string{"service.name": "frontend"}, nil, 5, 10),
+				mkASpan("b1", map[string]string{"service.name": "backend"}, nil, 0, 5),
+				mkASpan("b2", map[string]string{"service.name": "backend"}, nil, 20, 8),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"frontend": 53, "backend": 46},
+		},
+		{
+			// trace [100,150]: svc [100,150]=50 → 100%
+			name: "single span",
+			trace: buildTraceFromSpans(
+				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 100, 50),
+			),
+			field: fieldServiceName,
+			want:  map[string]uint64{"svc": 100},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := tc.trace.GetSpanAggregation(SpanAggregationExecutionTimePercentage, tc.field)
+			assert.Equal(t, tc.field, result.Field)
+			assert.Equal(t, SpanAggregationExecutionTimePercentage, result.Aggregation)
+			assert.Equal(t, tc.want, result.Value)
+		})
+	}
+}

pkg/types/tracedetailtypes/waterfall_span.go

@@ -2,11 +2,13 @@ package tracedetailtypes
 
 import (
 	"encoding/json"
+	"fmt"
 	"maps"
 	"sort"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 const (
@@ -21,9 +23,27 @@ var ErrTraceNotFound = errors.NewNotFoundf(errors.CodeNotFound, "trace not found
 
 // PostableWaterfall is the request body for the v3 waterfall API.
 type PostableWaterfall struct {
-	SelectedSpanID   string   `json:"selectedSpanId"`
-	UncollapsedSpans []string `json:"uncollapsedSpans"`
-	Limit            uint     `json:"limit"`
+	SelectedSpanID   string            `json:"selectedSpanId"`
+	UncollapsedSpans []string          `json:"uncollapsedSpans"`
+	Limit            uint              `json:"limit"`
+	Aggregations     []SpanAggregation `json:"aggregations"`
+}
+
+func (p *PostableWaterfall) Validate() error {
+	if len(p.Aggregations) > maxAggregationItems {
+		return ErrTooManyAggregationItems
+	}
+	for _, a := range p.Aggregations {
+		if !a.Aggregation.isValid() {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown aggregation type: %q", a.Aggregation)
+		}
+		fc := a.Field.FieldContext
+		if fc != telemetrytypes.FieldContextResource && fc != telemetrytypes.FieldContextAttribute {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "aggregation field context must be %q or %q, got %q",
+				telemetrytypes.FieldContextResource, telemetrytypes.FieldContextAttribute, fc)
+		}
+	}
+	return nil
 }
 
 // Event represents a span event.
@@ -160,7 +180,24 @@ func (ws *WaterfallSpan) GetSubtreeNodeCount() uint64 {
 	return count
 }
 
-// getPreOrderedSpans returns spans in pre-order, uncollapsedSpanIDs must be pre-computed.
+// FieldValue returns the string representation of field's value on this span for grouping.
+// The bool reports whether the field was present with a non-empty value.
+func (ws *WaterfallSpan) FieldValue(field telemetrytypes.TelemetryFieldKey) (string, bool) {
+	switch field.FieldContext {
+	case telemetrytypes.FieldContextResource:
+		v := ws.Resource[field.Name]
+		return v, v != ""
+	case telemetrytypes.FieldContextAttribute:
+		v, ok := ws.Attributes[field.Name]
+		if !ok {
+			return "", false
+		}
+		str := fmt.Sprintf("%v", v)
+		return str, str != ""
+	}
+	return "", false
+}
+
 func (ws *WaterfallSpan) getPreOrderedSpans(uncollapsedSpanIDs map[string]struct{}, selectAll bool, level uint64) []*WaterfallSpan {
 	result := []*WaterfallSpan{ws.GetWithoutChildren(level)}
 	_, isUncollapsed := uncollapsedSpanIDs[ws.SpanID]

pkg/types/tracedetailtypes/waterfall_trace.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/types/cachetypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 type TraceSummary struct {
@@ -31,17 +32,19 @@ type WaterfallTrace struct {
 
 // GettableWaterfallTrace is the response for the v3 waterfall API.
 type GettableWaterfallTrace struct {
-	StartTimestampMillis          uint64            `json:"startTimestampMillis"`
-	EndTimestampMillis            uint64            `json:"endTimestampMillis"`
-	RootServiceName               string            `json:"rootServiceName"`
-	RootServiceEntryPoint         string            `json:"rootServiceEntryPoint"`
-	TotalSpansCount               uint64            `json:"totalSpansCount"`
-	TotalErrorSpansCount          uint64            `json:"totalErrorSpansCount"`
-	ServiceNameToTotalDurationMap map[string]uint64 `json:"serviceNameToTotalDurationMap"`
-	Spans                         []*WaterfallSpan  `json:"spans"`
-	HasMissingSpans               bool              `json:"hasMissingSpans"`
-	UncollapsedSpans              []string          `json:"uncollapsedSpans"`
-	HasMore                       bool              `json:"hasMore"`
+	StartTimestampMillis  uint64 `json:"startTimestampMillis"`
+	EndTimestampMillis    uint64 `json:"endTimestampMillis"`
+	RootServiceName       string `json:"rootServiceName"`
+	RootServiceEntryPoint string `json:"rootServiceEntryPoint"`
+	TotalSpansCount       uint64 `json:"totalSpansCount"`
+	TotalErrorSpansCount  uint64 `json:"totalErrorSpansCount"`
+	// Deprecated: use Aggregations with SpanAggregationExecutionTimePercentage on the service.name field instead.
+	ServiceNameToTotalDurationMap map[string]uint64       `json:"serviceNameToTotalDurationMap"`
+	Spans                         []*WaterfallSpan        `json:"spans"`
+	HasMissingSpans               bool                    `json:"hasMissingSpans"`
+	UncollapsedSpans              []string                `json:"uncollapsedSpans"`
+	HasMore                       bool                    `json:"hasMore"`
+	Aggregations                  []SpanAggregationResult `json:"aggregations"`
 }
 
 // NewWaterfallTrace constructs a WaterfallTrace from processed span data.
@@ -240,12 +243,13 @@ func (wt *WaterfallTrace) UnmarshalBinary(data []byte) error {
 	return json.Unmarshal(data, wt)
 }
 
-// NewGettableWaterfallTrace constructs a WaterfallResponse from processed trace data and selected spans.
+// NewGettableWaterfallTrace constructs a GettableWaterfallTrace from processed trace data and selected spans.
 func NewGettableWaterfallTrace(
 	traceData *WaterfallTrace,
 	selectedSpans []*WaterfallSpan,
 	uncollapsedSpans []string,
 	selectAllSpans bool,
+	aggregations []SpanAggregationResult,
 ) *GettableWaterfallTrace {
 	var rootServiceName, rootServiceEntryPoint string
 	if len(traceData.TraceRoots) > 0 {
@@ -263,6 +267,15 @@ func NewGettableWaterfallTrace(
 		span.TimeUnixNano = span.TimeUnixNano / 1_000_000
 	}
 
+	// duration values are in nanoseconds; convert in-place to milliseconds.
+	for i := range aggregations {
+		if aggregations[i].Aggregation == SpanAggregationDuration {
+			for k, v := range aggregations[i].Value {
+				aggregations[i].Value[k] = v / 1_000_000
+			}
+		}
+	}
+
 	return &GettableWaterfallTrace{
 		Spans:                         selectedSpans,
 		UncollapsedSpans:              uncollapsedSpans,
@@ -275,6 +288,7 @@ func NewGettableWaterfallTrace(
 		ServiceNameToTotalDurationMap: serviceDurationsMillis,
 		HasMissingSpans:               traceData.HasMissingSpans,
 		HasMore:                       !selectAllSpans,
+		Aggregations:                  aggregations,
 	}
 }
 
@@ -307,29 +321,82 @@ func calculateServiceTime(spanIDToSpanNodeMap map[string]*WaterfallSpan) map[str
 
 	totalTimes := make(map[string]uint64)
 	for service, spans := range serviceSpans {
-		sort.Slice(spans, func(i, j int) bool {
-			return spans[i].TimeUnixNano < spans[j].TimeUnixNano
-		})
-
-		currentStart := spans[0].TimeUnixNano
-		currentEnd := currentStart + spans[0].DurationNano
-		total := uint64(0)
-
-		for _, span := range spans[1:] {
-			startNano := span.TimeUnixNano
-			endNano := startNano + span.DurationNano
-			if currentEnd >= startNano {
-				if endNano > currentEnd {
-					currentEnd = endNano
-				}
-			} else {
-				total += currentEnd - currentStart
-				currentStart = startNano
-				currentEnd = endNano
-			}
-		}
-		total += currentEnd - currentStart
-		totalTimes[service] = total
+		totalTimes[service] = mergeSpanIntervals(spans)
 	}
 	return totalTimes
 }
+
+// mergeSpanIntervals computes non-overlapping execution time for a set of spans.
+func mergeSpanIntervals(spans []*WaterfallSpan) uint64 {
+	if len(spans) == 0 {
+		return 0
+	}
+	sort.Slice(spans, func(i, j int) bool {
+		return spans[i].TimeUnixNano < spans[j].TimeUnixNano
+	})
+
+	currentStart := spans[0].TimeUnixNano
+	currentEnd := currentStart + spans[0].DurationNano
+	total := uint64(0)
+
+	for _, span := range spans[1:] {
+		startNano := span.TimeUnixNano
+		endNano := startNano + span.DurationNano
+		if currentEnd >= startNano {
+			if endNano > currentEnd {
+				currentEnd = endNano
+			}
+		} else {
+			total += currentEnd - currentStart
+			currentStart = startNano
+			currentEnd = endNano
+		}
+	}
+	return total + (currentEnd - currentStart)
+}
+
+// GetSpanAggregation computes one aggregation result over all spans in the trace.
+// Duration values are returned in nanoseconds; callers convert to milliseconds as needed.
+func (wt *WaterfallTrace) GetSpanAggregation(aggregation SpanAggregationType, field telemetrytypes.TelemetryFieldKey) SpanAggregationResult {
+	result := SpanAggregationResult{
+		Field:       field,
+		Aggregation: aggregation,
+		Value:       make(map[string]uint64),
+	}
+
+	switch aggregation {
+	case SpanAggregationSpanCount:
+		for _, span := range wt.SpanIDToSpanNodeMap {
+			if key, ok := span.FieldValue(field); ok {
+				result.Value[key]++
+			}
+		}
+
+	case SpanAggregationDuration:
+		spansByField := make(map[string][]*WaterfallSpan)
+		for _, span := range wt.SpanIDToSpanNodeMap {
+			if key, ok := span.FieldValue(field); ok {
+				spansByField[key] = append(spansByField[key], span)
+			}
+		}
+		for key, spans := range spansByField {
+			result.Value[key] = mergeSpanIntervals(spans)
+		}
+
+	case SpanAggregationExecutionTimePercentage:
+		traceDuration := wt.EndTime - wt.StartTime
+		spansByField := make(map[string][]*WaterfallSpan)
+		for _, span := range wt.SpanIDToSpanNodeMap {
+			if key, ok := span.FieldValue(field); ok {
+				spansByField[key] = append(spansByField[key], span)
+			}
+		}
+		if traceDuration > 0 {
+			for key, spans := range spansByField {
+				result.Value[key] = mergeSpanIntervals(spans) * 100 / traceDuration
+			}
+		}
+	}
+
+	return result
+}