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:
@@ -4596,6 +4603,11 @@ components:
       type: object
     TracedetailtypesGettableWaterfallTrace:
       properties:
+        aggregations:
+          items:
+            $ref: '#/components/schemas/TracedetailtypesSpanAggregationResult'
+          nullable: true
+          type: array
         endTimestampMillis:
           minimum: 0
           type: integer
@@ -4635,6 +4647,11 @@ components:
       type: object
     TracedetailtypesPostableWaterfall:
       properties:
+        aggregations:
+          items:
+            $ref: '#/components/schemas/TracedetailtypesSpanAggregation'
+          nullable: true
+          type: array
         limit:
           minimum: 0
           type: integer
@@ -4646,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:

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 {
@@ -5588,6 +5593,11 @@ export type TracedetailtypesGettableWaterfallTraceDTOServiceNameToTotalDurationM
 	{ [key: string]: number } | null;
 
 export interface TracedetailtypesGettableWaterfallTraceDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	aggregations?: TracedetailtypesSpanAggregationResultDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -5642,6 +5652,11 @@ export interface TracedetailtypesGettableWaterfallTraceDTO {
 }
 
 export interface TracedetailtypesPostableWaterfallDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	aggregations?: TracedetailtypesSpanAggregationDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -5658,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
  */

frontend/src/container/DashboardContainer/visualization/charts/ChartWrapper/ChartWrapper.tsx

@@ -33,7 +33,6 @@ export default function ChartWrapper({
 	children,
 	layoutChildren,
 	yAxisUnit,
-	groupBy,
 	customTooltip,
 	pinnedTooltipElement,
 	'data-testid': testId,
@@ -69,9 +68,8 @@ export default function ChartWrapper({
 	const syncMetadata = useMemo(
 		() => ({
 			yAxisUnit,
-			groupBy,
 		}),
-		[yAxisUnit, groupBy],
+		[yAxisUnit],
 	);
 
 	return (

frontend/src/container/DashboardContainer/visualization/charts/types.ts

@@ -6,7 +6,6 @@ import {
 	DashboardCursorSync,
 	TooltipClickData,
 } from 'lib/uPlotV2/plugins/TooltipPlugin/types';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 
 interface BaseChartProps {
 	width: number;
@@ -39,7 +38,6 @@ interface UPlotBasedChartProps {
 interface UPlotChartDataProps {
 	yAxisUnit?: string;
 	decimalPrecision?: PrecisionOption;
-	groupBy?: BaseAutocompleteData[];
 }
 
 export interface TimeSeriesChartProps

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/BarPanel.tsx

@@ -113,10 +113,6 @@ function BarPanel(props: PanelWrapperProps): JSX.Element {
 		uPlotRef.current = plot;
 	}, []);
 
-	const groupBy = useMemo(() => {
-		return widget.query.builder.queryData[0].groupBy;
-	}, [widget.query]);
-
 	return (
 		<div className="panel-container" ref={graphRef}>
 			{containerDimensions.width > 0 && containerDimensions.height > 0 && (
@@ -132,7 +128,6 @@ function BarPanel(props: PanelWrapperProps): JSX.Element {
 					width={containerDimensions.width}
 					height={containerDimensions.height}
 					layoutChildren={layoutChildren}
-					groupBy={groupBy}
 					isStackedBarChart={widget.stackedBarChart ?? false}
 					yAxisUnit={widget.yAxisUnit}
 					decimalPrecision={widget.decimalPrecision}

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/utils.ts

@@ -105,7 +105,6 @@ export function prepareBarPanelConfig({
 			colorMapping: widget.customLegendColors ?? {},
 			isDarkMode,
 			stepInterval: currentStepInterval,
-			metric: series.metric,
 		});
 	});
 

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx

@@ -104,10 +104,6 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 		widget.decimalPrecision,
 	]);
 
-	const groupBy = useMemo(() => {
-		return widget.query.builder.queryData[0].groupBy;
-	}, [widget.query]);
-
 	return (
 		<div className="panel-container" ref={graphRef}>
 			{containerDimensions.width > 0 && containerDimensions.height > 0 && (
@@ -121,7 +117,6 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 					yAxisUnit={widget.yAxisUnit}
 					decimalPrecision={widget.decimalPrecision}
 					data={chartData as uPlot.AlignedData}
-					groupBy={groupBy}
 					width={containerDimensions.width}
 					height={containerDimensions.height}
 					layoutChildren={layoutChildren}

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -131,7 +131,6 @@ export const prepareUPlotConfig = ({
 			pointSize: 5,
 			fillMode: widget.fillMode || FillMode.None,
 			isDarkMode,
-			metric: series.metric,
 		});
 	});
 

frontend/src/lib/uPlotV2/components/Tooltip/BarChartTooltip.tsx

@@ -16,7 +16,6 @@ export default function BarChartTooltip(props: BarTooltipProps): JSX.Element {
 				yAxisUnit: props.yAxisUnit ?? '',
 				decimalPrecision: props.decimalPrecision,
 				isStackedBarChart: props.isStackedBarChart,
-				syncedSeriesIndexes: props.syncedSeriesIndexes,
 			}),
 		[
 			props.uPlotInstance,
@@ -25,7 +24,6 @@ export default function BarChartTooltip(props: BarTooltipProps): JSX.Element {
 			props.yAxisUnit,
 			props.decimalPrecision,
 			props.isStackedBarChart,
-			props.syncedSeriesIndexes,
 		],
 	);
 

frontend/src/lib/uPlotV2/components/Tooltip/HistogramTooltip.tsx

@@ -17,7 +17,6 @@ export default function HistogramTooltip(
 				uPlotInstance: props.uPlotInstance,
 				yAxisUnit: props.yAxisUnit ?? '',
 				decimalPrecision: props.decimalPrecision,
-				syncedSeriesIndexes: props.syncedSeriesIndexes,
 			}),
 		[
 			props.uPlotInstance,
@@ -25,7 +24,6 @@ export default function HistogramTooltip(
 			props.dataIndexes,
 			props.yAxisUnit,
 			props.decimalPrecision,
-			props.syncedSeriesIndexes,
 		],
 	);
 

frontend/src/lib/uPlotV2/components/Tooltip/TimeSeriesTooltip.tsx

@@ -17,7 +17,6 @@ export default function TimeSeriesTooltip(
 				uPlotInstance: props.uPlotInstance,
 				yAxisUnit: props.yAxisUnit ?? '',
 				decimalPrecision: props.decimalPrecision,
-				syncedSeriesIndexes: props.syncedSeriesIndexes,
 			}),
 		[
 			props.uPlotInstance,
@@ -25,7 +24,6 @@ export default function TimeSeriesTooltip(
 			props.dataIndexes,
 			props.yAxisUnit,
 			props.decimalPrecision,
-			props.syncedSeriesIndexes,
 		],
 	);
 

frontend/src/lib/uPlotV2/components/Tooltip/utils.ts

@@ -62,7 +62,6 @@ export function buildTooltipContent({
 	yAxisUnit,
 	decimalPrecision,
 	isStackedBarChart,
-	syncedSeriesIndexes,
 }: {
 	data: AlignedData;
 	series: Series[];
@@ -72,34 +71,18 @@ export function buildTooltipContent({
 	yAxisUnit: string;
 	decimalPrecision?: PrecisionOption;
 	isStackedBarChart?: boolean;
-	syncedSeriesIndexes?: number[] | null;
 }): TooltipContentItem[] {
 	const items: TooltipContentItem[] = [];
-	const allowedIndexes =
-		syncedSeriesIndexes != null ? new Set(syncedSeriesIndexes) : null;
 
 	for (let seriesIndex = 1; seriesIndex < series.length; seriesIndex += 1) {
 		const seriesItem = series[seriesIndex];
 		if (!seriesItem?.show) {
 			continue;
 		}
-		if (allowedIndexes != null && !allowedIndexes.has(seriesIndex)) {
-			continue;
-		}
 
 		const dataIndex = dataIndexes[seriesIndex];
-		const isSync = allowedIndexes != null;
-
+		// Skip series with no data at the current cursor position
 		if (dataIndex === null) {
-			if (isSync) {
-				items.push({
-					label: String(seriesItem.label ?? ''),
-					value: 0,
-					tooltipValue: 'No Data',
-					color: resolveSeriesColor(seriesItem.stroke, uPlotInstance, seriesIndex),
-					isActive: false,
-				});
-			}
 			continue;
 		}
 
@@ -119,14 +102,6 @@ export function buildTooltipContent({
 				color: resolveSeriesColor(seriesItem.stroke, uPlotInstance, seriesIndex),
 				isActive: seriesIndex === activeSeriesIndex,
 			});
-		} else if (isSync) {
-			items.push({
-				label: String(seriesItem.label ?? ''),
-				value: 0,
-				tooltipValue: 'No Data',
-				color: resolveSeriesColor(seriesItem.stroke, uPlotInstance, seriesIndex),
-				isActive: false,
-			});
 		}
 	}
 

frontend/src/lib/uPlotV2/components/types.ts

@@ -58,9 +58,6 @@ export interface TooltipRenderArgs {
 	isPinned: boolean;
 	dismiss: () => void;
 	viaSync: boolean;
-	/** In Tooltip sync mode, limits which series are rendered in the receiver tooltip.
-	 * null = no filtering; [] = no matches (tooltip hidden upstream); [...] = allowed indexes */
-	syncedSeriesIndexes?: number[] | null;
 }
 
 export interface BaseTooltipProps {

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -9,7 +9,6 @@ import {
 	BarAlignment,
 	ConfigBuilder,
 	DrawStyle,
-	ExtendedSeries,
 	FillMode,
 	LineInterpolation,
 	LineStyle,
@@ -28,10 +27,7 @@ let builders: PathBuilders | null = null;
 
 const DEFAULT_LINE_WIDTH = 2;
 export const POINT_SIZE_FACTOR = 2.5;
-export class UPlotSeriesBuilder extends ConfigBuilder<
-	SeriesProps,
-	ExtendedSeries
-> {
+export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 	constructor(props: SeriesProps) {
 		super(props);
 		const pathBuilders = uPlot.paths;
@@ -209,8 +205,8 @@ export class UPlotSeriesBuilder extends ConfigBuilder<
 		);
 	}
 
-	getConfig(): ExtendedSeries {
-		const { scaleKey, label, spanGaps, show = true, metric } = this.props;
+	getConfig(): Series {
+		const { scaleKey, label, spanGaps, show = true } = this.props;
 
 		const resolvedLineColor = this.getLineColor();
 
@@ -237,7 +233,6 @@ export class UPlotSeriesBuilder extends ConfigBuilder<
 			...lineConfig,
 			...pathConfig,
 			points: Object.keys(pointsConfig).length > 0 ? pointsConfig : undefined,
-			metric,
 		};
 	}
 }

frontend/src/lib/uPlotV2/config/types.ts

@@ -171,10 +171,6 @@ export enum FillMode {
 	None = 'none',
 }
 
-export type ExtendedSeries = Series & {
-	metric?: { [key: string]: string };
-};
-
 export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
 	scaleKey: string;
 	label?: string;
@@ -198,7 +194,6 @@ export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
 	fillMode?: FillMode;
 	isDarkMode?: boolean;
 	stepInterval?: number;
-	metric?: { [key: string]: string };
 }
 
 export interface LegendItem {

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/TooltipPlugin.tsx

@@ -3,7 +3,7 @@ import { createPortal } from 'react-dom';
 import cx from 'classnames';
 import uPlot from 'uplot';
 
-import { createSyncDisplayHook } from './syncDisplayHook';
+import { syncCursorRegistry } from './syncCursorRegistry';
 import {
 	createInitialControllerState,
 	createSetCursorHandler,
@@ -104,16 +104,32 @@ export default function TooltipPlugin({
 
 		// Enable uPlot's built-in cursor sync when requested so that
 		// crosshair / tooltip can follow the dashboard-wide cursor.
-		let removeSyncDisplayHook: (() => void) | null = null;
 		if (syncMode !== DashboardCursorSync.None && config.scales[0]?.props.time) {
 			config.setCursor({
 				sync: { key: syncKey, scales: ['x', 'y'] },
 			});
 
-			removeSyncDisplayHook = config.addHook(
-				'setCursor',
-				createSyncDisplayHook(syncKey, syncMetadata, controller),
-			);
+			// Show the horizontal crosshair only when the receiving panel shares
+			// the same y-axis unit as the source panel. When this panel is the
+			// source (cursor.event != null) the line is always shown and this
+			// panel's metadata is written to the registry so receivers can read it.
+			config.addHook('setCursor', (u: uPlot): void => {
+				const yCursorEl = u.root.querySelector<HTMLElement>('.u-cursor-y');
+				if (!yCursorEl) {
+					return;
+				}
+
+				if (u.cursor.event != null) {
+					// This panel is the source — publish metadata and always show line.
+					syncCursorRegistry.setMetadata(syncKey, syncMetadata);
+					yCursorEl.style.display = '';
+				} else {
+					// This panel is receiving sync — show only if units match.
+					const sourceMeta = syncCursorRegistry.getMetadata(syncKey);
+					yCursorEl.style.display =
+						sourceMeta?.yAxisUnit === syncMetadata?.yAxisUnit ? '' : 'none';
+				}
+			});
 		}
 
 		// Dismiss the tooltip when the user clicks / presses a key
@@ -121,12 +137,7 @@ export default function TooltipPlugin({
 		const onOutsideInteraction = (event: Event): void => {
 			const target = event.target as Node;
 			if (!containerRef.current?.contains(target)) {
-				// Don't dismiss if the click landed inside any other pinned tooltip.
-				const isInsideAnyPinnedTooltip =
-					(target as Element).closest?.('[data-pinned="true"]') != null;
-				if (!isInsideAnyPinnedTooltip) {
-					dismissTooltip();
-				}
+				dismissTooltip();
 			}
 		};
 
@@ -145,7 +156,7 @@ export default function TooltipPlugin({
 		function updateCursorLock(): void {
 			const plot = getPlot(controller);
 			if (plot) {
-				// @ts-expect-error uPlot cursor lock is not working as expected
+				// @ts-ignore uPlot cursor lock is not working as expected
 				plot.cursor._lock = controller.pinned;
 			}
 		}
@@ -192,16 +203,6 @@ export default function TooltipPlugin({
 			if (!controller.hoverActive || !plot) {
 				return null;
 			}
-			// In Tooltip sync mode, suppress the receiver tooltip entirely when
-			// no receiver series match the source panel's focused series.
-			if (
-				syncTooltipWithDashboard &&
-				controller.cursorDrivenBySync &&
-				Array.isArray(controller.syncedSeriesIndexes) &&
-				controller.syncedSeriesIndexes.length === 0
-			) {
-				return null;
-			}
 			return renderRef.current({
 				uPlotInstance: plot,
 				dataIndexes: controller.seriesIndexes,
@@ -209,7 +210,6 @@ export default function TooltipPlugin({
 				isPinned: controller.pinned,
 				dismiss: dismissTooltip,
 				viaSync: controller.cursorDrivenBySync,
-				syncedSeriesIndexes: controller.syncedSeriesIndexes,
 			});
 		}
 
@@ -431,7 +431,6 @@ export default function TooltipPlugin({
 			removeSetSeriesHook();
 			removeSetLegendHook();
 			removeSetCursorHook();
-			removeSyncDisplayHook?.();
 			if (overClickHandler) {
 				const plot = getPlot(controller);
 				plot?.over.removeEventListener('click', overClickHandler);
@@ -494,7 +493,7 @@ export default function TooltipPlugin({
 		isHovering,
 		contents,
 	]);
-	const isTooltipVisible = tooltipBody != null;
+	const isTooltipVisible = isHovering || tooltipBody != null;
 
 	if (!hasPlot) {
 		return null;

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/syncCursorRegistry.ts

@@ -9,13 +9,9 @@ import type { TooltipSyncMetadata } from './types';
  *
  * Receivers use this to make decisions such as:
  * - Whether to show the horizontal crosshair line (matching yAxisUnit)
- * - Which series to highlight when panels share the same groupBy
+ * - Future: what to render inside the tooltip (matching groupBy, etc.)
  */
 const metadataBySyncKey = new Map<string, TooltipSyncMetadata | undefined>();
-const activeSeriesMetricBySyncKey = new Map<
-	string,
-	Record<string, string> | null
->();
 
 export const syncCursorRegistry = {
 	setMetadata(syncKey: string, metadata: TooltipSyncMetadata | undefined): void {
@@ -25,15 +21,4 @@ export const syncCursorRegistry = {
 	getMetadata(syncKey: string): TooltipSyncMetadata | undefined {
 		return metadataBySyncKey.get(syncKey);
 	},
-
-	setActiveSeriesMetric(
-		syncKey: string,
-		metric: Record<string, string> | null,
-	): void {
-		activeSeriesMetricBySyncKey.set(syncKey, metric);
-	},
-
-	getActiveSeriesMetric(syncKey: string): Record<string, string> | null {
-		return activeSeriesMetricBySyncKey.get(syncKey) ?? null;
-	},
 };

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/syncDisplayHook.ts

@@ -1,175 +0,0 @@
-import uPlot from 'uplot';
-
-import type { ExtendedSeries } from '../../config/types';
-import { syncCursorRegistry } from './syncCursorRegistry';
-import type { TooltipControllerState, TooltipSyncMetadata } from './types';
-
-/**
- * Returns the dimension keys present in both groupBy arrays.
- * An empty result means no overlap — series highlighting should not run.
- *
- *   exact    [A, B] vs [A, B]  → [A, B]   one match
- *   subset   [A]    vs [A, B]  → [A]      multiple receiver series may match
- *   superset [A, B] vs [A]     → [A]      one receiver series matches
- *   partial  [A, B] vs [B, C]  → [B]
- */
-function getCommonGroupByKeys(
-	a: TooltipSyncMetadata['groupBy'],
-	b: TooltipSyncMetadata['groupBy'],
-): string[] {
-	if (!Array.isArray(a) || a.length === 0 || !Array.isArray(b) || b.length === 0) {
-		return [];
-	}
-	const bKeys = new Set(b.map((g) => g.key));
-	return a.filter((g) => bKeys.has(g.key)).map((g) => g.key);
-}
-
-/**
- * Returns the 1-based indexes of every series whose metric matches
- * sourceMetric on all commonKeys.
- */
-function findMatchingSeriesIndexes(
-	series: uPlot.Series[],
-	sourceMetric: Record<string, string>,
-	commonKeys: string[],
-): number[] {
-	return series.reduce<number[]>((acc, s, i) => {
-		if (i === 0) {return acc;}
-		const metric = (s as ExtendedSeries).metric;
-		if (
-			metric != null &&
-			commonKeys.every((key) => metric[key] === sourceMetric[key])
-		) {
-			acc.push(i);
-		}
-		return acc;
-	}, []);
-}
-
-function applySourceSync({
-	uPlotInstance,
-	syncKey,
-	syncMetadata,
-	focusedSeriesIndex,
-}: {
-	uPlotInstance: uPlot;
-	syncKey: string;
-	syncMetadata: TooltipSyncMetadata | undefined;
-	focusedSeriesIndex: number | null;
-}): void {
-	syncCursorRegistry.setMetadata(syncKey, syncMetadata);
-	const focusedSeries =
-		focusedSeriesIndex != null
-			? (uPlotInstance.series[focusedSeriesIndex] as ExtendedSeries)
-			: null;
-	syncCursorRegistry.setActiveSeriesMetric(syncKey, focusedSeries?.metric ?? null);
-}
-
-/**
- * Returns:
- *   null      – no groupBy filtering configured or cursor off-chart (no-op for tooltip)
- *   []        – groupBy configured but no receiver series match the source (hide synced tooltip)
- *   number[]  – 1-based indexes of matching receiver series (show only these)
- */
-function applyReceiverSync({
-	uPlotInstance,
-	yCrosshairEl,
-	syncKey,
-	syncMetadata,
-	sourceMetadata,
-	commonKeys,
-}: {
-	uPlotInstance: uPlot;
-	yCrosshairEl: HTMLElement;
-	syncKey: string;
-	syncMetadata: TooltipSyncMetadata | undefined;
-	sourceMetadata: TooltipSyncMetadata | undefined;
-	commonKeys: string[];
-}): number[] | null {
-	yCrosshairEl.style.display =
-		sourceMetadata?.yAxisUnit === syncMetadata?.yAxisUnit ? '' : 'none';
-
-	if (commonKeys.length === 0) {
-		return null;
-	}
-
-	if ((uPlotInstance.cursor.left ?? -1) < 0) {
-		uPlotInstance.setSeries(null, { focus: false });
-		return null;
-	}
-
-	const sourceSeriesMetric = syncCursorRegistry.getActiveSeriesMetric(syncKey);
-	if (sourceSeriesMetric == null) {
-		uPlotInstance.setSeries(null, { focus: false });
-		return [];
-	}
-
-	const matchingIdxs = findMatchingSeriesIndexes(
-		uPlotInstance.series,
-		sourceSeriesMetric,
-		commonKeys,
-	);
-
-	if (matchingIdxs.length === 0) {
-		uPlotInstance.setSeries(null, { focus: false });
-		return [];
-	}
-
-	uPlotInstance.setSeries(matchingIdxs[0], { focus: true });
-
-	return matchingIdxs;
-}
-
-export function createSyncDisplayHook(
-	syncKey: string,
-	syncMetadata: TooltipSyncMetadata | undefined,
-	controller: TooltipControllerState,
-): (u: uPlot) => void {
-	// Cached once — avoids a DOM query on every cursor move.
-	let yCrosshairEl: HTMLElement | null = null;
-
-	// groupBy on both panels is stable (set at config time). Recompute the
-	// intersection only when the source panel's groupBy reference changes.
-	let lastSourceGroupBy: TooltipSyncMetadata['groupBy'];
-	let cachedCommonKeys: string[] = [];
-
-	return (u: uPlot): void => {
-		yCrosshairEl ??= u.root.querySelector<HTMLElement>('.u-cursor-y');
-		if (!yCrosshairEl) {
-			return;
-		}
-
-		if (u.cursor.event != null) {
-			controller.syncedSeriesIndexes = null;
-			applySourceSync({
-				uPlotInstance: u,
-				syncKey,
-				syncMetadata,
-				focusedSeriesIndex: controller.focusedSeriesIndex,
-			});
-			yCrosshairEl.style.display = '';
-			return;
-		}
-
-		// Read metadata once and pass it down — avoids a second registry lookup
-		// inside applyReceiverSync.
-		const sourceMetadata = syncCursorRegistry.getMetadata(syncKey);
-
-		if (sourceMetadata?.groupBy !== lastSourceGroupBy) {
-			lastSourceGroupBy = sourceMetadata?.groupBy;
-			cachedCommonKeys = getCommonGroupByKeys(
-				sourceMetadata?.groupBy,
-				syncMetadata?.groupBy,
-			);
-		}
-
-		controller.syncedSeriesIndexes = applyReceiverSync({
-			uPlotInstance: u,
-			yCrosshairEl,
-			syncKey,
-			syncMetadata,
-			sourceMetadata,
-			commonKeys: cachedCommonKeys,
-		});
-	};
-}

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/tooltipController.ts

@@ -27,7 +27,6 @@ export function createInitialControllerState(): TooltipControllerState {
 		verticalOffset: 0,
 		seriesIndexes: [],
 		focusedSeriesIndex: null,
-		syncedSeriesIndexes: null,
 		cursorDrivenBySync: false,
 		plotWithinViewport: false,
 		windowWidth: window.innerWidth - WINDOW_OFFSET,
@@ -185,7 +184,7 @@ export function createSetLegendHandler(
 			return;
 		}
 
-		const newSeriesIndexes = [...plot.cursor.idxs];
+		const newSeriesIndexes = plot.cursor.idxs.slice();
 		const isAnySeriesActive = newSeriesIndexes.some((v, i) => i > 0 && v != null);
 
 		const previousCursorDrivenBySync = controller.cursorDrivenBySync;

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/types.ts

@@ -4,7 +4,6 @@ import type {
 	ReactNode,
 	RefObject,
 } from 'react';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import type uPlot from 'uplot';
 
 import type { TooltipRenderArgs } from '../../components/types';
@@ -40,7 +39,6 @@ export interface TooltipLayoutInfo {
 
 export interface TooltipSyncMetadata {
 	yAxisUnit?: string;
-	groupBy?: BaseAutocompleteData[];
 }
 
 export interface TooltipPluginProps {
@@ -97,11 +95,6 @@ export interface TooltipControllerState {
 	verticalOffset: number;
 	seriesIndexes: Array<number | null>;
 	focusedSeriesIndex: number | null;
-	/** Receiver-side series filtering for Tooltip sync mode.
-	 * null  = no filtering (source panel or no groupBy configured)
-	 * []    = no matching series found → hide the synced tooltip
-	 * [...] = only these 1-based series indexes should appear in the synced tooltip */
-	syncedSeriesIndexes: number[] | null;
 	cursorDrivenBySync: boolean;
 	plotWithinViewport: boolean;
 	windowWidth: number;

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