refactor(dashboards): declare the legend colors control as its resolver

useLegendSeries switched on the panel kind to pick how a panel's output becomes
legend entries — pie slices or flat series — while the kinds that expose the
colors control were already declaring it as Legend.controls.colors. Two places
described the same fact, so a new chart kind could declare the control and
silently get an empty color picker.

The colors control now carries the resolver instead of a boolean: declaring the
resolver is declaring the control, so the two cannot disagree. The hook becomes a
lookup and a call with no switch, and LegendSection's truthiness check is
unchanged.

legendSeries.ts moves from PanelEditor/utils to Panels/utils — it only ever
imported from Panels and queryV5, and kinds cannot import up into the editor. Both
resolvers take one args object so pie needs no placeholder parameter.

Assisted-by: Claude Opus 5

docs/api/openapi.yml

@@ -3064,79 +3064,6 @@ components:
       - tags
       - spec
       type: object
-    DashboardtypesHeatmapAxes:
-      properties:
-        yScale:
-          $ref: '#/components/schemas/DashboardtypesHeatmapYScale'
-      type: object
-    DashboardtypesHeatmapChartAppearance:
-      properties:
-        colors:
-          $ref: '#/components/schemas/DashboardtypesHeatmapColors'
-      type: object
-    DashboardtypesHeatmapColorMode:
-      enum:
-      - palette
-      - opacity
-      type: string
-    DashboardtypesHeatmapColorScale:
-      enum:
-      - log
-      - sqrt
-      - linear
-      type: string
-    DashboardtypesHeatmapColors:
-      properties:
-        fill:
-          type: string
-        maxCount:
-          nullable: true
-          type: number
-        minCount:
-          nullable: true
-          type: number
-        mode:
-          $ref: '#/components/schemas/DashboardtypesHeatmapColorMode'
-        palette:
-          $ref: '#/components/schemas/DashboardtypesHeatmapPalette'
-        scale:
-          $ref: '#/components/schemas/DashboardtypesHeatmapColorScale'
-        steps:
-          type: integer
-      type: object
-    DashboardtypesHeatmapPalette:
-      enum:
-      - ice
-      - moss
-      - rust
-      - graphite
-      - ember
-      - lagoon
-      - orchid
-      - verdant
-      - lava
-      - beacon
-      type: string
-    DashboardtypesHeatmapPanelSpec:
-      properties:
-        axes:
-          $ref: '#/components/schemas/DashboardtypesHeatmapAxes'
-        chartAppearance:
-          $ref: '#/components/schemas/DashboardtypesHeatmapChartAppearance'
-        formatting:
-          $ref: '#/components/schemas/DashboardtypesPanelFormatting'
-        legend:
-          $ref: '#/components/schemas/DashboardtypesLegend'
-        visualization:
-          $ref: '#/components/schemas/DashboardtypesBasicVisualization'
-      type: object
-    DashboardtypesHeatmapYScale:
-      enum:
-      - auto
-      - linear
-      - log
-      - symlog
-      type: string
     DashboardtypesHistogramBuckets:
       properties:
         bucketCount:
@@ -3489,7 +3416,6 @@ components:
       discriminator:
         mapping:
           signoz/BarChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec'
-          signoz/HeatmapPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec'
           signoz/HistogramPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
           signoz/ListPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
           signoz/NumberPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec'
@@ -3505,7 +3431,6 @@ components:
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
-      - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec'
       type: object
     DashboardtypesPanelPluginKind:
       enum:
@@ -3516,7 +3441,6 @@ components:
       - signoz/TablePanel
       - signoz/HistogramPanel
       - signoz/ListPanel
-      - signoz/HeatmapPanel
       type: string
     DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec:
       properties:
@@ -3530,18 +3454,6 @@ components:
       - kind
       - spec
       type: object
-    DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec:
-      properties:
-        kind:
-          enum:
-          - signoz/HeatmapPanel
-          type: string
-        spec:
-          $ref: '#/components/schemas/DashboardtypesHeatmapPanelSpec'
-      required:
-      - kind
-      - spec
-      type: object
     DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec:
       properties:
         kind:
@@ -7073,7 +6985,10 @@ components:
             $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
           type: array
         meta:
-          $ref: '#/components/schemas/Querybuildertypesv5AggregationMeta'
+          properties:
+            unit:
+              type: string
+          type: object
         predictedSeries:
           items:
             $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
@@ -7088,51 +7003,12 @@ components:
             $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
           type: array
       type: object
-    Querybuildertypesv5AggregationMeta:
+    Querybuildertypesv5Bucket:
       properties:
-        buckets:
-          items:
-            format: double
-            type: number
-          type: array
-        unit:
-          type: string
+        step:
+          format: double
+          type: number
       type: object
-    Querybuildertypesv5BucketOptions:
-      discriminator:
-        mapping:
-          linear: '#/components/schemas/Querybuildertypesv5BucketOptionsLinear'
-          log: '#/components/schemas/Querybuildertypesv5BucketOptionsLog'
-        propertyName: kind
-      oneOf:
-      - $ref: '#/components/schemas/Querybuildertypesv5BucketOptionsLinear'
-      - $ref: '#/components/schemas/Querybuildertypesv5BucketOptionsLog'
-      type: object
-    Querybuildertypesv5BucketOptionsLinear:
-      properties:
-        kind:
-          $ref: '#/components/schemas/Querybuildertypesv5BucketsKind'
-        spec:
-          $ref: '#/components/schemas/Querybuildertypesv5LinearBucketsSpec'
-      required:
-      - kind
-      - spec
-      type: object
-    Querybuildertypesv5BucketOptionsLog:
-      properties:
-        kind:
-          $ref: '#/components/schemas/Querybuildertypesv5BucketsKind'
-        spec:
-          $ref: '#/components/schemas/Querybuildertypesv5LogBucketsSpec'
-      required:
-      - kind
-      - spec
-      type: object
-    Querybuildertypesv5BucketsKind:
-      enum:
-      - linear
-      - log
-      type: string
     Querybuildertypesv5BuilderQuerySpec:
       discriminator:
         mapping:
@@ -7313,16 +7189,6 @@ components:
         value:
           type: string
       type: object
-    Querybuildertypesv5LinearBucketsSpec:
-      properties:
-        maxValue:
-          format: double
-          type: number
-        numBuckets:
-          type: integer
-      required:
-      - maxValue
-      type: object
     Querybuildertypesv5LogAggregation:
       properties:
         alias:
@@ -7330,12 +7196,6 @@ components:
         expression:
           type: string
       type: object
-    Querybuildertypesv5LogBucketsSpec:
-      properties:
-        scale:
-          nullable: true
-          type: integer
-      type: object
     Querybuildertypesv5MetricAggregation:
       properties:
         comparisonSpaceAggregationParam:
@@ -7794,8 +7654,6 @@ components:
         queries (traces, logs, metrics), formulas, joins, trace operators, PromQL,
         and ClickHouse SQL queries.
       properties:
-        bucketOptions:
-          $ref: '#/components/schemas/Querybuildertypesv5BucketOptions'
         compositeQuery:
           $ref: '#/components/schemas/Querybuildertypesv5CompositeQuery'
         end:
@@ -7895,7 +7753,6 @@ components:
       - raw
       - raw_stream
       - trace
-      - heatmap
       type: string
     Querybuildertypesv5ScalarData:
       properties:
@@ -7970,6 +7827,8 @@ components:
       type: object
     Querybuildertypesv5TimeSeriesValue:
       properties:
+        bucket:
+          $ref: '#/components/schemas/Querybuildertypesv5Bucket'
         partial:
           type: boolean
         timestamp:

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx

@@ -8,7 +8,7 @@ import { getPanelDefinition } from 'pages/DashboardPage/DashboardContainer/Panel
 import { resolveSignal } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getBuilderQueries';
 import type { EQueryType } from 'types/common/dashboard';
 
-import type { LegendSeries } from '../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 import type { TableColumnOption } from '../hooks/useTableColumns';
 import ConfigActions from './ConfigActions/ConfigActions';
 import SectionSlot from './SectionSlot/SectionSlot';

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/__tests__/PanelTypeSwitcher.test.tsx

@@ -5,8 +5,18 @@ import PanelTypeSwitcher from '../PanelTypeSwitcher';
 import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import { EQueryType } from 'types/common/dashboard';
 
+// Stub the registry so the test doesn't pull in the real renderers and chart libs.
 jest.mock('pages/DashboardPage/DashboardContainer/Panels/registry', () => ({
 	getPanelDefinition: jest.fn(),
+	PANEL_OPTIONS: [
+		{ kind: 'signoz/TimeSeriesPanel', displayName: 'Time Series' },
+		{ kind: 'signoz/NumberPanel', displayName: 'Number' },
+		{ kind: 'signoz/TablePanel', displayName: 'Table' },
+		{ kind: 'signoz/BarChartPanel', displayName: 'Bar Chart' },
+		{ kind: 'signoz/PieChartPanel', displayName: 'Pie Chart' },
+		{ kind: 'signoz/HistogramPanel', displayName: 'Histogram' },
+		{ kind: 'signoz/ListPanel', displayName: 'List' },
+	].map((option) => ({ ...option, icon: (): null => null })),
 }));
 
 const mockGetPanelDefinition = getPanelDefinition as unknown as jest.Mock;

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/usePanelTypeSelectItems.tsx

@@ -2,8 +2,8 @@ import { useMemo } from 'react';
 import type { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import type { EQueryType } from 'types/common/dashboard';
 
+import { PANEL_OPTIONS } from '../../../Panels/registry';
 import type { PanelKind } from '../../../Panels/types/panelKind';
-import { PANEL_TYPES } from '../../../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/constants';
 import type { ConfigSelectItem } from '../controls/ConfigSelect/ConfigSelect';
 
 import { getPanelTypeDisabledReason } from './utils';
@@ -27,17 +27,17 @@ export function usePanelTypeSelectItems({
 }: UsePanelTypeSelectItemsArgs): ConfigSelectItem<PanelKind>[] {
 	return useMemo(
 		() =>
-			PANEL_TYPES.map(({ panelKind, label, Icon }) => {
+			PANEL_OPTIONS.map(({ kind, displayName, icon: Icon }) => {
 				// One reason drives both the disabled flag and the tooltip, so they can't disagree.
 				const disabledReason = getPanelTypeDisabledReason({
-					kind: panelKind,
+					kind,
 					queryType,
 					signal,
-					label,
+					label: displayName,
 				});
 				return {
-					value: panelKind,
-					label,
+					value: kind,
+					label: displayName,
 					icon: <Icon size={14} />,
 					disabled: !!disabledReason,
 					tooltip: disabledReason,

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/LegendColors.tsx

@@ -5,7 +5,7 @@ import { Input } from 'antd';
 import type { DashboardtypesLegendDTOCustomColors } from 'api/generated/services/sigNoz.schemas';
 import { Virtuoso } from 'react-virtuoso';
 
-import type { LegendSeries } from '../../../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 import LegendColorRow from './LegendColorRow';
 import {
 	clearSeriesColor,

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/__tests__/LegendColors.test.tsx

@@ -1,6 +1,6 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 
-import type { LegendSeries } from '../../../../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 import LegendColors from '../LegendColors';
 
 const SERIES: LegendSeries[] = [

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/__tests__/legendColors.utils.test.ts

@@ -1,4 +1,4 @@
-import type { LegendSeries } from '../../../../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 import {
 	clearSeriesColor,
 	filterLegendSeries,

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/legendColors.utils.ts

@@ -1,6 +1,6 @@
 import type { DashboardtypesLegendDTOCustomColors } from 'api/generated/services/sigNoz.schemas';
 
-import type { LegendSeries } from '../../../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 
 /** Case-insensitive substring filter over series labels. Empty query → all series. */
 export function filterLegendSeries(

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionContext.ts

@@ -1,7 +1,7 @@
 import type { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 
 import type { PanelKind } from '../../Panels/types/panelKind';
-import type { LegendSeries } from '../utils/legendSeries';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
 import type { TableColumnOption } from '../hooks/useTableColumns';
 import { EQueryType } from 'types/common/dashboard';
 

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/VisualizationSection/__tests__/VisualizationSection.test.tsx

@@ -11,6 +11,10 @@ jest.mock('pages/DashboardPage/DashboardContainer/Panels/registry', () => ({
 		supportedSignals: ['metrics', 'logs', 'traces'],
 		supportedQueryTypes: ['builder', 'clickhouse_sql', 'promql'],
 	})),
+	PANEL_OPTIONS: [
+		{ kind: 'signoz/TimeSeriesPanel', displayName: 'Time Series' },
+		{ kind: 'signoz/TablePanel', displayName: 'Table' },
+	].map((option) => ({ ...option, icon: (): null => null })),
 }));
 
 // Open the antd Select by clicking its selector, then pick the option by label.

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useLegendSeries.ts

@@ -1,36 +1,27 @@
 import { useMemo } from 'react';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
+import type { LegendSeries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries';
+import { getSectionControls } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getSectionControls';
+import { SectionKind } from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';
 import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';
 
-import {
-	type LegendSeries,
-	resolvePieLegendSeries,
-	resolveTimeSeriesLegendSeries,
-} from '../utils/legendSeries';
-
 /**
  * Resolves the panel's rendered series into `{ label, defaultColor }` pairs so the
- * legend-colors control can key overrides by the exact labels the chart draws. Only the
- * kinds that expose a colors control resolve series (Pie from its scalar slices, Time
- * Series from its flat series); every other kind returns none.
+ * legend-colors control can key overrides by the exact labels the chart draws, using
+ * the resolver the kind declares as its `colors` control.
  */
 export function useLegendSeries(
 	panel: DashboardtypesPanelDTO,
 	data: PanelQueryData,
 ): LegendSeries[] {
 	const isDarkMode = useIsDarkMode();
+	const kind = panel.spec.plugin.kind;
 
 	return useMemo(() => {
-		switch (panel.spec.plugin.kind) {
-			case 'signoz/PieChartPanel':
-				return resolvePieLegendSeries(data, isDarkMode);
-			case 'signoz/TimeSeriesPanel':
-			case 'signoz/BarChartPanel':
-			case 'signoz/HistogramPanel':
-				return resolveTimeSeriesLegendSeries(panel.spec.queries, data, isDarkMode);
-			default:
-				return [];
-		}
-	}, [panel.spec.plugin.kind, panel.spec.queries, data, isDarkMode]);
+		const resolve = getSectionControls(kind, SectionKind.Legend)?.colors;
+		return resolve
+			? resolve({ queries: panel.spec.queries, data, isDarkMode })
+			: [];
+	}, [kind, panel.spec.queries, data, isDarkMode]);
 }

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/BarChartPanel/definition.ts

@@ -1,3 +1,5 @@
+import { BarChart } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/BarChartPanel'> = {
 	kind: 'signoz/BarChartPanel',
 	displayName: 'Bar Chart',
+	icon: BarChart,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/BarChartPanel/sections.ts

@@ -1,3 +1,4 @@
+import { resolveTimeSeriesLegendSeries } from '../../utils/legendSeries';
 import {
 	SectionKind,
 	ThresholdVariant,
@@ -13,7 +14,10 @@ export const sections: SectionConfig[] = [
 	},
 	{ kind: SectionKind.Formatting, controls: { unit: true, decimals: true } },
 	{ kind: SectionKind.Axes, controls: { minMax: true, logScale: true } },
-	{ kind: SectionKind.Legend, controls: { position: true, colors: true } },
+	{
+		kind: SectionKind.Legend,
+		controls: { position: true, colors: resolveTimeSeriesLegendSeries },
+	},
 	{
 		kind: SectionKind.Thresholds,
 		controls: { variant: ThresholdVariant.LABEL },

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/HistogramPanel/definition.ts

@@ -1,3 +1,5 @@
+import { BarChart } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/HistogramPanel'> = {
 	kind: 'signoz/HistogramPanel',
 	displayName: 'Histogram',
+	icon: BarChart,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/HistogramPanel/sections.ts

@@ -1,3 +1,4 @@
+import { resolveTimeSeriesLegendSeries } from '../../utils/legendSeries';
 import type { DashboardtypesHistogramPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';
 
 import { SectionKind, type SectionConfig } from '../../types/sections';
@@ -9,7 +10,7 @@ export const sections: SectionConfig[] = [
 	},
 	{
 		kind: SectionKind.Legend,
-		controls: { position: true, colors: true },
+		controls: { position: true, colors: resolveTimeSeriesLegendSeries },
 		// Merging all queries collapses to one distribution with no legend.
 		isHidden: (spec): boolean =>
 			Boolean(

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ListPanel/definition.ts

@@ -1,3 +1,5 @@
+import { List } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -11,6 +13,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/ListPanel'> = {
 	kind: 'signoz/ListPanel',
 	displayName: 'List',
+	icon: List,
 	Renderer,
 	// Raw records come from logs and traces; metrics don't produce row data.
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/NumberPanel/definition.ts

@@ -1,3 +1,5 @@
+import { Hash } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/NumberPanel'> = {
 	kind: 'signoz/NumberPanel',
 	displayName: 'Number',
+	icon: Hash,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/PieChartPanel/definition.ts

@@ -1,3 +1,5 @@
+import { ChartPie } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/PieChartPanel'> = {
 	kind: 'signoz/PieChartPanel',
 	displayName: 'Pie Chart',
+	icon: ChartPie,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/PieChartPanel/sections.ts

@@ -1,3 +1,4 @@
+import { resolvePieLegendSeries } from '../../utils/legendSeries';
 import { SectionKind, type SectionConfig } from '../../types/sections';
 
 // Pie has no axes, thresholds, or stacking — just value formatting and a legend
@@ -8,6 +9,9 @@ export const sections: SectionConfig[] = [
 		controls: { switchPanelKind: true, timePreference: true },
 	},
 	{ kind: SectionKind.Formatting, controls: { unit: true, decimals: true } },
-	{ kind: SectionKind.Legend, controls: { position: true, colors: true } },
+	{
+		kind: SectionKind.Legend,
+		controls: { position: true, colors: resolvePieLegendSeries },
+	},
 	{ kind: SectionKind.ContextLinks },
 ];

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/definition.ts

@@ -1,3 +1,5 @@
+import { Table } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/TablePanel'> = {
 	kind: 'signoz/TablePanel',
 	displayName: 'Table',
+	icon: Table,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TimeSeriesPanel/definition.ts

@@ -1,3 +1,5 @@
+import { ChartLine } from '@signozhq/icons';
+
 import type { PanelDefinition } from '../../types/panelDefinition';
 import Renderer from './Renderer';
 import { sections } from './sections';
@@ -10,6 +12,7 @@ import { EQueryType } from 'types/common/dashboard';
 export const definition: PanelDefinition<'signoz/TimeSeriesPanel'> = {
 	kind: 'signoz/TimeSeriesPanel',
 	displayName: 'Time Series',
+	icon: ChartLine,
 	Renderer,
 	sections,
 	supportedSignals: [

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TimeSeriesPanel/sections.ts

@@ -1,3 +1,4 @@
+import { resolveTimeSeriesLegendSeries } from '../../utils/legendSeries';
 import {
 	SectionKind,
 	ThresholdVariant,
@@ -11,7 +12,10 @@ export const sections: SectionConfig[] = [
 	},
 	{ kind: SectionKind.Formatting, controls: { unit: true, decimals: true } },
 	{ kind: SectionKind.Axes, controls: { minMax: true, logScale: true } },
-	{ kind: SectionKind.Legend, controls: { position: true, colors: true } },
+	{
+		kind: SectionKind.Legend,
+		controls: { position: true, colors: resolveTimeSeriesLegendSeries },
+	},
 	{
 		kind: SectionKind.ChartAppearance,
 		controls: {

frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/UnsupportedPanel/definition.ts

@@ -1,4 +1,5 @@
 import { Querybuildertypesv5RequestTypeDTO } from 'api/generated/services/sigNoz.schemas';
+import { TriangleAlert } from '@signozhq/icons';
 
 import {
 	NO_PANEL_ACTIONS,
@@ -18,6 +19,8 @@ import Renderer from './Renderer';
 export const UNSUPPORTED_PANEL: RenderablePanelDefinition = {
 	kind: '<unsupported>' as RenderablePanelDefinition['kind'],
 	displayName: 'Unsupported panel',
+	// Never offered in the UI — the kind lists come from the registry, which omits this.
+	icon: TriangleAlert,
 	Renderer,
 	sections: [],
 	supportedSignals: [],

frontend/src/pages/DashboardPage/DashboardContainer/Panels/registry.ts

@@ -7,22 +7,33 @@ import { definition as Table } from './kinds/TablePanel/definition';
 import { definition as List } from './kinds/ListPanel/definition';
 import { UNSUPPORTED_PANEL } from './kinds/UnsupportedPanel/definition';
 import type {
+	PanelDefinition,
 	PanelRegistry,
 	RenderablePanelDefinition,
 } from './types/panelDefinition';
 import { PanelKind } from './types/panelKind';
 
 // Each kind owns its PanelDefinition; registering a new panel is one entry here.
+// Declaration order is the order kinds are offered in the UI.
 export const PANELS: PanelRegistry = {
 	[TimeSeries.kind]: TimeSeries,
-	[BarChart.kind]: BarChart,
-	[Histogram.kind]: Histogram,
 	[NumberValue.kind]: NumberValue,
-	[PieChart.kind]: PieChart,
 	[Table.kind]: Table,
+	[BarChart.kind]: BarChart,
+	[PieChart.kind]: PieChart,
+	[Histogram.kind]: Histogram,
 	[List.kind]: List,
 };
 
+export type PanelOption = Pick<
+	PanelDefinition,
+	'kind' | 'displayName' | 'icon'
+>;
+
+// Backs both the new-panel picker and the editor's kind switcher; derived from PANELS
+// so a registered kind can't end up unreachable from the UI.
+export const PANEL_OPTIONS: PanelOption[] = Object.values(PANELS);
+
 /**
  * Whether this build can render the kind. `PanelKind` spans every kind the API declares,
  * but a dashboard spec written by a newer SigNoz can name one this client has never heard

frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelDefinition.ts

@@ -1,5 +1,6 @@
 import type { ComponentType } from 'react';
 import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
+import type { ChartLine } from '@signozhq/icons';
 import type { EQueryType } from 'types/common/dashboard';
 
 import type { SectionConfig } from './sections';
@@ -60,9 +61,14 @@ export const NO_PANEL_ACTIONS: PanelActionCapabilities = {
 	drilldown: false,
 };
 
+// Derived from an icon component so the props stay exact (size is a constrained
+// IconSize union) and ForwardRef-compatible.
+export type PanelIcon = typeof ChartLine;
+
 export interface PanelDefinition<K extends PanelKind = PanelKind> {
 	kind: K;
 	displayName: string;
+	icon: PanelIcon;
 	Renderer: ComponentType<PanelRendererProps<K>>;
 	sections: SectionConfig[];
 	/** Signals this kind can visualize. */

frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/sections.ts

@@ -13,6 +13,7 @@ import type {
 	DashboardtypesTimeSeriesChartAppearanceDTO,
 	TelemetrytypesTelemetryFieldKeyDTO,
 } from 'api/generated/services/sigNoz.schemas';
+import type { LegendSeriesResolver } from '../utils/legendSeries';
 import {
 	Antenna,
 	BarChart,
@@ -105,7 +106,12 @@ export interface SectionControls {
 		columnUnits?: boolean;
 	};
 	[SectionKind.Axes]: { minMax?: boolean; logScale?: boolean }; // minMax → softMin/softMax
-	[SectionKind.Legend]: { position?: boolean; colors?: boolean }; // colors → customColors
+	[SectionKind.Legend]: {
+		position?: boolean;
+		// colors → customColors; the resolver supplies the labels overrides are keyed by,
+		// so a kind can't offer color overrides with nothing to color
+		colors?: LegendSeriesResolver;
+	};
 	[SectionKind.ChartAppearance]: {
 		lineStyle?: boolean;
 		lineInterpolation?: boolean;

frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/buildPluginSpec.test.ts

@@ -79,7 +79,7 @@ describe('buildPluginSpec', () => {
 
 		it('omits the key entirely when a seed produces an empty slice (never key: undefined)', () => {
 			const result = buildPluginSpec([
-				{ kind: SectionKind.Legend, controls: { colors: true } },
+				{ kind: SectionKind.Legend, controls: { colors: (): [] => [] } },
 			]);
 
 			expect(result).toStrictEqual({});
@@ -129,7 +129,7 @@ describe('buildPluginSpec', () => {
 		it('seeds neither when their defaulting controls are absent', () => {
 			const sections: SectionConfig[] = [
 				{ kind: SectionKind.Visualization, controls: { switchPanelKind: true } },
-				{ kind: SectionKind.Legend, controls: { colors: true } },
+				{ kind: SectionKind.Legend, controls: { colors: (): [] => [] } },
 			];
 			expect(buildPluginSpec(sections)).toStrictEqual({});
 		});
@@ -180,7 +180,10 @@ describe('buildPluginSpec', () => {
 
 		it('carries old legend position but never customColors', () => {
 			const sections: SectionConfig[] = [
-				{ kind: SectionKind.Legend, controls: { position: true, colors: true } },
+				{
+					kind: SectionKind.Legend,
+					controls: { position: true, colors: (): [] => [] },
+				},
 			];
 			const oldSpec = oldSpecWith({
 				legend: {

frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/getSectionControls.test.ts

@@ -0,0 +1,46 @@
+import { SectionKind, ThresholdVariant } from '../../types/sections';
+import { getSectionControls } from '../getSectionControls';
+
+describe('getSectionControls', () => {
+	it('returns the controls a kind declares for a section', () => {
+		expect(
+			getSectionControls('signoz/TimeSeriesPanel', SectionKind.Formatting),
+		).toStrictEqual({ unit: true, decimals: true });
+	});
+
+	it('distinguishes kinds that key units per column from kinds with a panel unit', () => {
+		expect(
+			getSectionControls('signoz/TablePanel', SectionKind.Formatting)?.unit,
+		).toBeUndefined();
+		expect(
+			getSectionControls('signoz/TablePanel', SectionKind.Formatting)?.columnUnits,
+		).toBe(true);
+	});
+
+	it('reports the threshold variant each kind edits', () => {
+		expect(
+			getSectionControls('signoz/NumberPanel', SectionKind.Thresholds)?.variant,
+		).toBe(ThresholdVariant.COMPARISON);
+		expect(
+			getSectionControls('signoz/BarChartPanel', SectionKind.Thresholds)?.variant,
+		).toBe(ThresholdVariant.LABEL);
+	});
+
+	it('returns undefined when the kind does not expose the section', () => {
+		expect(
+			getSectionControls('signoz/ListPanel', SectionKind.Formatting),
+		).toBeUndefined();
+		expect(
+			getSectionControls('signoz/HistogramPanel', SectionKind.Thresholds),
+		).toBeUndefined();
+	});
+
+	it('returns undefined for an unregistered kind', () => {
+		expect(
+			getSectionControls(
+				'signoz/FuturePanel' as Parameters<typeof getSectionControls>[0],
+				SectionKind.Formatting,
+			),
+		).toBeUndefined();
+	});
+});

frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getSectionControls.ts

@@ -0,0 +1,22 @@
+import { getPanelDefinition } from '../registry';
+import type { PanelKind } from '../types/panelKind';
+import type { ControlledSectionKind, SectionControls } from '../types/sections';
+
+/**
+ * The controls a kind declares for one section, or `undefined` when it doesn't expose
+ * that section — so callers read `kinds/<Kind>/sections.ts` instead of switching on kind.
+ */
+export function getSectionControls<K extends ControlledSectionKind>(
+	kind: PanelKind,
+	sectionKind: K,
+): SectionControls[K] | undefined {
+	const section = getPanelDefinition(kind).sections.find(
+		(candidate) => candidate.kind === sectionKind,
+	);
+	if (!section || !('controls' in section)) {
+		return undefined;
+	}
+	// `find` can't correlate the matched member's `controls` with `sectionKind`; the
+	// SectionConfig union guarantees it.
+	return section.controls as SectionControls[K];
+}

frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries.ts

@@ -2,9 +2,9 @@ import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schem
 import { themeColors } from 'constants/theme';
 import getLabelName from 'lib/getLabelName';
 import { generateColor } from 'lib/uPlotLib/utils/generateColor';
-import { preparePieData } from 'pages/DashboardPage/DashboardContainer/Panels/kinds/PieChartPanel/prepareData';
-import { getBuilderQueries } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getBuilderQueries';
-import { resolveSeriesLabelV5 } from 'pages/DashboardPage/DashboardContainer/Panels/utils/resolveSeriesLabel';
+import { preparePieData } from '../kinds/PieChartPanel/prepareData';
+import { getBuilderQueries } from './getBuilderQueries';
+import { resolveSeriesLabelV5 } from './resolveSeriesLabel';
 import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';
 import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';
 import {
@@ -22,6 +22,15 @@ export interface LegendSeries {
 
 type PanelQueries = DashboardtypesPanelDTO['spec']['queries'];
 
+export interface LegendSeriesArgs {
+	queries: PanelQueries;
+	data: PanelQueryData;
+	isDarkMode: boolean;
+}
+
+/** Resolves a kind's output into the legend entries the colors control keys overrides by. */
+export type LegendSeriesResolver = (args: LegendSeriesArgs) => LegendSeries[];
+
 /**
  * Dedupes `labels` (first-seen order, empties dropped) into `{ label, defaultColor }`
  * pairs, resolving each unique label's color lazily via `colorFor` — so a repeated
@@ -48,10 +57,10 @@ function buildLegendSeries(
  * draws (without overrides, so their colors are the defaults) so the color control keys
  * overrides by the same labels the chart does.
  */
-export function resolvePieLegendSeries(
-	data: PanelQueryData,
-	isDarkMode: boolean,
-): LegendSeries[] {
+export function resolvePieLegendSeries({
+	data,
+	isDarkMode,
+}: LegendSeriesArgs): LegendSeries[] {
 	const slices = preparePieData({
 		tables: prepareScalarTables({
 			results: getScalarResults(data.response),
@@ -70,11 +79,11 @@ export function resolvePieLegendSeries(
  * Time-series kinds: resolve each flattened series' label the way the renderer does
  * (`getLabelName` → `resolveSeriesLabelV5`) and color it with `generateColor`.
  */
-export function resolveTimeSeriesLegendSeries(
-	queries: PanelQueries,
-	data: PanelQueryData,
-	isDarkMode: boolean,
-): LegendSeries[] {
+export function resolveTimeSeriesLegendSeries({
+	queries,
+	data,
+	isDarkMode,
+}: LegendSeriesArgs): LegendSeries[] {
 	const palette = isDarkMode
 		? themeColors.chartcolors
 		: themeColors.lightModeColor;

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.tsx

@@ -4,8 +4,8 @@ import { DialogWrapper } from '@signozhq/ui/dialog';
 import cx from 'classnames';
 
 import { useDashboardSections } from '../../../hooks/useDashboardSections';
+import { PANEL_OPTIONS } from '../../../Panels/registry';
 import type { PanelKind } from '../../../Panels/types/panelKind';
-import { PANEL_TYPES } from './constants';
 import PanelTypeSelectionModalFooter from './PanelTypeSelectionModalFooter';
 import { buildSectionOptions, resolveDefaultSectionValue } from './utils';
 import styles from './PanelTypeSelectionModal.module.scss';
@@ -91,19 +91,19 @@ function PanelTypeSelectionModal({
 					<span className={styles.pickerLabel}>Select panel type</span>
 				)}
 				<div className={styles.grid}>
-					{PANEL_TYPES.map(({ panelKind, label, Icon }) => (
+					{PANEL_OPTIONS.map(({ kind, displayName, icon: Icon }) => (
 						<button
-							key={panelKind}
+							key={kind}
 							type="button"
 							className={cx(styles.panelTypeCard, {
-								[styles.panelTypeCardSelected]: panelKind === selectedPanelKind,
+								[styles.panelTypeCardSelected]: kind === selectedPanelKind,
 							})}
-							data-testid={`panel-type-${panelKind}`}
-							aria-pressed={panelKind === selectedPanelKind}
-							onClick={(): void => handleTileClick(panelKind)}
+							data-testid={`panel-type-${kind}`}
+							aria-pressed={kind === selectedPanelKind}
+							onClick={(): void => handleTileClick(kind)}
 						>
 							<Icon size={24} color={Color.BG_ROBIN_400} />
-							{label}
+							{displayName}
 						</button>
 					))}
 				</div>

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/constants.ts

@@ -1,24 +0,0 @@
-import {
-	BarChart,
-	ChartLine,
-	ChartPie,
-	Hash,
-	List,
-	Table,
-} from '@signozhq/icons';
-
-import type { PanelType } from './types';
-
-export const PANEL_TYPES: PanelType[] = [
-	{
-		panelKind: 'signoz/TimeSeriesPanel',
-		label: 'Time Series',
-		Icon: ChartLine,
-	},
-	{ panelKind: 'signoz/NumberPanel', label: 'Number', Icon: Hash },
-	{ panelKind: 'signoz/TablePanel', label: 'Table', Icon: Table },
-	{ panelKind: 'signoz/BarChartPanel', label: 'Bar Chart', Icon: BarChart },
-	{ panelKind: 'signoz/PieChartPanel', label: 'Pie Chart', Icon: ChartPie },
-	{ panelKind: 'signoz/HistogramPanel', label: 'Histogram', Icon: BarChart },
-	{ panelKind: 'signoz/ListPanel', label: 'List', Icon: List },
-];

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/types.ts

@@ -1,20 +1,11 @@
 import type { IconSize } from '@signozhq/icons';
 import type { ComponentType, SVGProps } from 'react';
 
-import type { PanelKind } from '../../../Panels/types/panelKind';
-
 type IconProps = Omit<SVGProps<SVGSVGElement>, 'ref'> & {
 	size?: number | IconSize;
 	strokeWidth?: number;
 };
 
-export interface PanelType {
-	panelKind: PanelKind;
-	label: string;
-	/** Icon component — the consumer renders it and controls size/color/etc. */
-	Icon: ComponentType<IconProps>;
-}
-
 export interface SectionOption {
 	/** The section's `layoutIndex`, stringified for the Select value. */
 	value: string;

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/utils/buildCreateAlertUrl.ts

@@ -8,24 +8,24 @@ import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { PANEL_KIND_TO_PANEL_TYPE } from 'pages/DashboardPage/DashboardContainer/Panels/types/panelKind';
+import {
+	SectionKind,
+	type PanelFormattingSlice,
+} from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';
+import { getSectionControls } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getSectionControls';
 import { fromPerses } from 'pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters';
 import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import { deriveAlertPrefill, PanelAlertPrefill } from './deriveAlertPrefill';
 
-/** The panel's configured y-axis unit, for the kinds that carry one. */
+/** The panel's configured y-axis unit, for the kinds that declare one. */
 export function readPanelUnit(
 	plugin: DashboardtypesPanelPluginDTO,
 ): string | undefined {
-	switch (plugin.kind) {
-		case 'signoz/TimeSeriesPanel':
-		case 'signoz/BarChartPanel':
-		case 'signoz/NumberPanel':
-		case 'signoz/PieChartPanel':
-			return plugin.spec.formatting?.unit;
-		default:
-			return undefined;
+	if (!getSectionControls(plugin.kind, SectionKind.Formatting)?.unit) {
+		return undefined;
 	}
+	return (plugin.spec as { formatting?: PanelFormattingSlice }).formatting?.unit;
 }
 
 /**

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/utils/deriveAlertPrefill.ts

@@ -11,7 +11,15 @@ import {
 	AlertThresholdOperator,
 	Threshold,
 } from 'container/CreateAlertV2/context/types';
-import { THRESHOLD_COLOR_DANGER_ORDER } from 'pages/DashboardPage/DashboardContainer/Panels/types/threshold';
+import {
+	SectionKind,
+	ThresholdVariant,
+} from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';
+import {
+	THRESHOLD_COLOR_DANGER_ORDER,
+	type ComparisonThresholdShape,
+} from 'pages/DashboardPage/DashboardContainer/Panels/types/threshold';
+import { getSectionControls } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getSectionControls';
 import type { MetricAggregation } from 'types/api/v5/queryRange';
 import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { ReduceOperators } from 'types/common/queryBuilder';
@@ -64,27 +72,35 @@ export function uniformReduceTo(query: Query): ReduceOperators | undefined {
 		: undefined;
 }
 
+/**
+ * The panel's thresholds, normalized for alert prefill, read through the variant the
+ * kind declares. A `table` variant contributes nothing: per-column thresholds have no
+ * meaning for a panel-wide alert condition.
+ */
 function readPanelThresholds(
 	plugin: DashboardtypesPanelPluginDTO,
 ): NormalizedPanelThreshold[] {
-	switch (plugin.kind) {
-		case 'signoz/TimeSeriesPanel':
-		case 'signoz/BarChartPanel':
-			return (plugin.spec.thresholds ?? []).map((t) => ({
-				color: t.color,
-				value: t.value,
-				unit: t.unit,
-			}));
-		case 'signoz/NumberPanel':
-			return (plugin.spec.thresholds ?? []).map((t) => ({
-				color: t.color,
-				value: t.value,
-				unit: t.unit,
-				operator: t.operator,
-			}));
-		default:
-			return [];
+	const variant = getSectionControls(
+		plugin.kind,
+		SectionKind.Thresholds,
+	)?.variant;
+	if (
+		variant !== ThresholdVariant.LABEL &&
+		variant !== ThresholdVariant.COMPARISON
+	) {
+		return [];
 	}
+	const thresholds =
+		(plugin.spec as { thresholds?: ComparisonThresholdShape[] }).thresholds ?? [];
+	return thresholds.map((threshold) => ({
+		color: threshold.color,
+		value: threshold.value,
+		unit: threshold.unit,
+		// Only comparison thresholds carry an operator.
+		...(variant === ThresholdVariant.COMPARISON && {
+			operator: threshold.operator,
+		}),
+	}));
 }
 
 // Match case-insensitively (picker emits lowercase hex); unknown colors sort last.

frontend/src/pages/DashboardPage/PanelEditorPage/newPanelSeed.ts

@@ -12,6 +12,7 @@ import {
 	buildPluginSpec,
 	type SeededPluginSpec,
 } from '../DashboardContainer/Panels/utils/buildPluginSpec';
+import { getSectionControls } from '../DashboardContainer/Panels/utils/getSectionControls';
 import { toPerses } from '../DashboardContainer/queryV5/persesQueryAdapters';
 
 interface NewPanelSeed {
@@ -21,15 +22,6 @@ interface NewPanelSeed {
 	pluginSpec: SeededPluginSpec;
 }
 
-function kindSupportsUnit(kind: PanelKind): boolean {
-	return getPanelDefinition(kind).sections.some(
-		(section) =>
-			section.kind === SectionKind.Formatting &&
-			'controls' in section &&
-			section.controls.unit === true,
-	);
-}
-
 /** Kind to fall back to for a query language a builder-only kind (List) can't hold. */
 const FALLBACK_KIND_BY_QUERY_TYPE: Partial<Record<EQueryType, PanelKind>> = {
 	[EQueryType.PROM]: 'signoz/TimeSeriesPanel',
@@ -74,7 +66,10 @@ export function buildNewPanelSeed(
 	const queries = converted.length > 0 ? converted : buildDefaultQueries(kind);
 
 	// Explorers put the single `unit` on the query itself, not the panel spec.
-	if (compositeQuery.unit && kindSupportsUnit(kind)) {
+	if (
+		compositeQuery.unit &&
+		getSectionControls(kind, SectionKind.Formatting)?.unit
+	) {
 		return {
 			kind,
 			queries,

pkg/querier/bucket_cache.go

@@ -451,7 +451,7 @@ func (bc *bucketCache) mergeBuckets(ctx context.Context, buckets []*qbtypes.Cach
 	// Merge values based on type
 	var mergedValue any
 	switch resultType {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		mergedValue = bc.mergeTimeSeriesValues(ctx, buckets)
 		// Raw and Scalar types are not cached, so no merge needed
 	}
@@ -476,36 +476,14 @@ func (bc *bucketCache) mergeTimeSeriesValues(ctx context.Context, buckets []*qbt
 	}
 	seriesMap := make(map[seriesKey]*qbtypes.TimeSeries, estimatedSeries)
 
-	decodedTimeSeriesData := make([]*qbtypes.TimeSeriesData, 0, len(buckets))
-
-	// Alias and Meta are taken from whichever cached bucket covers the latest
-	// range, and the buckets do not arrive in StartMs order, so keep the winner
-	// per AggregationBucket.Index alongside the StartMs that won it.
-	aggregationIndexToLatest := map[int]*qbtypes.AggregationBucket{}
-	aggregationIndexToLatestStartMs := map[int]uint64{}
-
 	for _, bucket := range buckets {
 		var tsData *qbtypes.TimeSeriesData
 		if err := json.Unmarshal(bucket.Value, &tsData); err != nil {
 			bc.logger.ErrorContext(ctx, "failed to unmarshal time series data", errors.Attr(err))
 			continue
 		}
-		decodedTimeSeriesData = append(decodedTimeSeriesData, tsData)
 
 		for _, aggBucket := range tsData.Aggregations {
-			if _, seen := aggregationIndexToLatest[aggBucket.Index]; !seen || bucket.StartMs >= aggregationIndexToLatestStartMs[aggBucket.Index] {
-				aggregationIndexToLatest[aggBucket.Index] = aggBucket
-				aggregationIndexToLatestStartMs[aggBucket.Index] = bucket.StartMs
-			}
-		}
-	}
-
-	mergedUpperBounds := qbtypes.MergeBucketUpperBounds(decodedTimeSeriesData...)
-
-	for _, tsData := range decodedTimeSeriesData {
-		for _, aggBucket := range tsData.Aggregations {
-			aggBucket.ReindexValuesToNewUpperBounds(mergedUpperBounds[aggBucket.Index])
-
 			for _, series := range aggBucket.Series {
 				// Create series key from labels
 				key := seriesKey{
@@ -578,15 +556,10 @@ func (bc *bucketCache) mergeTimeSeriesValues(ctx context.Context, buckets []*qbt
 			}
 		}
 
-		aggBucket := &qbtypes.AggregationBucket{
+		result.Aggregations = append(result.Aggregations, &qbtypes.AggregationBucket{
 			Index:  index,
 			Series: seriesList,
-		}
-		if latest, ok := aggregationIndexToLatest[index]; ok {
-			aggBucket.Alias = latest.Alias
-			aggBucket.Meta = latest.Meta
-		}
-		result.Aggregations = append(result.Aggregations, aggBucket)
+		})
 	}
 
 	return result
@@ -599,7 +572,7 @@ func (bc *bucketCache) isEmptyResult(result *qbtypes.Result) (isEmpty bool, isFi
 	}
 
 	switch result.Type {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		if tsData, ok := result.Value.(*qbtypes.TimeSeriesData); ok {
 			// No aggregations at all means truly empty
 			if len(tsData.Aggregations) == 0 {
@@ -726,19 +699,14 @@ func (bc *bucketCache) trimResultToFluxBoundary(result *qbtypes.Result, fluxBoun
 	}
 
 	switch result.Type {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		// Trim time series data
 		if tsData, ok := result.Value.(*qbtypes.TimeSeriesData); ok && tsData != nil {
 			trimmedData := &qbtypes.TimeSeriesData{}
 
 			for _, aggBucket := range tsData.Aggregations {
-				// Meta has to survive the trim: a heatmap's counts are
-				// positional against Meta.Buckets, so a cached bucket that
-				// lost its axis cannot be read back against anything.
 				trimmedBucket := &qbtypes.AggregationBucket{
 					Index: aggBucket.Index,
-					Alias: aggBucket.Alias,
-					Meta:  aggBucket.Meta,
 				}
 
 				for _, series := range aggBucket.Series {
@@ -798,7 +766,7 @@ func (bc *bucketCache) filterResultToTimeRange(result *qbtypes.Result, startMs,
 	}
 
 	switch result.Type {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		if tsData, ok := result.Value.(*qbtypes.TimeSeriesData); ok {
 			filteredData := &qbtypes.TimeSeriesData{
 				Aggregations: make([]*qbtypes.AggregationBucket, 0, len(tsData.Aggregations)),

pkg/querier/builder_query.go

@@ -92,10 +92,6 @@ func (q *builderQuery[T]) Fingerprint() string {
 	// This needs to include all fields that affect the query results
 	parts := []string{q.queryType.StringValue()}
 
-	// A heatmap and a time series query can share every spec field and still
-	// return different rows, so the request type has to separate their entries
-	parts = append(parts, fmt.Sprintf("requestType=%s", q.kind.StringValue()))
-
 	// Add signal type
 	parts = append(parts, fmt.Sprintf("signal=%s", q.spec.Signal.StringValue()))
 
@@ -134,9 +130,6 @@ func (q *builderQuery[T]) Fingerprint() string {
 					}
 					part += ":" + route
 				}
-				if a.HeatmapBucketing != nil {
-					part += ":" + fingerprintHeatmapBucketing(*a.HeatmapBucketing)
-				}
 				aggParts = append(aggParts, part)
 			}
 		}
@@ -192,16 +185,6 @@ func (q *builderQuery[T]) Fingerprint() string {
 	return strings.Join(parts, "&")
 }
 
-// fingerprintHeatmapBucketing captures only what changes the rows ClickHouse
-// returns, which is why LogBucketsSpec.Scale is absent: coarsening it happens in
-// postprocessing, so every scale reads one cache entry.
-func fingerprintHeatmapBucketing(b qbtypes.HeatmapBucketing) string {
-	if b.Kind == qbtypes.BucketsKindLinear {
-		return fmt.Sprintf("%s:%v:%d", b.Kind.StringValue(), b.MaxValue, b.NumBuckets)
-	}
-	return b.Kind.StringValue()
-}
-
 func fingerprintGroupByKey(gb qbtypes.GroupByKey) string {
 	return fingerprintFieldKey(gb.TelemetryFieldKey)
 }
@@ -429,7 +412,7 @@ func (q *builderQuery[T]) narrowWindowByTraceID(ctx context.Context, fromMS, toM
 func emptyResultFor(kind qbtypes.RequestType, queryName string) *qbtypes.Result {
 	var value any
 	switch kind {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		value = &qbtypes.TimeSeriesData{QueryName: queryName}
 	case qbtypes.RequestTypeScalar:
 		value = &qbtypes.ScalarData{QueryName: queryName}
@@ -482,9 +465,8 @@ func (q *builderQuery[T]) executeWithContext(ctx context.Context, query string,
 	queryWindow := &qbtypes.TimeRange{From: q.fromMS, To: q.toMS}
 
 	kind := q.kind
-	// all metric queries are time series then reduced if required, except
-	// heatmaps, whose statement returns a row per bucket rather than per point
-	if q.spec.Signal == telemetrytypes.SignalMetrics && kind != qbtypes.RequestTypeHeatmap {
+	// all metric queries are time series then reduced if required
+	if q.spec.Signal == telemetrytypes.SignalMetrics {
 		kind = qbtypes.RequestTypeTimeSeries
 	}
 

pkg/querier/builder_query_test.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/stretchr/testify/assert"
@@ -121,170 +120,6 @@ func TestBuilderQueryFingerprintQueryType(t *testing.T) {
 	assert.Empty(t, ai.Fingerprint())
 }
 
-func TestBuilderQueryFingerprintHeatmapBucketing(t *testing.T) {
-	coarseLogScale := 1
-
-	testCases := []struct {
-		description   string
-		left          *builderQuery[qbtypes.MetricAggregation]
-		right         *builderQuery[qbtypes.MetricAggregation]
-		expectedEqual bool
-	}{
-		{
-			// fingerprintHeatmapBucketing leaves LogScale out, so the two are
-			// indistinguishable here by design
-			description: "a coarser logScale reads the same cache entry",
-			left: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLog, LogScale: qbtypes.MaxLogScale, NumBuckets: qbtypes.DefaultNumBuckets},
-					}},
-				},
-			},
-			right: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLog, LogScale: qbtypes.MaxLogScale, NumBuckets: qbtypes.DefaultNumBuckets},
-					}},
-				},
-			},
-			expectedEqual: true,
-		},
-		{
-			description: "linear separates on maxValue",
-			left: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLinear, MaxValue: 500, NumBuckets: 25},
-					}},
-				},
-			},
-			right: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLinear, MaxValue: 800, NumBuckets: 25},
-					}},
-				},
-			},
-			expectedEqual: false,
-		},
-		{
-			description: "linear separates on numBuckets",
-			left: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLinear, MaxValue: 500, NumBuckets: 25},
-					}},
-				},
-			},
-			right: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLinear, MaxValue: 500, NumBuckets: 40},
-					}},
-				},
-			},
-			expectedEqual: false,
-		},
-		{
-			description: "linear and log are separate entries",
-			left: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLinear, MaxValue: 500, NumBuckets: 25},
-					}},
-				},
-			},
-			right: &builderQuery[qbtypes.MetricAggregation]{
-				queryType: qbtypes.QueryTypeBuilder,
-				kind:      qbtypes.RequestTypeHeatmap,
-				spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-					Signal: telemetrytypes.SignalMetrics,
-					Aggregations: []qbtypes.MetricAggregation{{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{Kind: qbtypes.BucketsKindLog, LogScale: qbtypes.MaxLogScale, NumBuckets: qbtypes.DefaultNumBuckets},
-					}},
-				},
-			},
-			expectedEqual: false,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.description, func(t *testing.T) {
-			if testCase.expectedEqual {
-				assert.Equal(t, testCase.left.Fingerprint(), testCase.right.Fingerprint())
-				return
-			}
-			assert.NotEqual(t, testCase.left.Fingerprint(), testCase.right.Fingerprint())
-		})
-	}
-
-	t.Run("a coarser scale is carried but reads the same cache entry", func(t *testing.T) {
-		finest := (&qbtypes.BucketOptions{Kind: qbtypes.BucketsKindLog, Spec: qbtypes.LogBucketsSpec{}}).ToHeatmapBucketing()
-		coarse := (&qbtypes.BucketOptions{Kind: qbtypes.BucketsKindLog, Spec: qbtypes.LogBucketsSpec{Scale: &coarseLogScale}}).ToHeatmapBucketing()
-
-		assert.NotEqual(t, finest.LogScale, coarse.LogScale)
-		assert.Equal(t, fingerprintHeatmapBucketing(finest), fingerprintHeatmapBucketing(coarse))
-	})
-
-	t.Run("a histogram folds in no bucket options at all", func(t *testing.T) {
-		// resolveHeatmapBucketing leaves histograms nil, so bucketOptions sent
-		// alongside one must not fragment its cache
-		histogram := &builderQuery[qbtypes.MetricAggregation]{
-			queryType: qbtypes.QueryTypeBuilder,
-			kind:      qbtypes.RequestTypeHeatmap,
-			spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal: telemetrytypes.SignalMetrics,
-				Aggregations: []qbtypes.MetricAggregation{{
-					MetricName: "signoz_latency",
-					Type:       metrictypes.HistogramType,
-				}},
-			},
-		}
-
-		fingerprint := histogram.Fingerprint()
-		assert.NotContains(t, fingerprint, qbtypes.BucketsKindLog.StringValue())
-		assert.NotContains(t, fingerprint, qbtypes.BucketsKindLinear.StringValue())
-	})
-}
-
 func TestMakeBucketsOrder(t *testing.T) {
 	// Test that makeBuckets returns buckets in reverse chronological order by default
 	// Using milliseconds as input - need > 1 hour range to get multiple buckets

pkg/querier/consume.go

@@ -31,11 +31,6 @@ var (
 	// written clickhouse query. The column alias indcate which value is
 	// to be considered as final result (or target).
 	legacyReservedColumnTargetAliases = []string{"__result", "__value", "result", "res", "value"}
-
-	// userHeatmapBucketColumn is the alias a user written clickhouse query can
-	// give its bucket upper bound column, alongside the HeatmapBucketColumn the
-	// statement builder emits.
-	userHeatmapBucketColumn = "bucket"
 )
 
 // stripKeyAlias removes the __SELECT_KEY_<n>_ / __GROUP_BY_KEY_<n>_ prefix from a result
@@ -88,8 +83,6 @@ func consume(rows driver.Rows, kind qbtypes.RequestType, queryWindow *qbtypes.Ti
 		payload, err = readAsTimeSeries(rows, queryWindow, step, queryName)
 	case qbtypes.RequestTypeScalar:
 		payload, err = readAsScalar(rows, queryName)
-	case qbtypes.RequestTypeHeatmap:
-		payload, err = readAsHeatmap(rows, queryWindow, step, queryName)
 	case qbtypes.RequestTypeRaw, qbtypes.RequestTypeTrace, qbtypes.RequestTypeRawStream:
 		payload, err = readAsRaw(rows, queryName)
 		// TODO: add support for other request types
@@ -119,6 +112,35 @@ func readAsTimeSeries(rows driver.Rows, queryWindow *qbtypes.TimeRange, step qbt
 
 	stepMs := uint64(step.Milliseconds())
 
+	// Helper function to check if a timestamp represents a partial value
+	isPartialValue := func(timestamp int64) bool {
+		if stepMs == 0 || queryWindow == nil {
+			return false
+		}
+
+		timestampMs := uint64(timestamp)
+
+		// For the first interval, check if query start is misaligned
+		// The first complete interval starts at the first timestamp >= queryWindow.From that is aligned to step
+		firstCompleteInterval := queryWindow.From
+		if queryWindow.From%stepMs != 0 {
+			// Round up to next step boundary
+			firstCompleteInterval = ((queryWindow.From / stepMs) + 1) * stepMs
+		}
+
+		// If timestamp is before the first complete interval, it's partial
+		if timestampMs < firstCompleteInterval {
+			return true
+		}
+
+		// For the last interval, check if it would extend beyond query end
+		if timestampMs+stepMs > queryWindow.To {
+			return queryWindow.To%stepMs != 0
+		}
+
+		return false
+	}
+
 	// Pre-allocate for labels based on column count
 	lblValsCapacity := len(colNames) - 1 // -1 for timestamp
 	if lblValsCapacity < 0 {
@@ -249,7 +271,7 @@ func readAsTimeSeries(rows driver.Rows, queryWindow *qbtypes.TimeRange, step qbt
 			series.Values = append(series.Values, &qbtypes.TimeSeriesValue{
 				Timestamp: ts,
 				Value:     val,
-				Partial:   isPartialValue(ts, queryWindow, stepMs),
+				Partial:   isPartialValue(ts),
 			})
 		}
 	}
@@ -293,120 +315,6 @@ func readAsTimeSeries(rows driver.Rows, queryWindow *qbtypes.TimeRange, step qbt
 	}, nil
 }
 
-func isHeatmapBucketColumn(colName string) bool {
-	name := stripKeyAlias(colName)
-	return name == qbtypes.HeatmapBucketColumn || name == userHeatmapBucketColumn
-}
-
-// readAsHeatmap folds one row per cell — (timestamp, group labels, bucket upper
-// bound, count) — into one series per group.
-func readAsHeatmap(rows driver.Rows, queryWindow *qbtypes.TimeRange, step qbtypes.Step, queryName string) (*qbtypes.TimeSeriesData, error) {
-	colTypes := rows.ColumnTypes()
-	colNames := rows.Columns()
-
-	if !slices.ContainsFunc(colNames, isHeatmapBucketColumn) {
-		// there is no heatmap bucket column so empty response is returned.
-		return &qbtypes.TimeSeriesData{QueryName: queryName}, nil
-	}
-
-	slots := make([]any, len(colTypes))
-	for i, ct := range colTypes {
-		slots[i] = reflect.New(ct.ScanType()).Interface()
-	}
-
-	stepMs := uint64(step.Milliseconds())
-
-	accumulator := newHeatmapAccumulator()
-
-	for rows.Next() {
-		if err := rows.Scan(slots...); err != nil {
-			return nil, err
-		}
-
-		var (
-			ts         int64
-			upperBound float64
-			count      float64
-			lblVals    []string
-			lblObjs    []*qbtypes.Label
-		)
-
-		for idx, ptr := range slots {
-			name := stripKeyAlias(colNames[idx])
-			value := derefValue(ptr)
-
-			if t, ok := value.(time.Time); ok {
-				ts = t.UnixMilli()
-				continue
-			}
-
-			switch name {
-			case qbtypes.HeatmapBucketColumn, userHeatmapBucketColumn:
-				upperBound = numericAsFloat(value)
-			default:
-				if aggRe.MatchString(name) || slices.Contains(legacyReservedColumnTargetAliases, name) {
-					count = numericAsFloat(value)
-					continue
-				}
-				// a nullable label column comes back as a nil any, which would
-				// otherwise key the series on the literal "<nil>"
-				if value == nil {
-					value = ""
-				}
-				lblVals = append(lblVals, fmt.Sprint(value))
-				lblObjs = append(lblObjs, &qbtypes.Label{
-					Key:   telemetrytypes.TelemetryFieldKey{Name: name},
-					Value: value,
-				})
-			}
-		}
-
-		if ts == 0 || !isValidBucketUpperBound(upperBound) || math.IsNaN(count) || math.IsInf(count, 0) {
-			continue
-		}
-		sort.Strings(lblVals)
-		labelsKey := strings.Join(lblVals, ",")
-
-		accumulator.addCell(labelsKey, lblObjs, ts, upperBound, count)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return accumulator.foldSeries(queryWindow, stepMs, queryName), nil
-}
-
-// isPartialValue reports whether the step interval starting at timestamp is only
-// partly covered by the query window, which happens when the window boundaries
-// are not step-aligned.
-func isPartialValue(timestamp int64, queryWindow *qbtypes.TimeRange, stepMs uint64) bool {
-	if stepMs == 0 || queryWindow == nil {
-		return false
-	}
-
-	timestampMs := uint64(timestamp)
-
-	// For the first interval, check if query start is misaligned
-	// The first complete interval starts at the first timestamp >= queryWindow.From that is aligned to step
-	firstCompleteInterval := queryWindow.From
-	if queryWindow.From%stepMs != 0 {
-		// Round up to next step boundary
-		firstCompleteInterval = ((queryWindow.From / stepMs) + 1) * stepMs
-	}
-
-	// If timestamp is before the first complete interval, it's partial
-	if timestampMs < firstCompleteInterval {
-		return true
-	}
-
-	// For the last interval, check if it would extend beyond query end
-	if timestampMs+stepMs > queryWindow.To {
-		return queryWindow.To%stepMs != 0
-	}
-
-	return false
-}
-
 func isNumericKind(t reflect.Type) bool {
 	if t == nil {
 		return false

pkg/querier/heatmap_accumulator.go

@@ -1,116 +0,0 @@
-package querier
-
-import (
-	"math"
-	"slices"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-)
-
-// heatmapColumn maps a bucket's upper bound to the count in it, holding one
-// timestamp's cells. Keyed rather than indexed by band because the axis is only
-// known once every cell has been seen.
-type heatmapColumn map[float64]float64
-
-func isValidBucketUpperBound(upperBound float64) bool {
-	return !math.IsNaN(upperBound) && !math.IsInf(upperBound, -1)
-}
-
-// heatmapSeries accumulates one group's columns while the rows are read.
-type heatmapSeries struct {
-	labels             []*qbtypes.Label
-	columnsByTimestamp map[int64]heatmapColumn
-}
-
-// heatmapAccumulator collects cells from either reader and folds them into one
-// series per group.
-type heatmapAccumulator struct {
-	seriesByKey map[string]*heatmapSeries
-	seriesOrder []string
-	upperBounds map[float64]struct{}
-}
-
-func newHeatmapAccumulator() *heatmapAccumulator {
-	return &heatmapAccumulator{
-		seriesByKey: map[string]*heatmapSeries{},
-		upperBounds: map[float64]struct{}{},
-	}
-}
-
-// addCell files one cell under the group labelsKey identifies, keeping the
-// labels from the first cell seen for it.
-func (a *heatmapAccumulator) addCell(labelsKey string, lbls []*qbtypes.Label, ts int64, upperBound, count float64) {
-	series, ok := a.seriesByKey[labelsKey]
-	if !ok {
-		series = &heatmapSeries{labels: lbls, columnsByTimestamp: map[int64]heatmapColumn{}}
-		a.seriesByKey[labelsKey] = series
-		a.seriesOrder = append(a.seriesOrder, labelsKey)
-	}
-	if series.columnsByTimestamp[ts] == nil {
-		series.columnsByTimestamp[ts] = heatmapColumn{}
-	}
-	series.columnsByTimestamp[ts][upperBound] += count
-	if !math.IsInf(upperBound, 1) {
-		a.upperBounds[upperBound] = struct{}{}
-	}
-}
-
-// foldSeries turns the collected cells into one series per group, in the order
-// the groups first appeared.
-func (a *heatmapAccumulator) foldSeries(queryWindow *qbtypes.TimeRange, stepMs uint64, queryName string) *qbtypes.TimeSeriesData {
-	if len(a.seriesOrder) == 0 {
-		return &qbtypes.TimeSeriesData{QueryName: queryName}
-	}
-
-	upperBounds := make([]float64, 0, len(a.upperBounds))
-	for upperBound := range a.upperBounds {
-		upperBounds = append(upperBounds, upperBound)
-	}
-	slices.Sort(upperBounds)
-
-	// the index past the last upper bound is where the +Inf overflow lands
-	upperBoundToIndex := make(map[float64]int, len(upperBounds)+1)
-	for index, upperBound := range upperBounds {
-		upperBoundToIndex[upperBound] = index
-	}
-	upperBoundToIndex[math.Inf(1)] = len(upperBounds)
-
-	bucket := &qbtypes.AggregationBucket{
-		Index:  0,
-		Alias:  "__result_0",
-		Meta:   qbtypes.AggregationMeta{Buckets: upperBounds},
-		Series: make([]*qbtypes.TimeSeries, 0, len(a.seriesOrder)),
-	}
-
-	for _, labelsKey := range a.seriesOrder {
-		accumulated := a.seriesByKey[labelsKey]
-
-		timestamps := make([]int64, 0, len(accumulated.columnsByTimestamp))
-		for ts := range accumulated.columnsByTimestamp {
-			timestamps = append(timestamps, ts)
-		}
-		slices.Sort(timestamps)
-
-		series := &qbtypes.TimeSeries{
-			Labels: accumulated.labels,
-			Values: make([]*qbtypes.TimeSeriesValue, 0, len(timestamps)),
-		}
-		for _, ts := range timestamps {
-			values := make([]float64, len(upperBounds)+1)
-			for upperBound, count := range accumulated.columnsByTimestamp[ts] {
-				values[upperBoundToIndex[upperBound]] = count
-			}
-			series.Values = append(series.Values, &qbtypes.TimeSeriesValue{
-				Timestamp: ts,
-				Values:    values,
-				Partial:   isPartialValue(ts, queryWindow, stepMs),
-			})
-		}
-		bucket.Series = append(bucket.Series, series)
-	}
-
-	return &qbtypes.TimeSeriesData{
-		QueryName:    queryName,
-		Aggregations: []*qbtypes.AggregationBucket{bucket},
-	}
-}

pkg/querier/heatmap_test.go

@@ -1,101 +0,0 @@
-package querier
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMergeTimeSeriesResultsUnionsHeatmapAxes(t *testing.T) {
-	// a log axis holds whichever bands the data reached, so a wide cached range
-	// and a narrow fresh one routinely disagree on which bands exist
-	cached := &qbtypes.TimeSeriesData{
-		QueryName: "A",
-		Aggregations: []*qbtypes.AggregationBucket{{
-			Index: 0,
-			Meta:  qbtypes.AggregationMeta{Buckets: []float64{1, 4, 16}},
-			Series: []*qbtypes.TimeSeries{{
-				Labels: []*qbtypes.Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host.name"}, Value: "node-1"}},
-				Values: []*qbtypes.TimeSeriesValue{{Timestamp: 1710000000000, Values: []float64{1, 2, 3, 4}}},
-			}},
-		}},
-	}
-	fresh := []*qbtypes.Result{{
-		Value: &qbtypes.TimeSeriesData{
-			QueryName: "A",
-			Aggregations: []*qbtypes.AggregationBucket{{
-				Index: 0,
-				Meta:  qbtypes.AggregationMeta{Buckets: []float64{2, 4}},
-				Series: []*qbtypes.TimeSeries{{
-					Labels: []*qbtypes.Label{{Key: telemetrytypes.TelemetryFieldKey{Name: "host.name"}, Value: "node-1"}},
-					Values: []*qbtypes.TimeSeriesValue{{Timestamp: 1710000060000, Values: []float64{5, 6, 7}}},
-				}},
-			}},
-		},
-	}}
-
-	merged := (&querier{}).mergeTimeSeriesResults(cached, fresh)
-
-	require.Len(t, merged.Aggregations, 1)
-	aggBucket := merged.Aggregations[0]
-	assert.Equal(t, []float64{1, 2, 4, 16}, aggBucket.Meta.Buckets)
-
-	require.Len(t, aggBucket.Series, 1)
-	require.Len(t, aggBucket.Series[0].Values, 2)
-	// the cached 16 band survives even though the fresh range never reached it
-	assert.Equal(t, []float64{1, 0, 2, 3, 4}, aggBucket.Series[0].Values[0].Values)
-	// and the fresh 2 band survives even though the cached range never had it
-	assert.Equal(t, []float64{0, 5, 6, 0, 7}, aggBucket.Series[0].Values[1].Values)
-}
-
-func TestTrimResultToFluxBoundaryKeepsTheHeatmapAxis(t *testing.T) {
-	cache := &bucketCache{logger: instrumentationtest.New().Logger()}
-
-	result := &qbtypes.Result{
-		Type: qbtypes.RequestTypeHeatmap,
-		Value: &qbtypes.TimeSeriesData{
-			Aggregations: []*qbtypes.AggregationBucket{{
-				Index: 0,
-				Alias: "__result_0",
-				Meta:  qbtypes.AggregationMeta{Unit: "By", Buckets: []float64{1, 2, 4}},
-				Series: []*qbtypes.TimeSeries{{
-					Values: []*qbtypes.TimeSeriesValue{
-						{Timestamp: 1710000000000, Values: []float64{1, 2, 3, 4}},
-					},
-				}},
-			}},
-		},
-	}
-
-	trimmed := cache.trimResultToFluxBoundary(result, 1710000060000)
-
-	tsData, ok := trimmed.Value.(*qbtypes.TimeSeriesData)
-	require.True(t, ok)
-	require.Len(t, tsData.Aggregations, 1)
-
-	// the counts are positional against the axis, so a cached bucket that lost
-	// Meta.Buckets would be realigned from an empty axis and collapse into the
-	// overflow slot on the way back out
-	aggBucket := tsData.Aggregations[0]
-	assert.Equal(t, []float64{1, 2, 4}, aggBucket.Meta.Buckets)
-	assert.Equal(t, "By", aggBucket.Meta.Unit)
-	assert.Equal(t, "__result_0", aggBucket.Alias)
-}
-
-func TestRealignFromAnEmptyAxisCollapsesIntoTheOverflow(t *testing.T) {
-	// pins the behaviour the trim bug exposed: with no axis to read the counts
-	// against, everything lands in the overflow slot
-	aggBucket := &qbtypes.AggregationBucket{
-		Series: []*qbtypes.TimeSeries{{
-			Values: []*qbtypes.TimeSeriesValue{{Timestamp: 1710000000000, Values: []float64{7, 8, 9, 10}}},
-		}},
-	}
-
-	aggBucket.ReindexValuesToNewUpperBounds([]float64{1, 2, 4})
-
-	assert.Equal(t, []float64{0, 0, 0, 7}, aggBucket.Series[0].Values[0].Values)
-}

pkg/querier/postprocess.go

@@ -195,16 +195,6 @@ func postProcessBuilderQuery[T any](
 	return result
 }
 
-// resolveHeatmapBucketAxis brings the bucket axis to the resolution the caller
-// asked for. Downscaling runs first so AddHeatmapBucketsWithNoCounts adds them
-// at that resolution rather than the finer one ClickHouse bucketed at.
-func resolveHeatmapBucketAxis(tsData *qbtypes.TimeSeriesData, bucketing qbtypes.HeatmapBucketing) {
-	if bucketing.Kind == qbtypes.BucketsKindLog {
-		qbtypes.DownscaleHeatmapResolution(tsData, bucketing.LogScale)
-	}
-	qbtypes.AddHeatmapBucketsWithNoCounts(tsData, bucketing)
-}
-
 // postProcessMetricQuery applies postprocessing to a metric query result.
 func postProcessMetricQuery(
 	q *querier,
@@ -226,12 +216,6 @@ func postProcessMetricQuery(
 		}
 	}
 
-	if req.RequestType == qbtypes.RequestTypeHeatmap && config.HeatmapBucketing != nil {
-		if tsData, ok := result.Value.(*qbtypes.TimeSeriesData); ok {
-			resolveHeatmapBucketAxis(tsData, *config.HeatmapBucketing)
-		}
-	}
-
 	result = q.applySeriesLimit(result, query.Limit, query.Order)
 
 	if len(query.Functions) > 0 {
@@ -358,19 +342,6 @@ func (q *querier) applyFormulas(ctx context.Context, results map[string]*qbtypes
 				result = q.applySeriesLimit(result, formula.Limit, formula.Order)
 				results[name] = result
 			}
-		case qbtypes.RequestTypeHeatmap:
-			// The queries a formula reads were run as time series, so what
-			// arrives here is one value per group per timestamp.
-			result := q.processTimeSeriesFormula(ctx, results, formula, req)
-			if result != nil {
-				if tsData, ok := result.Value.(*qbtypes.TimeSeriesData); ok {
-					bucketing := req.BucketOptions.ToHeatmapBucketing()
-					bucketFormulaOutputAsHeatmap(tsData, bucketing)
-					resolveHeatmapBucketAxis(tsData, bucketing)
-				}
-				result = q.applySeriesLimit(result, formula.Limit, formula.Order)
-				results[name] = result
-			}
 		case qbtypes.RequestTypeScalar:
 			result := q.processScalarFormula(ctx, results, formula, req)
 			// For scalar results, apply limit by processScalarFormula itself since it needs to be applied before converting back to scalar format
@@ -439,89 +410,6 @@ func (q *querier) processTimeSeriesFormula(
 	return result
 }
 
-func bucketFormulaOutputAsHeatmap(tsData *qbtypes.TimeSeriesData, bucketing qbtypes.HeatmapBucketing) {
-	// A formula is one expression, so processTimeSeriesFormula gives it one
-	// aggregation.
-	if tsData == nil || len(tsData.Aggregations) == 0 || tsData.Aggregations[0] == nil {
-		return
-	}
-	aggBucket := tsData.Aggregations[0]
-
-	calculateUpperBound := calculateLogValueUpperBound
-	if bucketing.Kind == qbtypes.BucketsKindLinear {
-		calculateUpperBound = func(value float64) float64 {
-			return calculateLinearValueUpperBound(bucketing, value)
-		}
-	}
-
-	// +Inf is the open-above overflow rather than an upper bound of its own, and
-	// a NaN value has no bucket at all, so neither goes on the axis.
-	upperBounds := []float64{}
-	for _, series := range aggBucket.Series {
-		for _, point := range series.Values {
-			upperBound := calculateUpperBound(point.Value)
-			if !math.IsNaN(upperBound) && !math.IsInf(upperBound, 0) {
-				upperBounds = append(upperBounds, upperBound)
-			}
-		}
-	}
-	slices.Sort(upperBounds)
-	upperBounds = slices.Compact(upperBounds)
-
-	upperBoundToIndex := make(map[float64]int, len(upperBounds))
-	for index, upperBound := range upperBounds {
-		upperBoundToIndex[upperBound] = index
-	}
-
-	overflowIndex := len(upperBounds)
-	for _, series := range aggBucket.Series {
-		for _, point := range series.Values {
-			upperBound := calculateUpperBound(point.Value)
-			point.Values = make([]float64, overflowIndex+1)
-			point.Value = 0
-			switch {
-			case math.IsNaN(upperBound):
-			case math.IsInf(upperBound, 1):
-				point.Values[overflowIndex] = 1
-			default:
-				point.Values[upperBoundToIndex[upperBound]] = 1
-			}
-		}
-	}
-
-	aggBucket.Meta.Buckets = upperBounds
-}
-
-// calculateLinearValueUpperBound and calculateLogValueUpperBound are the Go side
-// of what renderLinearUpperBoundExpr and renderLogUpperBoundExpr emit, and have
-// to stay identical to them: a formula heatmap and a metric heatmap that
-// disagreed here would put their counts in different buckets.
-func calculateLinearValueUpperBound(bucketing qbtypes.HeatmapBucketing, value float64) float64 {
-	if value > bucketing.MaxValue {
-		return math.Inf(1)
-	}
-	numBuckets := float64(bucketing.NumBuckets)
-	index := math.Min(math.Max(math.Ceil(value*numBuckets/bucketing.MaxValue), 1), numBuckets)
-	return index * bucketing.MaxValue / numBuckets
-}
-
-// Like renderLogUpperBoundExpr, this reads MaxLogScale rather than the requested
-// scale: ClickHouse buckets at the finest resolution and resolveHeatmapBucketAxis
-// folds the axis down afterwards.
-func calculateLogValueUpperBound(value float64) float64 {
-	if value <= 0 {
-		return 0
-	}
-	if value <= qbtypes.MinLogUpperBound {
-		return qbtypes.MinLogUpperBound
-	}
-	if value > qbtypes.MaxLogUpperBound {
-		return math.Inf(1)
-	}
-	bucketsPerDoubling := math.Exp2(qbtypes.MaxLogScale)
-	return math.Exp2(math.Ceil(math.Log2(value)*bucketsPerDoubling) / bucketsPerDoubling)
-}
-
 func (q *querier) processScalarFormula(
 	ctx context.Context,
 	results map[string]*qbtypes.Result,
@@ -606,7 +494,7 @@ func (q *querier) processScalarFormula(
 				bucket := &qbtypes.AggregationBucket{
 					Index:  aggIdx,
 					Alias:  scalarData.Columns[colIdx].Name,
-					Meta:   qbtypes.AggregationMeta{Unit: scalarData.Columns[colIdx].Meta.Unit},
+					Meta:   scalarData.Columns[colIdx].Meta,
 					Series: make([]*qbtypes.TimeSeries, 0),
 				}
 
@@ -779,14 +667,13 @@ func convertTimeSeriesDataToScalar(tsData *qbtypes.TimeSeriesData, queryName str
 		if name == "" {
 			name = fmt.Sprintf("__result_%d", agg.Index)
 		}
-		column := &qbtypes.ColumnDescriptor{
+		columns = append(columns, &qbtypes.ColumnDescriptor{
 			TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: name},
 			QueryName:         queryName,
 			AggregationIndex:  int64(agg.Index),
+			Meta:              agg.Meta,
 			Type:              qbtypes.ColumnTypeAggregation,
-		}
-		column.Meta.Unit = agg.Meta.Unit
-		columns = append(columns, column)
+		})
 	}
 
 	// Build rows.

pkg/querier/preview.go

@@ -50,7 +50,7 @@ func (q *querier) QueryRangePreview(
 		env := []qbtypes.QueryEnvelope{req.CompositeQuery.Queries[idx]}
 		ps.Warnings = append(ps.Warnings, q.adjustStepInterval(env, req.Start, req.End)...)
 
-		missingMetricQueries, metricWarnings, mErr := q.resolveMetricMetadata(ctx, orgID, env, req.Start, req.End, req.RequestType, req.BucketOptions)
+		missingMetricQueries, metricWarnings, mErr := q.resolveMetricMetadata(ctx, orgID, env, req.Start, req.End)
 		if mErr != nil {
 			// Report this query's error but keep previewing the rest.
 			ps.Error = mErr

pkg/querier/promql_heatmap.go

@@ -1,131 +0,0 @@
-package querier
-
-import (
-	"fmt"
-	"math"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/prometheus/prometheus/model/labels"
-
-	"github.com/prometheus/prometheus/promql"
-
-	qbv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-// promHistogramBucketLabel is the label a classic histogram carries its
-// cumulative upper bound on.
-const promHistogramBucketLabel = "le"
-
-// cumulativeColumn maps a bucket's upper bound to the cumulative count at it.
-// Differencing turns it into the per-band counts a heatmapColumn holds.
-type cumulativeColumn map[float64]float64
-
-// promHeatmapGroup assembles one group across the several matrix series its `le`
-// values arrive as, since differencing needs all of them.
-type promHeatmapGroup struct {
-	labels     []*qbv5.Label
-	labelsKey  string
-	cumulative map[int64]cumulativeColumn
-}
-
-// foldMatrixAsHeatmap folds a matrix of one cumulative series per (group, `le`)
-// into one series per group whose points hold a count per band.
-func foldMatrixAsHeatmap(matrix promql.Matrix, queryWindow *qbv5.TimeRange, stepMs uint64, queryName string) *qbv5.TimeSeriesData {
-	groups, groupOrder := collectCumulativeGroups(matrix)
-
-	accumulator := newHeatmapAccumulator()
-	for _, labelsKey := range groupOrder {
-		groups[labelsKey].addDifferencedCells(accumulator)
-	}
-
-	return accumulator.foldSeries(queryWindow, stepMs, queryName)
-}
-
-// collectCumulativeGroups reads the matrix into one group per label set. A series
-// without `le` has no band to sit in, so an expression that dropped the label
-// draws nothing.
-func collectCumulativeGroups(matrix promql.Matrix) (groups map[string]*promHeatmapGroup, groupOrder []string) {
-	groups = map[string]*promHeatmapGroup{}
-
-	for _, promSeries := range matrix {
-		upperBound, ok := extractBucketUpperBound(promSeries.Metric)
-		if !ok {
-			continue
-		}
-
-		lbls, labelsKey := extractHeatmapGroup(promSeries.Metric)
-		group, ok := groups[labelsKey]
-		if !ok {
-			group = &promHeatmapGroup{labels: lbls, labelsKey: labelsKey, cumulative: map[int64]cumulativeColumn{}}
-			groups[labelsKey] = group
-			groupOrder = append(groupOrder, labelsKey)
-		}
-
-		for _, point := range promSeries.Floats {
-			// skipping widens the band above onto the next upper bound that has
-			// a count, which is what lagInFrame does with an absent row
-			if math.IsNaN(point.F) || math.IsInf(point.F, 0) {
-				continue
-			}
-			if group.cumulative[point.T] == nil {
-				group.cumulative[point.T] = cumulativeColumn{}
-			}
-			group.cumulative[point.T][upperBound] = point.F
-		}
-	}
-
-	return groups, groupOrder
-}
-
-func extractBucketUpperBound(metric labels.Labels) (float64, bool) {
-	raw := metric.Get(promHistogramBucketLabel)
-	if raw == "" {
-		return 0, false
-	}
-	upperBound, err := strconv.ParseFloat(raw, 64)
-	if err != nil || !isValidBucketUpperBound(upperBound) {
-		return 0, false
-	}
-	return upperBound, true
-}
-
-// extractHeatmapGroup returns a series' group labels — everything but `le`.
-func extractHeatmapGroup(metric labels.Labels) ([]*qbv5.Label, string) {
-	lbls := make([]*qbv5.Label, 0, metric.Len())
-	pairs := make([]string, 0, metric.Len())
-
-	metric.Range(func(l labels.Label) {
-		if l.Name == promHistogramBucketLabel || excludePromLabel(l.Name) {
-			return
-		}
-		lbls = append(lbls, &qbv5.Label{
-			Key:   telemetrytypes.TelemetryFieldKey{Name: l.Name},
-			Value: l.Value,
-		})
-		pairs = append(pairs, fmt.Sprintf("%s=%s", l.Name, l.Value))
-	})
-
-	sort.Strings(pairs)
-	return lbls, strings.Join(pairs, ",")
-}
-
-// each cell is its upper bound's cumulative count minus the one below it.
-func (g *promHeatmapGroup) addDifferencedCells(accumulator *heatmapAccumulator) {
-	for ts, cumulative := range g.cumulative {
-		upperBounds := make([]float64, 0, len(cumulative))
-		for upperBound := range cumulative {
-			upperBounds = append(upperBounds, upperBound)
-		}
-		slices.Sort(upperBounds)
-
-		previous := float64(0)
-		for _, upperBound := range upperBounds {
-			accumulator.addCell(g.labelsKey, g.labels, ts, upperBound, math.Max(cumulative[upperBound]-previous, 0))
-			previous = cumulative[upperBound]
-		}
-	}
-}

pkg/querier/promql_heatmap_test.go

@@ -1,86 +0,0 @@
-package querier
-
-import (
-	"log/slog"
-	"math"
-	"testing"
-	"time"
-
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql"
-
-	qbv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// The cache key is the fingerprint alone, so two request types over one
-// expression must not produce the same one — a time series payload served to a
-// heatmap request has no axis and reads back as a single collapsed band.
-func TestFingerprintSeparatesHeatmapFromTimeSeries(t *testing.T) {
-	fingerprintFor := func(requestType qbv5.RequestType) string {
-		q := &promqlQuery{
-			logger:      slog.New(slog.DiscardHandler),
-			query:       qbv5.PromQuery{Name: "A", Query: "sum by (le) (increase(signoz_latency_bucket[5m]))", Step: qbv5.Step{Duration: time.Minute}},
-			tr:          qbv5.TimeRange{From: 1710000000000, To: 1710003600000},
-			requestType: requestType,
-		}
-		return q.Fingerprint()
-	}
-
-	heatmap := fingerprintFor(qbv5.RequestTypeHeatmap)
-	timeSeries := fingerprintFor(qbv5.RequestTypeTimeSeries)
-
-	assert.NotEmpty(t, heatmap, "a heatmap decomposes into time buckets like a time series")
-	assert.NotEqual(t, timeSeries, heatmap)
-	assert.Empty(t, fingerprintFor(qbv5.RequestTypeScalar), "a scalar result is its window's last point")
-}
-
-func TestFoldMatrixAsHeatmapClampsADecreasingCumulativeCount(t *testing.T) {
-	at := int64(1710000000000)
-
-	matrix := promql.Matrix{
-		{
-			Metric: labels.FromStrings("le", "5"),
-			Floats: []promql.FPoint{{T: at, F: 10}},
-		},
-		{
-			Metric: labels.FromStrings("le", "10"),
-			Floats: []promql.FPoint{{T: at, F: 4}},
-		},
-	}
-
-	data := foldMatrixAsHeatmap(matrix, &qbv5.TimeRange{From: 1710000000000, To: 1710000060000}, uint64(time.Minute.Milliseconds()), "A")
-	require.Len(t, data.Aggregations, 1)
-
-	// a cumulative count that went backwards would difference to -6
-	assert.Equal(t, []float64{10, 0, 0}, data.Aggregations[0].Series[0].Values[0].Values)
-}
-
-func TestFoldMatrixAsHeatmapWidensTheBandOverAMissingUpperBound(t *testing.T) {
-	at := int64(1710000000000)
-
-	matrix := promql.Matrix{
-		{
-			Metric: labels.FromStrings("le", "5"),
-			Floats: []promql.FPoint{{T: at, F: 3}},
-		},
-		{
-			Metric: labels.FromStrings("le", "10"),
-			Floats: []promql.FPoint{{T: at, F: math.NaN()}},
-		},
-		{
-			Metric: labels.FromStrings("le", "20"),
-			Floats: []promql.FPoint{{T: at, F: 30}},
-		},
-	}
-
-	data := foldMatrixAsHeatmap(matrix, &qbv5.TimeRange{From: 1710000000000, To: 1710000060000}, uint64(time.Minute.Milliseconds()), "A")
-	require.Len(t, data.Aggregations, 1)
-
-	aggregation := data.Aggregations[0]
-	// 10 carried nothing to difference against, so it is not on the axis at all
-	// and 20 differences against 5, holding what (5,10] and (10,20] would split
-	assert.Equal(t, []float64{5, 20}, aggregation.Meta.Buckets)
-	assert.Equal(t, []float64{3, 27, 0}, aggregation.Series[0].Values[0].Values)
-}

pkg/querier/promql_query.go

@@ -155,10 +155,7 @@ func (q *promqlQuery) Fingerprint() string {
 	if q.opts.serve != nil {
 		return ""
 	}
-
-	switch q.requestType {
-	case qbv5.RequestTypeTimeSeries, qbv5.RequestTypeHeatmap:
-	default:
+	if q.requestType != qbv5.RequestTypeTimeSeries {
 		return ""
 	}
 
@@ -169,8 +166,6 @@ func (q *promqlQuery) Fingerprint() string {
 	}
 	parts := []string{
 		"promql",
-		// one expression returns a different shape per request type
-		fmt.Sprintf("requestType=%s", q.requestType.StringValue()),
 		query,
 		q.query.Step.String(),
 	}
@@ -454,52 +449,25 @@ func (q *promqlQuery) Execute(ctx context.Context) (*qbv5.Result, error) {
 	return q.toResult(matrix, warnings, began, &statsMu, &rowsScanned, &bytesScanned), nil
 }
 
-// excludePromLabel hides only known SigNoz storage keys: label names are user
-// data and may legitimately start with "__" (e.g. __address__), so a blanket
-// dunder strip mangles user labelsets. The __scope./__resource. prefixes cover
-// every exporter version's keys.
-func excludePromLabel(labelName string) bool {
-	return labelName == "__temporality__" ||
-		strings.HasPrefix(labelName, "__scope.") ||
-		strings.HasPrefix(labelName, "__resource.")
-}
-
-// collectExecStats snapshots the scan counters a query accumulated. Callers take
-// it at the point they are done with the matrix, so the duration covers the
-// shaping they did.
-func collectExecStats(began time.Time, statsMu *sync.Mutex, rowsScanned, bytesScanned *uint64) qbv5.ExecStats {
-	statsMu.Lock()
-	defer statsMu.Unlock()
-	return qbv5.ExecStats{
-		RowsScanned:  *rowsScanned,
-		BytesScanned: *bytesScanned,
-		DurationMS:   uint64(time.Since(began).Milliseconds()),
-	}
-}
-
+// toResult converts an evaluated matrix into the v5 result shape, attaching
+// the ClickHouse scan stats accumulated during evaluation.
 func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began time.Time, statsMu *sync.Mutex, rowsScanned, bytesScanned *uint64) *qbv5.Result {
-	if q.requestType == qbv5.RequestTypeHeatmap {
-		return q.toResultForHeatmap(matrix, warnings, began, statsMu, rowsScanned, bytesScanned)
+	// Hide only known SigNoz storage keys: label names are user data and may
+	// legitimately start with "__" (e.g. __address__), so a blanket dunder
+	// strip mangles user labelsets. The __scope./__resource. prefixes cover
+	// every exporter version's keys.
+	excludeLabel := func(labelName string) bool {
+		return labelName == "__temporality__" ||
+			strings.HasPrefix(labelName, "__scope.") ||
+			strings.HasPrefix(labelName, "__resource.")
 	}
-	return q.toResultForTimeSeriesAndScalar(matrix, warnings, began, statsMu, rowsScanned, bytesScanned)
-}
 
-func (q *promqlQuery) toResultForHeatmap(matrix promql.Matrix, warnings []string, began time.Time, statsMu *sync.Mutex, rowsScanned, bytesScanned *uint64) *qbv5.Result {
-	return &qbv5.Result{
-		Type:     q.requestType,
-		Value:    foldMatrixAsHeatmap(matrix, &q.tr, uint64(q.query.Step.Milliseconds()), q.query.Name),
-		Warnings: warnings,
-		Stats:    collectExecStats(began, statsMu, rowsScanned, bytesScanned),
-	}
-}
-
-func (q *promqlQuery) toResultForTimeSeriesAndScalar(matrix promql.Matrix, warnings []string, began time.Time, statsMu *sync.Mutex, rowsScanned, bytesScanned *uint64) *qbv5.Result {
 	var series []*qbv5.TimeSeries
 	for _, v := range matrix {
 		var s qbv5.TimeSeries
 		lbls := make([]*qbv5.Label, 0, v.Metric.Len())
 		v.Metric.Range(func(l labels.Label) {
-			if excludePromLabel(l.Name) {
+			if excludeLabel(l.Name) {
 				return
 			}
 			lbls = append(lbls, &qbv5.Label{
@@ -527,7 +495,13 @@ func (q *promqlQuery) toResultForTimeSeriesAndScalar(matrix promql.Matrix, warni
 		series = append(series, &s)
 	}
 
-	stats := collectExecStats(began, statsMu, rowsScanned, bytesScanned)
+	statsMu.Lock()
+	stats := qbv5.ExecStats{
+		RowsScanned:  *rowsScanned,
+		BytesScanned: *bytesScanned,
+		DurationMS:   uint64(time.Since(began).Milliseconds()),
+	}
+	statsMu.Unlock()
 
 	tsData := &qbv5.TimeSeriesData{QueryName: q.query.Name}
 	// No bucket at all when nothing survived: a bucket holding no series reads

pkg/querier/querier.go

@@ -156,7 +156,7 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 	// We need to set if it is unspecified or adjust it if value is not within recommended range
 	intervalWarnings := q.adjustStepInterval(req.CompositeQuery.Queries, req.Start, req.End)
 
-	missingMetricQueries, metricWarnings, err := q.resolveMetricMetadata(ctx, orgID, req.CompositeQuery.Queries, req.Start, req.End, req.RequestType, req.BucketOptions)
+	missingMetricQueries, metricWarnings, err := q.resolveMetricMetadata(ctx, orgID, req.CompositeQuery.Queries, req.Start, req.End)
 	if err != nil {
 		return nil, err
 	}
@@ -177,7 +177,7 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 	preseededResults := make(map[string]any)
 	for _, name := range missingMetricQueries {
 		switch req.RequestType {
-		case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+		case qbtypes.RequestTypeTimeSeries:
 			preseededResults[name] = &qbtypes.TimeSeriesData{QueryName: name}
 		case qbtypes.RequestTypeScalar:
 			preseededResults[name] = &qbtypes.ScalarData{QueryName: name}
@@ -334,22 +334,15 @@ func (q *querier) buildQueries(
 				if missingMetricQuerySet[spec.Name] {
 					continue
 				}
-				requestType := req.RequestType
-				if requestType == qbtypes.RequestTypeHeatmap && spec.Disabled {
-					// A disabled query in a heatmap request feeds a formula, and the
-					// formula converts time series into heatmap data, so its inputs
-					// run as time series queries.
-					requestType = qbtypes.RequestTypeTimeSeries
-				}
 				spec.ShiftBy = extractShiftFromBuilderQuery(spec)
-				timeRange := adjustTimeRangeForShift(spec, qbtypes.TimeRange{From: req.Start, To: req.End}, requestType)
+				timeRange := adjustTimeRangeForShift(spec, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType)
 				var bq *builderQuery[qbtypes.MetricAggregation]
 
 				if spec.Source == telemetrytypes.SourceMeter {
 					event.Source = telemetrytypes.SourceMeter.StringValue()
-					bq = newBuilderQuery(q.logger, q.telemetryStore, orgID, q.meterStmtBuilder, query.Type, spec, timeRange, requestType, tmplVars, builderConfig{})
+					bq = newBuilderQuery(q.logger, q.telemetryStore, orgID, q.meterStmtBuilder, query.Type, spec, timeRange, req.RequestType, tmplVars, builderConfig{})
 				} else {
-					bq = newBuilderQuery(q.logger, q.telemetryStore, orgID, q.metricStmtBuilder, query.Type, spec, timeRange, requestType, tmplVars, builderConfig{})
+					bq = newBuilderQuery(q.logger, q.telemetryStore, orgID, q.metricStmtBuilder, query.Type, spec, timeRange, req.RequestType, tmplVars, builderConfig{})
 				}
 
 				queries[spec.Name] = bq
@@ -422,7 +415,7 @@ func (q *querier) populateQBEvent(event *qbtypes.QBEvent, queries []qbtypes.Quer
 //     resolved: never-seen metrics and dormant metrics (seen but no data in
 //     the query window).
 //   - err: Internal when a metadata fetch fails.
-func (q *querier) resolveMetricMetadata(ctx context.Context, orgID valuer.UUID, queries []qbtypes.QueryEnvelope, start, end uint64, requestType qbtypes.RequestType, bucketOptions *qbtypes.BucketOptions) (missingMetricQueries []string, metricWarnings []string, err error) {
+func (q *querier) resolveMetricMetadata(ctx context.Context, orgID valuer.UUID, queries []qbtypes.QueryEnvelope, start, end uint64) (missingMetricQueries []string, metricWarnings []string, err error) {
 	metricNames := make([]string, 0)
 	for idx := range queries {
 		if queries[idx].Type != qbtypes.QueryTypeBuilder {
@@ -472,13 +465,6 @@ func (q *querier) resolveMetricMetadata(ctx context.Context, orgID valuer.UUID,
 					spec.Aggregations[i].Type = foundMetricType
 				}
 			}
-			// Only the enabled query is used to render the heatmap, so bucket
-			// options are only applied to the enabled query.
-			if requestType == qbtypes.RequestTypeHeatmap && !spec.Disabled {
-				if err := spec.Aggregations[i].VerifyAndApplyBucketOptions(bucketOptions); err != nil {
-					return nil, nil, err
-				}
-			}
 			if spec.Aggregations[i].Type == metrictypes.UnspecifiedType {
 				missingMetrics = append(missingMetrics, spec.Aggregations[i].MetricName)
 				continue
@@ -693,7 +679,7 @@ func (q *querier) run(
 			if val, ok := result.Value.(*qbtypes.RawData); ok && val != nil {
 				return len(val.Rows) != 0
 			}
-		case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+		case qbtypes.RequestTypeTimeSeries:
 			if val, ok := result.Value.(*qbtypes.TimeSeriesData); ok && val != nil {
 				if len(val.Aggregations) != 0 {
 					anyNonEmpty := false
@@ -1014,7 +1000,7 @@ func (q *querier) mergeResults(cached *qbtypes.Result, fresh []*qbtypes.Result)
 
 		// Merge all fresh results including the first one
 		switch merged.Type {
-		case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+		case qbtypes.RequestTypeTimeSeries:
 			// Pass nil as cached value to ensure proper merging of all fresh results
 			merged.Value = q.mergeTimeSeriesResults(nil, fresh)
 		}
@@ -1037,7 +1023,7 @@ func (q *querier) mergeResults(cached *qbtypes.Result, fresh []*qbtypes.Result)
 	}
 
 	switch merged.Type {
-	case qbtypes.RequestTypeTimeSeries, qbtypes.RequestTypeHeatmap:
+	case qbtypes.RequestTypeTimeSeries:
 		merged.Value = q.mergeTimeSeriesResults(cached.Value.(*qbtypes.TimeSeriesData), fresh)
 	}
 
@@ -1058,16 +1044,6 @@ func (q *querier) mergeResults(cached *qbtypes.Result, fresh []*qbtypes.Result)
 	return merged
 }
 
-func mergeBucketUpperBounds(cachedValue *qbtypes.TimeSeriesData, freshResults []*qbtypes.Result) map[int][]float64 {
-	upperBoundSources := make([]*qbtypes.TimeSeriesData, 0, len(freshResults)+1)
-	upperBoundSources = append(upperBoundSources, cachedValue)
-	for _, result := range freshResults {
-		freshTS, _ := result.Value.(*qbtypes.TimeSeriesData)
-		upperBoundSources = append(upperBoundSources, freshTS)
-	}
-	return qbtypes.MergeBucketUpperBounds(upperBoundSources...)
-}
-
 // mergeTimeSeriesResults merges time series data.
 func (q *querier) mergeTimeSeriesResults(cachedValue *qbtypes.TimeSeriesData, freshResults []*qbtypes.Result) *qbtypes.TimeSeriesData {
 
@@ -1076,15 +1052,12 @@ func (q *querier) mergeTimeSeriesResults(cachedValue *qbtypes.TimeSeriesData, fr
 	// Map to store aggregation bucket metadata
 	bucketMetadata := make(map[int]*qbtypes.AggregationBucket)
 
-	mergedUpperBounds := mergeBucketUpperBounds(cachedValue, freshResults)
-
 	// Process cached data if available
 	if cachedValue != nil && cachedValue.Aggregations != nil {
 		for _, aggBucket := range cachedValue.Aggregations {
 			if seriesMap[aggBucket.Index] == nil {
 				seriesMap[aggBucket.Index] = make(map[string]*qbtypes.TimeSeries)
 			}
-			aggBucket.ReindexValuesToNewUpperBounds(mergedUpperBounds[aggBucket.Index])
 			if bucketMetadata[aggBucket.Index] == nil {
 				bucketMetadata[aggBucket.Index] = aggBucket
 			}
@@ -1136,7 +1109,6 @@ func (q *querier) mergeTimeSeriesResults(cachedValue *qbtypes.TimeSeriesData, fr
 		}
 
 		for _, aggBucket := range freshTS.Aggregations {
-			aggBucket.ReindexValuesToNewUpperBounds(mergedUpperBounds[aggBucket.Index])
 			for _, series := range aggBucket.Series {
 				key := qbtypes.GetUniqueSeriesKey(series.Labels)
 

pkg/statementbuilder/meterstatementbuilder/statement_builder.go

@@ -129,7 +129,7 @@ func (b *meterQueryStatementBuilder) buildPipelineStatement(
 	}
 
 	// final SELECT
-	return b.metricsStatementBuilder.BuildFinalSelect(cteFragments, cteArgs, qbtypes.RequestTypeTimeSeries, query)
+	return b.metricsStatementBuilder.BuildFinalSelect(cteFragments, cteArgs, query)
 }
 
 func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(

pkg/statementbuilder/metricsstatementbuilder/statement_builder.go

@@ -4,13 +4,9 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"math"
 	"slices"
-	"strconv"
-	"strings"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
@@ -117,7 +113,7 @@ func (b *StatementBuilder) Build(
 	orgID valuer.UUID,
 	start uint64,
 	end uint64,
-	requestType qbtypes.RequestType,
+	_ qbtypes.RequestType,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	variables map[string]qbtypes.VariableItem,
 ) (*qbtypes.Statement, error) {
@@ -129,14 +125,13 @@ func (b *StatementBuilder) Build(
 
 	start, end = querybuilder.AdjustedMetricTimeRange(start, end, uint64(query.StepInterval.Seconds()), query)
 
-	return b.buildPipelineStatement(ctx, orgID, start, end, requestType, query, keys, variables)
+	return b.buildPipelineStatement(ctx, orgID, start, end, query, keys, variables)
 }
 
 func (b *StatementBuilder) buildPipelineStatement(
 	ctx context.Context,
 	orgID valuer.UUID,
 	start, end uint64,
-	requestType qbtypes.RequestType,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 	variables map[string]qbtypes.VariableItem,
@@ -149,7 +144,7 @@ func (b *StatementBuilder) buildPipelineStatement(
 	cteQuery := query
 	if query.Aggregations[0].Type == metrictypes.HistogramType {
 		query.GroupBy = slices.DeleteFunc(slices.Clone(query.GroupBy), isHistogramBucket)
-		cteQuery = rewriteQueryForHistogramCTE(requestType, query)
+		cteQuery = histogramCTEQuery(query)
 	}
 
 	agg := cteQuery.Aggregations[0]
@@ -221,7 +216,7 @@ func (b *StatementBuilder) buildPipelineStatement(
 		}
 	}
 
-	mainStmt, err := b.BuildFinalSelect(cteFragments, cteArgs, requestType, query)
+	mainStmt, err := b.BuildFinalSelect(cteFragments, cteArgs, query)
 	if err != nil {
 		return nil, err
 	}
@@ -229,29 +224,13 @@ func (b *StatementBuilder) buildPipelineStatement(
 	if reducedFragments == nil {
 		return mainStmt, nil
 	}
-	reducedStmt, err := b.BuildFinalSelect(reducedFragments, reducedArgs, requestType, query)
+	reducedStmt, err := b.BuildFinalSelect(reducedFragments, reducedArgs, query)
 	if err != nil {
 		return nil, err
 	}
 	return unionStatements(mainStmt, reducedStmt, query)
 }
 
-func rewriteQueryForHistogramCTE(requestType qbtypes.RequestType, query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation] {
-	query.GroupBy = append(slices.Clone(query.GroupBy), qbtypes.GroupByKey{
-		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: histogramBucketKey},
-	})
-
-	query.Aggregations = slices.Clone(query.Aggregations)
-	if query.Aggregations[0].SpaceAggregation.IsPercentile() && requestType != qbtypes.RequestTypeHeatmap {
-		query.Aggregations[0].TimeAggregation = metrictypes.TimeAggregationRate
-	} else {
-		query.Aggregations[0].TimeAggregation = metrictypes.TimeAggregationIncrease
-	}
-	query.Aggregations[0].SpaceAggregation = metrictypes.SpaceAggregationSum
-
-	return query
-}
-
 func unionStatements(main, reduced *qbtypes.Statement, query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) (*qbtypes.Statement, error) {
 	orderBy := "ts"
 	for i, g := range query.GroupBy {
@@ -779,9 +758,11 @@ func (b *StatementBuilder) buildSpatialAggregationCTE(
 func (b *StatementBuilder) BuildFinalSelect(
 	cteFragments []string,
 	cteArgs [][]any,
-	requestType qbtypes.RequestType,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 ) (*qbtypes.Statement, error) {
+	metricType := query.Aggregations[0].Type
+	spaceAgg := query.Aggregations[0].SpaceAggregation
+
 	combined := querybuilder.CombineCTEs(cteFragments)
 
 	var args []any
@@ -789,22 +770,6 @@ func (b *StatementBuilder) BuildFinalSelect(
 		args = append(args, a...)
 	}
 
-	if requestType == qbtypes.RequestTypeHeatmap {
-		return buildHeatmapFinalSelect(combined, args, query)
-	}
-	return buildAggregationFinalSelect(combined, args, query)
-}
-
-// buildAggregationFinalSelect reads __spatial_aggregation_cte as one value per
-// (group, timestamp), which is what every request type but heatmap wants.
-func buildAggregationFinalSelect(
-	combined string,
-	args []any,
-	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
-) (*qbtypes.Statement, error) {
-	metricType := query.Aggregations[0].Type
-	spaceAgg := query.Aggregations[0].SpaceAggregation
-
 	sb := sqlbuilder.NewSelectBuilder()
 
 	if metricType == metrictypes.HistogramType && spaceAgg.IsPercentile() {
@@ -877,136 +842,24 @@ func buildAggregationFinalSelect(
 	return &qbtypes.Statement{Query: combined + q, Args: append(args, a...)}, nil
 }
 
-const (
-	histogramBucketKey = "le"
-
-	heatmapValueAlias = "__result_0"
-	heatmapWindow     = "__heatmap_window"
-)
+const histogramBucketKey = "le"
 
 func isHistogramBucket(k qbtypes.GroupByKey) bool { return k.Name == histogramBucketKey }
 
-// buildHeatmapFinalSelect turns __spatial_aggregation_cte into one row per
-// heatmap cell: (ts, group labels..., bucket upper bound, count).
-func buildHeatmapFinalSelect(
-	combined string,
-	args []any,
-	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
-) (*qbtypes.Statement, error) {
-	if query.Aggregations[0].Type == metrictypes.HistogramType {
-		return buildHistogramHeatmapFinalSelect(combined, args, query)
+func histogramCTEQuery(query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation] {
+	query.GroupBy = append(slices.Clone(query.GroupBy), qbtypes.GroupByKey{
+		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: histogramBucketKey},
+	})
+
+	query.Aggregations = slices.Clone(query.Aggregations)
+	if query.Aggregations[0].SpaceAggregation.IsPercentile() {
+		query.Aggregations[0].TimeAggregation = metrictypes.TimeAggregationRate
+	} else {
+		query.Aggregations[0].TimeAggregation = metrictypes.TimeAggregationIncrease
 	}
-	return buildValueHeatmapFinalSelect(combined, args, query)
-}
+	query.Aggregations[0].SpaceAggregation = metrictypes.SpaceAggregationSum
 
-// buildHistogramHeatmapFinalSelect differences the cumulative per-`le` counts in
-// __spatial_aggregation_cte into a count per band. The upper bound reported is the
-// `le` itself, so the `le=+Inf` row reaches the reader as an infinite upper bound
-// for it to fold into the overflow band.
-func buildHistogramHeatmapFinalSelect(
-	combined string,
-	args []any,
-	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
-) (*qbtypes.Statement, error) {
-	groupAliases := GroupByAliases(query.GroupBy)
-	partitionBy := append(append([]string{}, groupAliases...), "ts")
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("ts")
-	sb.SelectMore(groupAliases...)
-	sb.SelectMore(fmt.Sprintf("toFloat64(%s) AS %s", histogramBucketKey, qbtypes.HeatmapBucketColumn))
-	// a partial scrape can break monotonicity across `le`, and a negative cell
-	// count has no meaning
-	sb.SelectMore(fmt.Sprintf(
-		"greatest(value - lagInFrame(value, 1, 0) OVER %s, 0) AS %s",
-		heatmapWindow, heatmapValueAlias,
-	))
-	// sqlbuilder has no WINDOW clause; appending it to FROM lands it between FROM
-	// and ORDER BY, since these statements carry no WHERE or GROUP BY
-	sb.From(fmt.Sprintf(
-		"__spatial_aggregation_cte WINDOW %s AS (PARTITION BY %s ORDER BY toFloat64(%s))",
-		heatmapWindow, strings.Join(partitionBy, ", "), histogramBucketKey,
-	))
-	sb.OrderBy(groupAliases...)
-	sb.OrderBy("ts", fmt.Sprintf("toFloat64(%s)", histogramBucketKey))
-
-	q, a := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return &qbtypes.Statement{Query: combined + q, Args: append(args, a...)}, nil
-}
-
-// buildValueHeatmapFinalSelect places each spatially aggregated value in a band
-// of the requested axis. __spatial_aggregation_cte holds one row per (group,
-// timestamp), so every cell counts exactly one.
-func buildValueHeatmapFinalSelect(
-	combined string,
-	args []any,
-	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
-) (*qbtypes.Statement, error) {
-	bucketing := query.Aggregations[0].HeatmapBucketing
-	if bucketing == nil {
-		return nil, errors.NewInternalf(errors.CodeInternal,
-			"heatmap over a %s metric reached the statement builder without a resolved bucket axis",
-			query.Aggregations[0].Type.StringValue())
-	}
-
-	upperBound, err := renderHeatmapUpperBoundExpr(*bucketing)
-	if err != nil {
-		return nil, err
-	}
-
-	groupAliases := GroupByAliases(query.GroupBy)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("ts")
-	sb.SelectMore(groupAliases...)
-	sb.SelectMore(fmt.Sprintf("%s AS %s", upperBound, qbtypes.HeatmapBucketColumn))
-	sb.SelectMore(fmt.Sprintf("toFloat64(1) AS %s", heatmapValueAlias))
-	sb.From("__spatial_aggregation_cte")
-	sb.OrderBy(groupAliases...)
-	sb.OrderBy("ts", qbtypes.HeatmapBucketColumn)
-
-	q, a := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return &qbtypes.Statement{Query: combined + q, Args: append(args, a...)}, nil
-}
-
-// renderHeatmapUpperBoundExpr renders the upper bound of the band `value` falls in.
-func renderHeatmapUpperBoundExpr(bucketing qbtypes.HeatmapBucketing) (string, error) {
-	switch bucketing.Kind {
-	case qbtypes.BucketsKindLinear:
-		return renderLinearUpperBoundExpr(bucketing), nil
-	case qbtypes.BucketsKindLog:
-		return renderLogUpperBoundExpr(), nil
-	default:
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"unsupported bucketsScaling %q for heatmap requests", bucketing.Kind.StringValue())
-	}
-}
-
-func renderLinearUpperBoundExpr(bucketing qbtypes.HeatmapBucketing) string {
-	maxValue := formatFloat(bucketing.MaxValue)
-	numBuckets := strconv.Itoa(bucketing.NumBuckets)
-	return fmt.Sprintf(
-		"multiIf(value > %s, toFloat64('+Inf'), least(greatest(ceil(value * %s / %s), 1), %s) * %s / %s)",
-		maxValue, numBuckets, maxValue, numBuckets, maxValue, numBuckets,
-	)
-}
-
-// ClickHouse buckets at MaxLogScale whatever HeatmapBucketing.LogScale asks for;
-// postprocessing folds the axis down afterwards.
-func renderLogUpperBoundExpr() string {
-	bandsPerDoubling := formatFloat(math.Exp2(qbtypes.MaxLogScale))
-	lowest := formatFloat(qbtypes.MinLogUpperBound)
-	highest := formatFloat(qbtypes.MaxLogUpperBound)
-	return fmt.Sprintf(
-		"multiIf(value <= 0, toFloat64(0), value <= %s, %s, value > %s, toFloat64('+Inf'), pow(2, ceil(log2(value) * %s) / %s))",
-		lowest, lowest, highest, bandsPerDoubling, bandsPerDoubling,
-	)
-}
-
-// formatFloat renders a float64 as the shortest literal that reads back as the
-// same value, so an upper bound computed from it is identical on every row.
-func formatFloat(v float64) string {
-	return strconv.FormatFloat(v, 'g', -1, 64)
+	return query
 }
 
 func GroupByColumnAlias(i int, name string) string {

pkg/statementbuilder/metricsstatementbuilder/stmt_builder_test.go

@@ -284,199 +284,6 @@ func TestStatementBuilder(t *testing.T) {
 			},
 			expectedErr: nil,
 		},
-		{
-			name:        "test_histogram_heatmap_sum",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "signoz_latency",
-						Type:             metrictypes.HistogramType,
-						Temporality:      metrictypes.Delta,
-						TimeAggregation:  metrictypes.TimeAggregationIncrease,
-						SpaceAggregation: metrictypes.SpaceAggregationSum,
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "service.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __spatial_aggregation_cte AS (SELECT toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_service.name`, `le`, sum(value) AS value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'service.name') AS `__GROUP_BY_KEY_0_service.name`, JSONExtractString(labels, 'le') AS `le` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_service.name`, `le`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY ts, `__GROUP_BY_KEY_0_service.name`, `le`) SELECT ts, `__GROUP_BY_KEY_0_service.name`, toFloat64(le) AS __bucket, greatest(value - lagInFrame(value, 1, 0) OVER __heatmap_window, 0) AS __result_0 FROM __spatial_aggregation_cte WINDOW __heatmap_window AS (PARTITION BY `__GROUP_BY_KEY_0_service.name`, ts ORDER BY toFloat64(le)) ORDER BY `__GROUP_BY_KEY_0_service.name`, ts, toFloat64(le)",
-				Args:  []any{"signoz_latency", uint64(1747936800000), uint64(1747983420000), "delta", "signoz_latency", uint64(1747947360000), uint64(1747983420000)},
-			},
-			expectedErr: nil,
-		},
-		{
-			name:        "test_histogram_heatmap_percentile",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "signoz_latency",
-						Type:             metrictypes.HistogramType,
-						Temporality:      metrictypes.Delta,
-						TimeAggregation:  metrictypes.TimeAggregationRate,
-						SpaceAggregation: metrictypes.SpaceAggregationPercentile95,
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "service.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __spatial_aggregation_cte AS (SELECT toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_service.name`, `le`, sum(value) AS value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'service.name') AS `__GROUP_BY_KEY_0_service.name`, JSONExtractString(labels, 'le') AS `le` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_service.name`, `le`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY ts, `__GROUP_BY_KEY_0_service.name`, `le`) SELECT ts, `__GROUP_BY_KEY_0_service.name`, toFloat64(le) AS __bucket, greatest(value - lagInFrame(value, 1, 0) OVER __heatmap_window, 0) AS __result_0 FROM __spatial_aggregation_cte WINDOW __heatmap_window AS (PARTITION BY `__GROUP_BY_KEY_0_service.name`, ts ORDER BY toFloat64(le)) ORDER BY `__GROUP_BY_KEY_0_service.name`, ts, toFloat64(le)",
-				Args:  []any{"signoz_latency", uint64(1747936800000), uint64(1747983420000), "delta", "signoz_latency", uint64(1747947360000), uint64(1747983420000)},
-			},
-			expectedErr: nil,
-		},
-		{
-			name:        "test_gauge_heatmap_log",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						Temporality:      metrictypes.Unspecified,
-						TimeAggregation:  metrictypes.TimeAggregationAvg,
-						SpaceAggregation: metrictypes.SpaceAggregationSum,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{
-							Kind:       qbtypes.BucketsKindLog,
-							LogScale:   qbtypes.MaxLogScale,
-							NumBuckets: qbtypes.DefaultNumBuckets,
-						},
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "host.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __temporal_aggregation_cte AS (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_host.name`, avg(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'host.name') AS `__GROUP_BY_KEY_0_host.name` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_host.name`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `__GROUP_BY_KEY_0_host.name` ORDER BY fingerprint, ts), __spatial_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_host.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `__GROUP_BY_KEY_0_host.name`) SELECT ts, `__GROUP_BY_KEY_0_host.name`, multiIf(value <= 0, toFloat64(0), value <= 2.3283064365386963e-10, 2.3283064365386963e-10, value > 1.8446744073709552e+19, toFloat64('+Inf'), pow(2, ceil(log2(value) * 16) / 16)) AS __bucket, toFloat64(1) AS __result_0 FROM __spatial_aggregation_cte ORDER BY `__GROUP_BY_KEY_0_host.name`, ts, __bucket",
-				Args:  []any{"system.memory.usage", uint64(1747936800000), uint64(1747983420000), "unspecified", "system.memory.usage", uint64(1747947360000), uint64(1747983420000), 0},
-			},
-			expectedErr: nil,
-		},
-		{
-			name:        "test_gauge_heatmap_linear",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "system.memory.usage",
-						Type:             metrictypes.GaugeType,
-						Temporality:      metrictypes.Unspecified,
-						TimeAggregation:  metrictypes.TimeAggregationAvg,
-						SpaceAggregation: metrictypes.SpaceAggregationSum,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{
-							Kind:       qbtypes.BucketsKindLinear,
-							LogScale:   qbtypes.MaxLogScale,
-							MaxValue:   500,
-							NumBuckets: 25,
-						},
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "host.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __temporal_aggregation_cte AS (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_host.name`, avg(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'host.name') AS `__GROUP_BY_KEY_0_host.name` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_host.name`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `__GROUP_BY_KEY_0_host.name` ORDER BY fingerprint, ts), __spatial_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_host.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `__GROUP_BY_KEY_0_host.name`) SELECT ts, `__GROUP_BY_KEY_0_host.name`, multiIf(value > 500, toFloat64('+Inf'), least(greatest(ceil(value * 25 / 500), 1), 25) * 500 / 25) AS __bucket, toFloat64(1) AS __result_0 FROM __spatial_aggregation_cte ORDER BY `__GROUP_BY_KEY_0_host.name`, ts, __bucket",
-				Args:  []any{"system.memory.usage", uint64(1747936800000), uint64(1747983420000), "unspecified", "system.memory.usage", uint64(1747947360000), uint64(1747983420000), 0},
-			},
-			expectedErr: nil,
-		},
-		{
-			// cumulative keeps CanShortCircuitDelta false, so the counts reach the
-			// bucket differencing through the temporal CTE rather than the delta
-			// fast path
-			name:        "test_histogram_heatmap_cumulative",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "http_server_duration_bucket",
-						Type:             metrictypes.HistogramType,
-						Temporality:      metrictypes.Cumulative,
-						TimeAggregation:  metrictypes.TimeAggregationRate,
-						SpaceAggregation: metrictypes.SpaceAggregationPercentile95,
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "service.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __temporal_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_service.name`, `le`, multiIf(row_number() OVER rate_window = 1, nan, (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) < 0, per_series_value, per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) AS per_series_value FROM (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_service.name`, `le`, max(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'service.name') AS `__GROUP_BY_KEY_0_service.name`, JSONExtractString(labels, 'le') AS `le` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_service.name`, `le`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `__GROUP_BY_KEY_0_service.name`, `le` ORDER BY fingerprint, ts) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)), __spatial_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_service.name`, `le`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `__GROUP_BY_KEY_0_service.name`, `le`) SELECT ts, `__GROUP_BY_KEY_0_service.name`, toFloat64(le) AS __bucket, greatest(value - lagInFrame(value, 1, 0) OVER __heatmap_window, 0) AS __result_0 FROM __spatial_aggregation_cte WINDOW __heatmap_window AS (PARTITION BY `__GROUP_BY_KEY_0_service.name`, ts ORDER BY toFloat64(le)) ORDER BY `__GROUP_BY_KEY_0_service.name`, ts, toFloat64(le)",
-				Args:  []any{"http_server_duration_bucket", uint64(1747936800000), uint64(1747983420000), "cumulative", "http_server_duration_bucket", uint64(1747947300000), uint64(1747983420000), 0},
-			},
-			expectedErr: nil,
-		},
-		{
-			name:        "test_sum_heatmap_cumulative",
-			requestType: qbtypes.RequestTypeHeatmap,
-			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-				Signal:       telemetrytypes.SignalMetrics,
-				StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-				Aggregations: []qbtypes.MetricAggregation{
-					{
-						MetricName:       "signoz_calls_total",
-						Type:             metrictypes.SumType,
-						Temporality:      metrictypes.Cumulative,
-						TimeAggregation:  metrictypes.TimeAggregationIncrease,
-						SpaceAggregation: metrictypes.SpaceAggregationSum,
-						HeatmapBucketing: &qbtypes.HeatmapBucketing{
-							Kind:       qbtypes.BucketsKindLog,
-							LogScale:   qbtypes.MaxLogScale,
-							NumBuckets: qbtypes.DefaultNumBuckets,
-						},
-					},
-				},
-				GroupBy: []qbtypes.GroupByKey{
-					{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "service.name",
-						},
-					},
-				},
-			},
-			expected: qbtypes.Statement{
-				Query: "WITH __temporal_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_service.name`, multiIf(row_number() OVER rate_window = 1, nan, (per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) < 0, per_series_value, per_series_value - lagInFrame(per_series_value, 1) OVER rate_window) AS per_series_value FROM (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(60)) AS ts, `__GROUP_BY_KEY_0_service.name`, max(value) AS per_series_value FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint, JSONExtractString(labels, 'service.name') AS `__GROUP_BY_KEY_0_service.name` FROM signoz_metrics.time_series_v4_6hrs WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli <= ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, `__GROUP_BY_KEY_0_service.name`) AS filtered_time_series ON points.fingerprint = filtered_time_series.fingerprint WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? GROUP BY fingerprint, ts, `__GROUP_BY_KEY_0_service.name` ORDER BY fingerprint, ts) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)), __spatial_aggregation_cte AS (SELECT ts, `__GROUP_BY_KEY_0_service.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `__GROUP_BY_KEY_0_service.name`) SELECT ts, `__GROUP_BY_KEY_0_service.name`, multiIf(value <= 0, toFloat64(0), value <= 2.3283064365386963e-10, 2.3283064365386963e-10, value > 1.8446744073709552e+19, toFloat64('+Inf'), pow(2, ceil(log2(value) * 16) / 16)) AS __bucket, toFloat64(1) AS __result_0 FROM __spatial_aggregation_cte ORDER BY `__GROUP_BY_KEY_0_service.name`, ts, __bucket",
-				Args:  []any{"signoz_calls_total", uint64(1747936800000), uint64(1747983420000), "cumulative", "signoz_calls_total", uint64(1747947300000), uint64(1747983420000), 0},
-			},
-			expectedErr: nil,
-		},
 		{
 			name:        "test_gauge_avg_sum",
 			requestType: qbtypes.RequestTypeTimeSeries,

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -524,96 +524,6 @@ func TestInvalidateUnknownPluginKind(t *testing.T) {
 	}
 }
 
-// TestHeatmapPanelQueryKinds pins the panel allowlist to what validateHeatmap
-// accepts in querybuildertypesv5: everything but a trace operator.
-func TestHeatmapPanelQueryKinds(t *testing.T) {
-	testCases := []struct {
-		description     string
-		queryPluginKind string
-		queryPluginSpec string
-		expectedAllowed bool
-	}{
-		{
-			description:     "a metrics builder query is allowed",
-			queryPluginKind: "signoz/BuilderQuery",
-			queryPluginSpec: `{"name": "A", "signal": "metrics", "aggregations": [
-				{"metricName": "http.server.request.duration", "timeAggregation": "increase", "spaceAggregation": "sum"}
-			]}`,
-			expectedAllowed: true,
-		},
-		{
-			description:     "a promql query is allowed",
-			queryPluginKind: "signoz/PromQLQuery",
-			queryPluginSpec: `{"name": "A", "query": "sum by (le) (increase(signoz_latency_bucket[5m]))"}`,
-			expectedAllowed: true,
-		},
-		{
-			description:     "a clickhouse query is allowed",
-			queryPluginKind: "signoz/ClickHouseSQL",
-			queryPluginSpec: `{"name": "A", "query": "SELECT ts, bucket, value FROM cells"}`,
-			expectedAllowed: true,
-		},
-		{
-			description:     "a formula is allowed",
-			queryPluginKind: "signoz/Formula",
-			queryPluginSpec: `{"name": "F1", "expression": "A / B"}`,
-			expectedAllowed: true,
-		},
-		{
-			description:     "a composite query is allowed, since a formula needs its disabled inputs alongside it",
-			queryPluginKind: "signoz/CompositeQuery",
-			queryPluginSpec: `{"queries": [
-				{"type": "builder_query", "spec": {"name": "A", "signal": "metrics", "disabled": true, "aggregations": [
-					{"metricName": "http.server.request.duration", "timeAggregation": "increase", "spaceAggregation": "sum"}
-				]}},
-				{"type": "builder_formula", "spec": {"name": "F1", "expression": "A * 2"}}
-			]}`,
-			expectedAllowed: true,
-		},
-		{
-			description:     "a trace operator is refused",
-			queryPluginKind: "signoz/TraceOperator",
-			queryPluginSpec: `{"name": "T1", "expression": "A => B"}`,
-			expectedAllowed: false,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.description, func(t *testing.T) {
-			data := fmt.Sprintf(`{
-				"variables": [],
-				"panels": {
-					"p1": {
-						"kind": "Panel",
-						"spec": {
-							"links": [],
-							"plugin": {"kind": "signoz/HeatmapPanel", "spec": {}},
-							"queries": [{
-								"kind": "heatmap",
-								"spec": {
-									"plugin": {"kind": %q, "spec": %s}
-								}
-							}]
-						}
-					}
-				},
-				"links": [],
-				"layouts": []
-			}`, testCase.queryPluginKind, testCase.queryPluginSpec)
-
-			_, err := unmarshalDashboard([]byte(data))
-
-			if testCase.expectedAllowed {
-				require.NoError(t, err)
-				return
-			}
-
-			require.Error(t, err)
-			assert.Contains(t, err.Error(), "is not supported by panel kind")
-		})
-	}
-}
-
 func TestInvalidateOneInvalidPanel(t *testing.T) {
 	data := []byte(`{
 		"variables": [],

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -35,7 +35,6 @@ func (PanelPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {
 		string(PanelKindTable):      schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec"),
 		string(PanelKindHistogram):  schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec"),
 		string(PanelKindList):       schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec"),
-		string(PanelKindHeatmap):    schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec"),
 	})
 }
 
@@ -66,7 +65,6 @@ func (PanelPlugin) JSONSchemaOneOf() []any {
 		PanelPluginVariant[TablePanelSpec]{Kind: string(PanelKindTable)},
 		PanelPluginVariant[HistogramPanelSpec]{Kind: string(PanelKindHistogram)},
 		PanelPluginVariant[ListPanelSpec]{Kind: string(PanelKindList)},
-		PanelPluginVariant[HeatmapPanelSpec]{Kind: string(PanelKindHeatmap)},
 	}
 }
 
@@ -230,7 +228,6 @@ var (
 		PanelKindTable:      func() any { return new(TablePanelSpec) },
 		PanelKindHistogram:  func() any { return new(HistogramPanelSpec) },
 		PanelKindList:       func() any { return new(ListPanelSpec) },
-		PanelKindHeatmap:    func() any { return new(HeatmapPanelSpec) },
 	}
 	queryPluginSpecs = map[QueryPluginKind]func() any{
 		QueryKindBuilder:       func() any { return new(BuilderQuerySpec) },
@@ -253,7 +250,6 @@ var (
 		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
 		PanelKindTable:      {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
 		PanelKindList:       {QueryKindBuilder},
-		PanelKindHeatmap:    {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL},
 	}
 )
 

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -173,11 +173,10 @@ const (
 	PanelKindTable      PanelPluginKind = "signoz/TablePanel"
 	PanelKindHistogram  PanelPluginKind = "signoz/HistogramPanel"
 	PanelKindList       PanelPluginKind = "signoz/ListPanel"
-	PanelKindHeatmap    PanelPluginKind = "signoz/HeatmapPanel"
 )
 
 func (PanelPluginKind) Enum() []any {
-	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList, PanelKindHeatmap}
+	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList}
 }
 
 type TimeSeriesPanelSpec struct {
@@ -238,56 +237,6 @@ type ListPanelSpec struct {
 	SelectFields []telemetrytypes.TelemetryFieldKey `json:"selectFields,omitzero" validate:"dive"`
 }
 
-type HeatmapPanelSpec struct {
-	Visualization   BasicVisualization     `json:"visualization"`
-	Formatting      PanelFormatting        `json:"formatting"`
-	Axes            HeatmapAxes            `json:"axes"`
-	Legend          Legend                 `json:"legend"`
-	ChartAppearance HeatmapChartAppearance `json:"chartAppearance"`
-}
-
-// HeatmapAxes carries only the Y scale. The shared Axes type models a value
-// axis with soft bounds, where a heatmap's Y axis is the bucket boundaries the
-// response already fixed.
-type HeatmapAxes struct {
-	YScale HeatmapYScale `json:"yScale"`
-}
-
-type HeatmapChartAppearance struct {
-	Colors HeatmapColors `json:"colors"`
-}
-
-type HeatmapColors struct {
-	Mode    HeatmapColorMode  `json:"mode"`
-	Palette HeatmapPalette    `json:"palette"`
-	Scale   HeatmapColorScale `json:"scale"`
-	Steps   int               `json:"steps" validate:"omitempty,min=2,max=128"`
-	// MinCount and MaxCount clamp the colour scale; nil derives them from the
-	// grid, 0 and the highest count in it.
-	MinCount *float64 `json:"minCount"`
-	MaxCount *float64 `json:"maxCount"`
-	// Fill applies in opacity mode; empty means the selected group's legend colour.
-	Fill string `json:"fill"`
-}
-
-func (c *HeatmapColors) UnmarshalJSON(data []byte) error {
-	type alias HeatmapColors
-	var tmp alias
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid heatmap colors")
-	}
-	*c = HeatmapColors(tmp)
-	return c.validate()
-}
-
-func (c HeatmapColors) validate() error {
-	if c.MinCount != nil && c.MaxCount != nil && *c.MinCount > *c.MaxCount {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput,
-			"heatmap colors.minCount %v is greater than colors.maxCount %v", *c.MinCount, *c.MaxCount)
-	}
-	return nil
-}
-
 // ══════════════════════════════════════════════
 // Panel common types
 // ══════════════════════════════════════════════
@@ -760,168 +709,3 @@ func (p *PrecisionOption) UnmarshalJSON(data []byte) error {
 		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid precision option %q: must be `0`, `1`, `2`, `3`, `4`, or `full`", v)
 	}
 }
-
-type HeatmapColorMode struct{ valuer.String }
-
-var (
-	HeatmapColorModePalette = HeatmapColorMode{valuer.NewString("palette")} // default
-	HeatmapColorModeOpacity = HeatmapColorMode{valuer.NewString("opacity")}
-)
-
-func (HeatmapColorMode) Enum() []any {
-	return []any{HeatmapColorModePalette, HeatmapColorModeOpacity}
-}
-
-func (m HeatmapColorMode) ValueOrDefault() string {
-	if m.IsZero() {
-		return HeatmapColorModePalette.StringValue()
-	}
-	return m.StringValue()
-}
-
-func (m HeatmapColorMode) MarshalJSON() ([]byte, error) {
-	return json.Marshal(m.ValueOrDefault())
-}
-
-func (m *HeatmapColorMode) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid heatmap color mode: must be a string, one of `palette` or `opacity`")
-	}
-	mode := HeatmapColorMode{valuer.NewString(v)}
-	switch mode {
-	case HeatmapColorModePalette, HeatmapColorModeOpacity:
-		*m = mode
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid heatmap color mode %q: must be `palette` or `opacity`", v)
-	}
-}
-
-type HeatmapPalette struct{ valuer.String }
-
-var (
-	HeatmapPaletteIce      = HeatmapPalette{valuer.NewString("ice")}
-	HeatmapPaletteMoss     = HeatmapPalette{valuer.NewString("moss")}
-	HeatmapPaletteRust     = HeatmapPalette{valuer.NewString("rust")}
-	HeatmapPaletteGraphite = HeatmapPalette{valuer.NewString("graphite")}
-	HeatmapPaletteEmber    = HeatmapPalette{valuer.NewString("ember")}
-	HeatmapPaletteLagoon   = HeatmapPalette{valuer.NewString("lagoon")}
-	HeatmapPaletteOrchid   = HeatmapPalette{valuer.NewString("orchid")}
-	HeatmapPaletteVerdant  = HeatmapPalette{valuer.NewString("verdant")}
-	HeatmapPaletteLava     = HeatmapPalette{valuer.NewString("lava")} // default
-	HeatmapPaletteBeacon   = HeatmapPalette{valuer.NewString("beacon")}
-)
-
-func (HeatmapPalette) Enum() []any {
-	return []any{
-		HeatmapPaletteIce, HeatmapPaletteMoss, HeatmapPaletteRust, HeatmapPaletteGraphite,
-		HeatmapPaletteEmber, HeatmapPaletteLagoon, HeatmapPaletteOrchid, HeatmapPaletteVerdant,
-		HeatmapPaletteLava, HeatmapPaletteBeacon,
-	}
-}
-
-func (p HeatmapPalette) ValueOrDefault() string {
-	if p.IsZero() {
-		return HeatmapPaletteLava.StringValue()
-	}
-	return p.StringValue()
-}
-
-func (p HeatmapPalette) MarshalJSON() ([]byte, error) {
-	return json.Marshal(p.ValueOrDefault())
-}
-
-func (p *HeatmapPalette) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid heatmap palette: must be a string, one of `ice`, `moss`, `rust`, `graphite`, `ember`, `lagoon`, `orchid`, `verdant`, `lava`, or `beacon`")
-	}
-	palette := HeatmapPalette{valuer.NewString(v)}
-	switch palette {
-	case HeatmapPaletteIce, HeatmapPaletteMoss, HeatmapPaletteRust, HeatmapPaletteGraphite,
-		HeatmapPaletteEmber, HeatmapPaletteLagoon, HeatmapPaletteOrchid, HeatmapPaletteVerdant,
-		HeatmapPaletteLava, HeatmapPaletteBeacon:
-		*p = palette
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid heatmap palette %q: must be `ice`, `moss`, `rust`, `graphite`, `ember`, `lagoon`, `orchid`, `verdant`, `lava`, or `beacon`", v)
-	}
-}
-
-type HeatmapYScale struct{ valuer.String }
-
-var (
-	HeatmapYScaleAuto   = HeatmapYScale{valuer.NewString("auto")} // default
-	HeatmapYScaleLinear = HeatmapYScale{valuer.NewString("linear")}
-	HeatmapYScaleLog    = HeatmapYScale{valuer.NewString("log")}
-	HeatmapYScaleSymlog = HeatmapYScale{valuer.NewString("symlog")}
-)
-
-func (HeatmapYScale) Enum() []any {
-	return []any{HeatmapYScaleAuto, HeatmapYScaleLinear, HeatmapYScaleLog, HeatmapYScaleSymlog}
-}
-
-func (s HeatmapYScale) ValueOrDefault() string {
-	if s.IsZero() {
-		return HeatmapYScaleAuto.StringValue()
-	}
-	return s.StringValue()
-}
-
-func (s HeatmapYScale) MarshalJSON() ([]byte, error) {
-	return json.Marshal(s.ValueOrDefault())
-}
-
-func (s *HeatmapYScale) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid heatmap y scale: must be a string, one of `auto`, `linear`, `log`, or `symlog`")
-	}
-	scale := HeatmapYScale{valuer.NewString(v)}
-	switch scale {
-	case HeatmapYScaleAuto, HeatmapYScaleLinear, HeatmapYScaleLog, HeatmapYScaleSymlog:
-		*s = scale
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid heatmap y scale %q: must be `auto`, `linear`, `log`, or `symlog`", v)
-	}
-}
-
-type HeatmapColorScale struct{ valuer.String }
-
-var (
-	HeatmapColorScaleLog    = HeatmapColorScale{valuer.NewString("log")} // default
-	HeatmapColorScaleSqrt   = HeatmapColorScale{valuer.NewString("sqrt")}
-	HeatmapColorScaleLinear = HeatmapColorScale{valuer.NewString("linear")}
-)
-
-func (HeatmapColorScale) Enum() []any {
-	return []any{HeatmapColorScaleLog, HeatmapColorScaleSqrt, HeatmapColorScaleLinear}
-}
-
-func (s HeatmapColorScale) ValueOrDefault() string {
-	if s.IsZero() {
-		return HeatmapColorScaleLog.StringValue()
-	}
-	return s.StringValue()
-}
-
-func (s HeatmapColorScale) MarshalJSON() ([]byte, error) {
-	return json.Marshal(s.ValueOrDefault())
-}
-
-func (s *HeatmapColorScale) UnmarshalJSON(data []byte) error {
-	var v string
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid heatmap color scale: must be a string, one of `log`, `sqrt`, or `linear`")
-	}
-	scale := HeatmapColorScale{valuer.NewString(v)}
-	switch scale {
-	case HeatmapColorScaleLog, HeatmapColorScaleSqrt, HeatmapColorScaleLinear:
-		*s = scale
-		return nil
-	default:
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid heatmap color scale %q: must be `log`, `sqrt`, or `linear`", v)
-	}
-}

pkg/types/querybuildertypes/querybuildertypesv5/builder_elements.go

@@ -540,8 +540,6 @@ type MetricAggregation struct {
 	// reduce to operator for metric scalar requests
 	ReduceTo ReduceTo `json:"reduceTo,omitzero"`
 
-	HeatmapBucketing *HeatmapBucketing `json:"-"`
-
 	Reduced bool `json:"-"`
 }
 
@@ -556,10 +554,6 @@ func (m MetricAggregation) Copy() MetricAggregation {
 		valueFilterCopy := *m.ValueFilter
 		c.ValueFilter = &valueFilterCopy
 	}
-	if m.HeatmapBucketing != nil {
-		bucketingCopy := *m.HeatmapBucketing
-		c.HeatmapBucketing = &bucketingCopy
-	}
 	return c
 }
 

pkg/types/querybuildertypes/querybuildertypesv5/heatmap.go

@@ -1,296 +0,0 @@
-package querybuildertypesv5
-
-import (
-	"math"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-)
-
-const (
-	// HeatmapBucketColumn is the alias a heatmap statement gives the column holding
-	// a row's bucket upper bound. Every other aggregation returns a single numeric
-	// column the reader treats as the value; this name tells the two apart.
-	HeatmapBucketColumn = "__bucket"
-
-	DefaultNumBuckets = 60
-
-	// MaxLogScale is the resolution ClickHouse buckets every log heatmap at:
-	// 2^MaxLogScale bands per doubling. It is both the default and the finest
-	// available, since a coarser LogBucketsSpec.Scale folds down from it.
-	MaxLogScale = 4
-	// MinLogScale is one band per 16x, the coarsest axis worth rendering.
-	MinLogScale = -4
-
-	// A positive value approaching zero runs its band index off to -inf, so
-	// without a clamp one near-zero sample would stretch the axis by thousands
-	// of bands once AddHeatmapBucketsWithNoCounts spans it.
-	MinLogBandIndex = -512 // 2^-32, about 2.3e-10
-	MaxLogBandIndex = 1024 // 2^64, about 1.8e19
-)
-
-// MinLogUpperBound and MaxLogUpperBound are the ends the log axis is clamped
-// to. They do not vary with the requested scale.
-var (
-	MinLogUpperBound = math.Exp2(float64(MinLogBandIndex) / math.Exp2(MaxLogScale))
-	MaxLogUpperBound = math.Exp2(float64(MaxLogBandIndex) / math.Exp2(MaxLogScale))
-)
-
-// HeatmapBucketing is the bucket axis a heatmap statement builds in ClickHouse,
-// resolved from BucketOptions once the metric type is known. It stays nil for
-// histograms, whose upper bounds come from their own `le` labels.
-type HeatmapBucketing struct {
-	Kind BucketsKind
-	// LogScale is the resolution the caller asked for. ClickHouse always buckets
-	// at MaxLogScale, and postprocessing folds the axis down to this.
-	LogScale int
-	// MaxValue and NumBuckets are linear only.
-	MaxValue   float64
-	NumBuckets int
-}
-
-// ToHeatmapBucketing fills in what the caller left unset. An absent
-// BucketOptions resolves to the finest log axis, the one kind that needs nothing
-// from the caller.
-func (b *BucketOptions) ToHeatmapBucketing() HeatmapBucketing {
-	resolved := HeatmapBucketing{
-		Kind:       BucketsKindLog,
-		LogScale:   MaxLogScale,
-		NumBuckets: DefaultNumBuckets,
-	}
-	if b == nil {
-		return resolved
-	}
-
-	switch spec := b.Spec.(type) {
-	case LinearBucketsSpec:
-		resolved.Kind = BucketsKindLinear
-		resolved.MaxValue = spec.MaxValue
-		if spec.NumBuckets > 0 {
-			resolved.NumBuckets = spec.NumBuckets
-		}
-	case LogBucketsSpec:
-		if spec.Scale != nil {
-			resolved.LogScale = *spec.Scale
-		}
-	}
-
-	return resolved
-}
-
-// This cannot be called in validateHeatmap cuz type is resolved in querier.go.
-func (a *MetricAggregation) VerifyAndApplyBucketOptions(bucketOptions *BucketOptions) error {
-	switch a.Type {
-	case metrictypes.HistogramType:
-		if bucketOptions != nil {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"bucketOptions are not supported for histogram metrics: %q takes its bucket axis from its own `le` labels, so nothing in the spec would be applied", a.MetricName)
-		}
-		a.HeatmapBucketing = nil
-		return nil
-	// A summary carries no upper bounds of its own either, and its samples reach
-	// the final select the same way a gauge's do, so it buckets identically.
-	case metrictypes.GaugeType, metrictypes.SumType, metrictypes.SummaryType:
-		bucketing := bucketOptions.ToHeatmapBucketing()
-		a.HeatmapBucketing = &bucketing
-		return nil
-	case metrictypes.UnspecifiedType:
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"heatmaps need a metric whose type is known: no type is recorded for %q, so its bucket axis cannot be chosen", a.MetricName)
-	case metrictypes.ExpHistogramType:
-		return errors.Newf(errors.TypeUnsupported, errors.CodeUnsupported,
-			"heatmaps are not supported for exponential histograms yet: %q keeps its bucket counts in a sketch column, which needs its own reader", a.MetricName)
-	default:
-		return errors.Newf(errors.TypeUnsupported, errors.CodeUnsupported,
-			"heatmaps are not supported for %s metrics", a.Type.StringValue())
-	}
-}
-
-func MergeBucketUpperBounds(tsData ...*TimeSeriesData) map[int][]float64 {
-	upperBoundsByAggregation := map[int][]float64{}
-
-	for _, data := range tsData {
-		if data == nil {
-			continue
-		}
-		for _, aggBucket := range data.Aggregations {
-			if len(aggBucket.Meta.Buckets) == 0 {
-				continue
-			}
-			upperBoundsByAggregation[aggBucket.Index] = append(upperBoundsByAggregation[aggBucket.Index], aggBucket.Meta.Buckets...)
-		}
-	}
-
-	for index, upperBounds := range upperBoundsByAggregation {
-		slices.Sort(upperBounds)
-		upperBoundsByAggregation[index] = slices.Compact(upperBounds)
-	}
-
-	return upperBoundsByAggregation
-}
-
-// DownscaleHeatmapResolution folds the MaxLogScale axis ClickHouse buckets at
-// down to toScale, merging every 2^(MaxLogScale-toScale) adjacent bands into
-// one. The coarser upper bounds are a subset of the finer ones, so the fold is
-// exact.
-func DownscaleHeatmapResolution(tsData *TimeSeriesData, toScale int) {
-	if tsData == nil || toScale >= MaxLogScale {
-		return
-	}
-	for _, aggBucket := range tsData.Aggregations {
-		downscaleHeatmapResolutionForAggregation(aggBucket, toScale)
-	}
-}
-
-func downscaleHeatmapResolutionForAggregation(aggBucket *AggregationBucket, toScale int) {
-	if aggBucket == nil || len(aggBucket.Meta.Buckets) == 0 {
-		return
-	}
-
-	factor := int(math.Exp2(float64(MaxLogScale - toScale)))
-
-	// Merging is by index in the exponential mapping, not by position in
-	// Meta.Buckets, which lists only the upper bounds some series reached.
-	coarseUpperBounds := make([]float64, 0, len(aggBucket.Meta.Buckets))
-	upperBoundToCoarseIndex := make(map[float64]int, len(aggBucket.Meta.Buckets))
-	mergedInto := make([]int, len(aggBucket.Meta.Buckets))
-	for index, upperBound := range aggBucket.Meta.Buckets {
-		coarsened := coarsenUpperBound(upperBound, toScale, factor)
-		coarseIndex, ok := upperBoundToCoarseIndex[coarsened]
-		if !ok {
-			coarseIndex = len(coarseUpperBounds)
-			coarseUpperBounds = append(coarseUpperBounds, coarsened)
-			upperBoundToCoarseIndex[coarsened] = coarseIndex
-		}
-		mergedInto[index] = coarseIndex
-	}
-
-	overflowIndex := len(coarseUpperBounds)
-	for _, series := range aggBucket.Series {
-		for _, point := range series.Values {
-			if len(point.Values) == 0 {
-				continue
-			}
-			coarseCounts := make([]float64, overflowIndex+1)
-			for index, count := range point.Values {
-				if index >= len(mergedInto) {
-					coarseCounts[overflowIndex] += count
-					continue
-				}
-				coarseCounts[mergedInto[index]] += count
-			}
-			point.Values = coarseCounts
-		}
-	}
-	aggBucket.Meta.Buckets = coarseUpperBounds
-}
-
-// coarsenUpperBound moves an upper bound from the MaxLogScale exponential axis
-// onto the toScale one. The zero band has no exponent to rescale and stays put.
-func coarsenUpperBound(upperBound float64, toScale, factor int) float64 {
-	if upperBound <= 0 || math.IsInf(upperBound, 0) || math.IsNaN(upperBound) {
-		return upperBound
-	}
-	index := int(math.Round(math.Log2(upperBound) * math.Exp2(MaxLogScale)))
-	merged := int(math.Ceil(float64(index) / float64(factor)))
-	return math.Exp2(float64(merged) / math.Exp2(float64(toScale)))
-}
-
-// AddHeatmapBucketsWithNoCounts spans the range from the lowest upper bound some
-// series reached to the highest. Meta.Buckets leaves the ones in between out
-// entirely, so without this a gap renders with its two sides touching.
-//
-// Only a value-derived axis can be spanned: its upper bounds come from an index
-// that is a pure function of the value, so the ones in between are known without
-// having seen them. Nothing says what sits between two `le` labels.
-func AddHeatmapBucketsWithNoCounts(tsData *TimeSeriesData, bucketing HeatmapBucketing) {
-	if tsData == nil {
-		return
-	}
-	for _, aggBucket := range tsData.Aggregations {
-		addHeatmapBucketsWithNoCountsForAggregation(aggBucket, bucketing)
-	}
-}
-
-func addHeatmapBucketsWithNoCountsForAggregation(aggBucket *AggregationBucket, bucketing HeatmapBucketing) {
-	if aggBucket == nil || len(aggBucket.Meta.Buckets) == 0 {
-		return
-	}
-
-	// The zero bucket holds everything at or below zero. It has no index on either
-	// axis and sits below every other upper bound, so it keeps index 0 and the
-	// fill runs over the rest.
-	offset := 0
-	if aggBucket.Meta.Buckets[0] <= 0 {
-		offset = 1
-	}
-	positive := aggBucket.Meta.Buckets[offset:]
-	if len(positive) == 0 {
-		return
-	}
-
-	// Only finite upper bounds have an index, and the fill sizes a slice from
-	// one. Nothing should put +Inf or NaN on the axis, but bail if it happens.
-	indexes := make([]int, len(positive))
-	for i, upperBound := range positive {
-		if math.IsInf(upperBound, 0) || math.IsNaN(upperBound) {
-			return
-		}
-		indexes[i] = bucketing.calculateIndexOfUpperBound(upperBound)
-	}
-	lowest, highest := slices.Min(indexes), slices.Max(indexes)
-
-	denseUpperBounds := append([]float64{}, aggBucket.Meta.Buckets[:offset]...)
-	for index := lowest; index <= highest; index++ {
-		denseUpperBounds = append(denseUpperBounds, bucketing.calculateUpperBoundAtIndex(index))
-	}
-	if len(denseUpperBounds) == len(aggBucket.Meta.Buckets) {
-		return
-	}
-
-	// Counts map through their index rather than by matching upper bounds, so a
-	// regenerated upper bound differing from ClickHouse's in its last bit still
-	// lands where it came from.
-	shiftedTo := make([]int, len(aggBucket.Meta.Buckets))
-	for i, index := range indexes {
-		shiftedTo[i+offset] = index - lowest + offset
-	}
-
-	overflowIndex := len(denseUpperBounds)
-	for _, series := range aggBucket.Series {
-		for _, point := range series.Values {
-			if len(point.Values) == 0 {
-				continue
-			}
-			denseCounts := make([]float64, overflowIndex+1)
-			for index, count := range point.Values {
-				if index >= len(shiftedTo) {
-					denseCounts[overflowIndex] += count
-					continue
-				}
-				denseCounts[shiftedTo[index]] += count
-			}
-			point.Values = denseCounts
-		}
-	}
-	aggBucket.Meta.Buckets = denseUpperBounds
-}
-
-// calculateIndexOfUpperBound and calculateUpperBoundAtIndex are inverses over
-// the axis being returned, so they read h.LogScale rather than the MaxLogScale
-// ClickHouse bucketed at: k * maxValue / numBuckets on a linear axis,
-// 2^(k / 2^scale) on a log one.
-func (h HeatmapBucketing) calculateIndexOfUpperBound(upperBound float64) int {
-	if h.Kind == BucketsKindLinear {
-		return int(math.Round(upperBound * float64(h.NumBuckets) / h.MaxValue))
-	}
-	return int(math.Round(math.Log2(upperBound) * math.Exp2(float64(h.LogScale))))
-}
-
-func (h HeatmapBucketing) calculateUpperBoundAtIndex(index int) float64 {
-	if h.Kind == BucketsKindLinear {
-		return float64(index) * h.MaxValue / float64(h.NumBuckets)
-	}
-	return math.Exp2(float64(index) / math.Exp2(float64(h.LogScale)))
-}

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -397,8 +397,6 @@ type QueryRangeRequest struct {
 	PromQLProvider string `json:"-"`
 
 	FormatOptions *FormatOptions `json:"formatOptions,omitempty"`
-
-	BucketOptions *BucketOptions `json:"bucketOptions,omitempty"`
 }
 
 // PrepareJSONSchema adds description to the QueryRangeRequest schema.
@@ -736,130 +734,3 @@ func (r *QueryRangeRequest) GetQueriesSupportingZeroDefault() map[string]bool {
 
 	return canDefaultZero
 }
-
-type BucketOptions struct {
-	Kind BucketsKind `json:"kind"`
-	Spec any         `json:"spec"`
-}
-
-type BucketsKind struct {
-	valuer.String
-}
-
-var (
-	BucketsKindLinear = BucketsKind{valuer.NewString("linear")}
-	BucketsKindLog    = BucketsKind{valuer.NewString("log")}
-)
-
-// Enum implements jsonschema.Enum.
-func (BucketsKind) Enum() []any {
-	return []any{
-		BucketsKindLinear,
-		BucketsKindLog,
-	}
-}
-
-// LinearBucketsSpec divides (0, MaxValue] into NumBuckets equal bands.
-type LinearBucketsSpec struct {
-	// Everything above MaxValue is counted in the trailing overflow band. Evenly
-	// spaced upper bounds have no top to divide without it, so it is required.
-	MaxValue   float64 `json:"maxValue" required:"true"`
-	NumBuckets int     `json:"numBuckets,omitempty"`
-}
-
-// LogBucketsSpec spaces upper bounds at 2^Scale bands per doubling, the mapping
-// an exponential histogram uses.
-type LogBucketsSpec struct {
-	// ClickHouse always buckets at MaxLogScale and the surplus is folded away
-	// afterwards, so every Scale reads the same cache entry. MaxLogScale applies
-	// when unset.
-	Scale *int `json:"scale,omitempty"`
-}
-
-func (b *BucketOptions) UnmarshalJSON(data []byte) error {
-	var shadow struct {
-		Kind BucketsKind     `json:"kind"`
-		Spec json.RawMessage `json:"spec"`
-	}
-	if err := binding.JSON.BindBody(bytes.NewReader(data), &shadow, binding.WithDisallowUnknownFields(true)); err != nil {
-		return err
-	}
-
-	b.Kind = shadow.Kind
-
-	// An absent spec is a malformed pair rather than a request for defaults;
-	// `"spec": {}` asks for those.
-	if len(shadow.Spec) == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"bucketOptions spec is required, use an empty object for the kind's defaults")
-	}
-
-	switch shadow.Kind {
-	case BucketsKindLinear:
-		var spec LinearBucketsSpec
-		if err := binding.JSON.BindBody(bytes.NewReader(shadow.Spec), &spec, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("linear buckets spec")); err != nil {
-			return err
-		}
-		b.Spec = spec
-
-	case BucketsKindLog:
-		var spec LogBucketsSpec
-		if err := binding.JSON.BindBody(bytes.NewReader(shadow.Spec), &spec, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("log buckets spec")); err != nil {
-			return err
-		}
-		b.Spec = spec
-
-	default:
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid bucketOptions kind: %s",
-			shadow.Kind.StringValue(),
-		).WithAdditional(
-			"Valid bucket kinds are: linear, log",
-		)
-	}
-
-	return nil
-}
-
-// bucketOptionsLinear and bucketOptionsLog are the OpenAPI schemas for the two
-// BucketOptions variants. They have to be named types: the reflector turns an
-// anonymous one into an inline subschema, leaving the discriminator mapping in
-// PrepareJSONSchema pointing at components that were never emitted. `kind` is
-// required:"true" on both so oapi-codegen renders the discriminator non-pointer.
-type bucketOptionsLinear struct {
-	Kind BucketsKind       `json:"kind" required:"true" description:"How the upper bounds are spaced."`
-	Spec LinearBucketsSpec `json:"spec" required:"true" description:"The evenly spaced bucket specification."`
-}
-
-type bucketOptionsLog struct {
-	Kind BucketsKind    `json:"kind" required:"true" description:"How the upper bounds are spaced."`
-	Spec LogBucketsSpec `json:"spec" required:"true" description:"The logarithmic bucket specification."`
-}
-
-var _ jsonschema.OneOfExposer = BucketOptions{}
-
-func (BucketOptions) JSONSchemaOneOf() []any {
-	return []any{
-		bucketOptionsLinear{},
-		bucketOptionsLog{},
-	}
-}
-
-var _ jsonschema.Preparer = BucketOptions{}
-
-// PrepareJSONSchema marks the options as a `kind`-discriminated union;
-// signoz.attachDiscriminators promotes it and strips the base properties.
-func (BucketOptions) PrepareJSONSchema(s *jsonschema.Schema) error {
-	if s.ExtraProperties == nil {
-		s.ExtraProperties = map[string]any{}
-	}
-	s.ExtraProperties["x-signoz-discriminator"] = map[string]any{
-		"propertyName": "kind",
-		"mapping": map[string]string{
-			BucketsKindLinear.StringValue(): "#/components/schemas/Querybuildertypesv5BucketOptionsLinear",
-			BucketsKindLog.StringValue():    "#/components/schemas/Querybuildertypesv5BucketOptionsLog",
-		},
-	}
-	return nil
-}

pkg/types/querybuildertypes/querybuildertypesv5/request_type.go

@@ -19,11 +19,11 @@ func (r *RequestType) UnmarshalJSON(data []byte) error {
 	}
 	v := RequestType{valuer.NewString(s)}
 	switch v {
-	case RequestTypeScalar, RequestTypeTimeSeries, RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeDistribution, RequestTypeHeatmap:
+	case RequestTypeScalar, RequestTypeTimeSeries, RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeDistribution:
 		*r = v
 		return nil
 	default:
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown request type %q; allowed values: %s", s, "`scalar`, `time_series`, `raw`, `raw_stream`, `trace`, `distribution`, `heatmap`")
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown request type %q; allowed values: %s", s, "`scalar`, `time_series`, `raw`, `raw_stream`, `trace`, `distribution`")
 	}
 }
 
@@ -41,9 +41,6 @@ var (
 	RequestTypeTrace = RequestType{valuer.NewString("trace")}
 	// []Bucket (struct{Lower,Upper,Count float64}), example: histogram.
 	RequestTypeDistribution = RequestType{valuer.NewString("distribution")}
-	// TimeSeriesData carrying one count per histogram bucket at each timestamp,
-	// with the shared bucket upper bounds on the aggregation's meta.
-	RequestTypeHeatmap = RequestType{valuer.NewString("heatmap")}
 )
 
 // IsAggregation returns true for request types that produce aggregated results
@@ -52,7 +49,7 @@ var (
 // For non-aggregation types (raw, raw_stream, trace), those fields are ignored
 // and don't need to be validated.
 func (r RequestType) IsAggregation() bool {
-	return r == RequestTypeTimeSeries || r == RequestTypeScalar || r == RequestTypeDistribution || r == RequestTypeHeatmap
+	return r == RequestTypeTimeSeries || r == RequestTypeScalar || r == RequestTypeDistribution
 }
 
 // Enum implements jsonschema.Enum; returns the acceptable values for RequestType.
@@ -63,7 +60,6 @@ func (RequestType) Enum() []any {
 		RequestTypeRaw,
 		RequestTypeRawStream,
 		RequestTypeTrace,
-		RequestTypeHeatmap,
 		// RequestTypeDistribution,
 	}
 }

pkg/types/querybuildertypes/querybuildertypesv5/resp.go

@@ -138,10 +138,12 @@ type TimeSeriesData struct {
 }
 
 type AggregationBucket struct {
-	Index  int             `json:"index"` // or string Alias
-	Alias  string          `json:"alias"`
-	Meta   AggregationMeta `json:"meta,omitempty"`
-	Series []*TimeSeries   `json:"series"` // no extra nesting
+	Index int    `json:"index"` // or string Alias
+	Alias string `json:"alias"`
+	Meta  struct {
+		Unit string `json:"unit,omitempty"`
+	} `json:"meta,omitempty"`
+	Series []*TimeSeries `json:"series"` // no extra nesting
 
 	PredictedSeries  []*TimeSeries `json:"predictedSeries,omitempty"`
 	UpperBoundSeries []*TimeSeries `json:"upperBoundSeries,omitempty"`
@@ -149,54 +151,6 @@ type AggregationBucket struct {
 	AnomalyScores    []*TimeSeries `json:"anomalyScores,omitempty"`
 }
 
-// ReindexValuesToNewUpperBounds moves each count to the index its upper bound
-// holds in onto, a superset of Meta.Buckets. No count changes, only its position
-// in Values.
-func (a *AggregationBucket) ReindexValuesToNewUpperBounds(onto []float64) {
-	if a == nil {
-		return
-	}
-
-	from := a.Meta.Buckets
-	if len(onto) == 0 || slices.Equal(from, onto) {
-		return
-	}
-
-	upperBoundToIndex := make(map[float64]int, len(onto))
-	for index, upperBound := range onto {
-		upperBoundToIndex[upperBound] = index
-	}
-
-	for _, series := range a.Series {
-		for _, point := range series.Values {
-			if len(point.Values) == 0 {
-				continue
-			}
-			reindexed := make([]float64, len(onto)+1)
-			for index, count := range point.Values {
-				if index >= len(from) {
-					reindexed[len(onto)] = count
-					break
-				}
-				if newIndex, ok := upperBoundToIndex[from[index]]; ok {
-					reindexed[newIndex] = count
-				}
-			}
-			point.Values = reindexed
-		}
-	}
-
-	a.Meta.Buckets = onto
-}
-
-type AggregationMeta struct {
-	Unit string `json:"unit,omitempty"`
-	// Buckets holds ascending upper bounds shared by every series in the
-	// AggregationBucket, set only for heatmap results. Each point's Values holds
-	// len(Buckets)+1 counts: one per bound, then the open-above overflow.
-	Buckets []float64 `json:"buckets,omitempty"`
-}
-
 type TimeSeries struct {
 	Labels []*Label           `json:"labels,omitempty"`
 	Values []*TimeSeriesValue `json:"values"`
@@ -300,9 +254,13 @@ type TimeSeriesValue struct {
 	// on the client side, these partial values are rendered differently.
 	Partial bool `json:"partial,omitempty"`
 
-	// Values holds one count per histogram bucket for heatmap results, in the
-	// order of the aggregation's Meta.Buckets. Value is unused in that case.
+	// for the heatmap type chart
 	Values []float64 `json:"values,omitempty"`
+	Bucket *Bucket   `json:"bucket,omitempty"`
+}
+
+type Bucket struct {
+	Step float64 `json:"step"`
 }
 
 type ColumnType struct {

pkg/types/querybuildertypes/querybuildertypesv5/series_limit.go

@@ -127,7 +127,7 @@ func calculateSeriesValue(series *TimeSeries) float64 {
 
 	// For single-point series, return that value directly
 	if len(series.Values) == 1 {
-		value := calculatePointValue(series.Values[0])
+		value := series.Values[0].Value
 		if math.IsNaN(value) || math.IsInf(value, 0) {
 			return 0.0
 		}
@@ -139,11 +139,10 @@ func calculateSeriesValue(series *TimeSeries) float64 {
 	var count float64
 
 	for _, point := range series.Values {
-		value := calculatePointValue(point)
-		if math.IsNaN(value) || math.IsInf(value, 0) {
+		if math.IsNaN(point.Value) || math.IsInf(point.Value, 0) {
 			continue
 		}
-		sum += value
+		sum += point.Value
 		count++
 	}
 
@@ -155,25 +154,6 @@ func calculateSeriesValue(series *TimeSeries) float64 {
 	return sum / count
 }
 
-// calculatePointValue returns what a point contributes to its series' rank.
-// Heatmap points carry one count per bucket in Values and leave Value at zero,
-// so they rank on the total across buckets.
-func calculatePointValue(point *TimeSeriesValue) float64 {
-	if len(point.Values) == 0 {
-		return point.Value
-	}
-
-	var total float64
-	for _, value := range point.Values {
-		if math.IsNaN(value) || math.IsInf(value, 0) {
-			continue
-		}
-		total += value
-	}
-
-	return total
-}
-
 // convertValueToString converts various types to string for comparison.
 func convertValueToString(value any) string {
 	switch v := value.(type) {

pkg/types/querybuildertypes/querybuildertypesv5/series_limit_test.go

@@ -1,12 +1,10 @@
 package querybuildertypesv5
 
 import (
-	"math"
 	"testing"
 
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestApplySeriesLimit(t *testing.T) {
@@ -234,81 +232,3 @@ func TestApplySeriesLimit(t *testing.T) {
 		assert.Equal(t, 40.0, result[2].Values[0].Value)
 	})
 }
-
-func TestApplySeriesLimitRanksHeatmapSeriesByBucketTotals(t *testing.T) {
-	// A reshaped heatmap point leaves Value at zero and holds one count per
-	// bucket in Values, so ranking has to sum the buckets to see any difference.
-	series := []*TimeSeries{
-		{
-			Labels: []*Label{{
-				Key:   telemetrytypes.TelemetryFieldKey{Name: "service.name"},
-				Value: "quiet",
-			}},
-			Values: []*TimeSeriesValue{
-				{Timestamp: 1000, Values: []float64{1, 2, 0}},
-				{Timestamp: 1060, Values: []float64{0, 1, 0}},
-			},
-		},
-		{
-			Labels: []*Label{{
-				Key:   telemetrytypes.TelemetryFieldKey{Name: "service.name"},
-				Value: "busy",
-			}},
-			Values: []*TimeSeriesValue{
-				{Timestamp: 1000, Values: []float64{40, 60, 5}},
-				{Timestamp: 1060, Values: []float64{30, 70, 5}},
-			},
-		},
-		{
-			Labels: []*Label{{
-				Key:   telemetrytypes.TelemetryFieldKey{Name: "service.name"},
-				Value: "middling",
-			}},
-			Values: []*TimeSeriesValue{
-				{Timestamp: 1000, Values: []float64{5, 5, 0}},
-				{Timestamp: 1060, Values: []float64{4, 6, 0}},
-			},
-		},
-	}
-
-	result := ApplySeriesLimit(series, nil, 2)
-
-	require.Len(t, result, 2)
-	assert.Equal(t, "busy", result[0].Labels[0].Value)
-	assert.Equal(t, "middling", result[1].Labels[0].Value)
-}
-
-func TestCalculatePointValue(t *testing.T) {
-	testCases := []struct {
-		description   string
-		point         *TimeSeriesValue
-		expectedValue float64
-	}{
-		{
-			description:   "a plain time series point ranks on its single value",
-			point:         &TimeSeriesValue{Timestamp: 1000, Value: 7},
-			expectedValue: 7,
-		},
-		{
-			description:   "a heatmap point ranks on the total across its buckets",
-			point:         &TimeSeriesValue{Timestamp: 1000, Values: []float64{1, 12, 14, 3}},
-			expectedValue: 30,
-		},
-		{
-			description:   "non-finite bucket counts are skipped",
-			point:         &TimeSeriesValue{Timestamp: 1000, Values: []float64{2, math.NaN(), math.Inf(1), 3}},
-			expectedValue: 5,
-		},
-		{
-			description:   "an empty bucket list falls back to the single value",
-			point:         &TimeSeriesValue{Timestamp: 1000, Value: 4, Values: []float64{}},
-			expectedValue: 4,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.description, func(t *testing.T) {
-			assert.Equal(t, testCase.expectedValue, calculatePointValue(testCase.point))
-		})
-	}
-}

pkg/types/querybuildertypes/querybuildertypesv5/validation.go

@@ -2,7 +2,6 @@ package querybuildertypesv5
 
 import (
 	"fmt"
-	"math"
 	"slices"
 	"strings"
 
@@ -66,8 +65,6 @@ func wrapValidationError(cause error, contextIdentifier string, errorFormat stri
 const (
 	// Maximum limit for query results.
 	MaxQueryLimit = 10000
-
-	MaxNumBuckets = 512
 )
 
 // ValidationOption is a functional option for configuring validation behaviour.
@@ -584,7 +581,7 @@ func (r *QueryRangeRequest) Validate(opts ...ValidationOption) error {
 
 	// Validate request type
 	switch r.RequestType {
-	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeTimeSeries, RequestTypeScalar, RequestTypeHeatmap:
+	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeTimeSeries, RequestTypeScalar:
 		opts = append(opts, GetValidationOptions(r.RequestType)...)
 	default:
 		return errors.NewInvalidInputf(
@@ -592,14 +589,10 @@ func (r *QueryRangeRequest) Validate(opts ...ValidationOption) error {
 			"invalid request type: %s",
 			r.RequestType,
 		).WithAdditional(
-			"Valid request types are: raw, timeseries, scalar, heatmap",
+			"Valid request types are: raw, timeseries, scalar",
 		)
 	}
 
-	if err := r.validateHeatmap(); err != nil {
-		return err
-	}
-
 	// raw/trace request types don't support metric queries;
 	// metrics are always aggregated and there is no raw form.
 	if r.RequestType == RequestTypeRaw || r.RequestType == RequestTypeRawStream || r.RequestType == RequestTypeTrace {
@@ -637,15 +630,11 @@ func (r *QueryRangeRequest) ValidateRequestScope() ([]ValidationOption, error) {
 
 	var opts []ValidationOption
 	switch r.RequestType {
-	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeTimeSeries, RequestTypeScalar, RequestTypeHeatmap:
+	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeTimeSeries, RequestTypeScalar:
 		opts = GetValidationOptions(r.RequestType)
 	default:
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid request type: %s", r.RequestType).
-			WithAdditional("Valid request types are: raw, timeseries, scalar, heatmap")
-	}
-
-	if err := r.validateHeatmap(); err != nil {
-		return nil, err
+			WithAdditional("Valid request types are: raw, timeseries, scalar")
 	}
 
 	if r.RequestType == RequestTypeRaw || r.RequestType == RequestTypeRawStream || r.RequestType == RequestTypeTrace {
@@ -849,133 +838,9 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err
 	}
 }
 
-func (r *QueryRangeRequest) validateHeatmap() error {
-	if r.RequestType != RequestTypeHeatmap {
-		if r.BucketOptions != nil {
-			return errors.NewInvalidInputf(
-				errors.CodeInvalidInput,
-				"bucketOptions are only supported for heatmap requests, got %s",
-				r.RequestType,
-			)
-		}
-		return nil
-	}
-
-	if r.FormatOptions != nil && r.FormatOptions.FillGaps {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"fillGaps is not supported for heatmap requests: an absent column means collection stopped, which a zero-filled column would hide")
-	}
-
-	if err := r.BucketOptions.validateBucketOptions(); err != nil {
-		return err
-	}
-
-	enabled := 0
-	for _, envelope := range r.CompositeQuery.Queries {
-		switch spec := envelope.Spec.(type) {
-		case QueryBuilderQuery[MetricAggregation]:
-			if err := validateHeatmapQuery(spec.Functions, spec.Having); err != nil {
-				return err
-			}
-			if spec.Disabled {
-				continue
-			}
-			enabled++
-		case QueryBuilderFormula:
-			if err := validateHeatmapQuery(spec.Functions, spec.Having); err != nil {
-				return err
-			}
-			if spec.Disabled {
-				continue
-			}
-			enabled++
-		case ClickHouseQuery:
-			if spec.Disabled {
-				continue
-			}
-			enabled++
-		case PromQuery:
-			if r.BucketOptions != nil {
-				return errors.NewInvalidInputf(errors.CodeInvalidInput,
-					"bucketOptions are not supported for promql heatmap requests: the bucket axis comes from the `le` labels the query returns, so nothing in the spec would be applied")
-			}
-			if spec.Disabled {
-				continue
-			}
-			enabled++
-		// Logs and traces land here. Whichever case admits them must cap
-		// Aggregations at one: each carries its own Meta.Buckets, and a heatmap
-		// renders against a single bucket axis. Metrics needs no such cap, the
-		// statement builder reading Aggregations[0] alone.
-		default:
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"heatmap requests support one metrics builder query, one formula over them, one clickhouse query, or one promql query, got %q", envelope.Type.StringValue())
-		}
-	}
-
-	if enabled != 1 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"heatmap requests need exactly one enabled query, got %d", enabled)
-	}
-
-	return nil
-}
-
-func (b *BucketOptions) validateBucketOptions() error {
-	if b == nil {
-		return nil
-	}
-
-	switch spec := b.Spec.(type) {
-	case LinearBucketsSpec:
-		if math.IsNaN(spec.MaxValue) || math.IsInf(spec.MaxValue, 0) || spec.MaxValue <= 0 {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"linear buckets need a finite maxValue greater than 0, got %v", spec.MaxValue)
-		}
-		if spec.NumBuckets < 0 || spec.NumBuckets > MaxNumBuckets {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"numBuckets must be between 1 and %d, got %d", MaxNumBuckets, spec.NumBuckets)
-		}
-
-	case LogBucketsSpec:
-		if spec.Scale != nil && (*spec.Scale < MinLogScale || *spec.Scale > MaxLogScale) {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"scale must be between %d and %d, got %d", MinLogScale, MaxLogScale, *spec.Scale)
-		}
-
-	default:
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid bucketOptions kind: %s",
-			b.Kind.StringValue(),
-		).WithAdditional(
-			"Valid bucket kinds are: linear, log",
-		)
-	}
-
-	return nil
-}
-
-// validateHeatmapQuery refuses the per-query settings that cannot mean anything
-// on a heatmap. It runs on disabled queries too: a disabled query is a formula
-// input, so whatever it does still reaches the cells.
-func validateHeatmapQuery(functions []Function, having *Having) error {
-	if len(functions) > 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"functions are not supported for heatmap requests: a heatmap point is a count per bucket, not a single value")
-	}
-
-	if having != nil && having.Expression != "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"having is not supported for heatmap requests: it filters individual cells, which breaks the cumulative differencing")
-	}
-
-	return nil
-}
-
 func GetValidationOptions(requestType RequestType) []ValidationOption {
 	switch requestType {
-	case RequestTypeTimeSeries, RequestTypeHeatmap:
+	case RequestTypeTimeSeries:
 		return []ValidationOption{WithSkipSelectFieldValidation(), WithTimestampGroupByValidation()}
 	case RequestTypeScalar:
 		return []ValidationOption{WithSkipSelectFieldValidation(), WithReduceToValidation()}