SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
feat(dashboards): add plugin schema for scatter plot panel (#13030)
Abhi kumarb8fb5695ea5c
diff --git a/docs/api/openapi.yml b/docs/api/openapi.ymlindex 966a85ba55..19ed17a0f8 100644--- a/docs/api/openapi.yml+++ b/docs/api/openapi.yml@@ -4224,6 +4224,13 @@ components:nullable: truetype: numbertype: object+ DashboardtypesAxisScale:+ enum:+ - auto+ - linear+ - log+ - symlog+ type: stringDashboardtypesBarChartPanelSpec:properties:axes:@@ -5250,6 +5257,7 @@ components:signoz/ListPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'signoz/NumberPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec'signoz/PieChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec'+ signoz/ScatterPlotPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpec'signoz/TablePanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'signoz/TextPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec'signoz/TimeSeriesPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec'@@ -5265,6 +5273,7 @@ components:- $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'- $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec'- $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec'+ - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpec'type: objectDashboardtypesPanelPluginKind:enum:@@ -5278,6 +5287,7 @@ components:- signoz/ListPanel- signoz/TextPanel- signoz/HeatmapPanel+ - signoz/ScatterPlotPaneltype: stringDashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec:properties:@@ -5384,6 +5394,21 @@ components:- kind- spectype: object+ DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpec:+ properties:+ kind:+ description: The panel kind.+ enum:+ - signoz/ScatterPlotPanel+ type: string+ spec:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotPanelSpec'+ description: The options for this panel kind. {} accepts every default.+ required:+ - kind+ - spec+ type: objectDashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec:properties:kind:@@ -5494,6 +5519,16 @@ components:- $ref: '#/components/schemas/DashboardtypesBasicVisualization'description: The time range the slices are computed over.type: object+ DashboardtypesPointDiameter:+ maximum: 40+ minimum: 2+ nullable: true+ type: integer+ DashboardtypesPointOpacity:+ maximum: 1+ minimum: 0.1+ nullable: true+ type: numberDashboardtypesPostableDashboardV2:properties:generateName:@@ -5748,6 +5783,161 @@ components:required:- queryValuetype: object+ DashboardtypesScatterPlotAxes:+ properties:+ x:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotAxis'+ description: The axis dimensions.x is plotted along.+ "y":+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotAxis'+ description: The axis dimensions.y is plotted along.+ type: object+ DashboardtypesScatterPlotAxis:+ properties:+ label:+ description: Axis title. Empty draws none; the tooltip still names the column.+ type: string+ scale:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesAxisScale'+ description: auto (default) uses log, or symlog when values include zero+ or negatives, when that spreads the dots clearly more than linear does;+ otherwise linear. log cannot place a value at or below zero and leaves+ that dot out; symlog is log-like but places it.+ softMax:+ description: The highest value the axis always shows; data above it still+ extends the axis, as does a threshold on it. Null fits the data.+ nullable: true+ type: number+ softMin:+ description: The lowest value the axis always shows; data below it still+ extends the axis, as does a threshold on it. Null fits the data. A log+ axis ignores a bound at or below zero.+ nullable: true+ type: number+ type: object+ DashboardtypesScatterPlotChartAppearance:+ properties:+ points:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotPoints'+ description: Dot size and opacity.+ type: object+ DashboardtypesScatterPlotDimensions:+ properties:+ colorBy:+ description: Group-by label names (e.g. k8s.namespace.name) whose combined+ values color the dots and drive the legend. Empty colors by every group-by+ label.+ items:+ type: string+ nullable: true+ type: array+ sizeBy:+ description: Value column key that scales each dot's area between chartAppearance.points.minSize+ and maxSize. Empty draws every dot at chartAppearance.points.size, as+ does a dot with no value.+ type: string+ x:+ description: Value column key (queryName, or queryName.expression for a+ multi-aggregation query) plotted on the x axis. Empty, or a key the result+ lacks, uses the first value column.+ type: string+ "y":+ description: Value column key plotted on the y axis. Empty, or a key the+ result lacks, uses the first value column x does not use.+ type: string+ type: object+ DashboardtypesScatterPlotPanelSpec:+ properties:+ axes:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotAxes'+ description: Title, bounds and scale of each axis.+ chartAppearance:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotChartAppearance'+ description: Dot drawing options.+ dimensions:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesScatterPlotDimensions'+ description: 'Which result columns place, size and color the dots. Each+ dot is one row of the joined scalar result: one group.'+ formatting:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesTableFormatting'+ description: Per-column units and decimal precision. The x and y columns'+ units label their axes; every bound column's unit shows in the tooltip.+ legend:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesLegend'+ description: Legend placement and series colors. A series is one color group,+ labeled by its colorBy values joined with a comma, or All when nothing+ is grouped.+ thresholds:+ description: Reference lines drawn at fixed values across the x or y axis.+ items:+ $ref: '#/components/schemas/DashboardtypesScatterPlotThreshold'+ nullable: true+ type: array+ visualization:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesBasicVisualization'+ description: The time range the groups are computed over.+ type: object+ DashboardtypesScatterPlotPoints:+ properties:+ maxSize:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesPointDiameter'+ description: Diameter of the largest dot when dimensions.sizeBy is set,+ in CSS pixels from 2 to 40. Null means 24.+ minSize:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesPointDiameter'+ description: Diameter of the smallest dot when dimensions.sizeBy is set,+ in CSS pixels from 2 to 40. Null means 4.+ opacity:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesPointOpacity'+ description: Fill opacity of every dot, from 0.1 to 1. Null means 0.7.+ size:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesPointDiameter'+ description: Diameter of every dot when dimensions.sizeBy is unset, in CSS+ pixels from 2 to 40. Null means 6.+ type: object+ DashboardtypesScatterPlotThreshold:+ properties:+ axis:+ allOf:+ - $ref: '#/components/schemas/DashboardtypesThresholdAxis'+ description: 'The axis the line marks: y (default) draws it horizontally,+ x vertically. Unit converts against that axis''s column unit, and the+ axis extends to keep the line in view.'+ color:+ description: 'The CSS color of the line, for example #F1575F, which matches+ the SigNoz red preset; CSS named colors such as red also work.'+ type: string+ label:+ description: The caption shown on the line.+ type: string+ unit:+ description: The unit id of value, such as ms or percent. Empty means the+ panel's unit, or the column's unit for a table threshold. Prefer the panel's+ unit; a different unit works only when it converts to it, such as s against+ a panel in ms.+ type: string+ value:+ description: The value the line is drawn at, in unit.+ format: double+ type: number+ required:+ - value+ - color+ type: objectDashboardtypesSource:enum:- user@@ -5914,6 +6104,11 @@ components:- value- nametype: object+ DashboardtypesThresholdAxis:+ enum:+ - x+ - "y"+ type: stringDashboardtypesThresholdFormat:enum:- textdiff --git a/frontend/__mocks__/uplotMock.ts b/frontend/__mocks__/uplotMock.tsindex e8dde118e9..3fbbc56b6a 100644--- a/frontend/__mocks__/uplotMock.ts+++ b/frontend/__mocks__/uplotMock.ts@@ -57,6 +57,7 @@ const mockPaths = {const mockTzDate = jest.fn((date: Date, _timezone: string) => new Date(date.getTime()),);+const mockOrient = jest.fn();// Mock uPlot constructor - this needs to be a proper constructor functionfunction MockUPlot(@@ -70,6 +71,7 @@ function MockUPlot(// Add static methods to the constructorMockUPlot.tzDate = mockTzDate;MockUPlot.paths = mockPaths;+MockUPlot.orient = mockOrient;// Pinned so canvas-space maths in draw hooks is deterministic under jsdom.MockUPlot.pxRatio = 1;diff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.tsindex 91be92b6b5..d94d6b449b 100644--- a/frontend/src/api/generated/services/sigNoz.schemas.ts+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts@@ -5584,6 +5584,12 @@ export interface DashboardtypesAreaChartPanelSpecDTO {visualization?: DashboardtypesAreaChartVisualizationDTO;}+export enum DashboardtypesAxisScaleDTO {+ auto = 'auto',+ linear = 'linear',+ log = 'log',+ symlog = 'symlog',+}export interface DashboardtypesBarChartVisualizationDTO {/*** @type boolean@@ -6716,6 +6722,205 @@ export interface DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDaspec: DashboardtypesHeatmapPanelSpecDTO;}+/**+ * The panel kind.+ */+export enum DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpecDTOKind {+ 'signoz/ScatterPlotPanel' = 'signoz/ScatterPlotPanel',+}+export interface DashboardtypesScatterPlotAxisDTO {+ /**+ * @type string+ * @description Axis title. Empty draws none; the tooltip still names the column.+ */+ label?: string;+ /**+ * @description auto (default) uses log, or symlog when values include zero or negatives, when that spreads the dots clearly more than linear does; otherwise linear. log cannot place a value at or below zero and leaves that dot out; symlog is log-like but places it.+ */+ scale?: DashboardtypesAxisScaleDTO;+ /**+ * @type number,null+ * @description The highest value the axis always shows; data above it still extends the axis, as does a threshold on it. Null fits the data.+ */+ softMax?: number | null;+ /**+ * @type number,null+ * @description The lowest value the axis always shows; data below it still extends the axis, as does a threshold on it. Null fits the data. A log axis ignores a bound at or below zero.+ */+ softMin?: number | null;+}++export interface DashboardtypesScatterPlotAxesDTO {+ /**+ * @description The axis dimensions.x is plotted along.+ */+ x?: DashboardtypesScatterPlotAxisDTO;+ /**+ * @description The axis dimensions.y is plotted along.+ */+ y?: DashboardtypesScatterPlotAxisDTO;+}++/**+ * @minimum 2+ * @maximum 40+ * @nullable+ */+export type DashboardtypesPointDiameterDTO = number | null;++/**+ * @minimum 0.1+ * @maximum 1+ * @nullable+ */+export type DashboardtypesPointOpacityDTO = number | null;++/**+ * Diameter of the largest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 24.+ */+export type DashboardtypesScatterPlotPointsDTOMaxSize = DashboardtypesPointDiameterDTO | null;++/**+ * Diameter of the smallest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 4.+ */+export type DashboardtypesScatterPlotPointsDTOMinSize = DashboardtypesPointDiameterDTO | null;++/**+ * Fill opacity of every dot, from 0.1 to 1. Null means 0.7.+ */+export type DashboardtypesScatterPlotPointsDTOOpacity = DashboardtypesPointOpacityDTO | null;++/**+ * Diameter of every dot when dimensions.sizeBy is unset, in CSS pixels from 2 to 40. Null means 6.+ */+export type DashboardtypesScatterPlotPointsDTOSize = DashboardtypesPointDiameterDTO | null;++export interface DashboardtypesScatterPlotPointsDTO {+ /**+ * @description Diameter of the largest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 24.+ */+ maxSize?: DashboardtypesScatterPlotPointsDTOMaxSize;+ /**+ * @description Diameter of the smallest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 4.+ */+ minSize?: DashboardtypesScatterPlotPointsDTOMinSize;+ /**+ * @description Fill opacity of every dot, from 0.1 to 1. Null means 0.7.+ */+ opacity?: DashboardtypesScatterPlotPointsDTOOpacity;+ /**+ * @description Diameter of every dot when dimensions.sizeBy is unset, in CSS pixels from 2 to 40. Null means 6.+ */+ size?: DashboardtypesScatterPlotPointsDTOSize;+}++export interface DashboardtypesScatterPlotChartAppearanceDTO {+ /**+ * @description Dot size and opacity.+ */+ points?: DashboardtypesScatterPlotPointsDTO;+}++export interface DashboardtypesScatterPlotDimensionsDTO {+ /**+ * @type array,null+ * @description Group-by label names (e.g. k8s.namespace.name) whose combined values color the dots and drive the legend. Empty colors by every group-by label.+ */+ colorBy?: string[] | null;+ /**+ * @type string+ * @description Value column key that scales each dot's area between chartAppearance.points.minSize and maxSize. Empty draws every dot at chartAppearance.points.size, as does a dot with no value.+ */+ sizeBy?: string;+ /**+ * @type string+ * @description Value column key (queryName, or queryName.expression for a multi-aggregation query) plotted on the x axis. Empty, or a key the result lacks, uses the first value column.+ */+ x?: string;+ /**+ * @type string+ * @description Value column key plotted on the y axis. Empty, or a key the result lacks, uses the first value column x does not use.+ */+ y?: string;+}++export enum DashboardtypesThresholdAxisDTO {+ x = 'x',+ y = 'y',+}+export interface DashboardtypesScatterPlotThresholdDTO {+ /**+ * @description The axis the line marks: y (default) draws it horizontally, x vertically. Unit converts against that axis's column unit, and the axis extends to keep the line in view.+ */+ axis?: DashboardtypesThresholdAxisDTO;+ /**+ * @type string+ * @description The CSS color of the line, for example #F1575F, which matches the SigNoz red preset; CSS named colors such as red also work.+ */+ color: string;+ /**+ * @type string+ * @description The caption shown on the line.+ */+ label?: string;+ /**+ * @type string+ * @description The unit id of value, such as ms or percent. Empty means the panel's unit, or the column's unit for a table threshold. Prefer the panel's unit; a different unit works only when it converts to it, such as s against a panel in ms.+ */+ unit?: string;+ /**+ * @type number+ * @format double+ * @description The value the line is drawn at, in unit.+ */+ value: number;+}++export interface DashboardtypesScatterPlotPanelSpecDTO {+ /**+ * @description Title, bounds and scale of each axis.+ */+ axes?: DashboardtypesScatterPlotAxesDTO;+ /**+ * @description Dot drawing options.+ */+ chartAppearance?: DashboardtypesScatterPlotChartAppearanceDTO;+ /**+ * @description Which result columns place, size and color the dots. Each dot is one row of the joined scalar result: one group.+ */+ dimensions?: DashboardtypesScatterPlotDimensionsDTO;+ /**+ * @description Per-column units and decimal precision. The x and y columns' units label their axes; every bound column's unit shows in the tooltip.+ */+ formatting?: DashboardtypesTableFormattingDTO;+ /**+ * @description Legend placement and series colors. A series is one color group, labeled by its colorBy values joined with a comma, or All when nothing is grouped.+ */+ legend?: DashboardtypesLegendDTO;+ /**+ * @type array,null+ * @description Reference lines drawn at fixed values across the x or y axis.+ */+ thresholds?: DashboardtypesScatterPlotThresholdDTO[] | null;+ /**+ * @description The time range the groups are computed over.+ */+ visualization?: DashboardtypesBasicVisualizationDTO;+}++export interface DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpecDTO {+ /**+ * @enum signoz/ScatterPlotPanel+ * @type string+ * @description The panel kind.+ */+ kind: DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpecDTOKind;+ /**+ * @description The options for this panel kind. {} accepts every default.+ */+ spec: DashboardtypesScatterPlotPanelSpecDTO;+}+export type DashboardtypesPanelPluginDTO =| DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpecDTO| DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpecDTO@@ -6726,7 +6931,8 @@ export type DashboardtypesPanelPluginDTO =| DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpecDTO| DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpecDTO| DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpecDTO- | DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpecDTO;+ | DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpecDTO+ | DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpecDTO;export enum Querybuildertypesv5RequestTypeDTO {scalar = 'scalar',@@ -8006,6 +8212,7 @@ export enum DashboardtypesPanelPluginKindDTO {'signoz/ListPanel' = 'signoz/ListPanel','signoz/TextPanel' = 'signoz/TextPanel','signoz/HeatmapPanel' = 'signoz/HeatmapPanel',+ 'signoz/ScatterPlotPanel' = 'signoz/ScatterPlotPanel',}/*** The RFC 6902 operations, applied in order against the dashboard's postable shape.diff --git a/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.test.ts b/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.test.tsindex 2364bec690..0710e493d9 100644--- a/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.test.ts+++ b/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.test.ts@@ -21,6 +21,7 @@ import { DataSource, ReduceOperators } from 'types/common/queryBuilder';import {convertBuilderQueriesToV5,+ mapPanelTypeToRequestType,prepareQueryRangePayloadV5,} from './prepareQueryRangePayloadV5';@@ -904,6 +905,12 @@ describe('prepareQueryRangePayloadV5', () => {});});+describe('mapPanelTypeToRequestType', () => {+ it('sends a scatter plot as scalar, like a table', () => {+ expect(mapPanelTypeToRequestType(PANEL_TYPES.SCATTER)).toBe('scalar');+ });+});+describe('convertBuilderQueriesToV5 having normalization', () => {const buildSpec = (having: unknown): MetricBuilderQuery => {const [envelope] = convertBuilderQueriesToV5(diff --git a/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.ts b/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.tsindex d606095b48..f00e984902 100644--- a/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.ts+++ b/frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.ts@@ -51,6 +51,7 @@ export function mapPanelTypeToRequestType(panelType: PANEL_TYPES): RequestType {case PANEL_TYPES.BAR:return 'time_series';case PANEL_TYPES.TABLE:+ case PANEL_TYPES.SCATTER:case PANEL_TYPES.PIE:case PANEL_TYPES.VALUE:return 'scalar';@@ -274,6 +275,7 @@ export function createAggregation(queryData.dataSource === DataSource.METRICS &&panelType &&(panelType === PANEL_TYPES.TABLE ||+ panelType === PANEL_TYPES.SCATTER ||panelType === PANEL_TYPES.PIE ||panelType === PANEL_TYPES.VALUE);diff --git a/frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx b/frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsxindex 486fd1488a..5256bcee70 100644--- a/frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx+++ b/frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx@@ -106,9 +106,17 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({[resolvedConfig],);+ const traceOperatorField = useMemo(+ () =>+ resolveQueryBuilderField(QueryBuilderField.TraceOperator, resolvedConfig),+ [resolvedConfig],+ );++ const canShowTraceOperator = showTraceOperator && !traceOperatorField.hidden;+const isMultiQueryAllowed = useMemo(- () => !additionalQueries.hidden && (!isRawQuery || showTraceOperator),- [additionalQueries.hidden, showTraceOperator, isRawQuery],+ () => !additionalQueries.hidden && (!isRawQuery || canShowTraceOperator),+ [additionalQueries.hidden, canShowTraceOperator, isRawQuery],);const queryDataSources = useMemo(@@ -146,13 +154,14 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({);const hasTraceOperator = useMemo(- () => showTraceOperator && hasAtLeastOneTraceQuery && Boolean(traceOperator),- [showTraceOperator, traceOperator, hasAtLeastOneTraceQuery],+ () =>+ canShowTraceOperator && hasAtLeastOneTraceQuery && Boolean(traceOperator),+ [canShowTraceOperator, traceOperator, hasAtLeastOneTraceQuery],);const showQueryList = useMemo(- () => (!showOnlyWhereClause && !isRawQuery) || showTraceOperator,- [isRawQuery, showOnlyWhereClause, showTraceOperator],+ () => (!showOnlyWhereClause && !isRawQuery) || canShowTraceOperator,+ [isRawQuery, showOnlyWhereClause, canShowTraceOperator],);const showFormula = useMemo(() => {@@ -168,8 +177,8 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({}, [formula.hidden, isRawQuery, currentDataSource]);const showAddTraceOperator = useMemo(- () => showTraceOperator && !traceOperator && hasAtLeastOneTraceQuery,- [showTraceOperator, traceOperator, hasAtLeastOneTraceQuery],+ () => canShowTraceOperator && !traceOperator && hasAtLeastOneTraceQuery,+ [canShowTraceOperator, traceOperator, hasAtLeastOneTraceQuery],);// Nothing left to add means no footer at all, rather than an empty bar under the@@ -178,13 +187,13 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({() =>(!additionalQueries.hidden || showFormula || showAddTraceOperator) &&((!showOnlyWhereClause && !isRawQuery) ||- (currentDataSource === DataSource.TRACES && showTraceOperator)),+ (currentDataSource === DataSource.TRACES && canShowTraceOperator)),[additionalQueries.hidden,showFormula,showAddTraceOperator,isRawQuery,- showTraceOperator,+ canShowTraceOperator,showOnlyWhereClause,currentDataSource,],@@ -222,7 +231,7 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({fieldsConfig={fieldsConfig}allowedDataSources={queryDataSources}isMultiQueryAllowed={isMultiQueryAllowed}- showTraceOperator={showTraceOperator}+ showTraceOperator={canShowTraceOperator}hasTraceOperator={hasTraceOperator}version={version}isAvailableToDisable={false}@@ -247,7 +256,7 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({version={version}isMultiQueryAllowed={isMultiQueryAllowed}isAvailableToDisable={false}- showTraceOperator={showTraceOperator}+ showTraceOperator={canShowTraceOperator}hasTraceOperator={hasTraceOperator}queryVariant={config?.queryVariant || 'dropdown'}showOnlyWhereClause={showOnlyWhereClause}diff --git a/frontend/src/components/QueryBuilderV2/QueryV2/QueryAddOns/types.ts b/frontend/src/components/QueryBuilderV2/QueryV2/QueryAddOns/types.tsindex 5ff51e765e..964a3909ed 100644--- a/frontend/src/components/QueryBuilderV2/QueryV2/QueryAddOns/types.ts+++ b/frontend/src/components/QueryBuilderV2/QueryV2/QueryAddOns/types.ts@@ -6,7 +6,8 @@ export type NonAddOnField =| QueryBuilderField.StepInterval| QueryBuilderField.Functions| QueryBuilderField.Formula- | QueryBuilderField.AdditionalQueries;+ | QueryBuilderField.AdditionalQueries+ | QueryBuilderField.TraceOperator;export type AddOnField = Exclude<QueryBuilderField, NonAddOnField>;diff --git a/frontend/src/components/QueryBuilderV2/QueryV2/QueryAggregation/QueryAggregation.tsx b/frontend/src/components/QueryBuilderV2/QueryV2/QueryAggregation/QueryAggregation.tsxindex 63d0577858..23b8710b95 100644--- a/frontend/src/components/QueryBuilderV2/QueryV2/QueryAggregation/QueryAggregation.tsx+++ b/frontend/src/components/QueryBuilderV2/QueryV2/QueryAggregation/QueryAggregation.tsx@@ -18,6 +18,7 @@ import {STEP_INTERVAL_PLACEHOLDER,} from '../../queryBuilderFields.utils';+import { isScalarPanelType } from '../panelTypes';import QueryAggregationSelect from './QueryAggregationSelect';import './QueryAggregation.styles.scss';@@ -45,10 +46,7 @@ function QueryAggregationOptions({const isNonMetricSource =dataSource === DataSource.TRACES || dataSource === DataSource.LOGS;- if (- isNonMetricSource &&- (panelType === PANEL_TYPES.TABLE || panelType === PANEL_TYPES.PIE)- ) {+ if (isNonMetricSource && isScalarPanelType(panelType)) {return { hidden: true, disabled: false, pinned: false };}diff --git a/frontend/src/components/QueryBuilderV2/QueryV2/QueryV2.tsx b/frontend/src/components/QueryBuilderV2/QueryV2/QueryV2.tsxindex 64dfd391f8..0e409914ba 100644--- a/frontend/src/components/QueryBuilderV2/QueryV2/QueryV2.tsx+++ b/frontend/src/components/QueryBuilderV2/QueryV2/QueryV2.tsx@@ -9,7 +9,6 @@ import {import { Dropdown, type DropdownItemType } from '@signozhq/ui/dropdown';import cx from 'classnames';import { ENTITY_VERSION_V4, ENTITY_VERSION_V5 } from 'constants/app';-import { PANEL_TYPES } from 'constants/queryBuilder';import QBEntityOptions from 'container/QueryBuilder/components/QBEntityOptions/QBEntityOptions';import { QueryProps } from 'container/QueryBuilder/type';import SpanScopeSelector from 'container/QueryBuilder/filters/QueryBuilderSearchV2/SpanScopeSelector';@@ -27,6 +26,7 @@ import {resolveQueryBuilderField,} from '../queryBuilderFields.utils';+import { isScalarPanelType } from './panelTypes';import MetricsAggregateSection from './MerticsAggregateSection/MetricsAggregateSection';import { MetricsSelect } from './MetricsSelect/MetricsSelect';import QueryAddOns from './QueryAddOns/QueryAddOns';@@ -112,11 +112,7 @@ export const QueryV2 = forwardRef(function QueryV2(}const showReduceTo = useMemo(- () =>- dataSource === DataSource.METRICS &&- (panelType === PANEL_TYPES.TABLE ||- panelType === PANEL_TYPES.PIE ||- panelType === PANEL_TYPES.VALUE),+ () => dataSource === DataSource.METRICS && isScalarPanelType(panelType),[dataSource, panelType],);diff --git a/frontend/src/components/QueryBuilderV2/QueryV2/panelTypes.ts b/frontend/src/components/QueryBuilderV2/QueryV2/panelTypes.tsnew file mode 100644index 0000000000..ff2d0fcf2b--- /dev/null+++ b/frontend/src/components/QueryBuilderV2/QueryV2/panelTypes.ts@@ -0,0 +1,13 @@+import { PANEL_TYPES } from 'constants/queryBuilder';++/** Panels that reduce each query to one value per group over the whole window. */+const SCALAR_PANEL_TYPES: ReadonlySet<string> = new Set<string>([+ PANEL_TYPES.TABLE,+ PANEL_TYPES.SCATTER,+ PANEL_TYPES.PIE,+ PANEL_TYPES.VALUE,+]);++export function isScalarPanelType(panelType?: string | null): boolean {+ return panelType != null && SCALAR_PANEL_TYPES.has(panelType);+}diff --git a/frontend/src/components/QueryBuilderV2/__tests__/QueryAggregation.test.tsx b/frontend/src/components/QueryBuilderV2/__tests__/QueryAggregation.test.tsxindex e3b7ce5c1e..8e5c9620d1 100644--- a/frontend/src/components/QueryBuilderV2/__tests__/QueryAggregation.test.tsx+++ b/frontend/src/components/QueryBuilderV2/__tests__/QueryAggregation.test.tsx@@ -14,6 +14,17 @@ jest.mock('../QueryV2/QueryAggregation/QueryAggregationSelect', () => ({const queryData = initialQueriesMap.traces.builder.queryData[0] as IBuilderQuery;+function renderFor(panelType: PANEL_TYPES, dataSource: DataSource): void {+ render(+ <QueryAggregationOptions+ dataSource={dataSource}+ panelType={panelType}+ onAggregationIntervalChange={jest.fn()}+ queryData={queryData}+ />,+ );+}+describe('QueryAggregationOptions step interval placeholder', () => {it('shows the configured placeholder', () => {render(@@ -34,14 +45,27 @@ describe('QueryAggregationOptions step interval placeholder', () => {});it('falls back to Auto', () => {- render(- <QueryAggregationOptions- dataSource={DataSource.TRACES}- panelType={PANEL_TYPES.TIME_SERIES}- onAggregationIntervalChange={jest.fn()}- queryData={queryData}- />,- );+ renderFor(PANEL_TYPES.TIME_SERIES, DataSource.TRACES);expect(screen.getByPlaceholderText('Auto')).toBeInTheDocument();});});++describe('QueryAggregationOptions step interval', () => {+ it.each([PANEL_TYPES.TABLE, PANEL_TYPES.SCATTER, PANEL_TYPES.PIE])(+ 'is hidden for a %s panel over traces, which reduces the whole window',+ (panelType) => {+ renderFor(panelType, DataSource.TRACES);+ expect(screen.queryByText('every')).not.toBeInTheDocument();+ },+ );++ it('stays for a scatter plot over metrics, where it sets the series step', () => {+ renderFor(PANEL_TYPES.SCATTER, DataSource.METRICS);+ expect(screen.getByText('every')).toBeInTheDocument();+ });++ it('stays for a time series over traces', () => {+ renderFor(PANEL_TYPES.TIME_SERIES, DataSource.TRACES);+ expect(screen.getByText('every')).toBeInTheDocument();+ });+});diff --git a/frontend/src/components/QueryBuilderV2/queryBuilderFields.types.ts b/frontend/src/components/QueryBuilderV2/queryBuilderFields.types.tsindex 1663fa5324..4dda81479f 100644--- a/frontend/src/components/QueryBuilderV2/queryBuilderFields.types.ts+++ b/frontend/src/components/QueryBuilderV2/queryBuilderFields.types.ts@@ -20,6 +20,7 @@ export enum QueryBuilderField {// Builder levelFormula = 'formula',AdditionalQueries = 'additional_queries',+ TraceOperator = 'trace_operator',}/** Per-query builder fields that can be kept equal across a panel's queries. */diff --git a/frontend/src/components/QueryBuilderV2/queryBuilderFields.utils.ts b/frontend/src/components/QueryBuilderV2/queryBuilderFields.utils.tsindex bb3c75b4f5..1ba84d26af 100644--- a/frontend/src/components/QueryBuilderV2/queryBuilderFields.utils.ts+++ b/frontend/src/components/QueryBuilderV2/queryBuilderFields.utils.ts@@ -65,13 +65,13 @@ export function resolveQueryBuilderFields(/*** The surface a raw-row builder starts from, layered under a caller's own config.- * `AdditionalQueries` is deliberately absent — a raw trace builder still takes several- * queries when trace matching is on. Omit rather than Partial, so a field added to the- * enum has to be placed on one side.+ * `AdditionalQueries` and `TraceOperator` are deliberately absent — a raw trace builder+ * still takes several queries, and their trace operator, when trace matching is on.+ * Omit rather than Partial, so a field added to the enum has to be placed on one side.*/export const RAW_QUERY_FIELDS: Omit<Record<QueryBuilderField, QueryBuilderFieldRule>,- QueryBuilderField.AdditionalQueries+ QueryBuilderField.AdditionalQueries | QueryBuilderField.TraceOperator> = {[QueryBuilderField.Aggregation]: { state: 'hidden' },[QueryBuilderField.StepInterval]: { state: 'hidden' },diff --git a/frontend/src/constants/panelTypes.ts b/frontend/src/constants/panelTypes.tsindex 22a986522a..19845d162b 100644--- a/frontend/src/constants/panelTypes.ts+++ b/frontend/src/constants/panelTypes.ts@@ -36,6 +36,7 @@ export const getComponentForPanelType = ([PANEL_TYPES.HEATMAP]: null,// Dashboards v2 renders this kind; nothing reaches the V1 chart map for it.[PANEL_TYPES.TEXT]: null,+ [PANEL_TYPES.SCATTER]: null,[PANEL_TYPES.EMPTY_WIDGET]: null,};diff --git a/frontend/src/constants/queryBuilder.ts b/frontend/src/constants/queryBuilder.tsindex b80cb05125..f8c2ee2c14 100644--- a/frontend/src/constants/queryBuilder.ts+++ b/frontend/src/constants/queryBuilder.ts@@ -336,6 +336,7 @@ export enum PANEL_TYPES {TRACE = 'trace',BAR = 'bar',AREA = 'area',+ SCATTER = 'scatter',PIE = 'pie',HISTOGRAM = 'histogram',HEATMAP = 'heatmap',diff --git a/frontend/src/container/WidgetCard/Card/FullView/contants.ts b/frontend/src/container/WidgetCard/Card/FullView/contants.tsindex 77e924fa6e..4d00c94a21 100644--- a/frontend/src/container/WidgetCard/Card/FullView/contants.ts+++ b/frontend/src/container/WidgetCard/Card/FullView/contants.ts@@ -28,6 +28,7 @@ export const PANEL_TYPES_VS_FULL_VIEW_TABLE: PanelTypeAndGraphManagerVisibilityPTRACE: false,BAR: true,AREA: true,+ SCATTER: false,PIE: false,HISTOGRAM: false,HEATMAP: false,diff --git a/frontend/src/container/WidgetCard/Panels/constants.ts b/frontend/src/container/WidgetCard/Panels/constants.tsindex 21f5806e27..014472cb83 100644--- a/frontend/src/container/WidgetCard/Panels/constants.ts+++ b/frontend/src/container/WidgetCard/Panels/constants.ts@@ -16,6 +16,7 @@ export const PanelTypeVsPanelWrapper = {[PANEL_TYPES.TRACE]: null,// Dashboards v2 renders this kind; the V1 wrapper map is never asked for it.[PANEL_TYPES.TEXT]: null,+ [PANEL_TYPES.SCATTER]: null,[PANEL_TYPES.EMPTY_WIDGET]: null,[PANEL_TYPES.PIE]: PiePanelWrapper,[PANEL_TYPES.BAR]: BarPanel,diff --git a/frontend/src/lib/query/__tests__/handleQueryChange.test.ts b/frontend/src/lib/query/__tests__/handleQueryChange.test.tsindex 10c79dd586..1795a96615 100644--- a/frontend/src/lib/query/__tests__/handleQueryChange.test.ts+++ b/frontend/src/lib/query/__tests__/handleQueryChange.test.ts@@ -76,3 +76,39 @@ describe('handleQueryChange bucket options', () => {});});});++describe('handleQueryChange trace operator', () => {+ function queryWithTraceOperator(): Query {+ const base = initialQueriesMap[DataSource.TRACES];+ return {+ ...base,+ builder: {+ ...base.builder,+ queryTraceOperator: [+ { ...base.builder.queryData[0], queryName: 'T1', expression: 'A => B' },+ ],+ },+ };+ }++ // The API rejects a trace operator on a scatter plot, so the switch sheds it.+ it('drops the trace operator when switching to a scatter plot', () => {+ const result = handleQueryChange(+ PANEL_TYPES.SCATTER,+ queryWithTraceOperator(),+ PANEL_TYPES.TABLE,+ );++ expect(result.builder.queryTraceOperator).toStrictEqual([]);+ });++ it('keeps the trace operator when switching to a table', () => {+ const result = handleQueryChange(+ PANEL_TYPES.TABLE,+ queryWithTraceOperator(),+ PANEL_TYPES.TIME_SERIES,+ );++ expect(result.builder.queryTraceOperator).toHaveLength(1);+ });+});diff --git a/frontend/src/lib/query/panelQuery.ts b/frontend/src/lib/query/panelQuery.tsindex 6e8a0bd7de..b1c79f6dbc 100644--- a/frontend/src/lib/query/panelQuery.ts+++ b/frontend/src/lib/query/panelQuery.ts@@ -165,7 +165,7 @@ export function handleQueryChange(newPanelType,),queryTraceOperator:- newPanelType === PANEL_TYPES.LIST+ newPanelType === PANEL_TYPES.LIST || newPanelType === PANEL_TYPES.SCATTER? []: supersetQuery.builder.queryTraceOperator,},diff --git a/frontend/src/lib/query/panelTypeDataSourceFormValuesMap.ts b/frontend/src/lib/query/panelTypeDataSourceFormValuesMap.tsindex 0519f816fd..44ab21fac1 100644--- a/frontend/src/lib/query/panelTypeDataSourceFormValuesMap.ts+++ b/frontend/src/lib/query/panelTypeDataSourceFormValuesMap.ts@@ -14,6 +14,7 @@ export type PartialPanelTypes = {[PANEL_TYPES.AREA]: 'area';[PANEL_TYPES.VALUE]: 'value';[PANEL_TYPES.PIE]: 'pie';+ [PANEL_TYPES.SCATTER]: 'scatter';[PANEL_TYPES.HISTOGRAM]: 'histogram';[PANEL_TYPES.HEATMAP]: 'heatmap';};@@ -150,6 +151,7 @@ export const panelTypeDataSourceFormValuesMap: Record<[PANEL_TYPES.HEATMAP]: bySource(HEATMAP, HEATMAP_METRICS),[PANEL_TYPES.TABLE]: bySource(SERIES, SCALAR_METRICS),[PANEL_TYPES.PIE]: bySource(SERIES, SCALAR_METRICS),+ [PANEL_TYPES.SCATTER]: bySource(SERIES, SCALAR_METRICS),[PANEL_TYPES.VALUE]: bySource(SINGLE_VALUE, SINGLE_VALUE_METRICS),[PANEL_TYPES.LIST]: bySource(RAW_ROWS, RAW_ROWS_METRICS),};diff --git a/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.module.scss b/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.module.scssnew file mode 100644index 0000000000..381ddd1c70--- /dev/null+++ b/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.module.scss@@ -0,0 +1,94 @@+// Sections own the padding so the footer spans edge to edge.+.container {+ // Same inset as the heatmap tooltip.+ --gutter: 14px;++ font-family: 'Inter';+ font-size: 12px;+ background: var(--l2-background);+ -webkit-font-smoothing: antialiased;+ color: var(--l2-foreground);+ border-radius: 6px;+ border: 1px solid var(--l2-border);+ display: flex;+ flex-direction: column;+ min-width: 220px;++ &.pinned {+ border-color: var(--ring);+ }+}++.divider {+ display: block;+ width: 100%;+ height: 1px;+ background-color: var(--l2-border);+}++.header {+ display: flex;+ align-items: center;+ gap: var(--spacing-3);+ padding: var(--spacing-6) var(--gutter);+}++// Matches the legend row's marker.+.marker {+ box-sizing: border-box;+ width: 12px;+ height: 12px;+ border: 1.5px solid;+ border-radius: var(--radius);+ flex-shrink: 0;+}++.title {+ flex: 1;+ min-width: 0;+ font-family: var(--font-mono);+ font-size: var(--font-size-xs);+ font-weight: 600;+ color: var(--text-vanilla-100);+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+}++.rows {+ display: flex;+ flex-direction: column;+ gap: var(--spacing-2);+ padding: var(--spacing-5) var(--gutter);+}++.row {+ display: flex;+ align-items: baseline;+ justify-content: space-between;+ gap: var(--spacing-4);+ font-family: var(--font-mono);+ font-size: var(--font-size-xs);+ font-variant-numeric: tabular-nums;+ color: var(--text-vanilla-100);+}++.rowMuted {+ color: var(--text-vanilla-400);+}++.rowLabel {+ flex: 1;+ min-width: 0;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+}++.rowValue {+ flex: 0 0 auto;+ max-width: 60%;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+}diff --git a/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.tsx b/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.tsxnew file mode 100644index 0000000000..6eeb76a4e7--- /dev/null+++ b/frontend/src/lib/uPlotV2/components/Tooltip/ScatterTooltip.tsx@@ -0,0 +1,139 @@+import { useMemo } from 'react';+import cx from 'classnames';+import { Pin } from '@signozhq/icons';+import { Button } from '@signozhq/ui/button';+import { Typography } from '@signozhq/ui/typography';++import { ScatterTooltipProps } from '../types';+import { buildChannelRows, resolveHoveredPoint } from './scatterTooltipContent';++import Styles from './ScatterTooltip.module.scss';++/** Own component: the shared Tooltip lists one row per series at a shared x. */+export default function ScatterTooltip({+ uPlotInstance,+ dataIndexes,+ seriesIndex,+ channels,+ resolvePointGroupValues,+ decimalPrecision,+ isPinned,+ dismiss,+ renderTooltipFooter,+}: ScatterTooltipProps): JSX.Element | null {+ const hoveredPoint = useMemo(+ () => resolveHoveredPoint(uPlotInstance, seriesIndex, dataIndexes),+ [uPlotInstance, seriesIndex, dataIndexes],+ );++ const rows = useMemo(+ () =>+ hoveredPoint+ ? buildChannelRows(hoveredPoint, channels, decimalPrecision)+ : [],+ [hoveredPoint, channels, decimalPrecision],+ );++ const labels = useMemo(+ () =>+ hoveredPoint+ ? (resolvePointGroupValues?.(+ hoveredPoint.seriesIndex,+ hoveredPoint.dataIndex,+ ) ?? [])+ : [],+ [hoveredPoint, resolvePointGroupValues],+ );++ if (!hoveredPoint) {+ return null;+ }++ return (+ <div+ className={cx(Styles.container, { [Styles.pinned]: isPinned })}+ data-pinned={isPinned}+ data-testid="scatter-tooltip"+ >+ <div className={Styles.header}>+ <span+ className={Styles.marker}+ style={{+ backgroundColor: hoveredPoint.color,+ borderColor: hoveredPoint.color,+ }}+ />+ <Typography.Text+ as="span"+ className={Styles.title}+ title={hoveredPoint.label}+ testId="scatter-tooltip-title"+ >+ {hoveredPoint.label}+ </Typography.Text>+ {isPinned && (+ <Button+ variant="ghost"+ color="secondary"+ size="sm"+ prefix={<Pin size={12} />}+ testId="scatter-tooltip-status"+ >+ Pinned+ </Button>+ )}+ </div>++ <span className={Styles.divider} />++ <div className={Styles.rows}>+ {rows.map((row) => (+ <div+ key={row.label}+ className={Styles.row}+ data-testid="scatter-tooltip-row"+ >+ <Typography.Text as="span" className={Styles.rowLabel}>+ {row.label}+ </Typography.Text>+ <Typography.Text as="span" className={Styles.rowValue}>+ {row.value}+ </Typography.Text>+ </div>+ ))}+ </div>++ {labels.length > 0 && (+ <>+ <span className={Styles.divider} />+ <div className={Styles.rows}>+ {labels.map((label) => (+ <div+ key={label.key}+ className={cx(Styles.row, Styles.rowMuted)}+ data-testid="scatter-tooltip-label"+ >+ <Typography.Text+ as="span"+ className={Styles.rowLabel}+ title={label.key}+ >+ {label.key}+ </Typography.Text>+ <Typography.Text+ as="span"+ className={Styles.rowValue}+ title={label.value}+ >+ {label.value}+ </Typography.Text>+ </div>+ ))}+ </div>+ </>+ )}++ {renderTooltipFooter?.({ isPinned, dismiss })}+ </div>+ );+}diff --git a/frontend/src/lib/uPlotV2/components/Tooltip/__tests__/scatterTooltipContent.test.ts b/frontend/src/lib/uPlotV2/components/Tooltip/__tests__/scatterTooltipContent.test.tsnew file mode 100644index 0000000000..23a32237ee--- /dev/null+++ b/frontend/src/lib/uPlotV2/components/Tooltip/__tests__/scatterTooltipContent.test.ts@@ -0,0 +1,107 @@+import type uPlot from 'uplot';++import {+ buildChannelRows,+ resolveHoveredPoint,+ ScatterHoveredPoint,+} from '../scatterTooltipContent';++jest.mock('components/Graph/yAxisConfig', () => ({+ getToolTipValue: jest.fn((value: number | string, unit?: string) =>+ `${value} ${unit ?? ''}`.trim(),+ ),+}));++const plot = {+ data: [+ null,+ [+ [10, 20],+ [100, 200],+ [5, null],+ ],+ [[30], [300]],+ ],+ series: [+ {},+ { label: 'cart', stroke: '#ff0000' },+ { label: 'checkout', stroke: (): string => '#00ff00' },+ ],+} as unknown as uPlot;++describe('resolveHoveredPoint', () => {+ it('reads the focused series at its own data index', () => {+ expect(resolveHoveredPoint(plot, 1, [null, 1, null])).toStrictEqual({+ seriesIndex: 1,+ dataIndex: 1,+ label: 'cart',+ color: '#ff0000',+ x: 20,+ y: 200,+ size: null,+ });+ });++ it('carries the size column when present and resolves function strokes', () => {+ expect(resolveHoveredPoint(plot, 1, [null, 0, null])?.size).toBe(5);+ expect(resolveHoveredPoint(plot, 2, [null, null, 0])).toMatchObject({+ label: 'checkout',+ color: '#00ff00',+ size: null,+ });+ });++ it('is null without a focused series or an index for it', () => {+ expect(resolveHoveredPoint(plot, null, [null, 0, null])).toBeNull();+ expect(resolveHoveredPoint(plot, 0, [0, 0, null])).toBeNull();+ expect(resolveHoveredPoint(plot, 1, [null, null, null])).toBeNull();+ });+});++describe('buildChannelRows', () => {+ const point: ScatterHoveredPoint = {+ seriesIndex: 1,+ dataIndex: 0,+ label: 'cart',+ color: '#f00',+ x: 12,+ y: 340,+ size: 7,+ };++ it('formats x and y with their own units', () => {+ const rows = buildChannelRows(point, {+ x: { label: 'Throughput', unit: 'reqps' },+ y: { label: 'p99', unit: 'ms' },+ });++ expect(rows).toStrictEqual([+ { label: 'Throughput', value: '12 reqps' },+ { label: 'p99', value: '340 ms' },+ ]);+ });++ it('adds the size row only when the channel is mapped and the point has one', () => {+ const channels = {+ x: { label: 'x' },+ y: { label: 'y' },+ size: { label: 'Errors' },+ };++ expect(buildChannelRows(point, channels)).toHaveLength(3);+ expect(buildChannelRows({ ...point, size: null }, channels)).toHaveLength(2);+ });++ it('leaves out a size row that repeats the x row', () => {+ const rows = buildChannelRows(+ { ...point, size: point.x },+ {+ x: { label: 'A.count()' },+ y: { label: 'p99' },+ size: { label: 'A.count()' },+ },+ );++ expect(rows.map((row) => row.label)).toStrictEqual(['A.count()', 'p99']);+ });+});diff --git a/frontend/src/lib/uPlotV2/components/Tooltip/scatterTooltipContent.ts b/frontend/src/lib/uPlotV2/components/Tooltip/scatterTooltipContent.tsnew file mode 100644index 0000000000..26afcf40a3--- /dev/null+++ b/frontend/src/lib/uPlotV2/components/Tooltip/scatterTooltipContent.ts@@ -0,0 +1,97 @@+import { PrecisionOption } from 'components/Graph/types';+import { getToolTipValue } from 'components/Graph/yAxisConfig';+import type uPlot from 'uplot';++import type {+ ScatterChannel,+ ScatterChannels,+ ScatterSeriesData,+} from '../../plugins/ScatterPlugin/types';+import { resolveSeriesColor } from './utils';++export interface ScatterHoveredPoint {+ seriesIndex: number;+ dataIndex: number;+ label: string;+ color: string;+ x: number;+ y: number;+ size: number | null;+}++export interface ScatterTooltipRow {+ label: string;+ value: string;+}++export function resolveHoveredPoint(+ u: uPlot,+ seriesIndex: number | null,+ dataIndexes: Array<number | null>,+): ScatterHoveredPoint | null {+ if (seriesIndex == null || seriesIndex < 1) {+ return null;+ }+ const dataIndex = dataIndexes[seriesIndex];+ const series = u.series[seriesIndex];+ const columns = u.data[seriesIndex] as unknown as+ | ScatterSeriesData+ | undefined;+ if (dataIndex == null || !series || !columns) {+ return null;+ }+ const x = columns[0][dataIndex];+ const y = columns[1][dataIndex];+ if (x == null || y == null) {+ return null;+ }+ return {+ seriesIndex,+ dataIndex,+ label: String(series.label ?? ''),+ color: resolveSeriesColor(series.stroke, u, seriesIndex),+ x,+ y,+ size: columns[2]?.[dataIndex] ?? null,+ };+}++function formatChannel(+ value: number,+ channel: ScatterChannel,+ decimalPrecision?: PrecisionOption,+): string {+ return getToolTipValue(value, channel.unit, decimalPrecision);+}++export function buildChannelRows(+ point: ScatterHoveredPoint,+ channels: ScatterChannels,+ decimalPrecision?: PrecisionOption,+): ScatterTooltipRow[] {+ const rows: ScatterTooltipRow[] = [+ {+ label: channels.x.label,+ value: formatChannel(point.x, channels.x, decimalPrecision),+ },+ {+ label: channels.y.label,+ value: formatChannel(point.y, channels.y, decimalPrecision),+ },+ ];+ if (channels.size && point.size != null) {+ const sizeRow = {+ label: channels.size.label,+ value: formatChannel(point.size, channels.size, decimalPrecision),+ };+ // Size bound to the X or Y column would only repeat that row.+ if (+ !rows.some(+ (row) => row.label === sizeRow.label && row.value === sizeRow.value,+ )+ ) {+ rows.push(sizeRow);+ }+ }+ return rows;+}diff --git a/frontend/src/lib/uPlotV2/components/types.ts b/frontend/src/lib/uPlotV2/components/types.tsindex 2829c977ad..61d29291f0 100644--- a/frontend/src/lib/uPlotV2/components/types.ts+++ b/frontend/src/lib/uPlotV2/components/types.ts@@ -6,6 +6,10 @@ import uPlot from 'uplot';import { UPlotConfigBuilder } from '../config/UPlotConfigBuilder';import { LegendItem } from '../config/types';import { HeatmapSeries, HeatmapYAxis } from '../plugins/HeatmapPlugin/types';+import type {+ ScatterChannels,+ ScatterPointLabel,+} from '../plugins/ScatterPlugin/types';import { SyncTooltipFilterMode } from '../plugins/TooltipPlugin/types';/**@@ -119,6 +123,16 @@ export interface HeatmapTooltipPropsgroupColor: string;}+export interface ScatterTooltipProps+ extends BaseTooltipProps, TooltipRenderArgs {+ channels: ScatterChannels;+ /** The group values behind a point, e.g. `service.name` → `cart`. */+ resolvePointGroupValues?: (+ seriesIndex: number,+ dataIndex: number,+ ) => ScatterPointLabel[];+}+export type TooltipProps =| TimeSeriesTooltipProps| BarTooltipPropsdiff --git a/frontend/src/lib/uPlotV2/config/UPlotAxisBuilder.ts b/frontend/src/lib/uPlotV2/config/UPlotAxisBuilder.tsindex 047ed63187..4de8735082 100644--- a/frontend/src/lib/uPlotV2/config/UPlotAxisBuilder.ts+++ b/frontend/src/lib/uPlotV2/config/UPlotAxisBuilder.ts@@ -39,6 +39,16 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {};}+ /** Styled like the grid. */+ private buildBorderConfig(+ grid: uPlot.Axis.Grid | undefined,+ ): uPlot.Axis.Border | undefined {+ if (this.props.showBorder === false || !grid || grid.show === false) {+ return undefined;+ }+ return { show: true, stroke: grid.stroke, width: grid.width };+ }+/*** Build ticks configuration*/@@ -59,31 +69,47 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {/*** Build values formatter for X-axis (time)+ * A non-time x axis with a unit or precision formats like a value axis.*/private buildXAxisValuesFormatter(): uPlot.Axis.Values | undefined {- const { isTimeAxis } = this.props;+ const { isTimeAxis, yAxisUnit, decimalPrecision } = this.props;if (isTimeAxis) {return uPlotXAxisValuesFormat as uPlot.Axis.Values;}+ if (yAxisUnit !== undefined || decimalPrecision !== undefined) {+ return this.buildValueAxisFormatter();+ }+return undefined;}/*** Build values formatter for Y-axis (values with units)+ * Blanks splits outside the scale; uPlot's asinh splits always include ±threshold.*/- private buildYAxisValuesFormatter(): uPlot.Axis.Values {- const { yAxisUnit, decimalPrecision } = this.props;-- return (_, t): string[] =>- t.map((v) => {- if (v === null || v === undefined || Number.isNaN(v)) {+ private buildValueAxisFormatter(): uPlot.Axis.Values {+ const { yAxisUnit, decimalPrecision, scaleKey } = this.props;++ return (u, t): string[] => {+ const scale = u?.scales?.[scaleKey];+ const min = scale?.min ?? -Infinity;+ const max = scale?.max ?? Infinity;+ return t.map((v) => {+ if (+ v === null ||+ v === undefined ||+ Number.isNaN(v) ||+ v < min ||+ v > max+ ) {return '';}const value = getToolTipValue(v.toString(), yAxisUnit, decimalPrecision);return `${value}`;});+ };}/**@@ -101,7 +127,7 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {return scaleKey === 'x'? this.buildXAxisValuesFormatter(): scaleKey === 'y'- ? this.buildYAxisValuesFormatter()+ ? this.buildValueAxisFormatter(): undefined;}@@ -149,10 +175,12 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {side = 2, // bottom by defaultspace,splits,+ filter,gap = 5, // default gap is 5} = this.props;const grid = this.buildGridConfig();+ const border = this.buildBorderConfig(grid);const ticks = this.buildTicksConfig();const values = this.buildValuesFormatter();const size = this.buildSizeCalculator();@@ -177,6 +205,9 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {if (ticks) {axisConfig.ticks = ticks;}+ if (border) {+ axisConfig.border = border;+ }if (values) {axisConfig.values = values;}@@ -189,6 +220,9 @@ export class UPlotAxisBuilder extends ConfigBuilder<AxisProps, Axis> {if (space !== undefined) {axisConfig.space = space;}+ if (filter) {+ axisConfig.filter = filter;+ }if (size) {axisConfig.size = size;}diff --git a/frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts b/frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.tsindex 30d3d18cea..e4a40fa787 100644--- a/frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts+++ b/frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts@@ -20,6 +20,7 @@ import {ConfigBuilder,ConfigBuilderProps,LegendItem,+ PlotMode,SelectionPreferencesSource,StackMode,} from './types';@@ -66,6 +67,8 @@ export class UPlotConfigBuilder extends ConfigBuilder<private stackMode: StackMode = StackMode.None;+ private mode: PlotMode = PlotMode.Aligned;+private cursor: Cursor | undefined;private hooks: Hooks.Arrays = {};@@ -163,6 +166,10 @@ export class UPlotConfigBuilder extends ConfigBuilder<return this.stackMode;}+ setMode(mode: PlotMode): void {+ this.mode = mode;+ }+/*** Add or merge a scale configuration*/@@ -519,6 +526,10 @@ export class UPlotConfigBuilder extends ConfigBuilder<{} as Record<string, uPlot.Scale>,);+ if (this.mode === PlotMode.Faceted) {+ config.mode = this.mode as number as uPlot.Mode;+ }+config.hooks = this.hooks;config.select = this.select;diff --git a/frontend/src/lib/uPlotV2/config/UPlotScaleBuilder.ts b/frontend/src/lib/uPlotV2/config/UPlotScaleBuilder.tsindex d42d15f20b..bca0dfa49c 100644--- a/frontend/src/lib/uPlotV2/config/UPlotScaleBuilder.ts+++ b/frontend/src/lib/uPlotV2/config/UPlotScaleBuilder.ts@@ -40,6 +40,7 @@ export class UPlotScaleBuilder extends ConfigBuilder<range,thresholds,logBase = 10,+ asinhThreshold,padMinBy = 0,padMaxBy = 0.05,} = this.props;@@ -99,6 +100,7 @@ export class UPlotScaleBuilder extends ConfigBuilder<time,distr,logBase,+ asinhThreshold,});const { rangeConfig, hardMinOnly, hardMaxOnly, hasFixedRange } =diff --git a/frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts b/frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.tsindex 1443e4f28f..4be6b89694 100644--- a/frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts+++ b/frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts@@ -88,6 +88,8 @@ export class UPlotSeriesBuilder extends ConfigBuilder<lineConfig.fill = finalFillColor;} else if (this.props.drawStyle === DrawStyle.Histogram) {lineConfig.fill = `${finalFillColor}40`;+ } else if (this.props.drawStyle === DrawStyle.Scatter) {+ lineConfig.fill = `${finalFillColor}${toAlphaHex(resolveFillOpacity(fillOpacity))}`;} else if (fillMode && fillMode !== FillMode.None) {const resolvedOpacity = resolveFillOpacity(fillOpacity);if (fillMode === FillMode.Solid) {@@ -123,7 +125,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<return { paths: pathBuilder };}- if (drawStyle === DrawStyle.Points) {+ if (isMarkerOnlyDrawStyle(drawStyle)) {return { paths: (): null => null };}@@ -195,6 +197,10 @@ export class UPlotSeriesBuilder extends ConfigBuilder<if (drawStyle === DrawStyle.Points) {return true;}+ // The discs are the series path; uPlot's own points would double-draw them.+ if (drawStyle === DrawStyle.Scatter) {+ return false;+ }return !!showPoints;}@@ -226,6 +232,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<show = true,metric,partialTimestamps,+ facets,} = this.props;const resolvedLineColor = this.getLineColor();@@ -255,6 +262,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<points: Object.keys(pointsConfig).length > 0 ? pointsConfig : undefined,metric,...(partialTimestamps?.size ? { partialTimestamps } : {}),+ ...(facets && { facets }),};}}@@ -267,6 +275,11 @@ interface PathBuilders {[key: string]: Series.PathBuilder;}+/** Draws standalone markers, never a connecting line. */+function isMarkerOnlyDrawStyle(drawStyle: DrawStyle): boolean {+ return drawStyle === DrawStyle.Points || drawStyle === DrawStyle.Scatter;+}+/*** Get path builder based on draw style and interpolation*/diff --git a/frontend/src/lib/uPlotV2/config/__tests__/UPlotAxisBuilder.test.ts b/frontend/src/lib/uPlotV2/config/__tests__/UPlotAxisBuilder.test.tsindex 3db4d075d1..f6506f8759 100644--- a/frontend/src/lib/uPlotV2/config/__tests__/UPlotAxisBuilder.test.ts+++ b/frontend/src/lib/uPlotV2/config/__tests__/UPlotAxisBuilder.test.ts@@ -120,6 +120,41 @@ describe('UPlotAxisBuilder', () => {});});+ it('draws the axis line by default, styled like the grid', () => {+ const config = new UPlotAxisBuilder(+ createAxisProps({ isDarkMode: true, grid: { width: 0.5 } }),+ ).getConfig();++ expect(config.border).toStrictEqual({+ show: true,+ stroke: config.grid?.stroke,+ width: 0.5,+ });+ });++ it('leaves the axis line off when showBorder is false', () => {+ expect(+ new UPlotAxisBuilder(createAxisProps({ showBorder: false })).getConfig(),+ ).not.toHaveProperty('border');+ });++ it('leaves the axis line off when the grid is hidden', () => {+ expect(+ new UPlotAxisBuilder(createAxisProps({ grid: { show: false } })).getConfig(),+ ).not.toHaveProperty('border');+ });++ it('passes explicit splits and a label filter through to uPlot', () => {+ const splits = jest.fn();+ const filter = jest.fn();+ const config = new UPlotAxisBuilder(+ createAxisProps({ splits, filter }),+ ).getConfig();++ expect(config.splits).toBe(splits);+ expect(config.filter).toBe(filter);+ });+it('uses provided ticks config when present and falls back to defaults otherwise', () => {const customTicks = { width: 1, show: false };const withTicks = new UPlotAxisBuilder(@@ -376,3 +411,51 @@ describe('UPlotAxisBuilder', () => {expect(config.values).toBeDefined();});});++describe('UPlotAxisBuilder value x axis', () => {+ it('formats a non-time x axis with its unit', () => {+ (getToolTipValue as jest.Mock).mockReturnValue('1.2K req/s');+ const config = new UPlotAxisBuilder(+ createAxisProps({ scaleKey: 'x', isTimeAxis: false, yAxisUnit: 'reqps' }),+ ).getConfig();++ const values = (config.values as uPlot.Axis.DynamicValues)(+ {} as uPlot,+ [1200],+ 0,+ 0,+ 0,+ );++ expect(values).toStrictEqual(['1.2K req/s']);+ expect(getToolTipValue).toHaveBeenCalledWith('1200', 'reqps', undefined);+ });++ it('leaves a non-time x axis to uPlot when nothing says how to format it', () => {+ const config = new UPlotAxisBuilder(+ createAxisProps({ scaleKey: 'x', isTimeAxis: false }),+ ).getConfig();++ expect(config.values).toBeUndefined();+ });+});++describe('UPlotAxisBuilder out-of-range splits', () => {+ it('leaves a split the scale cannot place unlabelled', () => {+ (getToolTipValue as jest.Mock).mockImplementation((v: string) => `${v} ms`);+ const config = new UPlotAxisBuilder(+ createAxisProps({ scaleKey: 'y', yAxisUnit: 'ms' }),+ ).getConfig();+ const u = { scales: { y: { min: 0, max: 1000 } } } as unknown as uPlot;++ const values = (config.values as uPlot.Axis.DynamicValues)(+ u,+ [-10, 0, 500, 5000],+ 0,+ 0,+ 0,+ );++ expect(values).toStrictEqual(['', '0 ms', '500 ms', '']);+ });+});diff --git a/frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.ts b/frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.tsindex ebaecb1ff0..6de727e2ad 100644--- a/frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.ts+++ b/frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.ts@@ -5,7 +5,12 @@ import {STEP_INTERVAL_MULTIPLIER,} from '../../constants';import type { SeriesProps } from '../types';-import { DrawStyle, SelectionPreferencesSource, StackMode } from '../types';+import {+ DrawStyle,+ PlotMode,+ SelectionPreferencesSource,+ StackMode,+} from '../types';import { UPlotConfigBuilder } from '../UPlotConfigBuilder';// Mock only the real boundary that hits localStorage@@ -667,3 +672,14 @@ describe('UPlotConfigBuilder stacking', () => {expect(builder.getConfig().hooks?.draw).toHaveLength(1);});});++describe('UPlotConfigBuilder plot mode', () => {+ it('leaves mode unset for aligned data and emits 2 when faceted', () => {+ const aligned = new UPlotConfigBuilder({ id: 'aligned' });+ expect(aligned.getConfig().mode).toBeUndefined();++ const faceted = new UPlotConfigBuilder({ id: 'faceted' });+ faceted.setMode(PlotMode.Faceted);+ expect(faceted.getConfig().mode).toBe(2);+ });+});diff --git a/frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts b/frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.tsindex 54577d4da5..440ce66ce7 100644--- a/frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts+++ b/frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts@@ -425,3 +425,39 @@ describe('UPlotSeriesBuilder', () => {);});});++describe('UPlotSeriesBuilder scatter', () => {+ it('draws through the given path builder and hides uPlot points', () => {+ const pathBuilder = jest.fn();+ const config = new UPlotSeriesBuilder(+ createBaseProps({+ drawStyle: DrawStyle.Scatter,+ pathBuilder,+ facets: [{ scale: 'x' }, { scale: 'y' }],+ lineColor: '#ff0000',+ fillOpacity: 0.5,+ lineWidth: 1,+ pointSize: 8,+ }),+ ).getConfig();++ expect(config.paths).toBe(pathBuilder);+ expect(config.facets).toStrictEqual([{ scale: 'x' }, { scale: 'y' }]);+ expect(config.points?.show).toBe(false);+ expect(config.points?.size).toBe(8);+ expect(config.stroke).toBe('#ff0000');+ expect(config.width).toBe(1);+ expect(config.fill).toBe('#ff000080');+ });++ it('draws nothing without a path builder', () => {+ const config = new UPlotSeriesBuilder(+ createBaseProps({ drawStyle: DrawStyle.Scatter }),+ ).getConfig();++ expect(+ (config.paths as uPlot.Series.PathBuilder)({} as uPlot, 1, 0, 0),+ ).toBeNull();+ expect(config.facets).toBeUndefined();+ });+});diff --git a/frontend/src/lib/uPlotV2/config/types.ts b/frontend/src/lib/uPlotV2/config/types.tsindex cbb8f0ea67..afe5037ecf 100644--- a/frontend/src/lib/uPlotV2/config/types.ts+++ b/frontend/src/lib/uPlotV2/config/types.ts@@ -80,6 +80,10 @@ export interface AxisProps {values?: uPlot.Axis.Values;/** Explicit axis splits, overriding the default tick calculation. */splits?: uPlot.Axis.Splits;+ /** Which splits get a label, replacing uPlot's per-distribution default. */+ filter?: uPlot.Axis.Filter;+ /** Draw the axis line along the plot edge, styled like the grid. Default true. */+ showBorder?: boolean;/** Pixels between the ticks and their labels; also feeds the y axis width calculation. */gap?: number;/** Explicit axis thickness. Left unset, the y axis sizes itself to its widest label. */@@ -90,7 +94,7 @@ export interface AxisProps {isDarkMode?: boolean;/** Axis is on a log scale — thins the grid lines to keep dense decades readable. */isLogScale?: boolean;- /** Unit the y axis ticks are formatted in (`spec.formatting.unit`). */+ /** Unit the y axis ticks are formatted in (`spec.formatting.unit`); a non-time x axis reads it too. */yAxisUnit?: string;/*** X axis carries timestamps, so its ticks format as dates/times. Declared by the caller@@ -109,6 +113,13 @@ export interface AxisProps {export enum DistributionType {Linear = 'linear',Logarithmic = 'logarithmic',+ /** arcsinh: linear within ±`asinhThreshold`, log beyond; places zero and negatives. */+ SymmetricLog = 'symlog',+}++export enum PlotMode {+ Aligned = 1,+ Faceted = 2,}export interface ScaleProps {@@ -125,6 +136,8 @@ export interface ScaleProps {auto?: boolean;logBase?: uPlot.Scale.LogBase;distribution?: DistributionType;+ /** Half-width of a `SymmetricLog` scale's linear band around zero. Default 1. */+ asinhThreshold?: number;}export enum DisconnectedValuesMode {@@ -146,6 +159,7 @@ export enum DrawStyle {Points = 'points',Bar = 'bar',Histogram = 'histogram',+ Scatter = 'scatter',}export enum LineInterpolation {@@ -232,6 +246,8 @@ export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {metric?: { [key: string]: string };/** Epoch-second x values whose bucket doesn't cover a full step; marked with a dotted ring. */partialTimestamps?: Set<number>;+ /** Mode 2 only: the scales the series' own x and y columns are read against. */+ facets?: Series.Facet[];}export interface LegendItem {diff --git a/frontend/src/lib/uPlotV2/hooks/__tests__/useThresholdsDrawHook.test.ts b/frontend/src/lib/uPlotV2/hooks/__tests__/useThresholdsDrawHook.test.tsnew file mode 100644index 0000000000..8a286f19c9--- /dev/null+++ b/frontend/src/lib/uPlotV2/hooks/__tests__/useThresholdsDrawHook.test.ts@@ -0,0 +1,56 @@+import type uPlot from 'uplot';++import { thresholdsDrawHook } from '../useThresholdsDrawHook';++function mockPlot(ori: 0 | 1): { plot: uPlot; ctx: Record<string, jest.Mock> } {+ const ctx = {+ save: jest.fn(),+ restore: jest.fn(),+ setLineDash: jest.fn(),+ beginPath: jest.fn(),+ moveTo: jest.fn(),+ lineTo: jest.fn(),+ stroke: jest.fn(),+ fillText: jest.fn(),+ measureText: jest.fn(() => ({ width: 40 })),+ };+ const plot = {+ ctx: { ...ctx, canvas: { height: 300 } },+ bbox: { left: 10, top: 20, width: 400, height: 200 },+ scales: { s: { ori } },+ valToPos: (): number => 100,+ } as unknown as uPlot;+ return { plot, ctx };+}++const draw = (plot: uPlot): void =>+ (+ thresholdsDrawHook({+ scaleKey: 's',+ thresholds: [{ thresholdValue: 5, thresholdLabel: 'SLO' }],+ }) as (u: uPlot) => void+ )(plot);++describe('thresholdsDrawHook', () => {+ it('draws a horizontal line across a vertical scale', () => {+ const { plot, ctx } = mockPlot(1);+ draw(plot);++ expect(ctx.moveTo).toHaveBeenCalledWith(10, 100);+ expect(ctx.lineTo).toHaveBeenCalledWith(410, 100);+ expect(ctx.fillText).toHaveBeenCalledWith('SLO', 350, 85);+ });++ it('draws a vertical line across a horizontal scale', () => {+ const { plot, ctx } = mockPlot(0);+ draw(plot);++ expect(ctx.moveTo).toHaveBeenCalledWith(100, 20);+ expect(ctx.lineTo).toHaveBeenCalledWith(100, 220);+ expect(ctx.fillText).toHaveBeenCalledWith(+ 'SLO',+ expect.any(Number),+ expect.any(Number),+ );+ });+});diff --git a/frontend/src/lib/uPlotV2/hooks/useThresholdsDrawHook.ts b/frontend/src/lib/uPlotV2/hooks/useThresholdsDrawHook.tsindex 5e641eca75..472a57861c 100644--- a/frontend/src/lib/uPlotV2/hooks/useThresholdsDrawHook.ts+++ b/frontend/src/lib/uPlotV2/hooks/useThresholdsDrawHook.ts@@ -29,13 +29,42 @@ export function thresholdsDrawHook(const scaleVal = u.valToPos(Number(yValue), scaleKey, true);+ ctx.strokeStyle = color;++ // A horizontal scale (e.g. a scatter plot's x) takes a vertical line.+ if (u.scales[scaleKey]?.ori === 0) {+ const x = Math.round(scaleVal);+ const top = Math.round(u.bbox.top);++ ctx.beginPath();+ ctx.moveTo(x, top);+ ctx.lineTo(x, Math.round(u.bbox.top + u.bbox.height));+ ctx.stroke();++ if (threshold.thresholdLabel) {+ const gap = 6 * uPlot.pxRatio;+ const textWidth = ctx.measureText(threshold.thresholdLabel).width;+ const fitsRight = x + gap + textWidth <= u.bbox.left + u.bbox.width;+ // uPlot leaves the last axis's text alignment on the context.+ ctx.save();+ ctx.fillStyle = color;+ ctx.textAlign = 'left';+ ctx.textBaseline = 'top';+ ctx.fillText(+ threshold.thresholdLabel,+ fitsRight ? x + gap : x - gap - textWidth,+ top + gap,+ );+ ctx.restore();+ }+ continue;+ }+const x0 = Math.round(u.bbox.left);const y0 = Math.round(scaleVal);const x1 = Math.round(u.bbox.left + u.bbox.width);const y1 = Math.round(scaleVal);- ctx.strokeStyle = color;-ctx.beginPath();ctx.moveTo(x0, y0);ctx.lineTo(x1, y1);diff --git a/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/geometry.test.ts b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/geometry.test.tsnew file mode 100644index 0000000000..018d97928f--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/geometry.test.ts@@ -0,0 +1,116 @@+import type uPlot from 'uplot';++import { Quadtree } from '../../../utils/quadtree';+import {+ resolveHit,+ resolvePointDiameter,+ resolveSizeDomain,+} from '../geometry';+import { ScatterHit, ScatterPointSize } from '../types';++const POINT_SIZE: ScatterPointSize = { fixed: 6, min: 4, max: 20 };++const asData = (columns: unknown[]): uPlot.AlignedData =>+ columns as unknown as uPlot.AlignedData;++describe('resolveSizeDomain', () => {+ it('spans the size columns of every series, skipping nulls', () => {+ const data = asData([+ null,+ [+ [1, 2],+ [1, 2],+ [10, null],+ ],+ [[3], [3], [40]],+ ]);++ expect(resolveSizeDomain(data)).toStrictEqual({ min: 10, max: 40 });+ });++ it('is null when no series carries sizes', () => {+ expect(resolveSizeDomain(asData([null, [[1], [1]]]))).toBeNull();+ expect(resolveSizeDomain(asData([null, [[1], [1], [null]]]))).toBeNull();+ });+});++describe('resolvePointDiameter', () => {+ it('uses the fixed diameter without a size or a domain', () => {+ expect(resolvePointDiameter(null, { min: 0, max: 10 }, POINT_SIZE)).toBe(6);+ expect(resolvePointDiameter(5, null, POINT_SIZE)).toBe(6);+ });++ it('maps the domain ends to min and max', () => {+ const domain = { min: 0, max: 100 };+ expect(resolvePointDiameter(0, domain, POINT_SIZE)).toBe(4);+ expect(resolvePointDiameter(100, domain, POINT_SIZE)).toBe(20);+ });++ it('scales by area, not diameter', () => {+ const midArea = (4 ** 2 + 20 ** 2) / 2;+ expect(+ resolvePointDiameter(50, { min: 0, max: 100 }, POINT_SIZE),+ ).toBeCloseTo(Math.sqrt(midArea));+ });++ it('clamps values outside the domain', () => {+ const domain = { min: 10, max: 20 };+ expect(resolvePointDiameter(-5, domain, POINT_SIZE)).toBe(4);+ expect(resolvePointDiameter(500, domain, POINT_SIZE)).toBe(20);+ });++ it('uses the midpoint when every size is the same', () => {+ expect(resolvePointDiameter(7, { min: 7, max: 7 }, POINT_SIZE)).toBe(12);+ });+});++describe('resolveHit', () => {+ const hit = (+ seriesIndex: number,+ dataIndex: number,+ x: number,+ y: number,+ d: number,+ ): ScatterHit => ({ seriesIndex, dataIndex, x, y, w: d, h: d });++ it('returns the disc under the cursor', () => {+ const tree = new Quadtree<ScatterHit>(0, 0, 100, 100);+ tree.add(hit(1, 0, 10, 10, 6));+ tree.add(hit(2, 3, 50, 50, 6));++ expect(resolveHit(tree, 13, 13, 0)).toMatchObject({+ seriesIndex: 1,+ dataIndex: 0,+ });+ expect(resolveHit(tree, 52, 52, 0)).toMatchObject({+ seriesIndex: 2,+ dataIndex: 3,+ });+ });++ it('is null when the cursor is off every disc', () => {+ const tree = new Quadtree<ScatterHit>(0, 0, 100, 100);+ tree.add(hit(1, 0, 10, 10, 6));++ expect(resolveHit(tree, 30, 30, 0)).toBeNull();+ // Inside the disc's bounding square, outside the disc.+ expect(resolveHit(tree, 15.8, 15.8, 0)).toBeNull();+ });++ it('tolerance widens each disc', () => {+ const tree = new Quadtree<ScatterHit>(0, 0, 100, 100);+ tree.add(hit(1, 0, 10, 10, 6));++ expect(resolveHit(tree, 18, 13, 0)).toBeNull();+ expect(resolveHit(tree, 18, 13, 3)).not.toBeNull();+ });++ it('prefers the disc whose centre is nearest when they overlap', () => {+ const tree = new Quadtree<ScatterHit>(0, 0, 100, 100);+ tree.add(hit(1, 0, 10, 10, 10));+ tree.add(hit(1, 1, 14, 10, 10));++ expect(resolveHit(tree, 13, 15, 0)?.dataIndex).toBe(0);+ expect(resolveHit(tree, 21, 15, 0)?.dataIndex).toBe(1);+ });+});diff --git a/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/scatterPlugin.test.ts b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/scatterPlugin.test.tsnew file mode 100644index 0000000000..8ceff1ecd3--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/__tests__/scatterPlugin.test.ts@@ -0,0 +1,290 @@+import uPlot from 'uplot';++import { UPlotConfigBuilder } from '../../../config/UPlotConfigBuilder';+import {+ applyScatterPlugin,+ createScatterPlugin,+ SCATTER_FACETS,+} from '../scatterPlugin';++jest.mock('lib/visualization/panels/utils/legendVisibilityUtils', () => ({+ getStoredSeriesVisibility: jest.fn(),+}));++/** jsdom has no Path2D; the builder only needs something that takes the calls. */+class FakePath2D {+ moveTo = jest.fn();+ arc = jest.fn();+}++type OrientCallback = Parameters<typeof uPlot.orient>[2];++interface FakePlotArgs {+ series: Array<{ xs: number[]; ys: number[]; sizes?: Array<number | null> }>;+ cursor?: { left: number; top: number };+ scaleX?: { min: number; max: number };+ scaleY?: { min: number; max: number };+}++/**+ * A 100×100 plot at the canvas origin with identity scales: value 10 draws at+ * pixel 10 on x, and at 100 − 10 on y (uPlot's y grows downward).+ */+function createFakePlot({+ series,+ cursor = { left: -1, top: -1 },+ scaleX = { min: 0, max: 100 },+ scaleY = { min: 0, max: 100 },+}: FakePlotArgs): uPlot {+ const data = [+ null,+ ...series.map((entry) =>+ entry.sizes ? [entry.xs, entry.ys, entry.sizes] : [entry.xs, entry.ys],+ ),+ ];+ return {+ data,+ series: [{}, ...series.map((_, index) => ({ label: `s${index + 1}` }))],+ bbox: { left: 0, top: 0, width: 100, height: 100 },+ cursor,+ scales: { x: scaleX, y: scaleY },+ } as unknown as uPlot;+}++/** Stands in for `uPlot.orient`: identity x, flipped y, an `arc` that records. */+function orientWithIdentityScales(+ u: uPlot,+ seriesIdx: number,+ cb: OrientCallback,+): void {+ const columns = (u.data as unknown as Array<number[][] | null>)[seriesIdx];+ if (!columns) {+ return;+ }+ const scaleX = (u.scales as unknown as Record<string, uPlot.Scale>).x;+ const scaleY = (u.scales as unknown as Record<string, uPlot.Scale>).y;+ const valToPosX = (value: number): number => value;+ const valToPosY = (value: number): number => 100 - value;+ // Real uPlot's `arc` helper forwards to the path; the test counts those calls.+ const arc = (path: FakePath2D, ...args: number[]): void => {+ path.arc(...args);+ };+ cb(+ u.series[seriesIdx],+ columns[0],+ columns[1],+ scaleX,+ scaleY,+ valToPosX as unknown as uPlot.ValToPos,+ valToPosY as unknown as uPlot.ValToPos,+ 0,+ 0,+ 100,+ 100,+ jest.fn() as never,+ jest.fn() as never,+ jest.fn() as never,+ arc as never,+ jest.fn() as never,+ );+}++describe('createScatterPlugin', () => {+ beforeAll(() => {+ (globalThis as { Path2D?: unknown }).Path2D = FakePath2D;+ });++ let orient: jest.SpyInstance;++ beforeEach(() => {+ orient = jest+ .spyOn(uPlot, 'orient')+ .mockImplementation(orientWithIdentityScales);+ });++ afterEach(() => {+ orient.mockReset();+ });++ function drawAll(+ u: uPlot,+ plugin: ReturnType<typeof createScatterPlugin>,+ ): void {+ plugin.hooks.drawClear(u);+ for (let seriesIdx = 1; seriesIdx < u.series.length; seriesIdx++) {+ const columns = (u.data as unknown as number[][][])[seriesIdx];+ plugin.pathBuilder(u, seriesIdx, 0, columns[0].length - 1);+ }+ }++ /** Runs the cursor scan the way uPlot does: every data series, in order. */+ function scan(+ u: uPlot,+ plugin: ReturnType<typeof createScatterPlugin>,+ ): Array<number | null> {+ const dataIdx = plugin.cursor.dataIdx as NonNullable<uPlot.Cursor['dataIdx']>;+ const indexes: Array<number | null> = [null];+ for (let seriesIdx = 1; seriesIdx < u.series.length; seriesIdx++) {+ indexes.push(dataIdx(u, seriesIdx, 0, 0));+ }+ return indexes;+ }++ it('returns one path that strokes and fills the same discs', () => {+ const plugin = createScatterPlugin();+ const u = createFakePlot({ series: [{ xs: [10, 20], ys: [10, 20] }] });+ plugin.hooks.drawClear(u);++ const paths = plugin.pathBuilder(u, 1, 0, 1) as uPlot.Series.Paths;++ expect(paths.stroke).toBeInstanceOf(FakePath2D);+ expect(paths.fill).toBe(paths.stroke);+ expect((paths.fill as unknown as FakePath2D).arc).toHaveBeenCalledTimes(2);+ });++ it('resolves the hovered point to its own series and index', () => {+ const plugin = createScatterPlugin({+ pointSize: { fixed: 6, min: 4, max: 20 },+ });+ const u = createFakePlot({+ series: [+ { xs: [10, 50], ys: [10, 50] },+ { xs: [80], ys: [80] },+ ],+ // Over the second series' only point: x 80, y drawn at 100 − 80.+ cursor: { left: 80, top: 20 },+ });+ drawAll(u, plugin);++ expect(scan(u, plugin)).toStrictEqual([null, null, 0]);+ expect(plugin.getHit()).toMatchObject({ seriesIndex: 2, dataIndex: 0 });+ });++ it('returns null for every series when the cursor is off the plot or off any disc', () => {+ const plugin = createScatterPlugin();+ const u = createFakePlot({+ series: [{ xs: [10], ys: [10] }],+ cursor: { left: -1, top: -1 },+ });+ drawAll(u, plugin);++ expect(scan(u, plugin)).toStrictEqual([null, null]);++ (u.cursor as { left: number; top: number }).left = 50;+ (u.cursor as { left: number; top: number }).top = 50;+ expect(scan(u, plugin)).toStrictEqual([null, null]);+ });++ it('skips points outside the visible scale range', () => {+ const plugin = createScatterPlugin();+ const u = createFakePlot({+ series: [{ xs: [10, 500], ys: [10, 10] }],+ cursor: { left: 10, top: 90 },+ });+ drawAll(u, plugin);++ const paths = plugin.pathBuilder(u, 1, 0, 1) as uPlot.Series.Paths;+ expect((paths.fill as unknown as FakePath2D).arc).toHaveBeenCalledTimes(1);+ expect(scan(u, plugin)).toStrictEqual([null, 0]);+ });++ it('rings the hit disc, in CSS pixels, with a gap around it', () => {+ const plugin = createScatterPlugin({+ pointSize: { fixed: 8, min: 4, max: 20 },+ });+ const u = createFakePlot({+ series: [{ xs: [10], ys: [10] }],+ cursor: { left: 10, top: 90 },+ });+ drawAll(u, plugin);+ scan(u, plugin);++ const bbox = plugin.cursor.points?.bbox;+ // The 8px disc spans 6..14; the ring sits 3px out and is 2px wide.+ expect(bbox?.(u, 1)).toStrictEqual({+ left: 1,+ top: 81,+ width: 18,+ height: 18,+ });+ expect(bbox?.(u, 2)).toMatchObject({ width: 0, height: 0 });+ });++ it('snaps the ring to whole pixels without moving its centre', () => {+ const plugin = createScatterPlugin({+ pointSize: { fixed: 7, min: 4, max: 20 },+ });+ const u = createFakePlot({+ series: [{ xs: [10], ys: [10] }],+ cursor: { left: 10, top: 90 },+ });+ drawAll(u, plugin);+ scan(u, plugin);++ // The 7px disc starts at 6.5, so the ring's edge would land on 1.5.+ const ring = plugin.cursor.points?.bbox?.(u, 1);+ expect(ring).toMatchObject({ left: 1, width: 18 });+ expect((ring?.left ?? 0) + (ring?.width ?? 0) / 2).toBe(10);+ });++ it('draws the hover marker as an outline in the series colour', () => {+ const plugin = createScatterPlugin();+ const u = {+ series: [{}, { stroke: (): string => '#E5484D' }, { stroke: '#30A46C' }],+ } as unknown as uPlot;+ const points = plugin.cursor.points as {+ fill: (u: uPlot, seriesIdx: number) => string;+ stroke: (u: uPlot, seriesIdx: number) => string;+ width: (u: uPlot, seriesIdx: number, size: number) => number;+ };++ expect(points.fill(u, 1)).toBe('transparent');+ expect(points.stroke(u, 1)).toBe('#E5484D');+ expect(points.stroke(u, 2)).toBe('#30A46C');+ expect(points.width(u, 1, 0)).toBe(2);+ });++ it('drawClear drops cached paths on data series only', () => {+ const plugin = createScatterPlugin();+ const u = createFakePlot({ series: [{ xs: [1], ys: [1] }] });+ const [xSeries, dataSeries] = u.series as Array<{ _paths?: unknown }>;+ xSeries._paths = 'x';+ dataSeries._paths = 'cached';++ plugin.hooks.drawClear(u);++ expect(xSeries._paths).toBe('x');+ expect(dataSeries._paths).toBeNull();+ });++ it('focus distance is zero, so the hit series wins focus', () => {+ const plugin = createScatterPlugin();+ expect(plugin.cursor.focus?.dist?.({} as uPlot, 1, 0, 0, 0)).toBe(0);+ });+});++describe('applyScatterPlugin', () => {+ it('switches the builder to faceted mode and disables drag selection', () => {+ const builder = new UPlotConfigBuilder({ id: 'scatter' });+ const plugin = createScatterPlugin();++ applyScatterPlugin(builder, plugin);+ const config = builder.getConfig();++ expect(config.mode).toBe(2);+ expect(config.cursor?.drag).toMatchObject({+ x: false,+ y: false,+ setScale: false,+ });+ expect(config.hooks?.drawClear).toHaveLength(1);+ expect(config.hooks?.destroy).toHaveLength(1);+ });++ it('facets read x and y against the shared scales', () => {+ expect(SCATTER_FACETS).toStrictEqual([+ { scale: 'x', auto: true },+ { scale: 'y', auto: true },+ ]);+ });+});diff --git a/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/geometry.ts b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/geometry.tsnew file mode 100644index 0000000000..4107aa929e--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/geometry.ts@@ -0,0 +1,89 @@+import type uPlot from 'uplot';++import type { Quadtree } from '../../utils/quadtree';+import type { ScatterHit, ScatterPointSize, ScatterSeriesData } from './types';++export interface SizeDomain {+ min: number;+ max: number;+}++/** Size extent across all series, so equal values draw equal discs. */+export function resolveSizeDomain(data: uPlot.AlignedData): SizeDomain | null {+ let min = Infinity;+ let max = -Infinity;+ for (let seriesIndex = 1; seriesIndex < data.length; seriesIndex++) {+ const sizes = (data[seriesIndex] as unknown as ScatterSeriesData)[2];+ if (!sizes) {+ continue;+ }+ for (const size of sizes) {+ if (size == null || !Number.isFinite(size)) {+ continue;+ }+ min = Math.min(min, size);+ max = Math.max(max, size);+ }+ }+ return min <= max ? { min, max } : null;+}++/**+ * Diameter for a size-channel value. Grows the disc's area, not its width,+ * linearly with the value, so a value twice as large reads as twice the ink.+ */+export function resolvePointDiameter(+ size: number | null | undefined,+ domain: SizeDomain | null,+ pointSize: ScatterPointSize,+): number {+ if (size == null || domain == null || !Number.isFinite(size)) {+ return pointSize.fixed;+ }+ if (domain.max === domain.min) {+ return (pointSize.min + pointSize.max) / 2;+ }+ const t = Math.min(+ 1,+ Math.max(0, (size - domain.min) / (domain.max - domain.min)),+ );+ const minArea = pointSize.min ** 2;+ const maxArea = pointSize.max ** 2;+ return Math.sqrt(minArea + (maxArea - minArea) * t);+}++/**+ * The disc under the cursor, counting `tolerance` px beyond its edge as a hit.+ * Where discs overlap, the one whose centre is closest wins; `null` if none.+ */+export function resolveHit(+ tree: Quadtree<ScatterHit>,+ cx: number,+ cy: number,+ tolerance: number,+): ScatterHit | null {+ let best: ScatterHit | null = null;+ let bestDistance = Infinity;++ tree.get(+ cx - tolerance,+ cy - tolerance,+ tolerance * 2,+ tolerance * 2,+ (hit) => {+ const dx = cx - (hit.x + hit.w / 2);+ const dy = cy - (hit.y + hit.h / 2);+ const distance = dx * dx + dy * dy;+ const reach = hit.w / 2 + tolerance;+ if (distance > reach * reach) {+ return;+ }+ if (distance < bestDistance) {+ best = hit;+ bestDistance = distance;+ }+ },+ );++ return best;+}diff --git a/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/scatterPlugin.ts b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/scatterPlugin.tsnew file mode 100644index 0000000000..9a7f4e496b--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/scatterPlugin.ts@@ -0,0 +1,225 @@+import uPlot, { Series } from 'uplot';++import { DEFAULT_FOCUS_PROXIMITY_VALUE } from '../../constants';+import { PlotMode } from '../../config/types';+import type { UPlotConfigBuilder } from '../../config/UPlotConfigBuilder';+import { Quadtree } from '../../utils/quadtree';+import {+ resolveHit,+ resolvePointDiameter,+ resolveSizeDomain,+ SizeDomain,+} from './geometry';+import {+ DEFAULT_HOVER_TOLERANCE_PX,+ DEFAULT_SCATTER_POINT_SIZE,+ ScatterHit,+ ScatterPluginOptions,+ ScatterSeriesData,+} from './types';++export const SCATTER_FACETS: Series.Facet[] = [+ { scale: 'x', auto: true },+ { scale: 'y', auto: true },+];++const HIDDEN_BBOX: uPlot.BBox = { left: -10, top: -10, width: 0, height: 0 };++const TWO_PI = 2 * Math.PI;++/** CSS pixels between a hovered disc and the outline ring drawn around it. */+const HOVER_RING_GAP_PX = 3;+const HOVER_RING_WIDTH_PX = 2;++/** uPlot ceils a cursor point's left/top but not its size; snap so the ring stays centred. */+function snapToPixel(start: number, length: number): [number, number] {+ const snapped = Math.floor(start);+ return [snapped, length + (start - snapped) * 2];+}++export function getSeriesStroke(u: uPlot, seriesIdx: number): string {+ const { stroke } = u.series[seriesIdx];+ const color = typeof stroke === 'function' ? stroke(u, seriesIdx) : stroke;+ return typeof color === 'string' ? color : '';+}++/** uPlot caches built paths on the series; the field is internal to it. */+type SeriesWithPaths = Series & { _paths?: Series.Paths | null };++export interface ScatterPlugin {+ pathBuilder: Series.PathBuilder;+ /** Hover by disc rather than by nearest x: mode 2 has no shared x to scan. */+ cursor: uPlot.Cursor;+ hooks: {+ drawClear: (u: uPlot) => void;+ destroy: (u: uPlot) => void;+ };+ getHit: () => ScatterHit | null;+}++export function createScatterPlugin({+ pointSize = DEFAULT_SCATTER_POINT_SIZE,+ hoverTolerance = DEFAULT_HOVER_TOLERANCE_PX,+}: ScatterPluginOptions = {}): ScatterPlugin {+ let tree: Quadtree<ScatterHit> | null = null;+ let hit: ScatterHit | null = null;++ // Spans every series; cached per dataset.+ let cachedData: uPlot.AlignedData | null = null;+ let cachedDomain: SizeDomain | null = null;++ function getSizeDomain(u: uPlot): SizeDomain | null {+ if (cachedData !== u.data) {+ cachedDomain = resolveSizeDomain(u.data);+ cachedData = u.data;+ }+ return cachedDomain;+ }++ const pathBuilder: Series.PathBuilder = (u, seriesIdx, idx0, idx1) => {+ const path = new Path2D();+ const sizes = (u.data[seriesIdx] as unknown as ScatterSeriesData)[2];+ const domain = getSizeDomain(u);+ const { pxRatio } = uPlot;++ uPlot.orient(+ u,+ seriesIdx,+ (+ _series,+ dataX,+ dataY,+ scaleX,+ scaleY,+ valToPosX,+ valToPosY,+ xOff,+ yOff,+ xDim,+ yDim,+ _moveTo,+ _lineTo,+ _rect,+ arc,+ ) => {+ const xMin = scaleX.min ?? -Infinity;+ const xMax = scaleX.max ?? Infinity;+ const yMin = scaleY.min ?? -Infinity;+ const yMax = scaleY.max ?? Infinity;++ for (let i = idx0; i <= idx1; i++) {+ const x = dataX[i];+ const y = dataY[i];+ if (+ x == null ||+ y == null ||+ x < xMin ||+ x > xMax ||+ y < yMin ||+ y > yMax+ ) {+ continue;+ }++ const diameter =+ resolvePointDiameter(sizes?.[i], domain, pointSize) * pxRatio;+ const radius = diameter / 2;+ const cx = valToPosX(x, scaleX, xDim, xOff);+ const cy = valToPosY(y, scaleY, yDim, yOff);++ path.moveTo(cx + radius, cy);+ arc(path, cx, cy, radius, 0, TWO_PI);++ tree?.add({+ x: cx - radius - u.bbox.left,+ y: cy - radius - u.bbox.top,+ w: diameter,+ h: diameter,+ seriesIndex: seriesIdx,+ dataIndex: i,+ });+ }+ },+ );++ return { stroke: path, fill: path, clip: null };+ };++ const cursor: uPlot.Cursor = {+ // Selection would set the dashboard time range; neither axis is time here.+ drag: { x: false, y: false, setScale: false },+ dataIdx: (u, seriesIdx): number | null => {+ // uPlot asks series 1..n in order on every cursor move; resolve once.+ if (seriesIdx === 1) {+ const { left = -1, top = -1 } = u.cursor;+ const { pxRatio } = uPlot;+ hit =+ tree && left >= 0 && top >= 0+ ? resolveHit(+ tree,+ left * pxRatio,+ top * pxRatio,+ hoverTolerance * pxRatio,+ )+ : null;+ }+ return hit?.seriesIndex === seriesIdx ? hit.dataIndex : null;+ },+ points: {+ bbox: (_u, seriesIdx): uPlot.BBox => {+ if (hit?.seriesIndex !== seriesIdx) {+ return HIDDEN_BBOX;+ }+ const { pxRatio } = uPlot;+ const inset = HOVER_RING_GAP_PX + HOVER_RING_WIDTH_PX;+ const [left, width] = snapToPixel(+ hit.x / pxRatio - inset,+ hit.w / pxRatio + inset * 2,+ );+ const [top, height] = snapToPixel(+ hit.y / pxRatio - inset,+ hit.h / pxRatio + inset * 2,+ );+ return { left, top, width, height };+ },+ fill: (): string => 'transparent',+ stroke: getSeriesStroke,+ width: (): number => HOVER_RING_WIDTH_PX,+ },+ // uPlot only measures series that returned a data index, i.e. the hit one.+ focus: { prox: DEFAULT_FOCUS_PROXIMITY_VALUE, dist: (): number => 0 },+ };++ return {+ pathBuilder,+ cursor,+ hooks: {+ drawClear: (u: uPlot): void => {+ tree = new Quadtree<ScatterHit>(0, 0, u.bbox.width, u.bbox.height);+ // The tree holds only what the path builder drew, so force a rebuild.+ u.series.forEach((series, index) => {+ if (index > 0) {+ (series as SeriesWithPaths)._paths = null;+ }+ });+ },+ destroy: (): void => {+ tree = null;+ hit = null;+ cachedData = null;+ cachedDomain = null;+ },+ },+ getHit: (): ScatterHit | null => hit,+ };+}++export function applyScatterPlugin(+ builder: UPlotConfigBuilder,+ plugin: ScatterPlugin,+): void {+ builder.setMode(PlotMode.Faceted);+ builder.setCursor(plugin.cursor);+ builder.addHook('drawClear', plugin.hooks.drawClear);+ builder.addHook('destroy', plugin.hooks.destroy);+}diff --git a/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/types.ts b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/types.tsnew file mode 100644index 0000000000..6c3d6a0525--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/ScatterPlugin/types.ts@@ -0,0 +1,54 @@+import type { QuadtreeRect } from '../../utils/quadtree';++/** Diameters in CSS pixels. `min`/`max` bound the area scale when a size column is mapped. */+export interface ScatterPointSize {+ fixed: number;+ min: number;+ max: number;+}++export const DEFAULT_SCATTER_POINT_SIZE: ScatterPointSize = {+ fixed: 6,+ min: 4,+ max: 24,+};++/** CSS pixels around a point's disc that still register as a hover. */+export const DEFAULT_HOVER_TOLERANCE_PX = 3;++export interface ScatterPluginOptions {+ pointSize?: ScatterPointSize;+ hoverTolerance?: number;+}++/** Parallel columns; a `null` size draws at `fixed`. */+export type ScatterSeriesData = [+ xs: number[],+ ys: number[],+ sizes?: Array<number | null>,+];++/** Mode-2 data: series 0 is uPlot's x placeholder and carries nothing. */+export type ScatterChartData = [null, ...ScatterSeriesData[]];++/** A drawn point's disc, in canvas pixels relative to the plot area. */+export interface ScatterHit extends QuadtreeRect {+ seriesIndex: number;+ dataIndex: number;+}++export interface ScatterChannel {+ label: string;+ unit?: string;+}++export interface ScatterChannels {+ x: ScatterChannel;+ y: ScatterChannel;+ size?: ScatterChannel;+}++export interface ScatterPointLabel {+ key: string;+ value: string;+}diff --git a/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/buildClickData.test.ts b/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/buildClickData.test.tsnew file mode 100644index 0000000000..04a18c6a6c--- /dev/null+++ b/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/buildClickData.test.ts@@ -0,0 +1,52 @@+import type uPlot from 'uplot';++import { buildClickData } from '../utils';++jest.mock('lib/uPlotLib/plugins/onClickPlugin', () => ({+ getFocusedSeriesAtPosition: jest.fn(() => ({ seriesIndex: 1 })),+}));++const event = {+ offsetX: 10,+ offsetY: 20,+ clientX: 110,+ clientY: 220,+} as MouseEvent;++describe('buildClickData', () => {+ it('skips the x-index lookups on a faceted plot, which has no shared x series', () => {+ const posToIdx = jest.fn(() => {+ throw new Error('faceted data[0] is null');+ });+ const plot = {+ data: [null],+ posToVal: (pos: number): number => pos * 2,+ posToIdx,+ } as unknown as uPlot;++ expect(buildClickData(event, plot)).toStrictEqual({+ xValue: 20,+ yValue: 40,+ focusedSeries: null,+ clickedDataTimestamp: 20,+ mouseX: 10,+ mouseY: 20,+ absoluteMouseX: 110,+ absoluteMouseY: 220,+ });+ expect(posToIdx).not.toHaveBeenCalled();+ });++ it('resolves the focused series and clicked timestamp on an aligned plot', () => {+ const plot = {+ data: [[100, 200, 300]],+ posToVal: (pos: number): number => pos,+ posToIdx: (): number => 1,+ } as unknown as uPlot;++ expect(buildClickData(event, plot)).toMatchObject({+ focusedSeries: { seriesIndex: 1 },+ clickedDataTimestamp: 200,+ });+ });+});diff --git a/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/utils.ts b/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/utils.tsindex 90c0111b9f..19c84c0bf4 100644--- a/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/utils.ts+++ b/frontend/src/lib/uPlotV2/plugins/TooltipPlugin/utils.ts@@ -174,6 +174,24 @@ export function createLayoutObserver(export function buildClickData(event: MouseEvent, plot: uPlot): ChartClickData {const xValue = plot.posToVal(event.offsetX, 'x');const yValue = plot.posToVal(event.offsetY, 'y');+ const pointer = {+ mouseX: event.offsetX,+ mouseY: event.offsetY,+ absoluteMouseX: event.clientX,+ absoluteMouseY: event.clientY,+ };++ // Faceted (scatter): no shared x, so `posToIdx` would throw.+ if (plot.data[0] == null) {+ return {+ xValue,+ yValue,+ focusedSeries: null,+ clickedDataTimestamp: xValue,+ ...pointer,+ };+ }+const focusedSeries = getFocusedSeriesAtPosition(event, plot);const dataIndex = plot.posToIdx(event.offsetX);@@ -193,9 +211,6 @@ export function buildClickData(event: MouseEvent, plot: uPlot): ChartClickData {yValue,focusedSeries,clickedDataTimestamp,- mouseX: event.offsetX,- mouseY: event.offsetY,- absoluteMouseX: event.clientX,- absoluteMouseY: event.clientY,+ ...pointer,};}diff --git a/frontend/src/lib/uPlotV2/utils/__tests__/logGridSplits.test.ts b/frontend/src/lib/uPlotV2/utils/__tests__/logGridSplits.test.tsnew file mode 100644index 0000000000..f0e295a094--- /dev/null+++ b/frontend/src/lib/uPlotV2/utils/__tests__/logGridSplits.test.ts@@ -0,0 +1,66 @@+import type uPlot from 'uplot';++import { logScaleSplits, spacedLogLabels } from '../logGridSplits';++describe('logScaleSplits', () => {+ const splitsFor = (min: number, max: number): number[] =>+ (+ logScaleSplits as (+ u: uPlot,+ axisIdx: number,+ min: number,+ max: number,+ ) => number[]+ )({} as uPlot, 0, min, max);++ it('splits at 1, 2 and 5 × 10ⁿ inside an unsnapped range', () => {+ expect(splitsFor(10.6, 990)).toStrictEqual([20, 50, 100, 200, 500]);+ });++ it('includes the ends when they fall on a split', () => {+ expect(splitsFor(0.1, 10)).toStrictEqual([0.1, 0.2, 0.5, 1, 2, 5, 10]);+ });++ it('steps evenly through a range too narrow for two 1/2/5 splits', () => {+ expect(splitsFor(7.6, 9.4)).toStrictEqual([8, 9]);+ expect(splitsFor(8.12, 8.19)).toStrictEqual([+ 8.12, 8.13, 8.14, 8.15, 8.16, 8.17, 8.18, 8.19,+ ]);+ });++ it('is empty for a range a log scale cannot hold', () => {+ expect(splitsFor(0, 10)).toStrictEqual([]);+ expect(splitsFor(5, 5)).toStrictEqual([]);+ });+});++describe('spacedLogLabels', () => {+ // 100px per decade.+ const plot = {+ axes: [{ scale: 'x' }],+ valToPos: (value: number): number => Math.log10(value) * 100,+ } as unknown as uPlot;+ const label = (splits: number[], space: number): (number | null)[] =>+ spacedLogLabels(plot, splits, 0, space, 0) as (number | null)[];++ it('always labels the powers of ten', () => {+ expect(label([10, 20, 50, 100], 200)).toStrictEqual([10, null, null, 100]);+ });++ it('adds a 2 or 5 that clears the labels already kept', () => {+ // 20 is 30px from 10; 50 is 70px from 10 and 30px from 100.+ expect(label([10, 20, 50, 100], 25)).toStrictEqual([10, 20, 50, 100]);+ expect(label([10, 20, 50, 100], 40)).toStrictEqual([10, null, null, 100]);+ });++ it('labels both ends of a range spanning under a decade', () => {+ // 100 sits at 200px; 20 (130px) and 500 (270px) clear it, 50 and 200 do not.+ expect(label([20, 50, 100, 200, 500], 60)).toStrictEqual([+ 20,+ null,+ 100,+ null,+ 500,+ ]);+ });+});diff --git a/frontend/src/lib/uPlotV2/utils/__tests__/quadtree.test.ts b/frontend/src/lib/uPlotV2/utils/__tests__/quadtree.test.tsnew file mode 100644index 0000000000..22387496f8--- /dev/null+++ b/frontend/src/lib/uPlotV2/utils/__tests__/quadtree.test.ts@@ -0,0 +1,64 @@+import { Quadtree, QuadtreeRect } from '../quadtree';++interface Item extends QuadtreeRect {+ id: number;+}++function collect(+ tree: Quadtree<Item>,+ x: number,+ y: number,+ w: number,+ h: number,+): Set<number> {+ const ids = new Set<number>();+ tree.get(x, y, w, h, (item) => ids.add(item.id));+ return ids;+}++describe('Quadtree', () => {+ it('returns items in the queried region and not those far from it', () => {+ const tree = new Quadtree<Item>(0, 0, 100, 100);+ tree.add({ id: 1, x: 10, y: 10, w: 5, h: 5 });+ tree.add({ id: 2, x: 80, y: 80, w: 5, h: 5 });++ // Below the split threshold every item is visited; callers refine the hit.+ expect(collect(tree, 9, 9, 8, 8)).toStrictEqual(new Set([1, 2]));+ });++ it('splits past the object limit and still finds every item', () => {+ const tree = new Quadtree<Item>(0, 0, 100, 100);+ const total = 50;+ for (let id = 0; id < total; id++) {+ tree.add({ id, x: (id % 10) * 10, y: Math.floor(id / 10) * 10, w: 4, h: 4 });+ }++ expect(collect(tree, 0, 0, 100, 100).size).toBe(total);+ });++ it('after a split, a query in one quadrant skips items confined to another', () => {+ const tree = new Quadtree<Item>(0, 0, 100, 100);+ for (let id = 0; id < 20; id++) {+ // All in the north-west quadrant.+ tree.add({ id, x: 1 + id, y: 1, w: 2, h: 2 });+ }+ tree.add({ id: 99, x: 90, y: 90, w: 2, h: 2 });++ const northWest = collect(tree, 0, 0, 10, 10);+ expect(northWest.has(99)).toBe(false);+ expect(collect(tree, 85, 85, 10, 10).has(99)).toBe(true);+ });++ it('reports an item straddling the midline from either side', () => {+ const tree = new Quadtree<Item>(0, 0, 100, 100);+ for (let id = 0; id < 20; id++) {+ tree.add({ id, x: 1, y: 1 + id, w: 2, h: 2 });+ }+ tree.add({ id: 99, x: 48, y: 48, w: 4, h: 4 });++ expect(collect(tree, 40, 40, 5, 5).has(99)).toBe(true);+ expect(collect(tree, 55, 55, 5, 5).has(99)).toBe(true);+ // A zero-size query exactly on both midlines.+ expect(collect(tree, 50, 50, 0, 0).has(99)).toBe(true);+ });+});diff --git a/frontend/src/lib/uPlotV2/utils/__tests__/scale.test.ts b/frontend/src/lib/uPlotV2/utils/__tests__/scale.test.tsindex 6c08f20732..0578809304 100644--- a/frontend/src/lib/uPlotV2/utils/__tests__/scale.test.ts+++ b/frontend/src/lib/uPlotV2/utils/__tests__/scale.test.ts@@ -195,3 +195,22 @@ describe('scale utils', () => {});});});++describe('symmetric log scale', () => {+ it('maps to uPlot arcsinh with the given linear threshold', () => {+ expect(+ scaleUtils.getDistributionConfig({+ time: false,+ distr: DistributionType.SymmetricLog,+ asinhThreshold: 0.01,+ }),+ ).toStrictEqual({ distr: 4, log: 10, asinh: 0.01 });++ expect(+ scaleUtils.getDistributionConfig({+ time: false,+ distr: DistributionType.SymmetricLog,+ }).asinh,+ ).toBe(scaleUtils.DEFAULT_ASINH_THRESHOLD);+ });+});diff --git a/frontend/src/lib/uPlotV2/utils/logGridSplits.ts b/frontend/src/lib/uPlotV2/utils/logGridSplits.tsnew file mode 100644index 0000000000..19f87a3a0f--- /dev/null+++ b/frontend/src/lib/uPlotV2/utils/logGridSplits.ts@@ -0,0 +1,92 @@+import type uPlot from 'uplot';++const DECADE_TOLERANCE = 1e-9;++function isDecade(value: number): boolean {+ if (value === 0) {+ return true;+ }+ const exponent = Math.log10(Math.abs(value));+ return Math.abs(exponent - Math.round(exponent)) < DECADE_TOLERANCE;+}++const LOG_SPLIT_MULTIPLES = [1, 2, 5];++/** Decades finer than the range's own span that the fallback steps through. */+const FALLBACK_STEP_DECADES = 3;++/** Rounded through toPrecision so 0.1 × 3 noise can't fall outside [min, max]. */+function roundSplit(value: number): number {+ return Number(value.toPrecision(12));+}++/** Evenly stepped splits for a range too narrow to hold two 1/2/5 splits. */+function narrowRangeSplits(min: number, max: number): number[] {+ const coarsest = Math.floor(Math.log10(max - min));+ for (+ let exponent = coarsest;+ exponent > coarsest - FALLBACK_STEP_DECADES;+ exponent--+ ) {+ const step = 10 ** exponent;+ const first = Math.ceil(roundSplit(min / step));+ const last = Math.floor(roundSplit(max / step));+ if (last > first) {+ return Array.from({ length: last - first + 1 }, (_, index) =>+ roundSplit((first + index) * step),+ );+ }+ }+ return [];+}++/** 1, 2, 5 × 10ⁿ in range; uPlot's log splits step from an unsnapped min (10.79, 21.58…). */+export const logScaleSplits: uPlot.Axis.Splits = (_u, _axisIdx, min, max) => {+ if (!(min > 0) || !(max > min)) {+ return [];+ }+ const splits: number[] = [];+ for (+ let exponent = Math.floor(Math.log10(min));+ exponent <= Math.ceil(Math.log10(max));+ exponent+++ ) {+ LOG_SPLIT_MULTIPLES.forEach((multiple) => {+ const split = roundSplit(multiple * 10 ** exponent);+ if (split >= min && split <= max) {+ splits.push(split);+ }+ });+ }+ if (splits.length >= 2) {+ return splits;+ }+ const narrow = narrowRangeSplits(min, max);+ return narrow.length > splits.length ? narrow : splits;+};++/** Labels every decade, plus any 2 or 5 at least `space` px clear. */+export const spacedLogLabels: uPlot.Axis.Filter = (+ u,+ splits,+ axisIdx,+ space,+) => {+ const scaleKey = u.axes[axisIdx]?.scale ?? 'x';+ const positions = splits.map((split) =>+ split == null ? null : u.valToPos(split, scaleKey),+ );+ const kept = splits.map((split) => split != null && isDecade(split));+ const isClear = (index: number): boolean =>+ kept.every(+ (isKept, other) =>+ !isKept ||+ Math.abs((positions[other] ?? 0) - (positions[index] ?? 0)) >= space,+ );+ splits.forEach((split, index) => {+ if (split != null && !kept[index] && isClear(index)) {+ kept[index] = true;+ }+ });+ return splits.map((split, index) => (kept[index] ? split : null));+};diff --git a/frontend/src/lib/uPlotV2/utils/quadtree.ts b/frontend/src/lib/uPlotV2/utils/quadtree.tsnew file mode 100644index 0000000000..c64c96792b--- /dev/null+++ b/frontend/src/lib/uPlotV2/utils/quadtree.ts@@ -0,0 +1,101 @@+export interface QuadtreeRect {+ x: number;+ y: number;+ w: number;+ h: number;+}++const MAX_OBJECTS = 10;+const MAX_LEVELS = 4;++/** Rect index for cursor hit-testing; items straddling quadrants are stored in each, so `get` may repeat them. */+export class Quadtree<T extends QuadtreeRect = QuadtreeRect> {+ private items: T[] = [];+ private quadrants: Quadtree<T>[] | null = null;++ constructor(+ private readonly x: number,+ private readonly y: number,+ private readonly w: number,+ private readonly h: number,+ private readonly level = 0,+ ) {}++ add(item: T): void {+ if (this.quadrants) {+ this.forEachQuadrant(item, (quadrant) => quadrant.add(item));+ return;+ }++ this.items.push(item);++ if (this.items.length > MAX_OBJECTS && this.level < MAX_LEVELS) {+ this.split();+ const items = this.items;+ this.items = [];+ for (const existing of items) {+ this.forEachQuadrant(existing, (quadrant) => quadrant.add(existing));+ }+ }+ }++ /** Visits every item whose quadrant overlaps the rectangle; callers refine the test. */+ get(+ x: number,+ y: number,+ w: number,+ h: number,+ visit: (item: T) => void,+ ): void {+ for (const item of this.items) {+ visit(item);+ }+ if (this.quadrants) {+ this.forEachQuadrant({ x, y, w, h }, (quadrant) =>+ quadrant.get(x, y, w, h, visit),+ );+ }+ }++ private split(): void {+ const w = this.w / 2;+ const h = this.h / 2;+ const level = this.level + 1;+ // North-east, north-west, south-west, south-east.+ this.quadrants = [+ new Quadtree<T>(this.x + w, this.y, w, h, level),+ new Quadtree<T>(this.x, this.y, w, h, level),+ new Quadtree<T>(this.x, this.y + h, w, h, level),+ new Quadtree<T>(this.x + w, this.y + h, w, h, level),+ ];+ }++ private forEachQuadrant(+ rect: QuadtreeRect,+ visit: (quadrant: Quadtree<T>) => void,+ ): void {+ if (!this.quadrants) {+ return;+ }+ const midX = this.x + this.w / 2;+ const midY = this.y + this.h / 2;+ const startsNorth = rect.y < midY;+ const startsWest = rect.x < midX;+ // Inclusive, so a zero-size query on a midline still reaches a quadrant.+ const endsEast = rect.x + rect.w >= midX;+ const endsSouth = rect.y + rect.h >= midY;++ if (startsNorth && endsEast) {+ visit(this.quadrants[0]);+ }+ if (startsWest && startsNorth) {+ visit(this.quadrants[1]);+ }+ if (startsWest && endsSouth) {+ visit(this.quadrants[2]);+ }+ if (endsEast && endsSouth) {+ visit(this.quadrants[3]);+ }+ }+}diff --git a/frontend/src/lib/uPlotV2/utils/scale.ts b/frontend/src/lib/uPlotV2/utils/scale.tsindex c419a24753..b2b9d1d64a 100644--- a/frontend/src/lib/uPlotV2/utils/scale.ts+++ b/frontend/src/lib/uPlotV2/utils/scale.ts@@ -58,18 +58,23 @@ function normalizeLogLimit(return logBase ** exp;}+export const DEFAULT_ASINH_THRESHOLD = 1;+/**- * Returns uPlot scale distribution options for the Y axis.- * Time (X) scale gets no distr/log; Y scale gets distr 1 (linear) or 3 (log) and log base 2 or 10.+ * Returns uPlot scale distribution options for a value axis.+ * Time scales get no distr/log; value scales get distr 1 (linear), 3 (log) or+ * 4 (arcsinh, uPlot's symmetric log) and log base 2 or 10.*/export function getDistributionConfig({time,distr,logBase,+ asinhThreshold,}: {time: ScaleProps['time'];distr?: DistributionType;logBase?: number;+ asinhThreshold?: number;}): Partial<Scale> {if (time) {return {};@@ -77,6 +82,14 @@ export function getDistributionConfig({const resolvedLogBase = (logBase ?? 10) === 2 ? 2 : 10;+ if (distr === DistributionType.SymmetricLog) {+ return {+ distr: 4,+ log: resolvedLogBase,+ asinh: asinhThreshold ?? DEFAULT_ASINH_THRESHOLD,+ };+ }+return {distr: distr === DistributionType.Logarithmic ? 3 : 1,log: resolvedLogBase,diff --git a/frontend/src/lib/visualization/charts/ChartWrapper/ChartWrapper.tsx b/frontend/src/lib/visualization/charts/ChartWrapper/ChartWrapper.tsxindex 3481dc846c..e5dc4efe6a 100644--- a/frontend/src/lib/visualization/charts/ChartWrapper/ChartWrapper.tsx+++ b/frontend/src/lib/visualization/charts/ChartWrapper/ChartWrapper.tsx@@ -37,6 +37,7 @@ export default function ChartWrapper({syncKey,syncFilterMode,onDestroy = noop,+ plotRef,children,layoutChildren,yAxisUnit,@@ -123,6 +124,7 @@ export default function ChartWrapper({height={chartHeight}plotRef={(plot): void => {plotInstanceRef.current = plot;+ plotRef?.(plot);}}onDestroy={(plot: uPlot): void => {plotInstanceRef.current = null;diff --git a/frontend/src/lib/visualization/charts/ChartWrapper/__tests__/ChartWrapper.test.tsx b/frontend/src/lib/visualization/charts/ChartWrapper/__tests__/ChartWrapper.test.tsxnew file mode 100644index 0000000000..8b864a64d7--- /dev/null+++ b/frontend/src/lib/visualization/charts/ChartWrapper/__tests__/ChartWrapper.test.tsx@@ -0,0 +1,45 @@+import { render } from 'tests/test-utils';+import type uPlot from 'uplot';++import { LegendPosition } from 'lib/uPlotV2/components/types';+import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';++import ChartWrapper from '../ChartWrapper';++const FAKE_PLOT = { id: 'plot' } as unknown as uPlot;++jest.mock('lib/uPlotV2/components/UPlotChart/UPlotChart', () => ({+ __esModule: true,+ default: ({ plotRef }: { plotRef?: (plot: uPlot | null) => void }): null => {+ plotRef?.(FAKE_PLOT);+ return null;+ },+}));++window.ResizeObserver =+ window.ResizeObserver ||+ jest.fn().mockImplementation(() => ({+ disconnect: jest.fn(),+ observe: jest.fn(),+ unobserve: jest.fn(),+ }));++describe('ChartWrapper', () => {+ it('hands the plot instance to the caller', () => {+ const plotRef = jest.fn();+ render(+ <ChartWrapper+ config={new UPlotConfigBuilder({ id: 'chart' })}+ data={[[1], [2]]}+ width={400}+ height={300}+ legendConfig={{ position: LegendPosition.BOTTOM }}+ showLegend={false}+ showTooltip={false}+ plotRef={plotRef}+ />,+ );++ expect(plotRef).toHaveBeenCalledWith(FAKE_PLOT);+ });+});diff --git a/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.mocks.ts b/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.mocks.tsnew file mode 100644index 0000000000..803b2d9aaa--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.mocks.ts@@ -0,0 +1,104 @@+import type { Threshold } from 'lib/uPlotV2/hooks/types';++import { ScatterAxisScale, type ScatterSeries } from './types';++const SERVICES = [+ 'frontend',+ 'cart',+ 'checkout',+ 'payment',+ 'shipping',+ 'currency',+ 'email',+ 'recommendation',+ 'ads',+ 'product-catalog',+];++export type Shape = 'spread' | 'single' | 'sameX';++export interface ScatterStoryProps {+ groups: number;+ pointsPerGroup: number;+ /** Adds an error-count size column. */+ sized: boolean;+ xScale: ScatterAxisScale;+ yScale: ScatterAxisScale;+ /** Zeroes a share of y values, which forces the symmetric log. */+ withZeros: boolean;+ shape: Shape;+ thresholds: boolean;+ pointSize: number;+ /** 0–1. */+ fillOpacity: number;+ width: number;+ height: number;+}++/** Deterministic, so a story renders the same points on every run. */+function createRng(seed: number): () => number {+ let state = seed >>> 0;+ return (): number => {+ state = (state * 1664525 + 1013904223) >>> 0;+ return state / 2 ** 32;+ };+}++export function buildSeries({+ groups,+ pointsPerGroup,+ sized,+ withZeros,+ shape,+}: ScatterStoryProps): ScatterSeries[] {+ const rng = createRng(42);+ return Array.from({ length: groups }, (_, groupIndex) => {+ const label = SERVICES[groupIndex % SERVICES.length];+ // Each service sits in its own throughput/latency band, so groups are telling+ // apart rather than one cloud.+ const baseThroughput = 20 * 2 ** (groupIndex % 5);+ const baseLatency = 40 + 60 * (groupIndex % 4);++ const count = shape === 'single' ? 1 : pointsPerGroup;+ const xs: number[] = [];+ const ys: number[] = [];+ const sizes: Array<number | null> = [];++ for (let i = 0; i < count; i++) {+ const throughput =+ shape === 'sameX' ? baseThroughput : baseThroughput * (0.5 + rng() * 1.5);+ // Latency grows with load, plus noise; the odd outlier keeps the axis honest.+ const outlier = rng() < 0.03 ? 4 + rng() * 6 : 1;+ let latency =+ baseLatency *+ (0.8 + (throughput / baseThroughput) * 0.4 + rng() * 0.3) *+ outlier;+ if (withZeros && rng() < 0.2) {+ latency = 0;+ }+ xs.push(Number(throughput.toFixed(2)));+ ys.push(Number(latency.toFixed(2)));+ sizes.push(rng() < 0.1 ? null : Math.round(rng() * rng() * 500));+ }++ return sized ? { label, xs, ys, sizes } : { label, xs, ys };+ });+}++export const Y_THRESHOLDS: Threshold[] = [+ {+ thresholdValue: 300,+ thresholdUnit: 'ms',+ thresholdColor: '#E5484D',+ thresholdLabel: 'p99 SLO',+ },+];++export const X_THRESHOLDS: Threshold[] = [+ {+ thresholdValue: 60,+ thresholdUnit: 'reqps',+ thresholdColor: '#3E63DD',+ thresholdLabel: 'Capacity',+ },+];diff --git a/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.tsx b/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.tsxnew file mode 100644index 0000000000..4513f805ae--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/Scatter.stories.tsx@@ -0,0 +1,160 @@+import { useMemo } from 'react';+import type { Meta, StoryObj } from '@storybook/react-vite';+import { useIsDarkMode } from 'hooks/useDarkMode';+import { LegendPosition } from 'lib/uPlotV2/components/types';+import type { ScatterPointLabel } from 'lib/uPlotV2/plugins/ScatterPlugin/types';++import Scatter from './Scatter';+import {+ buildSeries,+ type ScatterStoryProps,+ X_THRESHOLDS,+ Y_THRESHOLDS,+} from './Scatter.stories.mocks';+import { ScatterAxisScale } from './types';+import { buildScatterConfig, prepareScatterChartData } from './utils';++function ScatterStory(props: ScatterStoryProps): JSX.Element {+ const {+ xScale,+ yScale,+ sized,+ thresholds,+ pointSize,+ fillOpacity,+ width,+ height,+ } = props;+ const isDarkMode = useIsDarkMode();++ const series = useMemo(() => buildSeries(props), [props]);++ const config = useMemo(+ () =>+ buildScatterConfig({+ id: 'scatter-story',+ series,+ isDarkMode,+ x: {+ unit: 'reqps',+ scale: xScale,+ thresholds: thresholds ? X_THRESHOLDS : undefined,+ },+ y: {+ unit: 'ms',+ scale: yScale,+ thresholds: thresholds ? Y_THRESHOLDS : undefined,+ },+ pointSize: { fixed: pointSize, min: 4, max: pointSize * 4 },+ fillOpacity,+ }),+ [series, isDarkMode, xScale, yScale, pointSize, fillOpacity, thresholds],+ );++ const data = useMemo(() => prepareScatterChartData(series), [series]);++ const resolvePointGroupValues = (+ seriesIndex: number,+ dataIndex: number,+ ): ScatterPointLabel[] => [+ { key: 'service.name', value: series[seriesIndex - 1]?.label ?? '' },+ {+ key: 'k8s.pod.name',+ value: `pod-${dataIndex.toString().padStart(3, '0')}`,+ },+ ];++ return (+ <div style={{ width, padding: 16 }}>+ <Scatter+ config={config}+ data={data}+ width={width}+ height={height}+ legendConfig={{ position: LegendPosition.BOTTOM }}+ channels={{+ x: { label: 'Throughput', unit: 'reqps' },+ y: { label: 'p99 latency', unit: 'ms' },+ ...(sized && { size: { label: 'Errors', unit: 'short' } }),+ }}+ resolvePointGroupValues={resolvePointGroupValues}+ canPinTooltip+ />+ </div>+ );+}++const meta = {+ title: 'Charts/Scatter',+ component: ScatterStory,+ parameters: { layout: 'padded' },+ args: {+ groups: 1,+ pointsPerGroup: 10,+ sized: false,+ xScale: ScatterAxisScale.Linear,+ yScale: ScatterAxisScale.Linear,+ withZeros: false,+ shape: 'spread',+ thresholds: false,+ pointSize: 6,+ fillOpacity: 0.7,+ width: 800,+ height: 420,+ },+ argTypes: {+ shape: { control: 'radio', options: ['spread', 'single', 'sameX'] },+ xScale: { control: 'radio', options: Object.values(ScatterAxisScale) },+ yScale: { control: 'radio', options: Object.values(ScatterAxisScale) },+ fillOpacity: { control: { type: 'range', min: 0, max: 1, step: 0.05 } },+ pointSize: { control: { type: 'range', min: 2, max: 16, step: 1 } },+ },+} satisfies Meta<ScatterStoryProps>;++export default meta;++type Story = StoryObj<ScatterStoryProps>;++/** One service, ten points: axes formatted with units, hover picks the right point. */+export const Basic: Story = {};++/** Five services, one legend entry each; toggling a row hides its points. */+export const Grouped: Story = {+ args: { groups: 5, pointsPerGroup: 40 },+};++/** Error count as disc area, between the configured min and max diameters. */+export const Sized: Story = {+ args: { groups: 5, pointsPerGroup: 40, sized: true, pointSize: 5 },+};++/** Log x; a fifth of the latencies are 0, so y falls back to the symmetric log. */+export const LogAxes: Story = {+ args: {+ groups: 5,+ pointsPerGroup: 60,+ xScale: ScatterAxisScale.Log,+ yScale: ScatterAxisScale.Log,+ withZeros: true,+ },+};++/** A single point still gets a padded range rather than an empty plot. */+export const SinglePoint: Story = {+ args: { shape: 'single' },+};++/** Fifty points sharing one x collide on nothing: no shared x array to align. */+export const SameX: Story = {+ args: { groups: 3, pointsPerGroup: 50, shape: 'sameX' },+};++/** Labelled lines on both axes; each scale stretches to include its line. */+export const Thresholds: Story = {+ args: { groups: 3, pointsPerGroup: 40, thresholds: true },+};++/** Perf harness: raise `pointsPerGroup` and read the draw time under the chart. */+export const Dense: Story = {+ args: { groups: 5, pointsPerGroup: 1000, pointSize: 4, fillOpacity: 0.5 },+};diff --git a/frontend/src/lib/visualization/charts/Scatter/Scatter.tsx b/frontend/src/lib/visualization/charts/Scatter/Scatter.tsxnew file mode 100644index 0000000000..36c07a05b1--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/Scatter.tsx@@ -0,0 +1,98 @@+import { useCallback, useRef } from 'react';+import ChartWrapper from 'lib/visualization/charts/ChartWrapper/ChartWrapper';+import ScatterTooltip from 'lib/uPlotV2/components/Tooltip/ScatterTooltip';+import {+ ScatterTooltipProps,+ TooltipRenderArgs,+} from 'lib/uPlotV2/components/types';+import { getSeriesStroke } from 'lib/uPlotV2/plugins/ScatterPlugin/scatterPlugin';+import type { ChartClickData } from 'lib/uPlotV2/plugins/TooltipPlugin/types';+import { ScatterChartProps } from 'lib/visualization/charts/types';+import uPlot from 'uplot';++import { getCursorHit } from './utils';++// Faceted uPlot can't mount without series; empty aligned data shows no-data instead.+const EMPTY_ALIGNED_DATA: uPlot.AlignedData = [[]];++export default function Scatter(props: ScatterChartProps): JSX.Element {+ const {+ children,+ customTooltip,+ channels,+ resolvePointGroupValues,+ pinnedTooltipElement,+ onPointClick,+ plotRef,+ ...rest+ } = props;++ const plotInstanceRef = useRef<uPlot | null>(null);++ const handlePlotRef = useCallback(+ (plot: uPlot | null): void => {+ plotInstanceRef.current = plot;+ plotRef?.(plot);+ },+ [plotRef],+ );++ // Faceted plots have no shared x; take the hit from the cursor.+ const handleClick = useCallback(+ (click: ChartClickData): void => {+ const plot = plotInstanceRef.current;+ const hit = plot ? getCursorHit(plot) : null;+ if (!plot || !hit || !onPointClick) {+ return;+ }+ onPointClick({+ ...hit,+ color: getSeriesStroke(plot, hit.seriesIndex),+ coordinates: { x: click.absoluteMouseX, y: click.absoluteMouseY },+ });+ },+ [onPointClick],+ );++ const renderTooltip = useCallback(+ (args: TooltipRenderArgs): React.ReactNode => {+ if (customTooltip) {+ return customTooltip(args);+ }+ const tooltipProps: ScatterTooltipProps = {+ ...args,+ id: rest.config.getId(),+ channels,+ resolvePointGroupValues,+ decimalPrecision: rest.decimalPrecision,+ canPinTooltip: rest.canPinTooltip,+ renderTooltipFooter: rest.renderTooltipFooter,+ };+ return <ScatterTooltip {...tooltipProps} />;+ },+ [+ customTooltip,+ channels,+ resolvePointGroupValues,+ rest.config,+ rest.decimalPrecision,+ rest.canPinTooltip,+ rest.renderTooltipFooter,+ ],+ );++ const hasSeries = rest.data.length > 1;++ return (+ <ChartWrapper+ {...rest}+ data={hasSeries ? rest.data : EMPTY_ALIGNED_DATA}+ plotRef={handlePlotRef}+ onClick={onPointClick ? handleClick : rest.onClick}+ customTooltip={renderTooltip}+ pinnedTooltipElement={pinnedTooltipElement}+ >+ {children}+ </ChartWrapper>+ );+}diff --git a/frontend/src/lib/visualization/charts/Scatter/__tests__/axisDistribution.test.ts b/frontend/src/lib/visualization/charts/Scatter/__tests__/axisDistribution.test.tsnew file mode 100644index 0000000000..921b80bb72--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/__tests__/axisDistribution.test.ts@@ -0,0 +1,112 @@+import { DistributionType } from 'lib/uPlotV2/config/types';++import { resolveAxisDistribution } from '../axisDistribution';+import { ScatterAxisScale } from '../types';++describe('resolveAxisDistribution', () => {+ it('is linear when asked, whatever the values', () => {+ expect(+ resolveAxisDistribution([1, 1e6], ScatterAxisScale.Linear),+ ).toStrictEqual({ distribution: DistributionType.Linear });+ });++ it('is a plain log when every value is positive', () => {+ expect(resolveAxisDistribution([1, 100], ScatterAxisScale.Log)).toStrictEqual(+ { distribution: DistributionType.Logarithmic },+ );+ });++ it('falls back from log to a symmetric log around the smallest magnitude when zero is present', () => {+ expect(+ resolveAxisDistribution([0, 0.05, 300], ScatterAxisScale.Log),+ ).toStrictEqual({+ distribution: DistributionType.SymmetricLog,+ asinhThreshold: 0.01,+ });+ });++ it('keeps an explicit log axis for a soft min it cannot place', () => {+ expect(+ resolveAxisDistribution([1, 100], ScatterAxisScale.Log, [-10]),+ ).toStrictEqual({ distribution: DistributionType.Logarithmic });+ });++ it('is a symmetric log when asked, even with only positive values', () => {+ expect(+ resolveAxisDistribution([2, 300], ScatterAxisScale.SymLog),+ ).toStrictEqual({+ distribution: DistributionType.SymmetricLog,+ asinhThreshold: 1,+ });+ });++ it('uses a unit threshold when nothing is positive', () => {+ expect(+ resolveAxisDistribution([0, -5], ScatterAxisScale.SymLog),+ ).toStrictEqual({+ distribution: DistributionType.SymmetricLog,+ asinhThreshold: 1,+ });+ });++ describe('auto', () => {+ const SKEWED = [1, 2, 3, 5, 8, 10, 20, 50, 1000];++ it.each([+ ['skewed positive values', SKEWED, DistributionType.Logarithmic],+ [+ 'values spread evenly across decades',+ [1, 250, 500, 750, 1000],+ DistributionType.Linear,+ ],+ [+ 'a single outlier among clustered values',+ [0.001, 40, 45, 50, 55, 60],+ DistributionType.Linear,+ ],+ [+ 'skewed values spanning under two decades',+ [10, 10, 10, 11, 50],+ DistributionType.Linear,+ ],+ ['no finite values', [Number.NaN], DistributionType.Linear],+ ])('picks a scale for %s', (_, values, distribution) => {+ expect(resolveAxisDistribution(values, ScatterAxisScale.Auto)).toStrictEqual(+ { distribution },+ );+ });++ it('picks symlog for skewed values that include zero', () => {+ expect(+ resolveAxisDistribution(+ [0, 0, 1, 2, 5, 10, 50, 100, 10_000],+ ScatterAxisScale.Auto,+ ),+ ).toStrictEqual({+ distribution: DistributionType.SymmetricLog,+ asinhThreshold: 1,+ });+ });++ it('picks symlog when a soft limit reaches zero or below', () => {+ expect(+ resolveAxisDistribution(SKEWED, ScatterAxisScale.Auto, [0]),+ ).toStrictEqual({+ distribution: DistributionType.SymmetricLog,+ asinhThreshold: 1,+ });+ });++ it('counts a soft limit towards the decades it spans', () => {+ expect(+ resolveAxisDistribution([5, 50], ScatterAxisScale.Auto, [null, 5000]),+ ).toStrictEqual({ distribution: DistributionType.Logarithmic });+ });++ it('is the default', () => {+ expect(resolveAxisDistribution(SKEWED)).toStrictEqual({+ distribution: DistributionType.Logarithmic,+ });+ });+ });+});diff --git a/frontend/src/lib/visualization/charts/Scatter/__tests__/buildScatterConfig.test.ts b/frontend/src/lib/visualization/charts/Scatter/__tests__/buildScatterConfig.test.tsnew file mode 100644index 0000000000..02b21ae550--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/__tests__/buildScatterConfig.test.ts@@ -0,0 +1,113 @@+import type uPlot from 'uplot';++import { ScatterAxisScale, type ScatterSeries } from '../types';+import { buildScatterConfig } from '../utils';++jest.mock('lib/visualization/panels/utils/legendVisibilityUtils', () => ({+ getStoredSeriesVisibility: jest.fn(),+}));++const SERIES: ScatterSeries[] = [+ { label: 'cart', xs: [10, 20], ys: [100, 200], sizes: [1, null] },+ { label: 'checkout', xs: [30], ys: [0] },+];++describe('buildScatterConfig', () => {+ const build = (+ overrides: Partial<Parameters<typeof buildScatterConfig>[0]> = {},+ ): ReturnType<typeof buildScatterConfig> =>+ buildScatterConfig({+ id: 'scatter',+ series: SERIES,+ isDarkMode: true,+ x: { unit: 'reqps' },+ y: { unit: 'ms', scale: ScatterAxisScale.Log },+ ...overrides,+ });++ it('draws a line along both plot edges', () => {+ const [xAxis, yAxis] = build().getConfig().axes ?? [];++ expect(xAxis?.border?.show).toBe(true);+ expect(yAxis?.border?.show).toBe(true);+ });++ it('titles each axis with its label, and leaves an unlabelled one bare', () => {+ const config = build({+ x: { unit: 'reqps', label: 'Throughput' },+ y: { unit: 'ms', label: '' },+ }).getConfig();+ const [xAxis, yAxis] = config.axes ?? [];++ expect(xAxis?.label).toBe('Throughput');+ expect(yAxis?.label).toBeUndefined();+ });++ it('emits a faceted plot with two value scales', () => {+ const config = build().getConfig();++ expect(config.mode).toBe(2);+ expect(config.scales?.x).toMatchObject({ time: false, distr: 1 });+ // The y column has a 0, so log becomes the symmetric variant.+ expect(config.scales?.y).toMatchObject({ time: false, distr: 4 });+ });++ it('draws one faceted series per group with the plugin path builder', () => {+ const config = build().getConfig();+ const [, cart, checkout] = config.series ?? [];++ expect(config.series).toHaveLength(3);+ expect(cart).toMatchObject({+ label: 'cart',+ facets: [+ { scale: 'x', auto: true },+ { scale: 'y', auto: true },+ ],+ });+ expect(typeof cart?.paths).toBe('function');+ expect(cart?.paths).toBe(checkout?.paths);+ expect(cart?.points?.show).toBe(false);+ });++ it('formats both axes with their units', () => {+ const config = build().getConfig();+ const [xAxis, yAxis] = config.axes ?? [];++ expect(xAxis).toMatchObject({ scale: 'x', side: 2, space: 90 });+ expect(yAxis).toMatchObject({ scale: 'y', side: 3 });+ expect(typeof xAxis?.values).toBe('function');+ expect(typeof yAxis?.values).toBe('function');+ });++ it('registers a y threshold draw hook when thresholds are given', () => {+ const config = build({+ y: {+ unit: 'ms',+ thresholds: [{ thresholdValue: 300, thresholdUnit: 'ms' }],+ },+ }).getConfig();++ expect(config.hooks?.draw).toHaveLength(1);+ expect(build().getConfig().hooks?.draw).toBeUndefined();+ });++ it('registers one draw hook per axis with thresholds', () => {+ const config = build({+ x: { unit: 'reqps', thresholds: [{ thresholdValue: 15 }] },+ y: { unit: 'ms', thresholds: [{ thresholdValue: 300 }] },+ }).getConfig();++ expect(config.hooks?.draw).toHaveLength(2);+ });++ it('stretches the x range to reach an x threshold', () => {+ const config = build({+ x: { unit: 'reqps', thresholds: [{ thresholdValue: 1000 }] },+ }).getConfig();+ const range = config.scales?.x?.range as uPlot.Range.Function;+ const plot = { bbox: { width: 0, height: 0 } } as uPlot;+ const [, max] = range(plot, 10, 30, 'x');++ expect(max).toBeGreaterThanOrEqual(1000);+ });+});diff --git a/frontend/src/lib/visualization/charts/Scatter/__tests__/scatterRange.test.ts b/frontend/src/lib/visualization/charts/Scatter/__tests__/scatterRange.test.tsnew file mode 100644index 0000000000..66ec786daa--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/__tests__/scatterRange.test.ts@@ -0,0 +1,98 @@+import { DistributionType } from 'lib/uPlotV2/config/types';+import uPlot from 'uplot';++import { createScatterRange } from '../scatterRange';+import type { ScatterRangeOptions } from '../types';++/** A 220px-tall, 420px-wide plot at a device pixel ratio of 1. */+const plot = { bbox: { width: 420, height: 220 } } as unknown as uPlot;++function rangeOf(+ options: Partial<ScatterRangeOptions>,+ dataMin: number | null,+ dataMax: number | null,+): [number, number] {+ const range = createScatterRange({+ dimension: 'y',+ marginPx: 10,+ distribution: DistributionType.Linear,+ ...options,+ }) as (u: uPlot, min: number | null, max: number | null) => [number, number];+ return range(plot, dataMin, dataMax);+}++describe('createScatterRange', () => {+ beforeAll(() => {+ Object.defineProperty(uPlot, 'pxRatio', { value: 1, configurable: true });+ });++ it('widens a linear range so the data sits marginPx inside each edge', () => {+ // 200px of data inside 220px: 10px at each end is 1/20 of the span.+ expect(rangeOf({}, 0, 100)).toStrictEqual([-5, 105]);+ });++ it('measures the margin along its own axis', () => {+ // 400px of data inside 420px.+ expect(rangeOf({ dimension: 'x' }, 0, 100)).toStrictEqual([-2.5, 102.5]);+ });++ it('pads a log range in decades, without snapping to the next power of ten', () => {+ const [min, max] = rangeOf(+ { distribution: DistributionType.Logarithmic },+ 1,+ 10,+ );+ expect(Math.log10(min)).toBeCloseTo(-0.05);+ expect(Math.log10(max)).toBeCloseTo(1.05);+ });++ it('pads a symmetric log range in its asinh space', () => {+ const [min, max] = rangeOf(+ { distribution: DistributionType.SymmetricLog, asinhThreshold: 2 },+ 0,+ 20,+ );+ const span = Math.asinh(10);+ expect(Math.asinh(min / 2)).toBeCloseTo(-span / 20);+ expect(Math.asinh(max / 2)).toBeCloseTo(span + span / 20);+ });++ it('stretches to the soft limits before padding', () => {+ expect(rangeOf({ softMin: 0, softMax: 200 }, 50, 100)).toStrictEqual([+ -10, 210,+ ]);+ });++ it('ignores a soft min at or below zero on a log scale', () => {+ const [min] = rangeOf(+ { distribution: DistributionType.Logarithmic, softMin: 0 },+ 10,+ 100,+ );+ expect(min).toBeGreaterThan(0);+ });++ it('spreads a single value around itself', () => {+ const [min, max] = rangeOf({}, 5, 5);+ expect(min).toBeLessThan(5);+ expect(max).toBeGreaterThan(5);+ expect(5 - min).toBeCloseTo(max - 5);+ });++ it('falls back to a unit range with no data', () => {+ expect(rangeOf({}, null, null)).toStrictEqual([0, 1]);+ expect(+ rangeOf({ distribution: DistributionType.Logarithmic }, null, null),+ ).toStrictEqual([1, 10]);+ });++ it('skips the margin on a plot too small to hold it', () => {+ const tiny = { bbox: { width: 15, height: 15 } } as unknown as uPlot;+ const range = createScatterRange({+ dimension: 'y',+ marginPx: 10,+ distribution: DistributionType.Linear,+ }) as (u: uPlot, min: number, max: number) => [number, number];+ expect(range(tiny, 0, 100)).toStrictEqual([0, 100]);+ });+});diff --git a/frontend/src/lib/visualization/charts/Scatter/__tests__/utils.test.ts b/frontend/src/lib/visualization/charts/Scatter/__tests__/utils.test.tsnew file mode 100644index 0000000000..23cf5f9c3a--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/__tests__/utils.test.ts@@ -0,0 +1,51 @@+import type uPlot from 'uplot';++import type { ScatterSeries } from '../types';+import { getCursorHit, prepareScatterChartData } from '../utils';++jest.mock('lib/visualization/panels/utils/legendVisibilityUtils', () => ({+ getStoredSeriesVisibility: jest.fn(),+}));++const SERIES: ScatterSeries[] = [+ { label: 'cart', xs: [10, 20], ys: [100, 200], sizes: [1, null] },+ { label: 'checkout', xs: [30], ys: [0] },+];++describe('prepareScatterChartData', () => {+ it('lays series out as facets behind an empty x slot', () => {+ expect(prepareScatterChartData(SERIES)).toStrictEqual([+ null,+ [+ [10, 20],+ [100, 200],+ [1, null],+ ],+ [[30], [0]],+ ]);+ });+});++describe('getCursorHit', () => {+ const plotWith = (idxs: Array<number | null>): uPlot =>+ ({ cursor: { idxs } }) as unknown as uPlot;++ it('reads the series the scatter plugin answered for', () => {+ expect(getCursorHit(plotWith([null, null, 4, null]))).toStrictEqual({+ seriesIndex: 2,+ dataIndex: 4,+ });+ });++ it('takes a data index of 0 as a hit', () => {+ expect(getCursorHit(plotWith([0, 0]))).toStrictEqual({+ seriesIndex: 1,+ dataIndex: 0,+ });+ });++ it('is null off every dot', () => {+ expect(getCursorHit(plotWith([null, null]))).toBeNull();+ expect(getCursorHit({ cursor: {} } as unknown as uPlot)).toBeNull();+ });+});diff --git a/frontend/src/lib/visualization/charts/Scatter/axisDistribution.ts b/frontend/src/lib/visualization/charts/Scatter/axisDistribution.tsnew file mode 100644index 0000000000..e164bd299d--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/axisDistribution.ts@@ -0,0 +1,130 @@+import { DistributionType } from 'lib/uPlotV2/config/types';++import { getScaleTransform } from './scatterRange';+import { type AxisDistribution, ScatterAxisScale } from './types';++const LINEAR_DISTRIBUTION: AxisDistribution = {+ distribution: DistributionType.Linear,+};++/** Orders of magnitude `auto` needs before it considers leaving linear. */+export const AUTO_MIN_DECADES = 2;++/** How many times more axis the middle half of the points must cover for `auto` to leave linear. */+export const AUTO_SPREAD_GAIN = 2;++function getMagnitudeRange(values: number[]): {+ minMagnitude: number;+ maxMagnitude: number;+ hasNonPositive: boolean;+} {+ let minMagnitude = Infinity;+ let maxMagnitude = -Infinity;+ let hasNonPositive = false;+ for (const value of values) {+ if (!Number.isFinite(value)) {+ continue;+ }+ if (value <= 0) {+ hasNonPositive = true;+ }+ if (value !== 0) {+ minMagnitude = Math.min(minMagnitude, Math.abs(value));+ maxMagnitude = Math.max(maxMagnitude, Math.abs(value));+ }+ }+ return { minMagnitude, maxMagnitude, hasNonPositive };+}++/** The linear band ends at the smallest non-zero magnitude so small values still spread. */+function symmetricLogDistribution(minMagnitude: number): AxisDistribution {+ const asinhThreshold = Number.isFinite(minMagnitude)+ ? 10 ** Math.floor(Math.log10(minMagnitude))+ : 1;+ return { distribution: DistributionType.SymmetricLog, asinhThreshold };+}++function quantile(sorted: number[], q: number): number {+ const position = (sorted.length - 1) * q;+ const lower = Math.floor(position);+ const upper = Math.ceil(position);+ return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);+}++/** Share of the axis the middle half of the points covers. */+function middleHalfSpread(+ sorted: number[],+ [min, max]: [number, number],+ distribution: AxisDistribution,+): number {+ const { forward } = getScaleTransform(distribution);+ const span = forward(max) - forward(min);+ return span > 0+ ? (forward(quantile(sorted, 0.75)) - forward(quantile(sorted, 0.25))) / span+ : 0;+}++/**+ * Log (symlog with zero or negatives) when it spreads the points out clearly+ * more than linear does; min/max alone would let one outlier decide.+ */+function resolveAutoDistribution(+ values: number[],+ softLimits: number[],+): AxisDistribution {+ const sorted = values+ .filter((value) => Number.isFinite(value))+ .sort((a, b) => a - b);+ if (sorted.length < 2) {+ return LINEAR_DISTRIBUTION;+ }+ const { minMagnitude, maxMagnitude, hasNonPositive } = getMagnitudeRange([+ ...sorted,+ ...softLimits,+ ]);+ if (!(Math.log10(maxMagnitude / minMagnitude) >= AUTO_MIN_DECADES)) {+ return LINEAR_DISTRIBUTION;+ }+ const candidate = hasNonPositive+ ? symmetricLogDistribution(minMagnitude)+ : { distribution: DistributionType.Logarithmic };+ const extent: [number, number] = [+ Math.min(sorted[0], ...softLimits),+ Math.max(sorted[sorted.length - 1], ...softLimits),+ ];+ const candidateSpread = middleHalfSpread(sorted, extent, candidate);+ const linearSpread = middleHalfSpread(sorted, extent, LINEAR_DISTRIBUTION);+ return candidateSpread > 0 &&+ candidateSpread >= AUTO_SPREAD_GAIN * linearSpread+ ? candidate+ : LINEAR_DISTRIBUTION;+}++/** `log` falls back to symlog rather than drop zero or negatives; callers filter first to drop them. */+export function resolveAxisDistribution(+ values: number[],+ scale: ScatterAxisScale = ScatterAxisScale.Auto,+ /** Soft limits and thresholds the axis must reach; only `auto` weighs them. */+ softLimits: Array<number | null | undefined> = [],+): AxisDistribution {+ switch (scale) {+ case ScatterAxisScale.Linear:+ return LINEAR_DISTRIBUTION;+ case ScatterAxisScale.SymLog:+ return symmetricLogDistribution(getMagnitudeRange(values).minMagnitude);+ case ScatterAxisScale.Log: {+ const { minMagnitude, hasNonPositive } = getMagnitudeRange(values);+ return hasNonPositive+ ? symmetricLogDistribution(minMagnitude)+ : { distribution: DistributionType.Logarithmic };+ }+ case ScatterAxisScale.Auto:+ default:+ return resolveAutoDistribution(+ values,+ softLimits.filter(+ (limit): limit is number => limit != null && Number.isFinite(limit),+ ),+ );+ }+}diff --git a/frontend/src/lib/visualization/charts/Scatter/scatterRange.ts b/frontend/src/lib/visualization/charts/Scatter/scatterRange.tsnew file mode 100644index 0000000000..276e17c78a--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/scatterRange.ts@@ -0,0 +1,92 @@+import { DistributionType } from 'lib/uPlotV2/config/types';+import { DEFAULT_ASINH_THRESHOLD } from 'lib/uPlotV2/utils/scale';+import uPlot from 'uplot';++import type {+ AxisDistribution,+ ScaleTransform,+ ScatterRangeOptions,+} from './types';++export function getScaleTransform({+ distribution,+ asinhThreshold = DEFAULT_ASINH_THRESHOLD,+}: AxisDistribution): ScaleTransform {+ switch (distribution) {+ case DistributionType.Logarithmic:+ return {+ forward: (value): number => Math.log10(value),+ inverse: (position): number => 10 ** position,+ };+ case DistributionType.SymmetricLog:+ return {+ forward: (value): number => Math.asinh(value / asinhThreshold),+ inverse: (position): number => Math.sinh(position) * asinhThreshold,+ };+ default:+ return {+ forward: (value): number => value,+ inverse: (position): number => position,+ };+ }+}++/** In transformed units. */+const SINGLE_VALUE_HALF_SPAN = 0.5;++/** The data's extent stretched to the soft limits; null with neither. */+function resolveExtent(+ dataMin: number | null,+ dataMax: number | null,+ softMin: number | null | undefined,+ softMax: number | null | undefined,+): [number, number] | null {+ const lows = [dataMin, softMin].filter(+ (value): value is number => value != null && Number.isFinite(value),+ );+ const highs = [dataMax, softMax].filter(+ (value): value is number => value != null && Number.isFinite(value),+ );+ return lows.length > 0 && highs.length > 0+ ? [Math.min(...lows), Math.max(...highs)]+ : null;+}++/** Data extent padded by `marginPx` so edge dots draw whole; log stays unsnapped (snapping after the margin can add an empty decade). */+export function createScatterRange({+ dimension,+ marginPx,+ softMin,+ softMax,+ ...distribution+}: ScatterRangeOptions): uPlot.Scale.Range {+ const transform = getScaleTransform(distribution);+ const isLog = distribution.distribution === DistributionType.Logarithmic;++ // A log scale cannot place a soft limit at or below zero.+ const usableSoftMin = isLog && (softMin ?? 0) <= 0 ? null : softMin;++ return (u, dataMin, dataMax): uPlot.Range.MinMax => {+ const extent = resolveExtent(dataMin, dataMax, usableSoftMin, softMax);+ if (!extent) {+ return isLog ? [1, 10] : [0, 1];+ }++ let start = transform.forward(extent[0]);+ let end = transform.forward(extent[1]);+ if (start === end) {+ start -= SINGLE_VALUE_HALF_SPAN;+ end += SINGLE_VALUE_HALF_SPAN;+ }++ const plotPx =+ (dimension === 'x' ? u.bbox.width : u.bbox.height) / uPlot.pxRatio;+ if (plotPx > 2 * marginPx) {+ const pad = ((end - start) * marginPx) / (plotPx - 2 * marginPx);+ start -= pad;+ end += pad;+ }++ return [transform.inverse(start), transform.inverse(end)];+ };+}diff --git a/frontend/src/lib/visualization/charts/Scatter/types.ts b/frontend/src/lib/visualization/charts/Scatter/types.tsnew file mode 100644index 0000000000..e68b4b31e6--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/types.ts@@ -0,0 +1,67 @@+import type { PrecisionOption } from 'components/Graph/types';+import type {+ DistributionType,+ SelectionPreferencesSource,+} from 'lib/uPlotV2/config/types';+import type { Threshold } from 'lib/uPlotV2/hooks/types';+import type { ScatterPointSize } from 'lib/uPlotV2/plugins/ScatterPlugin/types';++export interface ScatterSeries {+ label: string;+ xs: number[];+ ys: number[];+ /** Optional third channel, in the caller's units. */+ sizes?: Array<number | null>;+}++export enum ScatterAxisScale {+ /** Log or symlog when it spreads the points out more than linear does. */+ Auto = 'auto',+ Linear = 'linear',+ Log = 'log',+ /** Log-like, but places zero and negatives. */+ SymLog = 'symlog',+}++export interface ScatterAxisOptions {+ label?: string;+ unit?: string;+ softMin?: number | null;+ softMax?: number | null;+ scale?: ScatterAxisScale;+ /** Lines drawn across the plot at values on this axis. */+ thresholds?: Threshold[];+}++export interface BuildScatterConfigArgs {+ id: string;+ series: ScatterSeries[];+ isDarkMode: boolean;+ x: ScatterAxisOptions;+ y: ScatterAxisOptions;+ pointSize?: ScatterPointSize;+ /** 0–1. */+ fillOpacity?: number;+ colorMapping?: Record<string, string>;+ decimalPrecision?: PrecisionOption;+ selectionPreferencesSource?: SelectionPreferencesSource;+ shouldSaveSelectionPreference?: boolean;+}++export interface AxisDistribution {+ distribution: DistributionType;+ asinhThreshold?: number;+}++export interface ScaleTransform {+ forward: (value: number) => number;+ inverse: (position: number) => number;+}++export interface ScatterRangeOptions extends AxisDistribution {+ dimension: 'x' | 'y';+ /** CSS pixels kept clear at each end so the largest dot draws whole. */+ marginPx: number;+ softMin?: number | null;+ softMax?: number | null;+}diff --git a/frontend/src/lib/visualization/charts/Scatter/utils.ts b/frontend/src/lib/visualization/charts/Scatter/utils.tsnew file mode 100644index 0000000000..10f6e6adc8--- /dev/null+++ b/frontend/src/lib/visualization/charts/Scatter/utils.ts@@ -0,0 +1,209 @@+import {+ type AxisProps,+ DistributionType,+ DrawStyle,+} from 'lib/uPlotV2/config/types';+import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';+import type { ThresholdsDrawHookOptions } from 'lib/uPlotV2/hooks/types';+import {+ applyScatterPlugin,+ createScatterPlugin,+ SCATTER_FACETS,+} from 'lib/uPlotV2/plugins/ScatterPlugin/scatterPlugin';+import {+ DEFAULT_SCATTER_POINT_SIZE,+ ScatterChartData,+ ScatterSeriesData,+} from 'lib/uPlotV2/plugins/ScatterPlugin/types';+import {+ logScaleSplits,+ spacedLogLabels,+} from 'lib/uPlotV2/utils/logGridSplits';+import { adjustSoftLimitsWithThresholds } from 'lib/uPlotV2/utils/scale';+import uPlot from 'uplot';++import { resolveAxisDistribution } from './axisDistribution';+import { createScatterRange } from './scatterRange';+import type {+ AxisDistribution,+ BuildScatterConfigArgs,+ ScatterAxisOptions,+ ScatterSeries,+} from './types';++const POINT_STROKE_WIDTH = 1;++/** Unit-suffixed x labels are wider than uPlot's 50px default assumes. */+const X_AXIS_TICK_SPACE_PX = 90;+const X_AXIS_END_LABEL_PADDING_PX = 40;++/** The plugin's `dataIdx` answers only for the hit series. */+export function getCursorHit(+ plot: uPlot,+): { seriesIndex: number; dataIndex: number } | null {+ const idxs = plot.cursor.idxs ?? [];+ for (let seriesIndex = 1; seriesIndex < idxs.length; seriesIndex++) {+ const dataIndex = idxs[seriesIndex];+ if (dataIndex != null) {+ return { seriesIndex, dataIndex };+ }+ }+ return null;+}++/** `[null, [xs, ys, sizes?], …]`: uPlot's faceted layout, series 0 empty. */+export function prepareScatterChartData(+ series: ScatterSeries[],+): uPlot.AlignedData {+ const data: ScatterChartData = [+ null,+ ...series.map((entry): ScatterSeriesData =>+ entry.sizes ? [entry.xs, entry.ys, entry.sizes] : [entry.xs, entry.ys],+ ),+ ];+ return data as unknown as uPlot.AlignedData;+}++/** The scatter range is unsnapped, so a log axis places and labels its own ticks. */+function getLogAxisTicks({+ distribution,+}: AxisDistribution): Pick<AxisProps, 'splits' | 'filter'> {+ return distribution === DistributionType.Logarithmic+ ? { splits: logScaleSplits, filter: spacedLogLabels }+ : {};+}++function getThresholdOptions(+ scaleKey: 'x' | 'y',+ { thresholds, unit }: ScatterAxisOptions,+): ThresholdsDrawHookOptions | undefined {+ return thresholds && thresholds.length > 0+ ? { scaleKey, thresholds, yAxisUnit: unit }+ : undefined;+}++export function buildScatterConfig({+ id,+ series,+ isDarkMode,+ x,+ y,+ pointSize = DEFAULT_SCATTER_POINT_SIZE,+ fillOpacity,+ colorMapping = {},+ decimalPrecision,+ selectionPreferencesSource,+ shouldSaveSelectionPreference,+}: BuildScatterConfigArgs): UPlotConfigBuilder {+ const builder = new UPlotConfigBuilder({+ id,+ selectionPreferencesSource,+ shouldSaveSelectionPreference,+ });++ const plugin = createScatterPlugin({ pointSize });+ applyScatterPlugin(builder, plugin);+ // The last x label is centred on the plot's right edge; room for its unit.+ builder.setPadding([16, X_AXIS_END_LABEL_PADDING_PX, 8, 8]);++ const xSoftLimits = adjustSoftLimitsWithThresholds(+ x.softMin ?? null,+ x.softMax ?? null,+ x.thresholds,+ x.unit,+ );+ const ySoftLimits = adjustSoftLimitsWithThresholds(+ y.softMin ?? null,+ y.softMax ?? null,+ y.thresholds,+ y.unit,+ );+ const xDistribution = resolveAxisDistribution(+ series.flatMap((entry) => entry.xs),+ x.scale,+ [xSoftLimits.softMin, xSoftLimits.softMax],+ );+ const yDistribution = resolveAxisDistribution(+ series.flatMap((entry) => entry.ys),+ y.scale,+ [ySoftLimits.softMin, ySoftLimits.softMax],+ );++ const xThresholds = getThresholdOptions('x', x);+ const yThresholds = getThresholdOptions('y', y);++ // The largest disc drawn, plus its outline, kept clear of each plot edge.+ const largestDiameter = series.some((entry) => entry.sizes)+ ? pointSize.max+ : pointSize.fixed;+ const marginPx = largestDiameter / 2 + POINT_STROKE_WIDTH;++ builder.addScale({+ scaleKey: 'x',+ time: false,+ range: createScatterRange({+ dimension: 'x',+ marginPx,+ ...xSoftLimits,+ ...xDistribution,+ }),+ ...xDistribution,+ });+ builder.addScale({+ scaleKey: 'y',+ time: false,+ range: createScatterRange({+ dimension: 'y',+ marginPx,+ ...ySoftLimits,+ ...yDistribution,+ }),+ ...yDistribution,+ });++ builder.addAxis({+ scaleKey: 'x',+ side: 2,+ label: x.label || undefined,+ isDarkMode,+ isTimeAxis: false,+ yAxisUnit: x.unit ?? '',+ decimalPrecision,+ isLogScale: xDistribution.distribution !== DistributionType.Linear,+ ...getLogAxisTicks(xDistribution),+ space: X_AXIS_TICK_SPACE_PX,+ });+ builder.addAxis({+ scaleKey: 'y',+ side: 3,+ label: y.label || undefined,+ isDarkMode,+ yAxisUnit: y.unit ?? '',+ decimalPrecision,+ isLogScale: yDistribution.distribution !== DistributionType.Linear,+ ...getLogAxisTicks(yDistribution),+ });++ series.forEach((entry) => {+ builder.addSeries({+ scaleKey: 'y',+ label: entry.label,+ colorMapping,+ drawStyle: DrawStyle.Scatter,+ pathBuilder: plugin.pathBuilder,+ facets: SCATTER_FACETS,+ lineWidth: POINT_STROKE_WIDTH,+ pointSize: pointSize.fixed,+ fillOpacity,+ isDarkMode,+ });+ });++ [xThresholds, yThresholds].forEach((options) => {+ if (options) {+ builder.addThresholds(options);+ }+ });++ return builder;+}diff --git a/frontend/src/lib/visualization/charts/types.ts b/frontend/src/lib/visualization/charts/types.tsindex 003573b49b..253b9a8163 100644--- a/frontend/src/lib/visualization/charts/types.ts+++ b/frontend/src/lib/visualization/charts/types.ts@@ -16,6 +16,10 @@ import type {HeatmapColorOptions,HeatmapSeries,} from 'lib/uPlotV2/plugins/HeatmapPlugin/types';+import type {+ ScatterChannels,+ ScatterPointLabel,+} from 'lib/uPlotV2/plugins/ScatterPlugin/types';import {DashboardCursorSync,SyncTooltipFilterMode,@@ -88,6 +92,26 @@ export interface HistogramChartProps extends ChartWrapperProps {isQueriesMerged?: boolean;}+/** The dot a click landed on; `seriesIndex` is uPlot's, so the first series is 1. */+export interface ScatterPointClick {+ seriesIndex: number;+ dataIndex: number;+ color: string;+ /** Viewport coordinates of the click. */+ coordinates: { x: number; y: number };+}++/** `data` is mode-2 (`prepareScatterChartData`); `config` comes from `buildScatterConfig`. */+export interface ScatterChartProps extends ChartWrapperProps {+ channels: ScatterChannels;+ resolvePointGroupValues?: (+ seriesIndex: number,+ dataIndex: number,+ ) => ScatterPointLabel[];+ /** Fires for a click on a dot; a click on empty plot space fires nothing. */+ onPointClick?: (click: ScatterPointClick) => void;+}+/*** Data arrives as the query response carries it — bucket bounds plus one series per* group — and the chart pivots and sums it, so no caller has to get the transposediff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsxindex 99e5539d75..0edced3d70 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx@@ -40,6 +40,8 @@ interface ConfigPaneProps {legendSeries: LegendSeries[];/** Table panel's resolved value columns, for the table-only editors. */tableColumns: TableColumnOption[];+ /** Group-by columns of the joined scalar result. */+ groupColumns?: string[];/** Query step interval (seconds), for the chart-appearance span-gaps floor. */stepInterval?: number;/**@@ -67,6 +69,7 @@ function ConfigPane({queryType,legendSeries,tableColumns,+ groupColumns,stepInterval,panel,panelId,@@ -133,6 +136,7 @@ function ConfigPane({defaults={defaults}legendSeries={legendSeries}tableColumns={tableColumns}+ groupColumns={groupColumns}signal={signal}panelKind={panelKind}onChangePanelKind={onChangePanelKind}@@ -160,6 +164,7 @@ function ConfigPane({defaults={defaults}legendSeries={legendSeries}tableColumns={tableColumns}+ groupColumns={groupColumns}signal={signal}panelKind={panelKind}onChangePanelKind={onChangePanelKind}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsxindex 72cf68a18e..0f8bceb733 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsx@@ -12,6 +12,11 @@ import type { SectionEditorContext } from '../sectionContext';import { getSectionDefault, resolveSectionEditor } from '../sectionRegistry';import SettingsSection from '../SettingsSection/SettingsSection';import { isDifferent } from '../utils/changes';+import {+ getScatterAxisColumnNames,+ getScatterAxisColumnUnits,+} from '../utils/scatterAxisColumns';+import { getSizeColumnLabel } from '../utils/sizeColumnLabel';import SectionHeaderQuickAdd from './SectionHeaderQuickAdd';type SectionSlotProps = {@@ -63,6 +68,7 @@ function SectionSlot({bare,legendSeries,tableColumns,+ groupColumns,signal,panelKind,onChangePanelKind,@@ -74,7 +80,10 @@ function SectionSlot({const editor = resolveSectionEditor(config.kind);// Controlled so the header slot can expand on click; list sections open when populated.const [open, setOpen] = useState(() => {- if (config.kind === SectionKind.Visualization) {+ if (+ config.kind === SectionKind.Visualization ||+ config.kind === SectionKind.Dimensions+ ) {return true;}const value = editor?.get(spec);@@ -129,6 +138,10 @@ function SectionSlot({legendSeries,yAxisUnit,tableColumns,+ groupColumns,+ sizeColumnLabel: getSizeColumnLabel(spec, tableColumns),+ axisColumnNames: getScatterAxisColumnNames(spec, tableColumns),+ axisColumnUnits: getScatterAxisColumnUnits(spec, tableColumns),signal,panelKind,onChangePanelKind,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.module.scss b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.module.scssnew file mode 100644index 0000000000..e56deadfb7--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.module.scss@@ -0,0 +1,3 @@+.select {+ width: 100%;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.tsxnew file mode 100644index 0000000000..bc0857381c--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/ConfigMultiSelect.tsx@@ -0,0 +1,49 @@+import { ComboboxSimple } from '@signozhq/ui/combobox';++import styles from './ConfigMultiSelect.module.scss';++export interface ConfigMultiSelectItem<T extends string = string> {+ value: T;+ label: string;+}++interface ConfigMultiSelectProps<T extends string = string> {+ testId: string;+ value: T[];+ placeholder?: string;+ items: ConfigMultiSelectItem<T>[];+ onChange: (value: T[]) => void;+ disabled?: boolean;+}++/** Emits picks in items order, so the stored value is stable. */+function ConfigMultiSelect<T extends string = string>({+ testId,+ value,+ placeholder,+ items,+ onChange,+ disabled,+}: ConfigMultiSelectProps<T>): JSX.Element {+ return (+ <ComboboxSimple+ multiple+ className={styles.select}+ testId={testId}+ value={value}+ placeholder={placeholder}+ disabled={disabled}+ items={items}+ onChange={(next): void => {+ const picked = Array.isArray(next) ? next : [];+ onChange(+ items+ .map((item) => item.value)+ .filter((candidate) => picked.includes(candidate)),+ );+ }}+ />+ );+}++export default ConfigMultiSelect;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/__tests__/ConfigMultiSelect.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/__tests__/ConfigMultiSelect.test.tsxnew file mode 100644index 0000000000..37981155b6--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigMultiSelect/__tests__/ConfigMultiSelect.test.tsx@@ -0,0 +1,48 @@+import { render, screen, userEvent } from 'tests/test-utils';++import ConfigMultiSelect from '../ConfigMultiSelect';++const ITEMS = [+ { value: 'a', label: 'alpha' },+ { value: 'b', label: 'beta' },+ { value: 'c', label: 'gamma' },+];++async function open(): Promise<ReturnType<typeof userEvent.setup>> {+ const user = userEvent.setup();+ await user.click(screen.getByTestId('multi'));+ return user;+}++describe('ConfigMultiSelect', () => {+ it('shows the placeholder while nothing is picked', () => {+ render(+ <ConfigMultiSelect+ testId="multi"+ value={[]}+ placeholder="Every group key"+ items={ITEMS}+ onChange={jest.fn()}+ />,+ );++ expect(screen.getByText('Every group key')).toBeInTheDocument();+ });++ it('keeps picks in item order, not the order they were picked', async () => {+ const onChange = jest.fn();+ render(+ <ConfigMultiSelect+ testId="multi"+ value={['c']}+ items={ITEMS}+ onChange={onChange}+ />,+ );++ const user = await open();+ await user.click(await screen.findByRole('option', { name: 'alpha' }));++ expect(onChange).toHaveBeenLastCalledWith(['a', 'c']);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.module.scss b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.module.scssnew file mode 100644index 0000000000..29a42b59cc--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.module.scss@@ -0,0 +1,21 @@+.row {+ display: flex;+ align-items: center;+ gap: 12px;+}++.slider {+ flex: 1;+ min-width: 0;+ // Cancel the slider's half-thumb track inset so it aligns with the other controls.+ margin-inline: calc(var(--slider-thumb-width, 18px) / -2);+}++.value {+ flex-shrink: 0;+ min-width: 56px;+ text-align: right;+ font-size: 12px;+ font-variant-numeric: tabular-nums;+ color: var(--l3-foreground);+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.tsxnew file mode 100644index 0000000000..0f930fda31--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/ConfigRangeSlider.tsx@@ -0,0 +1,47 @@+import { Slider } from '@signozhq/ui/slider';++import styles from './ConfigRangeSlider.module.scss';++interface ConfigRangeSliderProps {+ testId: string;+ value: [number, number];+ min: number;+ max: number;+ step: number;+ formatValue?: (value: [number, number]) => string;+ onChange: (value: [number, number]) => void;+}++function ConfigRangeSlider({+ testId,+ value,+ min,+ max,+ step,+ formatValue,+ onChange,+}: ConfigRangeSliderProps): JSX.Element {+ return (+ <div className={styles.row}>+ <Slider+ range+ testId={testId}+ className={styles.slider}+ value={value}+ min={min}+ max={max}+ step={step}+ onChange={(next): void => {+ if (Array.isArray(next) && next.length === 2) {+ onChange([Math.min(next[0], next[1]), Math.max(next[0], next[1])]);+ }+ }}+ />+ <span className={styles.value}>+ {formatValue ? formatValue(value) : `${value[0]}–${value[1]}`}+ </span>+ </div>+ );+}++export default ConfigRangeSlider;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/__tests__/ConfigRangeSlider.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/__tests__/ConfigRangeSlider.test.tsxnew file mode 100644index 0000000000..b3facf5257--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigRangeSlider/__tests__/ConfigRangeSlider.test.tsx@@ -0,0 +1,55 @@+import { render, screen, userEvent, within } from 'tests/test-utils';++import ConfigRangeSlider from '../ConfigRangeSlider';++window.ResizeObserver =+ window.ResizeObserver ||+ jest.fn().mockImplementation(() => ({+ disconnect: jest.fn(),+ observe: jest.fn(),+ unobserve: jest.fn(),+ }));++describe('ConfigRangeSlider', () => {+ it('renders a thumb per end and the formatted range', () => {+ render(+ <ConfigRangeSlider+ testId="range"+ value={[4, 24]}+ min={2}+ max={40}+ step={1}+ formatValue={([min, max]): string => `${min}–${max} px`}+ onChange={jest.fn()}+ />,+ );++ expect(+ within(screen.getByTestId('range')).getAllByRole('slider'),+ ).toHaveLength(2);+ expect(screen.getByText('4–24 px')).toBeInTheDocument();+ });++ it('moves one end and reports the pair low to high', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ConfigRangeSlider+ testId="range"+ value={[4, 24]}+ min={2}+ max={40}+ step={1}+ onChange={onChange}+ />,+ );++ const [, maxThumb] = within(screen.getByTestId('range')).getAllByRole(+ 'slider',+ );+ maxThumb.focus();+ await user.keyboard('{ArrowRight}');++ expect(onChange).toHaveBeenLastCalledWith([4, 25]);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionContext.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionContext.tsindex 7c2343f119..bd7313f4dc 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionContext.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionContext.ts@@ -13,6 +13,14 @@ import { EQueryType } from 'types/common/dashboard';export interface SectionEditorContext {legendSeries?: LegendSeries[];tableColumns?: TableColumnOption[];+ /** Group-by labels of the joined scalar result; the colour-by options. */+ groupColumns?: string[];+ /** Scatter Plot's size column label, if bound. */+ sizeColumnLabel?: string;+ /** Name of the column each Scatter Plot axis plots, for its label's placeholder. */+ axisColumnNames?: { x?: string; y?: string };+ /** Unit of the column each Scatter Plot axis plots. */+ axisColumnUnits?: { x?: string; y?: string };signal?: TelemetrytypesSignalDTO;panelKind?: PanelKind;onChangePanelKind?: (kind: PanelKind) => void;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsxindex f7b6bffb92..17b47d6518 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsx@@ -4,6 +4,8 @@ import type {DashboardtypesHistogramBucketsDTO,DashboardtypesLegendDTO,DashboardtypesPanelSpecDTO,+ DashboardtypesScatterPlotAxesDTO,+ DashboardtypesScatterPlotDimensionsDTO,} from 'api/generated/services/sigNoz.schemas';import {SectionKind,@@ -22,9 +24,11 @@ import AxesSection from './sections/AxesSection/AxesSection';import BucketsSection from './sections/BucketsSection/BucketsSection';import ChartAppearanceSection from './sections/ChartAppearanceSection/ChartAppearanceSection';import ContextLinksSection from './sections/ContextLinksSection/ContextLinksSection';+import DimensionsSection from './sections/DimensionsSection/DimensionsSection';import FormattingSection from './sections/FormattingSection/FormattingSection';import LegendSection from './sections/LegendSection/LegendSection';import PanelHeaderSection from './sections/PanelHeaderSection/PanelHeaderSection';+import ScatterAxesSection from './sections/ScatterAxesSection/ScatterAxesSection';import TextLayoutSection from './sections/TextLayoutSection/TextLayoutSection';import ThresholdsSection from './sections/ThresholdsSection/ThresholdsSection';import VisualizationSection from './sections/VisualizationSection/VisualizationSection';@@ -86,6 +90,20 @@ export const SECTION_REGISTRY: {getPluginSlice<PanelAxesSlice>(spec, 'axes'),update: (spec, axes): PanelSpec => updatePluginSlice(spec, 'axes', axes),},+ // Same `axes` key as above, in Scatter Plot's per-axis shape.+ [SectionKind.ScatterAxes]: {+ Component: ScatterAxesSection,+ get: (spec): DashboardtypesScatterPlotAxesDTO | undefined =>+ getPluginSlice<DashboardtypesScatterPlotAxesDTO>(spec, 'axes'),+ update: (spec, axes): PanelSpec => updatePluginSlice(spec, 'axes', axes),+ },+ [SectionKind.Dimensions]: {+ Component: DimensionsSection,+ get: (spec): DashboardtypesScatterPlotDimensionsDTO | undefined =>+ getPluginSlice<DashboardtypesScatterPlotDimensionsDTO>(spec, 'dimensions'),+ update: (spec, dimensions): PanelSpec =>+ updatePluginSlice(spec, 'dimensions', dimensions),+ },[SectionKind.Legend]: {Component: LegendSection,get: (spec): DashboardtypesLegendDTO | undefined =>diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.tsxindex 73a45ac248..79cc853472 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.tsx@@ -14,6 +14,7 @@ import type { SectionEditorContext } from '../../sectionContext';import { createFieldResetter } from '../../utils/changes';import DisconnectValuesField from './DisconnectValuesField';import HeatmapColorsField from './HeatmapColorsField';+import PointsFields from './PointsFields';import {FILL_MODE_OPTIONS,FILLED_FILL_MODE_OPTIONS,@@ -39,8 +40,9 @@ function ChartAppearanceSection({controls,onChange,stepInterval,+ sizeColumnLabel,}: SectionEditorProps<SectionKind.ChartAppearance> &- Pick<SectionEditorContext, 'stepInterval'>): JSX.Element {+ Pick<SectionEditorContext, 'stepInterval' | 'sizeColumnLabel'>): JSX.Element {const reset = createFieldResetter(value, savedValue, onChange);const interpolation = value?.lineInterpolation;@@ -122,6 +124,15 @@ function ChartAppearanceSection({/>)}+ {controls.points && (+ <PointsFields+ value={value?.points}+ savedValue={savedValue?.points}+ sizeColumnLabel={sizeColumnLabel}+ onChange={(points): void => onChange({ ...value, points })}+ />+ )}+{controls.spanGaps && (<DisconnectValuesFieldtestId="panel-editor-v2-span-gaps"diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/PointsFields.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/PointsFields.tsxnew file mode 100644index 0000000000..00ea8510da--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/PointsFields.tsx@@ -0,0 +1,86 @@+import type { DashboardtypesScatterPlotPointsDTO } from 'api/generated/services/sigNoz.schemas';+import {+ POINT_OPACITY_BOUNDS,+ POINT_SIZE_BOUNDS,+ resolvePointOpacity,+ resolvePointSize,+} from 'pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/points';++import ConfigField from '../../controls/ConfigField/ConfigField';+import ConfigRangeSlider from '../../controls/ConfigRangeSlider/ConfigRangeSlider';+import ConfigSlider from '../../controls/ConfigSlider/ConfigSlider';+import { createFieldResetter } from '../../utils/changes';+import { formatOpacity, formatPointSize, formatPointSizeRange } from './utils';++const OPACITY_STEP = 0.01;++interface PointsFieldsProps {+ value: DashboardtypesScatterPlotPointsDTO | undefined;+ savedValue: DashboardtypesScatterPlotPointsDTO | undefined;+ onChange: (next: DashboardtypesScatterPlotPointsDTO) => void;+ sizeColumnLabel?: string;+}++function PointsFields({+ value,+ savedValue,+ onChange,+ sizeColumnLabel,+}: PointsFieldsProps): JSX.Element {+ const reset = createFieldResetter(value, savedValue, onChange);+ // Renderer defaults, so thumbs start where an unset field draws.+ const size = resolvePointSize(value);++ return (+ <>+ {sizeColumnLabel ? (+ <ConfigField+ label="Point size"+ help={`Each dot's area scales with ${sizeColumnLabel} between min and max.`}+ {...reset('minSize', 'maxSize')}+ >+ <ConfigRangeSlider+ testId="panel-editor-v2-point-size-range"+ value={[size.min, size.max]}+ min={POINT_SIZE_BOUNDS.min}+ max={POINT_SIZE_BOUNDS.max}+ step={1}+ formatValue={formatPointSizeRange}+ onChange={([minSize, maxSize]): void =>+ onChange({ ...value, minSize, maxSize })+ }+ />+ </ConfigField>+ ) : (+ <ConfigField+ label="Point size"+ help="Every dot uses this size. Map a Size column to draw a bubble chart."+ {...reset('size')}+ >+ <ConfigSlider+ testId="panel-editor-v2-point-size"+ value={size.fixed}+ min={POINT_SIZE_BOUNDS.min}+ max={POINT_SIZE_BOUNDS.max}+ step={1}+ formatValue={formatPointSize}+ onChange={(next): void => onChange({ ...value, size: next })}+ />+ </ConfigField>+ )}+ <ConfigField label="Fill opacity" {...reset('opacity')}>+ <ConfigSlider+ testId="panel-editor-v2-point-opacity"+ value={resolvePointOpacity(value)}+ min={POINT_OPACITY_BOUNDS.min}+ max={POINT_OPACITY_BOUNDS.max}+ step={OPACITY_STEP}+ formatValue={formatOpacity}+ onChange={(opacity): void => onChange({ ...value, opacity })}+ />+ </ConfigField>+ </>+ );+}++export default PointsFields;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/__tests__/PointsFields.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/__tests__/PointsFields.test.tsxnew file mode 100644index 0000000000..363bea753f--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/__tests__/PointsFields.test.tsx@@ -0,0 +1,117 @@+import { render, screen, userEvent, within } from 'tests/test-utils';++import ChartAppearanceSection from '../ChartAppearanceSection';++window.ResizeObserver =+ window.ResizeObserver ||+ jest.fn().mockImplementation(() => ({+ disconnect: jest.fn(),+ observe: jest.fn(),+ unobserve: jest.fn(),+ }));++describe('ChartAppearanceSection points', () => {+ it('offers one point size when nothing sizes the dots', () => {+ render(+ <ChartAppearanceSection+ value={undefined}+ controls={{ points: true }}+ onChange={jest.fn()}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-point-size')).toBeInTheDocument();+ expect(+ screen.queryByTestId('panel-editor-v2-point-size-range'),+ ).not.toBeInTheDocument();+ expect(screen.getByText('6 px')).toBeInTheDocument();+ expect(+ screen.getByText(+ 'Every dot uses this size. Map a Size column to draw a bubble chart.',+ ),+ ).toBeInTheDocument();+ expect(screen.getByText('70%')).toBeInTheDocument();+ });++ it('offers a min/max range named after the size column when one is bound', () => {+ render(+ <ChartAppearanceSection+ value={{ points: { minSize: 5 } }}+ controls={{ points: true }}+ sizeColumnLabel="B.count()"+ onChange={jest.fn()}+ />,+ );++ expect(+ screen.getByTestId('panel-editor-v2-point-size-range'),+ ).toBeInTheDocument();+ expect(+ screen.queryByTestId('panel-editor-v2-point-size'),+ ).not.toBeInTheDocument();+ expect(screen.getByText('5–24 px')).toBeInTheDocument();+ expect(+ screen.getByText(+ "Each dot's area scales with B.count() between min and max.",+ ),+ ).toBeInTheDocument();+ });++ it('steps the fixed size by a whole pixel, keeping the range', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ChartAppearanceSection+ value={{ points: { size: 6, minSize: 4, maxSize: 30 } }}+ controls={{ points: true }}+ onChange={onChange}+ />,+ );++ const sizeThumb = within(+ screen.getByTestId('panel-editor-v2-point-size'),+ ).getByRole('slider');+ sizeThumb.focus();+ await user.keyboard('{ArrowRight}');++ expect(onChange).toHaveBeenLastCalledWith({+ points: { size: 7, minSize: 4, maxSize: 30 },+ });+ });++ it('stops the opacity at 10%', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ChartAppearanceSection+ value={{ points: { opacity: 0.1 } }}+ controls={{ points: true }}+ onChange={onChange}+ />,+ );++ const opacityThumb = within(+ screen.getByTestId('panel-editor-v2-point-opacity'),+ ).getByRole('slider');+ expect(opacityThumb).toHaveAttribute('aria-valuemin', '0.1');+ opacityThumb.focus();+ await user.keyboard('{ArrowLeft}');++ expect(onChange).not.toHaveBeenCalled();+ });++ it('leaves the points out of a kind that does not declare them', () => {+ render(+ <ChartAppearanceSection+ value={undefined}+ controls={{ lineStyle: true }}+ onChange={jest.fn()}+ />,+ );++ expect(+ screen.queryByTestId('panel-editor-v2-point-size'),+ ).not.toBeInTheDocument();+ expect(screen.queryByText('Fill opacity')).not.toBeInTheDocument();+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/utils.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/utils.tsindex 31558d065f..b5100f7fe9 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/utils.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/utils.ts@@ -12,3 +12,11 @@ export function defaultDisconnectDuration(stepInterval?: number): string {export function formatOpacity(opacity: number): string {return `${Math.round(opacity * 100)}%`;}++export function formatPointSize(size: number): string {+ return `${size} px`;+}++export function formatPointSizeRange([min, max]: [number, number]): string {+ return `${min}–${max} px`;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.module.scss b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.module.scssnew file mode 100644index 0000000000..7325b66877--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.module.scss@@ -0,0 +1,24 @@+.section {+ display: flex;+ flex-direction: column;+ gap: 18px;+}++.labelWithInfo {+ display: inline-flex;+ align-items: center;+ gap: 6px;+}++.info {+ flex-shrink: 0;+ color: var(--l3-foreground);+ cursor: help;+}++.description {+ margin: 0;+ color: var(--l2-foreground);+ font-size: 12px;+ line-height: 17px;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.tsxnew file mode 100644index 0000000000..bd7e6906b8--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/DimensionsSection.tsx@@ -0,0 +1,111 @@+import { useMemo } from 'react';+import type {+ SectionEditorProps,+ SectionKind,+} from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';++import ConfigField from '../../controls/ConfigField/ConfigField';+import ConfigMultiSelect from '../../controls/ConfigMultiSelect/ConfigMultiSelect';+import ConfigSelect from '../../controls/ConfigSelect/ConfigSelect';+import type { SectionEditorContext } from '../../sectionContext';+import { resolveAutoAxes } from '../../utils/scatterAxisColumns';+import LabelWithInfo from './LabelWithInfo';+import {+ buildColorKeyItems,+ buildDimensionItems,+ formatAutoOption,+ formatColumnOption,+ UNSET_DIMENSION,+} from './utils';++import styles from './DimensionsSection.module.scss';++type DimensionsSectionProps = SectionEditorProps<SectionKind.Dimensions> &+ Pick<SectionEditorContext, 'tableColumns' | 'groupColumns'>;++const FIELD_INFO = {+ x: 'The value column that places each dot left to right. Auto takes the first value column.',+ y: "The value column that places each dot bottom to top. Auto takes the first value column X doesn't use.",+ sizeBy:+ "Optional. Scales each dot's area by this value column; a group without a value draws at the default size.",+ colorBy:+ 'One color and legend entry per combination of the selected keys. Leave it empty to color by every group key.',+};++function DimensionsSection({+ value,+ onChange,+ tableColumns = [],+ groupColumns = [],+}: DimensionsSectionProps): JSX.Element {+ const valueItems = useMemo(+ () =>+ tableColumns.map((column) => ({+ value: column.key,+ label: formatColumnOption(column),+ })),+ [tableColumns],+ );+ const autoAxes = resolveAutoAxes(tableColumns, {+ x: value?.x,+ y: value?.y,+ });+ const colorBy = value?.colorBy ?? [];+ const colorItems = buildColorKeyItems(groupColumns, colorBy);++ const fields = [+ { dimension: 'x', label: 'X axis', unsetLabel: formatAutoOption(autoAxes.x) },+ { dimension: 'y', label: 'Y axis', unsetLabel: formatAutoOption(autoAxes.y) },+ { dimension: 'sizeBy', label: 'Size by', unsetLabel: 'None' },+ ] as const;++ return (+ <div className={styles.section}>+ {fields.map(({ dimension, label, unsetLabel }) => (+ <ConfigField+ key={dimension}+ label={+ <LabelWithInfo+ label={label}+ info={FIELD_INFO[dimension]}+ testId={`panel-editor-v2-dimension-${dimension}-info`}+ />+ }+ >+ <ConfigSelect+ testId={`panel-editor-v2-dimension-${dimension}`}+ value={value?.[dimension] || UNSET_DIMENSION}+ items={buildDimensionItems(valueItems, value?.[dimension], unsetLabel)}+ onChange={(next): void => onChange({ ...value, [dimension]: next })}+ />+ </ConfigField>+ ))}+ <ConfigField+ label={+ <LabelWithInfo+ label="Color by"+ info={FIELD_INFO.colorBy}+ testId="panel-editor-v2-dimension-colorBy-info"+ />+ }+ >+ <ConfigMultiSelect+ testId="panel-editor-v2-dimension-colorBy"+ value={colorBy}+ items={colorItems}+ placeholder={+ colorItems.length > 0 ? 'Every group key' : 'No group-by labels'+ }+ disabled={colorItems.length === 0}+ onChange={(next): void => onChange({ ...value, colorBy: next })}+ />+ </ConfigField>+ <p className={styles.description}>+ Each dot is one group from the query. X and Y place it, Size by scales it,+ and Color by groups it in the legend.+ </p>+ </div>+ );+}++export default DimensionsSection;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/LabelWithInfo.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/LabelWithInfo.tsxnew file mode 100644index 0000000000..a7c85211ea--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/LabelWithInfo.tsx@@ -0,0 +1,27 @@+import { Info } from '@signozhq/icons';+import { Tooltip } from '@signozhq/ui/tooltip';++import styles from './DimensionsSection.module.scss';++interface LabelWithInfoProps {+ label: string;+ info: string;+ testId: string;+}++function LabelWithInfo({+ label,+ info,+ testId,+}: LabelWithInfoProps): JSX.Element {+ return (+ <span className={styles.labelWithInfo}>+ {label}+ <Tooltip title={info}>+ <Info size={12} className={styles.info} data-testid={testId} />+ </Tooltip>+ </span>+ );+}++export default LabelWithInfo;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/__tests__/DimensionsSection.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/__tests__/DimensionsSection.test.tsxnew file mode 100644index 0000000000..897de307a9--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/__tests__/DimensionsSection.test.tsx@@ -0,0 +1,184 @@+import { render, screen, userEvent } from 'tests/test-utils';++import DimensionsSection from '../DimensionsSection';++const TABLE_COLUMNS = [+ { key: 'A', label: 'A.Request rate', name: 'Request rate' },+ { key: 'B.p99(duration_nano)', label: 'B.p99 latency', name: 'p99 latency' },+ { key: 'C.count()', label: 'C.count()', name: 'count()' },+];++async function pick(dimension: string, label: string): Promise<void> {+ const user = userEvent.setup();+ const trigger = screen.getByTestId(`panel-editor-v2-dimension-${dimension}`);+ await user.click(trigger.querySelector('.ant-select-selector') as HTMLElement);+ await user.click(await screen.findByRole('option', { name: label }));+}++describe('DimensionsSection', () => {+ it('names the column each unset axis falls back to', () => {+ render(+ <DimensionsSection+ value={undefined}+ onChange={jest.fn()}+ tableColumns={TABLE_COLUMNS}+ groupColumns={['service.name']}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-dimension-x')).toHaveTextContent(+ 'Auto (A · Request rate)',+ );+ expect(screen.getByTestId('panel-editor-v2-dimension-y')).toHaveTextContent(+ 'Auto (B.p99(duration_nano) · p99 latency)',+ );+ expect(+ screen.getByTestId('panel-editor-v2-dimension-sizeBy'),+ ).toHaveTextContent('None');+ });++ it('falls Y back to a column other than the bound X', () => {+ render(+ <DimensionsSection+ value={{ x: 'B.p99(duration_nano)' }}+ onChange={jest.fn()}+ tableColumns={TABLE_COLUMNS}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-dimension-y')).toHaveTextContent(+ 'Auto (A · Request rate)',+ );+ });++ it('shows a column by its key alone when the name only repeats it', async () => {+ const onChange = jest.fn();+ render(+ <DimensionsSection+ value={undefined}+ onChange={onChange}+ tableColumns={TABLE_COLUMNS}+ />,+ );++ await pick('sizeBy', 'C.count()');++ expect(onChange).toHaveBeenCalledWith({ sizeBy: 'C.count()' });+ });++ it('binds an axis to a value column by its key', async () => {+ const onChange = jest.fn();+ render(+ <DimensionsSection+ value={{ x: 'A' }}+ onChange={onChange}+ tableColumns={TABLE_COLUMNS}+ />,+ );++ await pick('y', 'B.p99(duration_nano) · p99 latency');++ expect(onChange).toHaveBeenCalledWith({+ x: 'A',+ y: 'B.p99(duration_nano)',+ });+ });++ it('clears the size back to none', async () => {+ const onChange = jest.fn();+ render(+ <DimensionsSection+ value={{ sizeBy: 'A' }}+ onChange={onChange}+ tableColumns={TABLE_COLUMNS}+ />,+ );++ await pick('sizeBy', 'None');++ expect(onChange).toHaveBeenCalledWith({ sizeBy: '' });+ });++ it('keeps a binding the results no longer have visible', () => {+ render(+ <DimensionsSection+ value={{ x: 'D' }}+ onChange={jest.fn()}+ tableColumns={TABLE_COLUMNS}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-dimension-x')).toHaveTextContent(+ 'D (not in results)',+ );+ });++ it('colours by any combination of group-by keys, kept in result order', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <DimensionsSection+ value={{ colorBy: ['service.name'] }}+ onChange={onChange}+ groupColumns={['k8s.namespace.name', 'service.name']}+ />,+ );++ await user.click(screen.getByTestId('panel-editor-v2-dimension-colorBy'));+ await user.click(+ await screen.findByRole('option', { name: 'k8s.namespace.name' }),+ );++ expect(onChange).toHaveBeenLastCalledWith({+ colorBy: ['k8s.namespace.name', 'service.name'],+ });+ });++ it('explains every field from an info icon', () => {+ render(<DimensionsSection value={undefined} onChange={jest.fn()} />);++ ['x', 'y', 'sizeBy', 'colorBy'].forEach((dimension) => {+ expect(+ screen.getByTestId(`panel-editor-v2-dimension-${dimension}-info`),+ ).toBeInTheDocument();+ });+ });++ it('says what an empty colour selection means', () => {+ render(+ <DimensionsSection+ value={undefined}+ onChange={jest.fn()}+ groupColumns={['service.name']}+ />,+ );++ expect(screen.getByText('Every group key')).toBeInTheDocument();+ expect(+ screen.getByTestId('panel-editor-v2-dimension-colorBy-info'),+ ).toBeInTheDocument();+ });++ it('keeps a selected colour key the results no longer have', () => {+ render(+ <DimensionsSection+ value={{ colorBy: ['host.name'] }}+ onChange={jest.fn()}+ groupColumns={['service.name']}+ />,+ );++ expect(+ screen.getByTestId('panel-editor-v2-dimension-colorBy'),+ ).toHaveTextContent('host.name (not in results)');+ });++ it('disables colour when the query has no group by', () => {+ render(<DimensionsSection value={undefined} onChange={jest.fn()} />);++ expect(screen.getByText('No group-by labels')).toBeInTheDocument();+ expect(+ screen.getByTestId('panel-editor-v2-dimension-colorBy'),+ ).toHaveAttribute('aria-disabled', 'true');+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/utils.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/utils.tsnew file mode 100644index 0000000000..bc908bb977--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/DimensionsSection/utils.ts@@ -0,0 +1,45 @@+import type { ConfigMultiSelectItem } from '../../controls/ConfigMultiSelect/ConfigMultiSelect';+import type { ConfigSelectItem } from '../../controls/ConfigSelect/ConfigSelect';+import type { TableColumnOption } from '../../../hooks/useTableColumns';++/** The select value for an unset dimension; the spec stores it as `''`. */+export const UNSET_DIMENSION = '';++/** `A · Request rate`, or the key alone when the name only repeats it (`A.count()`). */+export function formatColumnOption({+ key,+ name,+}: Pick<TableColumnOption, 'key' | 'name'>): string {+ return key === name || key.endsWith(`.${name}`) ? key : `${key} · ${name}`;+}++export function formatAutoOption(+ column: TableColumnOption | undefined,+): string {+ return column ? `Auto (${formatColumnOption(column)})` : 'Auto';+}++/** Keeps a bound key the result lacks, so the select never shows a bare value. */+export function buildDimensionItems(+ columns: ConfigSelectItem[],+ current: string | undefined,+ unsetLabel: string,+): ConfigSelectItem[] {+ const items = [{ value: UNSET_DIMENSION, label: unsetLabel }, ...columns];+ if (current && !columns.some((column) => column.value === current)) {+ items.push({ value: current, label: `${current} (not in results)` });+ }+ return items;+}++export function buildColorKeyItems(+ groupColumns: string[],+ selected: string[],+): ConfigMultiSelectItem[] {+ return [+ ...groupColumns.map((column) => ({ value: column, label: column })),+ ...selected+ .filter((key) => !groupColumns.includes(key))+ .map((key) => ({ value: key, label: `${key} (not in results)` })),+ ];+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/__tests__/FormattingSection.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/__tests__/FormattingSection.test.tsxindex 96c5eee9e8..5595199706 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/__tests__/FormattingSection.test.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/__tests__/FormattingSection.test.tsx@@ -152,7 +152,7 @@ describe('FormattingSection', () => {<FormattingSectionvalue={{ columnUnits: { A: 'By' } }}controls={{ columnUnits: true }}- tableColumns={[{ key: 'A', label: 'A' }]}+ tableColumns={[{ key: 'A', label: 'A', name: 'A' }]}metricUnit="s"onChange={jest.fn()}/>,@@ -166,7 +166,7 @@ describe('FormattingSection', () => {<FormattingSectionvalue={{ columnUnits: { A: 's' } }}controls={{ columnUnits: true }}- tableColumns={[{ key: 'A', label: 'A' }]}+ tableColumns={[{ key: 'A', label: 'A', name: 'A' }]}metricUnit="s"onChange={jest.fn()}/>,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.module.scss b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.module.scssnew file mode 100644index 0000000000..fdaed7bd95--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.module.scss@@ -0,0 +1,10 @@+.axes {+ display: flex;+ flex-direction: column;+ gap: 24px;+}++.axis + .axis {+ padding-top: 24px;+ border-top: 1px solid var(--l1-border);+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.tsxnew file mode 100644index 0000000000..398bd0f30b--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxesSection.tsx@@ -0,0 +1,42 @@+import type {+ SectionEditorProps,+ SectionKind,+} from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';++import ConfigField from '../../controls/ConfigField/ConfigField';+import type { SectionEditorContext } from '../../sectionContext';+import { createFieldResetter } from '../../utils/changes';+import ScatterAxisFields from './ScatterAxisFields';++import styles from './ScatterAxesSection.module.scss';++type ScatterAxesSectionProps = SectionEditorProps<SectionKind.ScatterAxes> &+ Pick<SectionEditorContext, 'axisColumnNames'>;++function ScatterAxesSection({+ value,+ savedValue,+ onChange,+ axisColumnNames,+}: ScatterAxesSectionProps): JSX.Element {+ const reset = createFieldResetter(value, savedValue, onChange);++ return (+ <div className={styles.axes}>+ {(['x', 'y'] as const).map((axis) => (+ <div key={axis} className={styles.axis}>+ <ConfigField label={`${axis.toUpperCase()} axis`} {...reset(axis)}>+ <ScatterAxisFields+ axis={axis}+ value={value?.[axis]}+ columnName={axisColumnNames?.[axis]}+ onChange={(next): void => onChange({ ...value, [axis]: next })}+ />+ </ConfigField>+ </div>+ ))}+ </div>+ );+}++export default ScatterAxesSection;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxisFields.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxisFields.tsxnew file mode 100644index 0000000000..27a730a536--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/ScatterAxisFields.tsx@@ -0,0 +1,64 @@+import { Input } from '@signozhq/ui/input';+import {+ DashboardtypesAxisScaleDTO,+ type DashboardtypesScatterPlotAxisDTO,+} from 'api/generated/services/sigNoz.schemas';++import ConfigInlineField from '../../controls/ConfigInlineField/ConfigInlineField';+import AxisFields from '../AxesSection/AxisFields';+import AxisRangeField from '../AxesSection/AxisRangeField';+import AxisScaleField from '../AxesSection/AxisScaleField';+import { LOG_RANGE_IGNORED_HELP, SCALE_HELP, SCALE_OPTIONS } from './options';+import { hasBoundALogAxisDrops } from './utils';++interface ScatterAxisFieldsProps {+ axis: 'x' | 'y';+ value: DashboardtypesScatterPlotAxisDTO | undefined;+ onChange: (next: DashboardtypesScatterPlotAxisDTO) => void;+ columnName?: string;+}++function ScatterAxisFields({+ axis,+ value,+ onChange,+ columnName,+}: ScatterAxisFieldsProps): JSX.Element {+ const scale = value?.scale ?? DashboardtypesAxisScaleDTO.auto;+ const name = axis.toUpperCase();++ return (+ <AxisFields>+ <ConfigInlineField label="Label">+ <Input+ testId={`panel-editor-v2-${axis}-label`}+ aria-label={`${name}-axis label`}+ placeholder={columnName ?? 'None'}+ value={value?.label ?? ''}+ onChange={(event): void =>+ onChange({ ...value, label: event.target.value })+ }+ />+ </ConfigInlineField>+ <AxisRangeField+ testIdPrefix={`panel-editor-v2-${axis}`}+ value={value}+ onChange={(bounds): void => onChange({ ...value, ...bounds })}+ help={+ hasBoundALogAxisDrops(scale, value) ? LOG_RANGE_IGNORED_HELP : undefined+ }+ helpTestId={`panel-editor-v2-${axis}-range-help`}+ />+ <AxisScaleField+ testId={`panel-editor-v2-${axis}-scale`}+ aria-label={`${name}-axis scale`}+ value={scale}+ items={SCALE_OPTIONS}+ help={SCALE_HELP}+ onChange={(next): void => onChange({ ...value, scale: next })}+ />+ </AxisFields>+ );+}++export default ScatterAxisFields;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/__tests__/ScatterAxesSection.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/__tests__/ScatterAxesSection.test.tsxnew file mode 100644index 0000000000..1f9cb5c39b--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/__tests__/ScatterAxesSection.test.tsx@@ -0,0 +1,171 @@+import { DashboardtypesAxisScaleDTO } from 'api/generated/services/sigNoz.schemas';+import { render, screen, userEvent } from 'tests/test-utils';++import ScatterAxesSection from '../ScatterAxesSection';++describe('ScatterAxesSection', () => {+ it('renders bounds and scale for both axes', () => {+ render(<ScatterAxesSection value={undefined} onChange={jest.fn()} />);++ ['x', 'y'].forEach((axis) => {+ expect(+ screen.getByTestId(`panel-editor-v2-${axis}-soft-min`),+ ).toBeInTheDocument();+ expect(+ screen.getByTestId(`panel-editor-v2-${axis}-soft-max`),+ ).toBeInTheDocument();+ expect(+ screen.getByTestId(`panel-editor-v2-${axis}-scale`),+ ).toBeInTheDocument();+ });+ });++ it('writes a soft bound to its own axis', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ScatterAxesSection+ value={{ x: { scale: DashboardtypesAxisScaleDTO.log } }}+ onChange={onChange}+ />,+ );++ await user.type(screen.getByTestId('panel-editor-v2-y-soft-max'), '5');++ expect(onChange).toHaveBeenCalledWith({+ x: { scale: DashboardtypesAxisScaleDTO.log },+ y: { softMax: 5 },+ });+ });++ it('shows the plotted column as each label placeholder', () => {+ render(+ <ScatterAxesSection+ value={undefined}+ onChange={jest.fn()}+ axisColumnNames={{ x: 'Request rate', y: 'p99 latency' }}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-x-label')).toHaveAttribute(+ 'placeholder',+ 'Request rate',+ );+ expect(screen.getByTestId('panel-editor-v2-y-label')).toHaveAttribute(+ 'placeholder',+ 'p99 latency',+ );+ });++ it('resets one axis without touching the other', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ScatterAxesSection+ value={{+ x: { scale: DashboardtypesAxisScaleDTO.log, label: 'Throughput' },+ y: { scale: DashboardtypesAxisScaleDTO.symlog },+ }}+ savedValue={{}}+ onChange={onChange}+ />,+ );++ const [resetX] = screen.getAllByTestId('config-field-reset');+ await user.click(resetX);++ expect(onChange).toHaveBeenCalledWith({+ x: undefined,+ y: { scale: DashboardtypesAxisScaleDTO.symlog },+ });+ });++ it('says a log axis ignores a bound at or below zero', () => {+ render(+ <ScatterAxesSection+ value={{+ x: { scale: DashboardtypesAxisScaleDTO.log, softMin: -10 },+ y: { scale: DashboardtypesAxisScaleDTO.symlog, softMin: -10 },+ }}+ onChange={jest.fn()}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-x-range-help')).toHaveTextContent(+ "A log axis can't reach 0 or below",+ );+ expect(screen.getByTestId('panel-editor-v2-y-range-help')).toHaveTextContent(+ 'The axis always shows at least this range.',+ );+ });++ it('flags a soft min above the soft max on that axis only', () => {+ render(+ <ScatterAxesSection+ value={{ x: { softMin: 23, softMax: 12 }, y: { softMin: 1, softMax: 2 } }}+ onChange={jest.fn()}+ />,+ );++ expect(screen.getByTestId('panel-editor-v2-x-range-help')).toHaveTextContent(+ "Min can't be greater than Max.",+ );+ expect(screen.getByTestId('panel-editor-v2-y-range-help')).toHaveTextContent(+ 'The axis always shows at least this range.',+ );+ });++ it('writes an axis label', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(<ScatterAxesSection value={undefined} onChange={onChange} />);++ await user.type(screen.getByTestId('panel-editor-v2-y-label'), 'p');++ expect(onChange).toHaveBeenCalledWith({ y: { label: 'p' } });+ });++ it('clears a soft bound to null when the field is emptied', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ScatterAxesSection value={{ x: { softMin: 10 } }} onChange={onChange} />,+ );++ await user.clear(screen.getByTestId('panel-editor-v2-x-soft-min'));++ expect(onChange).toHaveBeenCalledWith({ x: { softMin: null } });+ });++ it.each([+ DashboardtypesAxisScaleDTO.linear,+ DashboardtypesAxisScaleDTO.log,+ DashboardtypesAxisScaleDTO.symlog,+ ])('sets the x scale to %s', async (scale) => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(<ScatterAxesSection value={undefined} onChange={onChange} />);++ await user.click(screen.getByTestId(`panel-editor-v2-x-scale-${scale}`));++ expect(onChange).toHaveBeenCalledWith({ x: { scale } });+ });++ it('marks a changed scale against the saved value and resets it', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(+ <ScatterAxesSection+ value={{ y: { scale: DashboardtypesAxisScaleDTO.log } }}+ savedValue={{ y: { scale: DashboardtypesAxisScaleDTO.auto } }}+ onChange={onChange}+ />,+ );++ await user.click(screen.getByRole('button', { name: /reset/i }));++ expect(onChange).toHaveBeenCalledWith({+ y: { scale: DashboardtypesAxisScaleDTO.auto },+ });+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/options.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/options.tsnew file mode 100644index 0000000000..d0afe09c90--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/options.ts@@ -0,0 +1,24 @@+import { DashboardtypesAxisScaleDTO } from 'api/generated/services/sigNoz.schemas';++import {+ pickScaleOptions,+ SCALE_HELP as AXIS_SCALE_HELP,+} from '../AxesSection/options';++export const SCALE_OPTIONS = pickScaleOptions([+ DashboardtypesAxisScaleDTO.auto,+ DashboardtypesAxisScaleDTO.linear,+ DashboardtypesAxisScaleDTO.log,+ DashboardtypesAxisScaleDTO.symlog,+]);++export const LOG_RANGE_IGNORED_HELP =+ "A log axis can't reach 0 or below, so that bound is ignored. Use Symlog to include it.";++export const SCALE_HELP: Record<DashboardtypesAxisScaleDTO, string> = {+ ...AXIS_SCALE_HELP,+ [DashboardtypesAxisScaleDTO.auto]:+ 'Logarithmic (Symlog with zero or negatives) when that spreads the points out more than linear does; otherwise linear.',+ [DashboardtypesAxisScaleDTO.log]:+ "Spreads out values that span orders of magnitude. Groups with a value of 0 or less can't be placed and are left out.",+};diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/utils.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/utils.tsnew file mode 100644index 0000000000..3b95f829aa--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ScatterAxesSection/utils.ts@@ -0,0 +1,16 @@+import {+ DashboardtypesAxisScaleDTO,+ type DashboardtypesScatterPlotAxisDTO,+} from 'api/generated/services/sigNoz.schemas';++export function hasBoundALogAxisDrops(+ scale: DashboardtypesAxisScaleDTO,+ axis: DashboardtypesScatterPlotAxisDTO | undefined,+): boolean {+ return (+ scale === DashboardtypesAxisScaleDTO.log &&+ [axis?.softMin, axis?.softMax].some(+ (bound) => typeof bound === 'number' && bound <= 0,+ )+ );+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsxindex af58aa4c66..fb7b3ea23e 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsx@@ -4,9 +4,10 @@ import { Button } from '@signozhq/ui/button';import {DashboardtypesComparisonOperatorDTO,type DashboardtypesComparisonThresholdDTO,+ type DashboardtypesScatterPlotThresholdDTO,type DashboardtypesTableThresholdDTO,+ DashboardtypesThresholdAxisDTO,DashboardtypesThresholdFormatDTO,- type DashboardtypesThresholdWithLabelDTO,} from 'api/generated/services/sigNoz.schemas';import {AnyThreshold,@@ -44,6 +45,7 @@ const ADD_TESTID: Record<ThresholdVariant, string> = {function defaultThreshold(variant: ThresholdVariant,tableColumns: TableColumnOption[],+ withAxis: boolean,): AnyThreshold {switch (variant) {case 'comparison':@@ -62,18 +64,23 @@ function defaultThreshold(format: DashboardtypesThresholdFormatDTO.background,};default:- return { value: 0, color: DEFAULT_THRESHOLD_COLOR, label: '' };+ return {+ value: 0,+ color: DEFAULT_THRESHOLD_COLOR,+ label: '',+ ...(withAxis && { axis: DashboardtypesThresholdAxisDTO.y }),+ };}}type ThresholdsSectionProps = {value: AnyThreshold[] | undefined;/** `variant` picks the row editor + element shape; defaults to `label`. */- controls?: { variant?: ThresholdVariant };+ controls?: { variant?: ThresholdVariant; axis?: boolean };onChange: (next: AnyThreshold[]) => void;} & Pick<SectionEditorContext,- 'yAxisUnit' | 'tableColumns' | 'registerHeaderAction'+ 'yAxisUnit' | 'tableColumns' | 'axisColumnUnits' | 'registerHeaderAction'>;/**@@ -88,9 +95,11 @@ function ThresholdsSection({onChange,yAxisUnit,tableColumns = [],+ axisColumnUnits,registerHeaderAction,}: ThresholdsSectionProps): JSX.Element {const variant = controls?.variant ?? ThresholdVariant.LABEL;+ const withAxis = !!controls?.axis;const thresholds = value ?? [];// Which row is being edited, and whether it was just added (so Discard removes it).const [editingIndex, setEditingIndex] = useState<number | null>(null);@@ -107,10 +116,10 @@ function ThresholdsSection({const addThreshold = useCallback((): void => {const current = value ?? [];- onChange([...current, defaultThreshold(variant, tableColumns)]);+ onChange([...current, defaultThreshold(variant, tableColumns, withAxis)]);setEditingIndex(current.length);setUnsavedIndex(current.length);- }, [value, onChange, variant, tableColumns]);+ }, [value, onChange, variant, tableColumns, withAxis]);useEffect(() => {registerHeaderAction?.(addThreshold);@@ -189,7 +198,9 @@ function ThresholdsSection({<LabelThresholdRow// eslint-disable-next-line react/no-array-index-keykey={index}- threshold={threshold as DashboardtypesThresholdWithLabelDTO}+ threshold={threshold as DashboardtypesScatterPlotThresholdDTO}+ showAxis={withAxis}+ axisUnits={axisColumnUnits}{...common}/>);diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.test.tsxindex 0f3b0d2014..f5086f800e 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.test.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.test.tsx@@ -173,3 +173,52 @@ describe('ThresholdsSection', () => {).not.toBeInTheDocument();});});++describe('ThresholdsSection with an axis picker', () => {+ function AxisHarness({+ onChange,+ }: {+ onChange: (next: AnyThreshold[]) => void;+ }): JSX.Element {+ const [value, setValue] = useState<AnyThreshold[]>([]);+ return (+ <ThresholdsSection+ value={value}+ controls={{ axis: true }}+ axisColumnUnits={{ x: 'reqps', y: 'ms' }}+ onChange={(next): void => {+ setValue(next);+ onChange(next);+ }}+ />+ );+ }++ it('adds a y threshold and saves the picked axis', async () => {+ const user = userEvent.setup();+ const onChange = jest.fn();+ render(<AxisHarness onChange={onChange} />);++ await user.click(screen.getByTestId('panel-editor-v2-add-threshold'));+ expect(onChange).toHaveBeenLastCalledWith([+ expect.objectContaining({ axis: 'y' }),+ ]);++ await user.click(screen.getByTestId('threshold-axis-0-x'));+ await user.click(screen.getByTestId('threshold-save-0'));++ expect(onChange).toHaveBeenLastCalledWith([+ expect.objectContaining({ axis: 'x' }),+ ]);+ expect(screen.getByText('X axis')).toBeInTheDocument();+ });++ it('hides the axis picker without the control', async () => {+ const user = userEvent.setup();+ render(<Harness />);++ await user.click(screen.getByTestId('panel-editor-v2-add-threshold'));++ expect(screen.queryByTestId('threshold-axis-0')).not.toBeInTheDocument();+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/LabelThresholdRow.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/LabelThresholdRow.tsxindex 5343893b90..c60e2a6d4d 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/LabelThresholdRow.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/LabelThresholdRow.tsx@@ -1,10 +1,14 @@import { useCallback } from 'react';import { Typography } from '@signozhq/ui/typography';import { Input } from 'antd';-import type { DashboardtypesThresholdWithLabelDTO } from 'api/generated/services/sigNoz.schemas';+import {+ type DashboardtypesScatterPlotThresholdDTO,+ DashboardtypesThresholdAxisDTO,+} from 'api/generated/services/sigNoz.schemas';import { formatPanelValue } from 'pages/DashboardPage/DashboardContainer/Panels/utils/formatPanelValue';import ThresholdAmountField from './shared/ThresholdAmountField';+import ThresholdAxisField from './shared/ThresholdAxisField';import ThresholdColorField from './shared/ThresholdColorField';import ThresholdMarker from './shared/ThresholdMarker';import ThresholdRowShell from './shared/ThresholdRowShell';@@ -12,16 +16,22 @@ import { useThresholdDraft } from './shared/useThresholdDraft';import styles from '../ThresholdsSection.module.scss';+/** `axis` is set only where the row picks one (Scatter Plot). */+type LabelThreshold = DashboardtypesScatterPlotThresholdDTO;+interface LabelThresholdRowProps {index: number;- threshold: DashboardtypesThresholdWithLabelDTO;+ threshold: LabelThreshold;/** Panel formatting unit — scopes the unit picker to its category (V1 parity). */yAxisUnit?: string;+ /** Shows the axis picker; the unit picker then scopes to the picked axis's unit. */+ showAxis?: boolean;+ axisUnits?: { x?: string; y?: string };isEditing: boolean;isNew: boolean;onEdit: () => void;- onSave: (next: DashboardtypesThresholdWithLabelDTO) => void;- onLiveChange: (next: DashboardtypesThresholdWithLabelDTO) => void;+ onSave: (next: LabelThreshold) => void;+ onLiveChange: (next: LabelThreshold) => void;onDiscard: () => void;onRemove: () => void;}@@ -31,6 +41,8 @@ function LabelThresholdRow({index,threshold,yAxisUnit,+ showAxis,+ axisUnits,isEditing,isNew,onEdit,@@ -50,6 +62,17 @@ function LabelThresholdRow({onSave({ ...draft, label: draft.label ?? '' });}, [onSave, draft]);+ const draftAxis = draft.axis ?? DashboardtypesThresholdAxisDTO.y;+ const scopeUnit = showAxis ? axisUnits?.[draftAxis] : yAxisUnit;+ const subtitle = showAxis+ ? [+ `${(threshold.axis ?? DashboardtypesThresholdAxisDTO.y).toUpperCase()} axis`,+ threshold.label,+ ]+ .filter(Boolean)+ .join(' · ')+ : threshold.label;+return (<ThresholdRowShellindex={index}@@ -58,12 +81,19 @@ function LabelThresholdRow({isEditing={isEditing}isNew={isNew}title={`Line at ${formatPanelValue(threshold.value, threshold.unit)}`}- subtitle={threshold.label}+ subtitle={subtitle}onEdit={onEdit}onSave={handleSave}onDiscard={onDiscard}onRemove={onRemove}>+ {showAxis && (+ <ThresholdAxisField+ testId={`threshold-axis-${index}`}+ value={draftAxis}+ onChange={(axis): void => setDraft((d) => ({ ...d, axis }))}+ />+ )}<ThresholdAmountFieldlabel="Draw a line at"testIdPrefix="threshold"@@ -71,8 +101,8 @@ function LabelThresholdRow({value={draft.value}onValueChange={setValue}unit={draft.unit}- scopeUnit={yAxisUnit}- scopeLabel="y-axis unit"+ scopeUnit={scopeUnit}+ scopeLabel={`${showAxis ? draftAxis : 'y'}-axis unit`}onUnitChange={(unit): void => setDraft((d) => ({ ...d, unit }))}/><ThresholdColorFielddiff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdAxisField.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdAxisField.tsxnew file mode 100644index 0000000000..6c0cf912f7--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdAxisField.tsx@@ -0,0 +1,41 @@+import { Typography } from '@signozhq/ui/typography';+import { DashboardtypesThresholdAxisDTO } from 'api/generated/services/sigNoz.schemas';++import ConfigTiles, {+ type ConfigTileItem,+} from '../../../../controls/ConfigTiles/ConfigTiles';++import styles from '../../ThresholdsSection.module.scss';++const AXIS_TILES: ConfigTileItem<DashboardtypesThresholdAxisDTO>[] = [+ { value: DashboardtypesThresholdAxisDTO.x, label: 'X axis' },+ { value: DashboardtypesThresholdAxisDTO.y, label: 'Y axis' },+];++interface ThresholdAxisFieldProps {+ testId: string;+ value: DashboardtypesThresholdAxisDTO;+ onChange: (axis: DashboardtypesThresholdAxisDTO) => void;+}++function ThresholdAxisField({+ testId,+ value,+ onChange,+}: ThresholdAxisFieldProps): JSX.Element {+ return (+ <div className={styles.field}>+ <Typography.Text className={styles.fieldLabel}>Axis</Typography.Text>+ <ConfigTiles+ compact+ testId={testId}+ aria-label="Axis"+ value={value}+ items={AXIS_TILES}+ onChange={onChange}+ />+ </div>+ );+}++export default ThresholdAxisField;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/scatterAxisColumns.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/scatterAxisColumns.test.tsnew file mode 100644index 0000000000..78aff872ab--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/scatterAxisColumns.test.ts@@ -0,0 +1,63 @@+import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';++import {+ getScatterAxisColumnNames,+ getScatterAxisColumnUnits,+} from '../scatterAxisColumns';++const COLUMNS = [+ { key: 'A', label: 'A.Request rate', name: 'Request rate' },+ { key: 'B', label: 'B.p99 latency', name: 'p99 latency', unit: 'ms' },+ { key: 'C', label: 'C.Errors', name: 'Errors' },+];++const scatterSpec = (dimensions: {+ x?: string;+ y?: string;+}): DashboardtypesPanelSpecDTO =>+ ({+ plugin: { kind: 'signoz/ScatterPlotPanel', spec: { dimensions } },+ queries: [],+ }) as unknown as DashboardtypesPanelSpecDTO;++describe('getScatterAxisColumnNames', () => {+ it('names the first two value columns when nothing is bound', () => {+ expect(getScatterAxisColumnNames(scatterSpec({}), COLUMNS)).toStrictEqual({+ x: 'Request rate',+ y: 'p99 latency',+ });+ });++ it('follows the bound columns, with Y avoiding the column X took', () => {+ expect(+ getScatterAxisColumnNames(scatterSpec({ x: 'A', y: 'C' }), COLUMNS),+ ).toStrictEqual({ x: 'Request rate', y: 'Errors' });+ expect(+ getScatterAxisColumnNames(scatterSpec({ x: 'B' }), COLUMNS),+ ).toStrictEqual({ x: 'p99 latency', y: 'Request rate' });+ });++ it('is empty before results load and for other kinds', () => {+ expect(getScatterAxisColumnNames(scatterSpec({}), [])).toStrictEqual({+ x: undefined,+ y: undefined,+ });+ expect(+ getScatterAxisColumnNames(+ {+ plugin: { kind: 'signoz/TablePanel', spec: {} },+ queries: [],+ } as unknown as DashboardtypesPanelSpecDTO,+ COLUMNS,+ ),+ ).toStrictEqual({});+ });+});++describe('getScatterAxisColumnUnits', () => {+ it('reads the unit of the column each axis plots', () => {+ expect(+ getScatterAxisColumnUnits(scatterSpec({ x: 'B', y: 'A' }), COLUMNS),+ ).toStrictEqual({ x: 'ms', y: undefined });+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/sizeColumnLabel.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/sizeColumnLabel.test.tsnew file mode 100644index 0000000000..9f0dc83935--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/__tests__/sizeColumnLabel.test.ts@@ -0,0 +1,41 @@+import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';++import { getSizeColumnLabel } from '../sizeColumnLabel';++const scatterSpec = (size?: string): DashboardtypesPanelSpecDTO =>+ ({+ plugin: {+ kind: 'signoz/ScatterPlotPanel',+ spec: { dimensions: { sizeBy: size } },+ },+ queries: [],+ }) as unknown as DashboardtypesPanelSpecDTO;++const COLUMNS = [{ key: 'B', label: 'B.count()', name: 'count()' }];++describe('getSizeColumnLabel', () => {+ it('names the bound column by its label', () => {+ expect(getSizeColumnLabel(scatterSpec('B'), COLUMNS)).toBe('B.count()');+ });++ it('is unset when nothing is bound', () => {+ expect(getSizeColumnLabel(scatterSpec(''), COLUMNS)).toBeUndefined();+ expect(getSizeColumnLabel(scatterSpec(), COLUMNS)).toBeUndefined();+ });++ it('is unset for a bound key the loaded result no longer has, as the chart draws it', () => {+ expect(getSizeColumnLabel(scatterSpec('C'), COLUMNS)).toBeUndefined();+ });++ it('falls back to the key before the result loads', () => {+ expect(getSizeColumnLabel(scatterSpec('B'), [])).toBe('B');+ });++ it('is unset for other kinds', () => {+ const spec = {+ plugin: { kind: 'signoz/TablePanel', spec: {} },+ queries: [],+ } as unknown as DashboardtypesPanelSpecDTO;+ expect(getSizeColumnLabel(spec, COLUMNS)).toBeUndefined();+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/scatterAxisColumns.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/scatterAxisColumns.tsnew file mode 100644index 0000000000..3fbbbd7f11--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/scatterAxisColumns.ts@@ -0,0 +1,44 @@+import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';++import type { TableColumnOption } from '../../hooks/useTableColumns';++/** Mirrors the renderer: bound key, else X = first value column, Y = first other. */+export function resolveAutoAxes(+ columns: TableColumnOption[],+ bound: { x?: string; y?: string },+): { x?: TableColumnOption; y?: TableColumnOption } {+ const x = columns.find((column) => column.key === bound.x) ?? columns[0];+ const y =+ columns.find((column) => column.key === bound.y) ??+ columns.find((column) => column !== x);+ return { x, y };+}++function resolveScatterAxisColumns(+ spec: DashboardtypesPanelSpecDTO,+ tableColumns: TableColumnOption[],+): { x?: TableColumnOption; y?: TableColumnOption } | null {+ if (spec.plugin.kind !== 'signoz/ScatterPlotPanel') {+ return null;+ }+ return resolveAutoAxes(tableColumns, {+ x: spec.plugin.spec.dimensions?.x,+ y: spec.plugin.spec.dimensions?.y,+ });+}++export function getScatterAxisColumnNames(+ spec: DashboardtypesPanelSpecDTO,+ tableColumns: TableColumnOption[] = [],+): { x?: string; y?: string } {+ const axes = resolveScatterAxisColumns(spec, tableColumns);+ return axes ? { x: axes.x?.name, y: axes.y?.name } : {};+}++export function getScatterAxisColumnUnits(+ spec: DashboardtypesPanelSpecDTO,+ tableColumns: TableColumnOption[] = [],+): { x?: string; y?: string } {+ const axes = resolveScatterAxisColumns(spec, tableColumns);+ return axes ? { x: axes.x?.unit, y: axes.y?.unit } : {};+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/sizeColumnLabel.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/sizeColumnLabel.tsnew file mode 100644index 0000000000..57fce82c13--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/ConfigPane/utils/sizeColumnLabel.ts@@ -0,0 +1,24 @@+import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';++import type { TableColumnOption } from '../../hooks/useTableColumns';++/**+ * What the dots are sized by, mirroring the renderer: a bound key the loaded+ * result no longer has sizes nothing. Before the result loads the key stands in.+ */+export function getSizeColumnLabel(+ spec: DashboardtypesPanelSpecDTO,+ tableColumns: TableColumnOption[] = [],+): string | undefined {+ if (spec.plugin.kind !== 'signoz/ScatterPlotPanel') {+ return undefined;+ }+ const key = spec.plugin.spec.dimensions?.sizeBy;+ if (!key) {+ return undefined;+ }+ if (tableColumns.length === 0) {+ return key;+ }+ return tableColumns.find((column) => column.key === key)?.label;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/QueryEditorBody.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/QueryEditorBody.tsxindex c81fd1c06f..3c3e633667 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/QueryEditorBody.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/QueryEditorBody.tsx@@ -29,6 +29,7 @@ import PanelEditorLayout, {import PreviewPane from './PreviewPane/PreviewPane';import { useLegendSeries } from './hooks/useLegendSeries';import type { PanelEditorDraftApi } from './types';+import { useGroupColumns } from './hooks/useGroupColumns';import { usePanelEditSession } from './hooks/usePanelEditSession';import { usePanelEditorSave } from './hooks/usePanelEditorSave';import { useSeedMetricUnit } from './hooks/useSeedMetricUnit';@@ -199,6 +200,7 @@ function QueryEditorBody({const { onDragSelect } = usePanelInteractions();const legendSeries = useLegendSeries(draft, data);const tableColumns = useTableColumns(draft, data);+ const groupColumns = useGroupColumns(draft, data);// Resolves the selected metric's unit and, on a new panel, seeds it into the right// formatting field for the kind (panel-wide `unit`, or per-column `columnUnits` for@@ -330,6 +332,7 @@ function QueryEditorBody({queryType={currentQuery.queryType}legendSeries={legendSeries}tableColumns={tableColumns}+ groupColumns={groupColumns}stepInterval={stepInterval}metricUnit={metricUnit}/>diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useGroupColumns.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useGroupColumns.test.tsnew file mode 100644index 0000000000..423dde416f--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useGroupColumns.test.ts@@ -0,0 +1,84 @@+import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';+import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';+import type {+ PanelQueryData,+ PanelTable,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';+import { renderHook } from 'tests/test-utils';++import { useGroupColumns } from '../useGroupColumns';++jest.mock(+ 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables',+ () => ({ prepareScalarTables: jest.fn() }),+);+jest.mock(+ 'pages/DashboardPage/DashboardContainer/queryV5/v5ResponseData',+ () => ({ getScalarResults: jest.fn(() => []) }),+);++const mockPrepareScalarTables = jest.mocked(prepareScalarTables);++const DATA = {+ response: undefined,+ legendMap: {},+ requestPayload: undefined,+} as unknown as PanelQueryData;++function panelOfKind(kind: string): DashboardtypesPanelDTO {+ return {+ kind: 'Panel',+ spec: { plugin: { kind, spec: {} }, queries: [] },+ } as unknown as DashboardtypesPanelDTO;+}++describe('useGroupColumns', () => {+ beforeEach(() => {+ jest.clearAllMocks();+ });++ it('returns [] for a kind that does not join its scalar rows', () => {+ const { result } = renderHook(() =>+ useGroupColumns(panelOfKind('signoz/PieChartPanel'), DATA),+ );++ expect(result.current).toStrictEqual([]);+ expect(mockPrepareScalarTables).not.toHaveBeenCalled();+ });++ it('keeps only the group-by columns, by key', () => {+ const empty: PanelTable = {+ queryName: 'A',+ legend: '',+ columns: [],+ rows: [],+ };+ mockPrepareScalarTables.mockReturnValue([+ empty,+ {+ ...empty,+ columns: [+ {+ id: 'k8s.namespace.name',+ name: 'k8s.namespace.name',+ queryName: '',+ isValueColumn: false,+ },+ { id: 'A', name: 'cpu', queryName: 'A', isValueColumn: true },+ {+ id: 'k8s.pod.name',+ name: 'k8s.pod.name',+ queryName: '',+ isValueColumn: false,+ },+ ],+ },+ ]);++ const { result } = renderHook(() =>+ useGroupColumns(panelOfKind('signoz/ScatterPlotPanel'), DATA),+ );++ expect(result.current).toStrictEqual(['k8s.namespace.name', 'k8s.pod.name']);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useLegendSeries.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useLegendSeries.test.tsindex c254bdc207..6b305011ce 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useLegendSeries.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useLegendSeries.test.ts@@ -3,8 +3,12 @@ import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemimport { useIsDarkMode } from 'hooks/useDarkMode';import { generateColor } from 'lib/uPlotLib/utils/generateColor';import { preparePieData } from 'pages/DashboardPage/DashboardContainer/Panels/kinds/PieChartPanel/prepareData';+import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';import { resolveSeriesLabelV5 } from 'pages/DashboardPage/DashboardContainer/Panels/utils/resolveSeriesLabel';-import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';+import type {+ PanelQueryData,+ PanelSeries,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';import { flattenTimeSeries } from 'pages/DashboardPage/DashboardContainer/queryV5/v5ResponseData';import { useLegendSeries } from '../useLegendSeries';@@ -42,11 +46,12 @@ jest.mock(() => ({ preparePieData: jest.fn(() => []) }),);-const mockUseIsDarkMode = useIsDarkMode as unknown as jest.Mock;-const mockFlatten = flattenTimeSeries as unknown as jest.Mock;-const mockResolveLabel = resolveSeriesLabelV5 as unknown as jest.Mock;-const mockGenerateColor = generateColor as unknown as jest.Mock;-const mockPreparePie = preparePieData as unknown as jest.Mock;+const mockUseIsDarkMode = jest.mocked(useIsDarkMode);+const mockFlatten = jest.mocked(flattenTimeSeries);+const mockResolveLabel = jest.mocked(resolveSeriesLabelV5);+const mockGenerateColor = jest.mocked(generateColor);+const mockPreparePie = jest.mocked(preparePieData);+const mockPrepareScalarTables = jest.mocked(prepareScalarTables);const PANEL = {kind: 'Panel',@@ -60,18 +65,36 @@ const HISTOGRAM_PANEL = {kind: 'Panel',spec: { plugin: { kind: 'signoz/HistogramPanel', spec: {} }, queries: [] },} as unknown as DashboardtypesPanelDTO;+const scatterPanel = (colorBy?: string[]): DashboardtypesPanelDTO =>+ ({+ kind: 'Panel',+ spec: {+ plugin: {+ kind: 'signoz/ScatterPlotPanel',+ spec: { dimensions: { colorBy } },+ },+ queries: [],+ },+ }) as unknown as DashboardtypesPanelDTO;const DATA = { response: {}, legendMap: {} } as unknown as PanelQueryData;// Each flattened series carries the label resolveSeriesLabelV5 should report.-function seriesWithLabels(labels: string[]): { __label: string }[] {- return labels.map((__label) => ({ __label }));+function seriesWithLabels(labels: string[]): PanelSeries[] {+ return labels.map((legend) => ({+ queryName: 'A',+ legend,+ labels: {},+ values: [],+ kind: 'series',+ aggregation: { index: 0, alias: '' },+ }));}describe('useLegendSeries', () => {beforeEach(() => {jest.clearAllMocks();mockUseIsDarkMode.mockReturnValue(true);- mockResolveLabel.mockImplementation((s: { __label: string }) => s.__label);+ mockResolveLabel.mockImplementation((s) => s.legend);});it('is empty when there are no series', () => {@@ -120,9 +143,9 @@ describe('useLegendSeries', () => {it('resolves pie panels from their scalar slices, deduped by label', () => {mockPreparePie.mockReturnValue([- { label: 'x', color: 'c1' },- { label: 'y', color: 'c2' },- { label: 'x', color: 'c1' },+ { label: 'x', value: 1, color: 'c1' },+ { label: 'y', value: 1, color: 'c2' },+ { label: 'x', value: 1, color: 'c1' },]);const { result } = renderHook(() => useLegendSeries(PIE_PANEL, DATA));expect(result.current).toStrictEqual([@@ -133,6 +156,36 @@ describe('useLegendSeries', () => {expect(mockFlatten).not.toHaveBeenCalled();});+ it('resolves scatter plot panels by the colour-by label', () => {+ mockPrepareScalarTables.mockReturnValue([+ {+ queryName: 'A',+ legend: '',+ columns: [+ { id: 'ns', name: 'ns', queryName: '', isValueColumn: false },+ { id: 'pod', name: 'pod', queryName: '', isValueColumn: false },+ { id: 'A', name: 'A', queryName: 'A', isValueColumn: true },+ { id: 'B', name: 'B', queryName: 'B', isValueColumn: true },+ ],+ rows: [+ { data: { ns: 'prod', pod: 'p1', A: 1, B: 2 } },+ { data: { ns: 'dev', pod: 'p2', A: 3, B: 4 } },+ { data: { ns: 'prod', pod: 'p3', A: 5, B: 6 } },+ ],+ },+ ]);++ const { result } = renderHook(() =>+ useLegendSeries(scatterPanel(['ns']), DATA),+ );++ expect(result.current).toStrictEqual([+ { label: 'prod', defaultColor: 'color:prod' },+ { label: 'dev', defaultColor: 'color:dev' },+ ]);+ expect(mockFlatten).not.toHaveBeenCalled();+ });+it('uses the dark palette in dark mode and the light palette otherwise', () => {mockFlatten.mockReturnValue(seriesWithLabels(['a']));diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useSeedMetricUnit.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useSeedMetricUnit.test.tsindex e1c8a86e19..4b9b07671d 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useSeedMetricUnit.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useSeedMetricUnit.test.ts@@ -39,8 +39,8 @@ function columnUnits(spec: DashboardtypesPanelSpecDTO): unknown {}const COLUMNS: TableColumnOption[] = [- { key: 'A', label: 'A' },- { key: 'B', label: 'B' },+ { key: 'A', label: 'A', name: 'A' },+ { key: 'B', label: 'B', name: 'B' },];const NO_COLUMNS: TableColumnOption[] = [];diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useTableColumns.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useTableColumns.test.tsindex 3de5a9a3cc..d502697570 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useTableColumns.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/__tests__/useTableColumns.test.ts@@ -56,6 +56,23 @@ describe('useTableColumns', () => {expect(mockPrepareScalarTables).not.toHaveBeenCalled();});+ it('resolves columns for a scatter plot, which joins its rows like a table', () => {+ tableWith([{ id: 'A', name: 'p99', isValueColumn: true }]);+ const panel = {+ kind: 'Panel',+ spec: {+ plugin: { kind: 'signoz/ScatterPlotPanel', spec: {} },+ queries: [],+ },+ } as unknown as DashboardtypesPanelDTO;++ const { result } = renderHook(() => useTableColumns(panel, DATA));++ expect(result.current).toStrictEqual([+ { key: 'A', label: 'p99', name: 'p99', unit: undefined },+ ]);+ });+it('returns [] when there is no scalar table with columns', () => {mockPrepareScalarTables.mockReturnValue([{ columns: [], rows: [] }]);@@ -73,7 +90,7 @@ describe('useTableColumns', () => {const { result } = renderHook(() => useTableColumns(tablePanel(), DATA));expect(result.current).toStrictEqual([- { key: 'A', label: 'p99', unit: undefined },+ { key: 'A', label: 'p99', name: 'p99', unit: undefined },]);});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useGroupColumns.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useGroupColumns.tsnew file mode 100644index 0000000000..4c6446d9f1--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useGroupColumns.ts@@ -0,0 +1,23 @@+import { useMemo } from 'react';+import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';+import { getQueryPanelDefinition } from 'pages/DashboardPage/DashboardContainer/Panels/capabilities';+import { getJoinedScalarTable } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getJoinedScalarTable';+import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++/** Group-by column ids of the joined scalar result; empty for non-joining kinds. */+export function useGroupColumns(+ panel: DashboardtypesPanelDTO,+ data: PanelQueryData,+): string[] {+ return useMemo(() => {+ if (+ !getQueryPanelDefinition(panel.spec.plugin.kind)?.queryCapabilities+ .formatTableResultForUI+ ) {+ return [];+ }+ return (getJoinedScalarTable(data)?.columns ?? [])+ .filter((column) => !column.isValueColumn)+ .map((column) => column.id);+ }, [panel.spec.plugin.kind, data]);+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useLegendSeries.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useLegendSeries.tsindex 0ab0809f79..befe9a1447 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useLegendSeries.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useLegendSeries.ts@@ -21,7 +21,12 @@ export function useLegendSeries(return useMemo(() => {const resolve = getSectionControls(kind, SectionKind.Legend)?.colors;return resolve- ? resolve({ queries: panel.spec.queries, data, isDarkMode })+ ? resolve({+ spec: panel.spec,+ queries: panel.spec.queries,+ data,+ isDarkMode,+ }): [];- }, [kind, panel.spec.queries, data, isDarkMode]);+ }, [kind, panel.spec, data, isDarkMode]);}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/usePanelEditSession.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/usePanelEditSession.tsindex 53b85e0391..33baae9ee9 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/usePanelEditSession.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/usePanelEditSession.ts@@ -3,6 +3,7 @@ import type {DashboardtypesPanelSpecDTO,TelemetrytypesSignalDTO,} from 'api/generated/services/sigNoz.schemas';+import { useCallback } from 'react';import type { PANEL_TYPES } from 'constants/queryBuilder';import {getSupportedSignals,@@ -104,7 +105,11 @@ export function usePanelEditSession({enabled: isPanelKindSupported(panelKind),});- const { runQuery, isQueryDirty, buildSaveSpec } = usePanelEditorQuerySync({+ const {+ runQuery,+ isQueryDirty,+ buildSaveSpec: buildQuerySaveSpec,+ } = usePanelEditorQuerySync({draft,panelType,setSpec,@@ -114,6 +119,17 @@ export function usePanelEditSession({savedQueries: savedPanel?.spec.queries,});+ const { reconcileWithQueries } = panelDefinition;+ const buildSaveSpec = useCallback(+ (next: DashboardtypesPanelSpecDTO): DashboardtypesPanelSpecDTO => {+ const withQueries = buildQuerySaveSpec(next);+ return reconcileWithQueries+ ? reconcileWithQueries(withQueries)+ : withQueries;+ },+ [buildQuerySaveSpec, reconcileWithQueries],+ );+return {draft,spec,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useTableColumns.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useTableColumns.tsindex 46d7a20c2f..3d9cb396d9 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useTableColumns.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/useTableColumns.ts@@ -1,7 +1,9 @@import { useMemo } from 'react';import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';+import { getQueryPanelDefinition } from 'pages/DashboardPage/DashboardContainer/Panels/capabilities';import type { PanelFormattingSlice } from 'pages/DashboardPage/DashboardContainer/Panels/types/sections';import { getColumnUnit } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getColumnUnit';+import { getValueColumnLabels } from 'pages/DashboardPage/DashboardContainer/Panels/utils/getValueColumnLabels';import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';import { getScalarResults } from 'pages/DashboardPage/DashboardContainer/queryV5/v5ResponseData';@@ -16,6 +18,8 @@ export interface TableColumnOption {key: string;/** Display label shown in the editor — the resolved column name. */label: string;+ /** The column's own name (alias/legend/expression), without the query prefix. */+ name: string;/*** The column's configured unit (`formatting.columnUnits[key]`), if any. The* per-column threshold editor scopes its unit picker to this unit's category@@ -28,14 +32,17 @@ export interface TableColumnOption {* Resolves a Table panel's value (aggregation) columns into `{ key, label }`* options, so the table-only config editors (column units, per-column thresholds)* store the query-keyed value the renderer looks up by while showing the readable- * column name. Empty for non-table kinds or before data arrives.+ * column name. Empty for kinds that don't join scalar rows, or before data arrives.*/export function useTableColumns(panel: DashboardtypesPanelDTO,data: PanelQueryData,): TableColumnOption[] {return useMemo(() => {- if (panel.spec.plugin.kind !== 'signoz/TablePanel') {+ if (+ !getQueryPanelDefinition(panel.spec.plugin.kind)?.queryCapabilities+ .formatTableResultForUI+ ) {return [];}const table = prepareScalarTables({@@ -49,13 +56,15 @@ export function useTableColumns(const columnUnits =(panel.spec.plugin.spec as { formatting?: PanelFormattingSlice }).formatting?.columnUnits ?? {};+ const labels = getValueColumnLabels(table.columns);return table.columns.filter((column) => column.isValueColumn).map((column) => {const key = column.id || column.name;return {key,- label: column.name,+ label: labels[key] ?? column.name,+ name: column.name,unit: getColumnUnit(key, columnUnits),};});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/__tests__/capabilities.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/__tests__/capabilities.test.tsindex f9addf4f5d..9b34ae7ceb 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/__tests__/capabilities.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/__tests__/capabilities.test.ts@@ -36,6 +36,7 @@ const EXPECTED_QUERY_TYPES: Record<PanelKind, EQueryType[]> = {'signoz/PieChartPanel': [QUERY_BUILDER, CLICKHOUSE],'signoz/TablePanel': [QUERY_BUILDER, CLICKHOUSE],'signoz/ListPanel': [QUERY_BUILDER],+ 'signoz/ScatterPlotPanel': [QUERY_BUILDER, CLICKHOUSE],// Static kind: no query surface at all.'signoz/TextPanel': [],};@@ -79,6 +80,7 @@ const EXPECTED_QUERY_MODES: Record<PanelKind, QueryMode[]> = {],'signoz/TablePanel': [QUERY_BUILDER, CLICKHOUSE, QueryMode.AI_QUERY_BUILDER],'signoz/ListPanel': [QUERY_BUILDER, QueryMode.AI_QUERY_BUILDER],+ 'signoz/ScatterPlotPanel': [QUERY_BUILDER, CLICKHOUSE],'signoz/TextPanel': [],};@@ -95,6 +97,7 @@ const EXPECTED_SIGNALS: Record<PanelKind, TelemetrytypesSignalDTO[]> = {// List renders raw rows; metrics produce no row data.'signoz/ListPanel': [logs, traces],'signoz/TextPanel': [],+ 'signoz/ScatterPlotPanel': [metrics, logs, traces],};// Exhaustive over PanelKind, so a new kind can't ship without stating how its request is@@ -156,7 +159,7 @@ const EXPECTED_QUERY_CAPABILITIES: Partial<orderTiebreaker: false,serverPaginated: false,},- // Only Table asks the server to transpose its scalar result into UI rows.+ // Only Table and Scatter Plot ask the server to join their scalar results into UI rows.'signoz/TablePanel': {requestType: scalar,formatTableResultForUI: true,@@ -164,6 +167,14 @@ const EXPECTED_QUERY_CAPABILITIES: Partial<orderTiebreaker: false,serverPaginated: false,},+ 'signoz/ScatterPlotPanel': {+ requestType: scalar,+ formatTableResultForUI: true,+ bucketedStepInterval: false,+ orderTiebreaker: false,+ serverPaginated: false,+ defaultRowLimit: 10_000,+ },// Only List reads raw rows, pages them server-side, and needs an order tiebreaker.'signoz/ListPanel': {requestType: raw,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.module.scss b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.module.scssnew file mode 100644index 0000000000..7c76532872--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.module.scss@@ -0,0 +1,5 @@+.chart {+ flex: 1;+ min-width: 0;+ min-height: 0;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.tsxnew file mode 100644index 0000000000..77d10d2e46--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/Renderer.tsx@@ -0,0 +1,228 @@+import { useCallback, useMemo, useRef } from 'react';+import { ChartScatter } from '@signozhq/icons';+import {+ type DashboardtypesScatterPlotPanelSpecDTO,+ DashboardtypesThresholdAxisDTO,+} from 'api/generated/services/sigNoz.schemas';+import { useIsDarkMode } from 'hooks/useDarkMode';+import { useResizeObserver } from 'hooks/useDimensions';+import type { IRenderTooltipFooterArgs } from 'lib/uPlotV2/components/types';+import type { ScatterPointLabel } from 'lib/uPlotV2/plugins/ScatterPlugin/types';+import type { ScatterPointClick } from 'lib/visualization/charts/types';+import Scatter from 'lib/visualization/charts/Scatter/Scatter';+import {+ buildScatterConfig,+ prepareScatterChartData,+} from 'lib/visualization/charts/Scatter/utils';+import TooltipFooter from 'lib/visualization/panels/components/TooltipFooter';++import NoData from '../../components/NoData/NoData';+import PanelMessage from '../../components/PanelMessage/PanelMessage';+import PanelStyles from '../../panel.module.scss';+import type { PanelRendererProps } from '../../types/rendererProps';+import { prepareScatterClickData } from '../../utils/drilldown/prepareScatterClickData';+import { getBuilderQueries } from '../../utils/getBuilderQueries';+import { getPanelTimeRange } from '../../utils/getPanelTimeRange';+import {+ resolveDecimalPrecision,+ resolveLegendPosition,+} from '../../utils/chartAppearance/resolvers';+import {+ resolveSelectionPreferencesSource,+ shouldSaveSelectionPreference,+} from '../../utils/selectionPreferences';++import { ScatterPlotDataStatus } from './types';+import { getAxisThresholds, toScatterAxisOptions } from './utils/axisOptions';+import { findGroupByMismatch } from './utils/groupByMismatch';+import { getScatterPlotData } from './utils/getScatterPlotData';+import { getScatterPlotEmptyMessage } from './utils/messages';+import { resolvePointOpacity, resolvePointSize } from './utils/points';++import styles from './Renderer.module.scss';++function ScatterPlotPanelRenderer({+ panelId,+ panel,+ data,+ isFetching,+ refetch,+ panelMode,+ onClick,+ enableDrillDown,+}: PanelRendererProps<'signoz/ScatterPlotPanel'>): JSX.Element {+ const graphRef = useRef<HTMLDivElement>(null);+ const containerDimensions = useResizeObserver(graphRef);+ const isDarkMode = useIsDarkMode();++ const spec = useMemo<DashboardtypesScatterPlotPanelSpecDTO>(+ () => panel.spec.plugin.spec,+ [panel.spec.plugin.spec],+ );++ const scatterData = useMemo(+ () => getScatterPlotData(data, spec),+ [data, spec],+ );++ const decimalPrecision = useMemo(+ () => resolveDecimalPrecision(spec.formatting?.decimalPrecision),+ [spec.formatting?.decimalPrecision],+ );++ const legendPosition = useMemo(+ () => resolveLegendPosition(spec.legend?.position),+ [spec.legend?.position],+ );++ const builderQueries = useMemo(+ () => getBuilderQueries(panel.spec.queries || []),+ [panel.spec.queries],+ );++ const groupByMismatch = useMemo(+ () => findGroupByMismatch(builderQueries),+ [builderQueries],+ );++ const emptyMessage = getScatterPlotEmptyMessage(scatterData, groupByMismatch);++ const readyData =+ scatterData.status === ScatterPlotDataStatus.Ready &&+ scatterData.drawnGroups > 0+ ? scatterData+ : undefined;++ const config = useMemo(+ () =>+ readyData+ ? buildScatterConfig({+ id: panelId,+ series: readyData.series,+ isDarkMode,+ x: toScatterAxisOptions(+ spec.axes?.x,+ readyData.channels.x.unit,+ getAxisThresholds(spec.thresholds, DashboardtypesThresholdAxisDTO.x),+ ),+ y: toScatterAxisOptions(+ spec.axes?.y,+ readyData.channels.y.unit,+ getAxisThresholds(spec.thresholds, DashboardtypesThresholdAxisDTO.y),+ ),+ pointSize: resolvePointSize(spec.chartAppearance?.points),+ fillOpacity: resolvePointOpacity(spec.chartAppearance?.points),+ colorMapping: spec.legend?.customColors ?? {},+ decimalPrecision,+ selectionPreferencesSource: resolveSelectionPreferencesSource(panelMode),+ shouldSaveSelectionPreference: shouldSaveSelectionPreference(panelMode),+ })+ : undefined,+ [+ readyData,+ panelId,+ isDarkMode,+ spec.axes?.x,+ spec.axes?.y,+ spec.chartAppearance?.points,+ spec.legend?.customColors,+ spec.thresholds,+ decimalPrecision,+ panelMode,+ ],+ );++ const chartData = useMemo(+ () => (readyData ? prepareScatterChartData(readyData.series) : undefined),+ [readyData],+ );++ const resolvePointGroupValues = useCallback(+ (seriesIndex: number, dataIndex: number): ScatterPointLabel[] =>+ readyData?.pointLabels[seriesIndex - 1]?.[dataIndex] ?? [],+ [readyData],+ );++ const handlePointClick = useCallback(+ ({ seriesIndex, dataIndex, color, coordinates }: ScatterPointClick): void => {+ if (!onClick || !readyData) {+ return;+ }+ const payload = prepareScatterClickData({+ labels: readyData.pointLabels[seriesIndex - 1]?.[dataIndex] ?? [],+ label: readyData.series[seriesIndex - 1]?.label ?? '',+ color,+ axisQueries: readyData.axisQueries,+ builderQueries,+ coordinates,+ timeRange: getPanelTimeRange(data.requestPayload),+ });+ if (payload) {+ onClick(payload);+ }+ },+ [onClick, readyData, builderQueries, data.requestPayload],+ );++ const renderTooltipFooter = useCallback(+ ({ isPinned, dismiss }: IRenderTooltipFooterArgs) => (+ <TooltipFooter+ id={panelId}+ isPinned={isPinned}+ dismiss={dismiss}+ canDrilldown={!!enableDrillDown}+ />+ ),+ [panelId, enableDrillDown],+ );++ return (+ <div+ data-testid="scatter-plot-panel-renderer"+ className={PanelStyles.panelContainer}+ >+ {!readyData && emptyMessage && (+ <PanelMessage+ icon={<ChartScatter size={18} />}+ title={emptyMessage.title}+ description={emptyMessage.description}+ data-testid="scatter-plot-empty-message"+ />+ )}+ {!readyData && !emptyMessage && (+ <NoData isFetching={isFetching} onRetry={refetch} panel={panel} />+ )}+ {/* Stays mounted through the empty states: the size observer is bound to this node. */}+ <div+ ref={graphRef}+ className={styles.chart}+ hidden={!readyData}+ data-testid="scatter-plot-chart-area"+ >+ {readyData &&+ config &&+ chartData &&+ containerDimensions.width > 0 &&+ containerDimensions.height > 0 && (+ <Scatter+ key={panelId}+ config={config}+ data={chartData}+ channels={readyData.channels}+ resolvePointGroupValues={resolvePointGroupValues}+ legendConfig={{ position: legendPosition }}+ decimalPrecision={decimalPrecision}+ canPinTooltip+ width={containerDimensions.width}+ height={containerDimensions.height}+ renderTooltipFooter={renderTooltipFooter}+ onPointClick={enableDrillDown ? handlePointClick : undefined}+ data-testid="scatter-plot-chart"+ />+ )}+ </div>+ </div>+ );+}++export default ScatterPlotPanelRenderer;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/__tests__/Renderer.test.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/__tests__/Renderer.test.tsxnew file mode 100644index 0000000000..22cdd7405a--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/__tests__/Renderer.test.tsx@@ -0,0 +1,167 @@+import { useState } from 'react';+import type {+ DashboardtypesPanelDTO,+ DashboardtypesScatterPlotPanelSpecDTO,+ QueryRangeV5200,+} from 'api/generated/services/sigNoz.schemas';+import { PanelMode } from 'lib/visualization/panels/types';+import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';+import { render, screen, userEvent } from 'tests/test-utils';++import type { BaseRendererProps } from '../../../types/rendererProps';+import BaseScatterPlotPanelRenderer from '../Renderer';++const ScatterPlotPanelRenderer =+ BaseScatterPlotPanelRenderer as React.FC<BaseRendererProps>;++jest.mock('hooks/useDimensions', () => ({+ useResizeObserver: (): { width: number; height: number } => ({+ width: 400,+ height: 300,+ }),+}));+jest.mock('lib/visualization/charts/Scatter/Scatter', () => ({+ __esModule: true,+ default: (): JSX.Element => <div data-testid="scatter-chart" />,+}));++window.ResizeObserver =+ window.ResizeObserver ||+ jest.fn().mockImplementation(() => ({+ disconnect: jest.fn(),+ observe: jest.fn(),+ unobserve: jest.fn(),+ }));++function panelWith(+ spec: DashboardtypesScatterPlotPanelSpecDTO,+): DashboardtypesPanelDTO {+ return {+ kind: 'Panel',+ spec: { plugin: { kind: 'signoz/ScatterPlotPanel', spec } },+ } as unknown as DashboardtypesPanelDTO;+}++/** A joined scalar result: one group column plus one value column per query. */+function dataWith(queryNames: string[], rows: unknown[][]): PanelQueryData {+ return {+ response: {+ status: 'success',+ data: {+ type: 'scalar',+ data: {+ results: [+ {+ queryName: queryNames[0],+ columns: [+ { name: 'service.name', queryName: '', columnType: 'group' },+ ...queryNames.map((queryName) => ({+ name: '__result_0',+ queryName,+ columnType: 'aggregation',+ aggregationIndex: 0,+ })),+ ],+ data: rows,+ },+ ],+ },+ },+ } as unknown as QueryRangeV5200,+ requestPayload: undefined,+ legendMap: {},+ };+}++function renderPanel(data: PanelQueryData): ReturnType<typeof render> {+ return render(+ <ScatterPlotPanelRenderer+ panelId="panel-1"+ panel={panelWith({})}+ data={data}+ isFetching={false}+ error={null}+ panelMode={PanelMode.DASHBOARD_VIEW}+ />,+ );+}++describe('ScatterPlotPanelRenderer', () => {+ it('shows the plain empty state when the query returns no groups', () => {+ const { getByTestId } = renderPanel(dataWith(['A', 'B'], []));++ expect(getByTestId('panel-no-data')).toBeInTheDocument();+ });++ it('asks for a second value when the query has one value column', () => {+ const { getByTestId, getByText } = renderPanel(+ dataWith(['A'], [['cart', 120]]),+ );++ expect(getByTestId('scatter-plot-empty-message')).toBeInTheDocument();+ expect(getByText('Add a second aggregation or query')).toBeInTheDocument();+ });++ it('explains the group by mismatch when no row has both an x and a y', () => {+ const { getByText } = renderPanel(+ dataWith(['A', 'B'], [['checkout', 45, 'n/a']]),+ );++ expect(getByText('0 of 1 group plotted')).toBeInTheDocument();+ });++ it('plots once two value columns line up for a group', () => {+ const { getByTestId, queryByTestId } = renderPanel(+ dataWith(+ ['A', 'B'],+ [+ ['cart', 120, 340],+ ['checkout', 45, 'n/a'],+ ],+ ),+ );++ expect(getByTestId('scatter-plot-panel-renderer')).toBeInTheDocument();+ expect(getByTestId('scatter-chart')).toBeInTheDocument();+ expect(queryByTestId('panel-no-data')).not.toBeInTheDocument();+ });++ it('keeps the chart area mounted through an empty state, so it plots again on return', async () => {+ const user = userEvent.setup();+ const ready = dataWith(['A', 'B'], [['cart', 120, 340]]);+ const mismatch = dataWith(['A', 'B'], [['checkout', 45, 'n/a']]);+ function Harness(): JSX.Element {+ const [data, setData] = useState(ready);+ return (+ <>+ <button type="button" onClick={(): void => setData(mismatch)}>+ mismatch+ </button>+ <button type="button" onClick={(): void => setData(ready)}>+ ready+ </button>+ <ScatterPlotPanelRenderer+ panelId="panel-1"+ panel={panelWith({})}+ data={data}+ isFetching={false}+ error={null}+ panelMode={PanelMode.DASHBOARD_VIEW}+ />+ </>+ );+ }+ render(<Harness />);+ const chartArea = screen.getByTestId('scatter-plot-chart-area');+ expect(screen.getByTestId('scatter-chart')).toBeInTheDocument();++ await user.click(screen.getByRole('button', { name: 'mismatch' }));+ expect(screen.getByTestId('scatter-plot-empty-message')).toBeInTheDocument();+ expect(chartArea).not.toBeVisible();++ await user.click(screen.getByRole('button', { name: 'ready' }));+ expect(screen.getByTestId('scatter-plot-chart-area')).toBe(chartArea);+ expect(chartArea).toBeVisible();+ expect(screen.getByTestId('scatter-chart')).toBeInTheDocument();+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/definition.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/definition.tsnew file mode 100644index 0000000000..edbe507d81--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/definition.ts@@ -0,0 +1,74 @@+import { ChartScatter } from '@signozhq/icons';++import type { PanelDefinition } from '../../types/panelDefinition';+import { QueryModeKind } from '../../types/panelCapabilities';+import QueryBuilderEditorPane from 'pages/DashboardPage/DashboardContainer/PanelEditor/PanelEditorQueryBuilder/QueryBuilderEditorPane';+import Renderer from './Renderer';+import { MAX_PLOTTED_GROUPS } from './utils/prepareData';+import { sections } from './sections';+import { getScatterPlotDataWarning } from './utils/warning';+import { pruneStaleDimensions } from './utils/pruneStaleDimensions';+import {+ Querybuildertypesv5RequestTypeDTO,+ TelemetrytypesSignalDTO,+} from 'api/generated/services/sigNoz.schemas';+import { QueryMode } from 'types/api/queryBuilder/queryBuilderData';+import { QueryBuilderField } from 'components/QueryBuilderV2/queryBuilderFields.types';++export const definition: PanelDefinition<'signoz/ScatterPlotPanel'> = {+ kind: 'signoz/ScatterPlotPanel',+ displayName: 'Scatter Plot',+ mode: 'query',+ icon: ChartScatter,+ Renderer,+ EditorPane: QueryBuilderEditorPane,+ sections,+ supportedQueryModesKindMap: {+ [QueryMode.QUERY_BUILDER]: {+ kind: QueryModeKind.SIGNAL,+ signals: [+ TelemetrytypesSignalDTO.metrics,+ TelemetrytypesSignalDTO.logs,+ TelemetrytypesSignalDTO.traces,+ ],+ },+ [QueryMode.CLICKHOUSE]: { kind: QueryModeKind.SIGNAL_LESS },+ },+ queryBuilderFields: {+ // Pinned so it opens empty: the group-by template a click would seed names nothing here.+ legend_format: {+ state: 'pinned',+ placeholder: 'Name for this value, e.g. p95 latency',+ },+ trace_operator: {+ state: 'hidden',+ },+ limit: {+ state: 'pinned',+ placeholder: `Default ${MAX_PLOTTED_GROUPS.toLocaleString('en-US')} for Scatter Plot`,+ },+ },+ // One joined row per group, so x and y can come from different queries.+ queryCapabilities: {+ requestType: Querybuildertypesv5RequestTypeDTO.scalar,+ formatTableResultForUI: true,+ bucketedStepInterval: false,+ orderTiebreaker: false,+ serverPaginated: false,+ defaultRowLimit: MAX_PLOTTED_GROUPS,+ },+ // One group by everywhere, so the queries' results join row for row.+ syncedQueryBuilderFields: [QueryBuilderField.GroupBy],+ getDataWarning: getScatterPlotDataWarning,+ reconcileWithQueries: pruneStaleDimensions,+ actions: {+ view: true,+ edit: true,+ clone: true,+ // Every group of the joined table, plotted or not.+ download: { csv: true, png: true, svg: true },+ createAlert: false,+ search: false,+ drilldown: true,+ },+};diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/sections.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/sections.tsnew file mode 100644index 0000000000..3a0e8d3629--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/sections.ts@@ -0,0 +1,29 @@+import { resolveScatterLegendSeries } from '../../utils/legendSeries';+import {+ SectionKind,+ ThresholdVariant,+ type SectionConfig,+} from '../../types/sections';++export const sections: SectionConfig[] = [+ {+ kind: SectionKind.Visualization,+ controls: { switchPanelKind: true, timePreference: true },+ },+ { kind: SectionKind.Dimensions },+ { kind: SectionKind.ScatterAxes },+ { kind: SectionKind.ChartAppearance, controls: { points: true } },+ {+ kind: SectionKind.Formatting,+ controls: { decimals: true, columnUnits: true },+ },+ {+ kind: SectionKind.Legend,+ controls: { position: true, colors: resolveScatterLegendSeries },+ },+ {+ kind: SectionKind.Thresholds,+ controls: { variant: ThresholdVariant.LABEL, axis: true },+ },+ { kind: SectionKind.ContextLinks },+];diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/types.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/types.tsnew file mode 100644index 0000000000..53f67bc64e--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/types.ts@@ -0,0 +1,65 @@+import type {+ DashboardtypesScatterPlotAxesDTO,+ DashboardtypesScatterPlotDimensionsDTO,+} from 'api/generated/services/sigNoz.schemas';+import type { ScatterSeries } from 'lib/visualization/charts/Scatter/types';+import type {+ ScatterChannels,+ ScatterPointLabel,+} from 'lib/uPlotV2/plugins/ScatterPlugin/types';+import type { PanelTable } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++export interface PrepareScatterPlotDataArgs {+ /** The joined scalar table (`formatTableResultForUI`). */+ table: PanelTable | undefined;+ dimensions: DashboardtypesScatterPlotDimensionsDTO | undefined;+ /** A `log` axis drops values ≤ 0, which it cannot place. */+ axes?: DashboardtypesScatterPlotAxesDTO;+ columnUnits: Record<string, string>;+}++export enum ScatterPlotDataStatus {+ Ready = 'ready',+ /** Fewer than two value columns: nothing to put on y. */+ NeedsSecondValue = 'needsSecondValue',+}++export enum ScatterDimension {+ X = 'X',+ Y = 'Y',+ Size = 'Size',+ Color = 'Color',+}++/** A dimension bound to a column key the result doesn't have. */+export interface StaleDimension {+ dimension: ScatterDimension;+ key: string;+}++export type ScatterPlotData =+ | {+ status: ScatterPlotDataStatus.NeedsSecondValue;+ totalGroups: number;+ }+ | {+ status: ScatterPlotDataStatus.Ready;+ /** One per colour group. */+ series: ScatterSeries[];+ /** `[seriesIndex][dataIndex]`: the point's group-by labels. */+ pointLabels: ScatterPointLabel[][][];+ channels: ScatterChannels;+ /** The query each axis's column comes from, for drilldown. */+ axisQueries: { x: string; y: string };+ /** Rows the query returned. */+ totalGroups: number;+ /** Rows plotted. */+ drawnGroups: number;+ /** Rows missing a finite x or y, e.g. a group absent from one query. */+ missingValueGroups: number;+ /** Rows with a value ≤ 0 on a `log` axis. */+ nonPositiveOnLogGroups: number;+ /** Plottable rows left out past `MAX_PLOTTED_GROUPS`. */+ cappedGroups: number;+ staleDimensions: StaleDimension[];+ };diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/axisOptions.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/axisOptions.test.tsnew file mode 100644index 0000000000..0511ee1d7e--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/axisOptions.test.ts@@ -0,0 +1,49 @@+import { DashboardtypesThresholdAxisDTO } from 'api/generated/services/sigNoz.schemas';++import { getAxisThresholds, toScatterAxisOptions } from '../axisOptions';++const X_LINE = {+ value: 50,+ color: '#00f',+ axis: DashboardtypesThresholdAxisDTO.x,+};+const Y_LINE = {+ value: 300,+ color: '#f00',+ axis: DashboardtypesThresholdAxisDTO.y,+};+const UNSET_LINE = { value: 10, color: '#0f0' };++describe('getAxisThresholds', () => {+ it('splits thresholds by axis, counting an unset axis as y', () => {+ const thresholds = [X_LINE, Y_LINE, UNSET_LINE];++ expect(+ getAxisThresholds(thresholds, DashboardtypesThresholdAxisDTO.x),+ ).toStrictEqual([X_LINE]);+ expect(+ getAxisThresholds(thresholds, DashboardtypesThresholdAxisDTO.y),+ ).toStrictEqual([Y_LINE, UNSET_LINE]);+ });++ it('is empty without thresholds', () => {+ expect(+ getAxisThresholds(null, DashboardtypesThresholdAxisDTO.y),+ ).toStrictEqual([]);+ });+});++describe('toScatterAxisOptions', () => {+ it('carries the axis thresholds onto the chart axis', () => {+ expect(+ toScatterAxisOptions(undefined, 'reqps', [X_LINE]).thresholds,+ ).toStrictEqual([+ {+ thresholdValue: 50,+ thresholdColor: '#00f',+ thresholdUnit: undefined,+ thresholdLabel: undefined,+ },+ ]);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getColorGroupLabels.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getColorGroupLabels.test.tsnew file mode 100644index 0000000000..bf02c841e4--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getColorGroupLabels.test.ts@@ -0,0 +1,67 @@+import type {+ PanelTable,+ PanelTableColumn,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import { getColorGroupLabels, UNGROUPED_SERIES_LABEL } from '../prepareData';++const column = (id: string, isValueColumn = false): PanelTableColumn => ({+ id,+ name: id,+ queryName: 'A',+ isValueColumn,+});++function makeTable(+ columns: PanelTableColumn[],+ rows: Record<string, unknown>[],+): PanelTable {+ return {+ queryName: 'A',+ legend: '',+ columns,+ rows: rows.map((data) => ({ data })),+ };+}++describe('getColorGroupLabels', () => {+ it('labels each row by the selected keys, in row order', () => {+ const table = makeTable(+ [column('region'), column('env'), column('A', true)],+ [+ { region: 'eu', env: 'prod', A: 1 },+ { region: 'us', env: 'dev', A: 2 },+ ],+ );++ expect(getColorGroupLabels(table, ['env'])).toStrictEqual(['prod', 'dev']);+ expect(getColorGroupLabels(table, undefined)).toStrictEqual([+ 'eu, prod',+ 'us, dev',+ ]);+ });++ it('keeps groups apart when a value holds the separator', () => {+ const table = makeTable(+ [column('region'), column('env'), column('A', true)],+ [+ { region: 'us, east', env: 'prod', A: 1 },+ { region: 'us', env: 'east, prod', A: 2 },+ ],+ );++ expect(getColorGroupLabels(table, undefined)).toStrictEqual([+ '"us, east", prod',+ 'us, "east, prod"',+ ]);+ });++ it('puts every row in one group when the query has no group by', () => {+ const table = makeTable([column('A', true)], [{ A: 1 }, { A: 2 }]);++ expect(getColorGroupLabels(table, undefined)).toStrictEqual([+ UNGROUPED_SERIES_LABEL,+ UNGROUPED_SERIES_LABEL,+ ]);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getScatterPlotData.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getScatterPlotData.test.tsnew file mode 100644index 0000000000..84da50f9ec--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/getScatterPlotData.test.ts@@ -0,0 +1,74 @@+import type { DashboardtypesScatterPlotPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';+import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import { getJoinedScalarTable } from '../../../../utils/getJoinedScalarTable';+import { ScatterPlotDataStatus, type ScatterPlotData } from '../../types';+import { getScatterPlotData } from '../getScatterPlotData';+import { prepareScatterPlotData } from '../prepareData';++jest.mock('../../../../utils/getJoinedScalarTable');+jest.mock('../prepareData');++const mockPrepare = jest.mocked(prepareScatterPlotData);++function makeReady(): ScatterPlotData {+ return {+ status: ScatterPlotDataStatus.Ready,+ series: [],+ pointLabels: [],+ channels: { x: { label: 'A' }, y: { label: 'B' } },+ axisQueries: { x: 'A', y: 'B' },+ totalGroups: 0,+ drawnGroups: 0,+ missingValueGroups: 0,+ nonPositiveOnLogGroups: 0,+ cappedGroups: 0,+ staleDimensions: [],+ };+}++function makeData(): PanelQueryData {+ return { response: undefined, requestPayload: undefined, legendMap: {} };+}++describe('getScatterPlotData', () => {+ beforeEach(() => {+ jest.mocked(getJoinedScalarTable).mockReturnValue(undefined);+ mockPrepare.mockImplementation(makeReady);+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ it('prepares a response once for the same spec', () => {+ const data = makeData();+ const spec: DashboardtypesScatterPlotPanelSpecDTO = {+ dimensions: { x: 'A', y: 'B' },+ };++ const first = getScatterPlotData(data, spec);+ const second = getScatterPlotData(data, spec);++ expect(second).toBe(first);+ expect(mockPrepare).toHaveBeenCalledTimes(1);+ });++ it('prepares again when the dimensions change', () => {+ const data = makeData();++ getScatterPlotData(data, { dimensions: { x: 'A', y: 'B' } });+ getScatterPlotData(data, { dimensions: { x: 'B', y: 'A' } });++ expect(mockPrepare).toHaveBeenCalledTimes(2);+ });++ it('prepares each response separately', () => {+ const spec: DashboardtypesScatterPlotPanelSpecDTO = {};++ getScatterPlotData(makeData(), spec);+ getScatterPlotData(makeData(), spec);++ expect(mockPrepare).toHaveBeenCalledTimes(2);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/groupByMismatch.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/groupByMismatch.test.tsnew file mode 100644index 0000000000..66fd9d6995--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/groupByMismatch.test.ts@@ -0,0 +1,64 @@+import type { BuilderQuery } from 'types/api/v5/queryRange';++import { findGroupByMismatch, formatGroupByMismatch } from '../groupByMismatch';++const query = (+ name: string,+ labels: string[],+ disabled = false,+): BuilderQuery =>+ ({+ name,+ disabled,+ groupBy: labels.map((label) => ({ name: label })),+ }) as BuilderQuery;++describe('findGroupByMismatch', () => {+ it('is null when every query groups by the same labels, in any order', () => {+ expect(+ findGroupByMismatch([+ query('A', ['service.name', 'host.name']),+ query('B', ['host.name', 'service.name']),+ ]),+ ).toBeNull();+ });++ it('is null for a single query', () => {+ expect(findGroupByMismatch([query('A', ['service.name'])])).toBeNull();+ });++ it("lists each query's labels when they differ", () => {+ expect(+ findGroupByMismatch([+ query('A', ['service.name']),+ query('B', ['host.name']),+ ]),+ ).toStrictEqual([+ { queryName: 'A', labels: ['service.name'] },+ { queryName: 'B', labels: ['host.name'] },+ ]);+ });++ it('counts disabled queries', () => {+ expect(+ findGroupByMismatch([+ query('A', ['service.name']),+ query('B', ['host.name'], true),+ ]),+ ).toStrictEqual([+ { queryName: 'A', labels: ['service.name'] },+ { queryName: 'B', labels: ['host.name'] },+ ]);+ });+});++describe('formatGroupByMismatch', () => {+ it('names each query and its labels', () => {+ expect(+ formatGroupByMismatch([+ { queryName: 'A', labels: ['service.name', 'host.name'] },+ { queryName: 'B', labels: [] },+ ]),+ ).toBe('A by service.name, host.name · B ungrouped');+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/messages.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/messages.test.tsnew file mode 100644index 0000000000..7a7427373e--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/messages.test.ts@@ -0,0 +1,204 @@+import { getScatterPlotEmptyMessage, getScatterPlotWarning } from '../messages';+import {+ ScatterDimension,+ type ScatterPlotData,+ ScatterPlotDataStatus,+ type StaleDimension,+} from '../../types';++const MISMATCH = [+ { queryName: 'A', labels: ['service.name'] },+ { queryName: 'B', labels: ['host.name'] },+];+const MISMATCH_NOTE =+ "Queries are grouped by different labels (A by service.name · B by host.name), so their groups don't line up. Change any query's group by to apply it to all.";++function ready(counts: {+ totalGroups: number;+ drawnGroups: number;+ missingValueGroups?: number;+ nonPositiveOnLogGroups?: number;+ cappedGroups?: number;+ staleDimensions?: StaleDimension[];+}): ScatterPlotData {+ return {+ status: ScatterPlotDataStatus.Ready,+ series: [],+ pointLabels: [],+ channels: { x: { label: 'x' }, y: { label: 'y' } },+ axisQueries: { x: 'A', y: 'A' },+ missingValueGroups: 0,+ nonPositiveOnLogGroups: 0,+ cappedGroups: 0,+ staleDimensions: [],+ ...counts,+ };+}++describe('getScatterPlotEmptyMessage', () => {+ it('leaves an empty result to the plain no-data state', () => {+ expect(+ getScatterPlotEmptyMessage({+ status: ScatterPlotDataStatus.NeedsSecondValue,+ totalGroups: 0,+ }),+ ).toBeUndefined();+ expect(+ getScatterPlotEmptyMessage(ready({ totalGroups: 0, drawnGroups: 0 })),+ ).toBeUndefined();+ });++ it('asks for a second value', () => {+ expect(+ getScatterPlotEmptyMessage({+ status: ScatterPlotDataStatus.NeedsSecondValue,+ totalGroups: 3,+ })?.title,+ ).toBe('Add a second aggregation or query');+ });++ it('says nothing once a group plots', () => {+ expect(+ getScatterPlotEmptyMessage(+ ready({ totalGroups: 3, drawnGroups: 1, missingValueGroups: 2 }),+ ),+ ).toBeUndefined();+ });++ it('points at the group by when no group has both values', () => {+ expect(+ getScatterPlotEmptyMessage(+ ready({ totalGroups: 52, drawnGroups: 0, missingValueGroups: 52 }),+ ),+ ).toStrictEqual({+ title: '0 of 52 groups plotted',+ description:+ 'No group has both an X and a Y value. Group every query by exactly the same labels; a group missing from one query has no dot.',+ });+ });++ it('points at symlog when a log axis hid every group', () => {+ expect(+ getScatterPlotEmptyMessage(+ ready({ totalGroups: 1, drawnGroups: 0, nonPositiveOnLogGroups: 1 }),+ ),+ ).toStrictEqual({+ title: '0 of 1 group plotted',+ description:+ "1 group with a value ≤ 0 can't go on a log axis. Switch the axis to symlog to show them.",+ });+ });+});++describe('getScatterPlotWarning', () => {+ it('is null when every group plots', () => {+ expect(+ getScatterPlotWarning(ready({ totalGroups: 4, drawnGroups: 4 })),+ ).toBeNull();+ });++ it('leaves a plot with no dots to the empty state', () => {+ expect(+ getScatterPlotWarning(+ ready({ totalGroups: 4, drawnGroups: 0, missingValueGroups: 4 }),+ ),+ ).toBeNull();+ });++ it('counts the groups shown and why the rest are missing', () => {+ expect(+ getScatterPlotWarning(+ ready({+ totalGroups: 52,+ drawnGroups: 37,+ missingValueGroups: 12,+ nonPositiveOnLogGroups: 3,+ }),+ ),+ ).toStrictEqual({+ message: 'Showing 37 of 52 groups.',+ messages: [+ '12 groups missing an X or Y value.',+ "3 groups with a value ≤ 0 can't go on a log axis. Switch the axis to symlog to show them.",+ ],+ });+ });++ it('flags a result at the cap', () => {+ expect(+ getScatterPlotWarning(+ ready({+ totalGroups: 584393,+ drawnGroups: 10000,+ cappedGroups: 574393,+ }),+ ),+ ).toStrictEqual({+ message: 'Showing the first 10,000 groups.',+ messages: ['Add a filter or narrow the group by to see the rest.'],+ });+ });++ it('treats a result at the server limit as capped', () => {+ expect(+ getScatterPlotWarning(ready({ totalGroups: 10000, drawnGroups: 10000 }))+ ?.message,+ ).toBe('Showing the first 10,000 groups.');+ });++ it('does not flag the cap when only missing values left groups out', () => {+ expect(+ getScatterPlotWarning(+ ready({+ totalGroups: 12000,+ drawnGroups: 9000,+ missingValueGroups: 3000,+ }),+ ),+ ).toStrictEqual({+ message: 'Showing 9,000 of 12,000 groups.',+ messages: ['3,000 groups missing an X or Y value.'],+ });+ });++ it('names dimensions bound to columns the result lacks', () => {+ expect(+ getScatterPlotWarning(+ ready({+ totalGroups: 4,+ drawnGroups: 4,+ staleDimensions: [+ { dimension: ScatterDimension.X, key: 'A.count()' },+ { dimension: ScatterDimension.Color, key: 'host.name' },+ ],+ }),+ ),+ ).toStrictEqual({+ message: "Some dimensions aren't in the results.",+ messages: [+ "X uses A.count(), which isn't in the results, so X falls back to Auto.",+ "Color uses host.name, which isn't in the results, so it's left out of the color.",+ ],+ });+ });++ it("explains missing values by the queries' differing group bys", () => {+ expect(+ getScatterPlotWarning(+ ready({ totalGroups: 6, drawnGroups: 4, missingValueGroups: 2 }),+ MISMATCH,+ )?.messages,+ ).toStrictEqual(['2 groups missing an X or Y value.', MISMATCH_NOTE]);+ });+});++describe('getScatterPlotEmptyMessage with differing group bys', () => {+ it('names the queries instead of the generic advice', () => {+ expect(+ getScatterPlotEmptyMessage(+ ready({ totalGroups: 4, drawnGroups: 0, missingValueGroups: 4 }),+ MISMATCH,+ )?.description,+ ).toBe(MISMATCH_NOTE);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/points.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/points.test.tsnew file mode 100644index 0000000000..7944b54f27--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/points.test.ts@@ -0,0 +1,21 @@+import { DEFAULT_SCATTER_POINT_SIZE } from 'lib/uPlotV2/plugins/ScatterPlugin/types';++import {+ DEFAULT_POINT_OPACITY,+ resolvePointOpacity,+ resolvePointSize,+} from '../points';++describe('scatter plot points', () => {+ it('draws unset points at the defaults', () => {+ expect(resolvePointSize(undefined)).toStrictEqual(DEFAULT_SCATTER_POINT_SIZE);+ expect(resolvePointOpacity(undefined)).toBe(DEFAULT_POINT_OPACITY);+ });++ it('takes each set field and defaults the rest, null included', () => {+ expect(+ resolvePointSize({ size: 10, minSize: null, maxSize: 30 }),+ ).toStrictEqual({ fixed: 10, min: DEFAULT_SCATTER_POINT_SIZE.min, max: 30 });+ expect(resolvePointOpacity({ opacity: 0.1 })).toBe(0.1);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/prepareData.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/prepareData.test.tsnew file mode 100644index 0000000000..95db1f7f17--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/prepareData.test.ts@@ -0,0 +1,458 @@+import { DashboardtypesAxisScaleDTO } from 'api/generated/services/sigNoz.schemas';+import type {+ PanelTable,+ PanelTableColumn,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import {+ MAX_PLOTTED_GROUPS,+ prepareScatterPlotData,+ UNGROUPED_SERIES_LABEL,+} from '../prepareData';+import { ScatterDimension, ScatterPlotDataStatus } from '../../types';++const group = (id: string): PanelTableColumn => ({+ id,+ name: id,+ queryName: '',+ isValueColumn: false,+});++const value = (id: string, name = id): PanelTableColumn => ({+ id,+ name,+ queryName: id.split('.')[0],+ isValueColumn: true,+});++function makeTable(+ columns: PanelTableColumn[],+ rows: Record<string, unknown>[],+): PanelTable {+ return {+ queryName: 'A',+ legend: '',+ columns,+ rows: rows.map((data) => ({ data })),+ };+}++const tracesTable = makeTable(+ [+ group('service.name'),+ value('A.count()', 'count()'),+ value('A.p99(duration_nano)', 'p99(duration_nano)'),+ value('A.countIf(has_error = true)', 'errors'),+ ],+ [+ {+ 'service.name': 'cart',+ 'A.count()': 12000,+ 'A.p99(duration_nano)': 340,+ 'A.countIf(has_error = true)': 15,+ },+ {+ 'service.name': 'payment',+ 'A.count()': 8500,+ 'A.p99(duration_nano)': 900,+ 'A.countIf(has_error = true)': 420,+ },+ ],+);++describe('prepareScatterPlotData', () => {+ it('plots the first two value columns when no dimensions are set', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: undefined,+ columnUnits: {},+ });++ expect(result.status).toBe(ScatterPlotDataStatus.Ready);+ if (result.status !== ScatterPlotDataStatus.Ready) {+ return;+ }+ expect(result.channels.x.label).toBe('count()');+ expect(result.channels.y.label).toBe('p99(duration_nano)');+ expect(result.channels.size).toBeUndefined();+ expect(result.series).toStrictEqual([+ { label: 'cart', xs: [12000], ys: [340] },+ { label: 'payment', xs: [8500], ys: [900] },+ ]);+ expect(result.pointLabels).toStrictEqual([+ [[{ key: 'service.name', value: 'cart' }]],+ [[{ key: 'service.name', value: 'payment' }]],+ ]);+ });++ it('binds x, y and size to the configured columns, with their units', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: {+ x: 'A.p99(duration_nano)',+ y: 'A.count()',+ sizeBy: 'A.countIf(has_error = true)',+ },+ columnUnits: { 'A.p99(duration_nano)': 'ns' },+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.channels).toStrictEqual({+ x: { label: 'p99(duration_nano)', unit: 'ns' },+ y: { label: 'count()', unit: undefined },+ size: { label: 'errors', unit: undefined },+ });+ expect(result.series[1]).toStrictEqual({+ label: 'payment',+ xs: [900],+ ys: [8500],+ sizes: [420],+ });+ });++ it('falls back to the defaults when a dimension names a column that is gone', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: { x: 'B', y: 'A.avg(duration_nano)', sizeBy: 'C' },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.channels.x.label).toBe('count()');+ expect(result.channels.y.label).toBe('p99(duration_nano)');+ expect(result.channels.size).toBeUndefined();+ });++ it('prefixes value columns whose names collide with their query', () => {+ const result = prepareScatterPlotData({+ table: makeTable(+ [+ group('service.name'),+ value('A.count()', 'count()'),+ value('A.p99(duration_nano)', 'p99(duration_nano)'),+ value('B', 'count()'),+ ],+ [+ {+ 'service.name': 'cart',+ 'A.count()': 1,+ 'A.p99(duration_nano)': 2,+ B: 3,+ },+ ],+ ),+ dimensions: { sizeBy: 'B' },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.channels.x.label).toBe('A.count()');+ expect(result.channels.y.label).toBe('p99(duration_nano)');+ expect(result.channels.size?.label).toBe('B.count()');+ expect(result.axisQueries).toStrictEqual({ x: 'A', y: 'A' });+ });++ it('names an axis channel by its axis label when one is set', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: undefined,+ axes: { x: { label: 'Throughput' }, y: { label: '' } },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.channels.x.label).toBe('Throughput');+ expect(result.channels.y.label).toBe('p99(duration_nano)');+ });++ it('picks a y column other than the bound x', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: { x: 'A.count()' },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.channels.y.label).toBe('p99(duration_nano)');+ });++ it('colours by the configured group label and keeps every label for the tooltip', () => {+ const table = makeTable(+ [group('k8s.namespace.name'), group('k8s.pod.name'), value('A'), value('B')],+ [+ { 'k8s.namespace.name': 'prod', 'k8s.pod.name': 'p1', A: 1, B: 2 },+ { 'k8s.namespace.name': 'dev', 'k8s.pod.name': 'p2', A: 3, B: 4 },+ { 'k8s.namespace.name': 'prod', 'k8s.pod.name': 'p3', A: 5, B: 6 },+ ],+ );++ const result = prepareScatterPlotData({+ table,+ dimensions: { colorBy: ['k8s.namespace.name'] },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.series.map((series) => series.label)).toStrictEqual([+ 'prod',+ 'dev',+ ]);+ expect(result.series[0]).toMatchObject({ xs: [1, 5], ys: [2, 6] });+ expect(result.pointLabels[0][1]).toStrictEqual([+ { key: 'k8s.namespace.name', value: 'prod' },+ { key: 'k8s.pod.name', value: 'p3' },+ ]);+ });++ describe('colour keys', () => {+ const table = makeTable(+ [group('k8s.namespace.name'), group('k8s.pod.name'), value('A'), value('B')],+ [+ { 'k8s.namespace.name': 'prod', 'k8s.pod.name': 'p1', A: 1, B: 2 },+ { 'k8s.namespace.name': 'prod', 'k8s.pod.name': 'p2', A: 3, B: 4 },+ ],+ );+ const seriesLabels = (color: string[] | null | undefined): string[] => {+ const result = prepareScatterPlotData({+ table,+ dimensions: { colorBy: color },+ columnUnits: {},+ });+ return result.status === ScatterPlotDataStatus.Ready+ ? result.series.map((series) => series.label)+ : [];+ };++ it.each([+ ['none selected', []],+ ['an unset field', undefined],+ ['null from the wire', null],+ ])('colours by every group key with %s', (_, color) => {+ expect(seriesLabels(color)).toStrictEqual(['prod, p1', 'prod, p2']);+ });++ it('colours by the combination of the selected keys, in result order', () => {+ expect(seriesLabels(['k8s.pod.name', 'k8s.namespace.name'])).toStrictEqual([+ 'prod, p1',+ 'prod, p2',+ ]);+ });++ it('colours by one key alone', () => {+ expect(seriesLabels(['k8s.namespace.name'])).toStrictEqual(['prod']);+ });++ it('ignores keys the result does not have', () => {+ expect(seriesLabels(['host.name', 'k8s.pod.name'])).toStrictEqual([+ 'p1',+ 'p2',+ ]);+ expect(seriesLabels(['host.name'])).toStrictEqual(['prod, p1', 'prod, p2']);+ });+ });++ it('draws everything as one series when there is no group by', () => {+ const result = prepareScatterPlotData({+ table: makeTable([value('A'), value('B')], [{ A: 1, B: 2 }]),+ dimensions: undefined,+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.series).toStrictEqual([+ { label: UNGROUPED_SERIES_LABEL, xs: [1], ys: [2] },+ ]);+ });++ it.each([+ ['a join miss', 'n/a'],+ ['NaN', 'NaN'],+ ['Inf', 'Inf'],+ ['-Inf', '-Inf'],+ ['an empty cell', undefined],+ ])('drops a row whose y is %s and counts it', (_, cell) => {+ const table = makeTable(+ [group('service.name'), value('A'), value('B')],+ [+ { 'service.name': 'cart', A: 120, B: 340 },+ { 'service.name': 'checkout', A: 45, B: cell },+ ],+ );++ const result = prepareScatterPlotData({+ table,+ dimensions: undefined,+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.series.map((series) => series.label)).toStrictEqual(['cart']);+ expect(result.totalGroups).toBe(2);+ expect(result.drawnGroups).toBe(1);+ });++ describe('log axes', () => {+ const table = makeTable(+ [group('service.name'), value('A'), value('B')],+ [+ { 'service.name': 'cart', A: 120, B: 340 },+ { 'service.name': 'idle', A: 0, B: 12 },+ { 'service.name': 'refund', A: 4, B: -1 },+ ],+ );++ it('drops values ≤ 0 on a log axis and counts them apart from missing values', () => {+ const result = prepareScatterPlotData({+ table,+ dimensions: undefined,+ axes: {+ x: { scale: DashboardtypesAxisScaleDTO.log },+ y: { scale: DashboardtypesAxisScaleDTO.log },+ },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.series.map((series) => series.label)).toStrictEqual(['cart']);+ expect(result.nonPositiveOnLogGroups).toBe(2);+ expect(result.missingValueGroups).toBe(0);+ });++ it.each([+ DashboardtypesAxisScaleDTO.symlog,+ DashboardtypesAxisScaleDTO.auto,+ DashboardtypesAxisScaleDTO.linear,+ ])('keeps values ≤ 0 on a %s axis', (scale) => {+ const result = prepareScatterPlotData({+ table,+ dimensions: undefined,+ axes: { x: { scale }, y: { scale } },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.drawnGroups).toBe(3);+ expect(result.nonPositiveOnLogGroups).toBe(0);+ });+ });++ it('draws a row with a missing size at the default size', () => {+ const table = makeTable(+ [group('service.name'), value('A'), value('B'), value('C')],+ [+ { 'service.name': 'search', A: 300, B: 120, C: 'n/a' },+ { 'service.name': 'cart', A: 120, B: 340, C: '0.2' },+ ],+ );++ const result = prepareScatterPlotData({+ table,+ dimensions: { sizeBy: 'C' },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected ready data');+ }+ expect(result.series.map((series) => series.sizes)).toStrictEqual([+ [null],+ [0.2],+ ]);+ expect(result.drawnGroups).toBe(2);+ });++ it('asks for a second value when the query has one aggregation', () => {+ const result = prepareScatterPlotData({+ table: makeTable(+ [group('service.name'), value('A')],+ [{ 'service.name': 'cart', A: 1 }],+ ),+ dimensions: undefined,+ columnUnits: {},+ });++ expect(result).toStrictEqual({+ status: ScatterPlotDataStatus.NeedsSecondValue,+ totalGroups: 1,+ });+ });++ it('asks for a second value when there is no table yet', () => {+ expect(+ prepareScatterPlotData({+ table: undefined,+ dimensions: undefined,+ columnUnits: {},+ }).status,+ ).toBe(ScatterPlotDataStatus.NeedsSecondValue);+ });++ it('plots the first MAX_PLOTTED_GROUPS rows and counts the rest', () => {+ const rows = Array.from({ length: MAX_PLOTTED_GROUPS + 5 }, (_, index) => ({+ 'service.name': `svc-${index}`,+ 'A.count()': index + 1,+ 'A.p99(duration_nano)': 100,+ }));+ const result = prepareScatterPlotData({+ table: makeTable(+ [+ group('service.name'),+ value('A.count()', 'count()'),+ value('A.p99(duration_nano)', 'p99(duration_nano)'),+ ],+ rows,+ ),+ dimensions: undefined,+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected a ready plot');+ }+ expect(result.drawnGroups).toBe(MAX_PLOTTED_GROUPS);+ expect(result.cappedGroups).toBe(5);+ expect(result.series.at(-1)?.label).toBe(`svc-${MAX_PLOTTED_GROUPS - 1}`);+ });++ it('lists dimensions bound to columns the result lacks', () => {+ const result = prepareScatterPlotData({+ table: tracesTable,+ dimensions: {+ x: 'A.count()',+ y: 'B.gone',+ sizeBy: 'C.gone',+ colorBy: ['service.name', 'host.name'],+ },+ columnUnits: {},+ });++ if (result.status !== ScatterPlotDataStatus.Ready) {+ throw new Error('expected a ready plot');+ }+ expect(result.staleDimensions).toStrictEqual([+ { dimension: ScatterDimension.Y, key: 'B.gone' },+ { dimension: ScatterDimension.Size, key: 'C.gone' },+ { dimension: ScatterDimension.Color, key: 'host.name' },+ ]);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/pruneStaleDimensions.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/pruneStaleDimensions.test.tsnew file mode 100644index 0000000000..b4aad59bfd--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/__tests__/pruneStaleDimensions.test.ts@@ -0,0 +1,120 @@+import {+ type DashboardtypesPanelPluginDTO,+ DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpecDTOKind as ScatterPlotKind,+ DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpecDTOKind as TableKind,+ type DashboardtypesPanelSpecDTO,+ DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTOKind as CompositeQueryKind,+ type DashboardtypesScatterPlotDimensionsDTO,+ type DashboardtypesScatterPlotPanelSpecDTO,+ Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTOSignal as LogsSignal,+ type Querybuildertypesv5QueryEnvelopeDTO,+ Querybuildertypesv5QueryEnvelopeBuilderDTOType,+ Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType,+ Querybuildertypesv5RequestTypeDTO,+} from 'api/generated/services/sigNoz.schemas';++import { pruneStaleDimensions } from '../pruneStaleDimensions';++const scatterPlugin = (+ dimensions: DashboardtypesScatterPlotDimensionsDTO,+): DashboardtypesPanelPluginDTO => ({+ kind: ScatterPlotKind['signoz/ScatterPlotPanel'],+ spec: { dimensions },+});++function panelSpec(+ envelopes: Querybuildertypesv5QueryEnvelopeDTO[],+ plugin: DashboardtypesPanelPluginDTO,+): DashboardtypesPanelSpecDTO {+ return {+ display: { name: 'p' },+ plugin,+ queries: [+ {+ kind: Querybuildertypesv5RequestTypeDTO.scalar,+ spec: {+ plugin: {+ kind: CompositeQueryKind['signoz/CompositeQuery'],+ spec: { queries: envelopes },+ },+ },+ },+ ],+ };+}++const builderQuery = (+ name: string,+ expressions: string[],+ groupBy: string[] = [],+): Querybuildertypesv5QueryEnvelopeDTO => ({+ type: Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query,+ spec: {+ name,+ signal: LogsSignal.logs,+ aggregations: expressions.map((expression) => ({ expression })),+ groupBy: groupBy.map((label) => ({ name: label })),+ },+});++const dimensionsOf = (+ spec: DashboardtypesPanelSpecDTO,+): DashboardtypesScatterPlotDimensionsDTO | undefined =>+ (spec.plugin.spec as DashboardtypesScatterPlotPanelSpecDTO).dimensions;++describe('pruneStaleDimensions', () => {+ it('keeps the spec when every binding is a column of the queries', () => {+ const spec = panelSpec(+ [+ builderQuery('A', ['count()', 'avg(duration)'], ['service.name']),+ builderQuery('B', ['count()'], ['service.name']),+ ],+ scatterPlugin({+ x: 'A.count()',+ y: 'B',+ sizeBy: 'A.avg(duration)',+ colorBy: ['service.name'],+ }),+ );+ expect(pruneStaleDimensions(spec)).toBe(spec);+ });++ it('clears value bindings and drops color labels the queries no longer produce', () => {+ const spec = panelSpec(+ [builderQuery('A', ['count()'], ['host.name'])],+ scatterPlugin({+ x: 'A.count()',+ y: 'A',+ sizeBy: 'B',+ colorBy: ['service.name', 'host.name'],+ }),+ );+ expect(dimensionsOf(pruneStaleDimensions(spec))).toStrictEqual({+ x: '',+ y: 'A',+ sizeBy: '',+ colorBy: ['host.name'],+ });+ });++ it('keeps bindings when a query has columns known only at run time', () => {+ const spec = panelSpec(+ [+ {+ type: Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType.clickhouse_sql,+ spec: { name: 'A', query: 'SELECT 1' },+ },+ ],+ scatterPlugin({ x: 'value', y: 'other' }),+ );+ expect(pruneStaleDimensions(spec)).toBe(spec);+ });++ it('leaves other panel kinds untouched', () => {+ const spec = panelSpec([builderQuery('A', ['count()'])], {+ kind: TableKind['signoz/TablePanel'],+ spec: {},+ });+ expect(pruneStaleDimensions(spec)).toBe(spec);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/axisOptions.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/axisOptions.tsnew file mode 100644index 0000000000..a43729e089--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/axisOptions.ts@@ -0,0 +1,44 @@+import {+ DashboardtypesAxisScaleDTO,+ type DashboardtypesScatterPlotAxisDTO,+ type DashboardtypesScatterPlotThresholdDTO,+ DashboardtypesThresholdAxisDTO,+} from 'api/generated/services/sigNoz.schemas';+import {+ type ScatterAxisOptions,+ ScatterAxisScale,+} from 'lib/visualization/charts/Scatter/types';++import { mapThresholds } from '../../../utils/baseConfigBuilder';++const CHART_SCALE: Record<DashboardtypesAxisScaleDTO, ScatterAxisScale> = {+ [DashboardtypesAxisScaleDTO.auto]: ScatterAxisScale.Auto,+ [DashboardtypesAxisScaleDTO.linear]: ScatterAxisScale.Linear,+ [DashboardtypesAxisScaleDTO.log]: ScatterAxisScale.Log,+ [DashboardtypesAxisScaleDTO.symlog]: ScatterAxisScale.SymLog,+};++export function toScatterAxisOptions(+ axis: DashboardtypesScatterPlotAxisDTO | undefined,+ unit: string | undefined,+ thresholds: DashboardtypesScatterPlotThresholdDTO[] = [],+): ScatterAxisOptions {+ return {+ label: axis?.label,+ unit,+ softMin: axis?.softMin,+ softMax: axis?.softMax,+ scale: axis?.scale ? CHART_SCALE[axis.scale] : ScatterAxisScale.Auto,+ thresholds: mapThresholds(thresholds),+ };+}++/** A threshold without an axis marks y. */+export function getAxisThresholds(+ thresholds: DashboardtypesScatterPlotThresholdDTO[] | null | undefined,+ axis: DashboardtypesThresholdAxisDTO,+): DashboardtypesScatterPlotThresholdDTO[] {+ return (thresholds ?? []).filter(+ (threshold) => (threshold.axis ?? DashboardtypesThresholdAxisDTO.y) === axis,+ );+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/getScatterPlotData.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/getScatterPlotData.tsnew file mode 100644index 0000000000..875a569bbc--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/getScatterPlotData.ts@@ -0,0 +1,45 @@+import type { DashboardtypesScatterPlotPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';+import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import { getJoinedScalarTable } from '../../../utils/getJoinedScalarTable';+import type { ScatterPlotData } from '../types';+import { prepareScatterPlotData } from './prepareData';++type ScatterPlotDataSpec = Pick<+ DashboardtypesScatterPlotPanelSpecDTO,+ 'dimensions' | 'axes' | 'formatting'+>;++interface CachedScatterPlotData {+ dimensions: ScatterPlotDataSpec['dimensions'];+ axes: ScatterPlotDataSpec['axes'];+ columnUnits: NonNullable<ScatterPlotDataSpec['formatting']>['columnUnits'];+ result: ScatterPlotData;+}++const cache = new WeakMap<PanelQueryData, CachedScatterPlotData>();++/** Prepares a response once per spec, so the renderer and the header warning share it. */+export function getScatterPlotData(+ data: PanelQueryData,+ { dimensions, axes, formatting }: ScatterPlotDataSpec,+): ScatterPlotData {+ const columnUnits = formatting?.columnUnits;+ const cached = cache.get(data);+ if (+ cached &&+ cached.dimensions === dimensions &&+ cached.axes === axes &&+ cached.columnUnits === columnUnits+ ) {+ return cached.result;+ }+ const result = prepareScatterPlotData({+ table: getJoinedScalarTable(data),+ dimensions,+ axes,+ columnUnits: columnUnits ?? {},+ });+ cache.set(data, { dimensions, axes, columnUnits, result });+ return result;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/groupByMismatch.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/groupByMismatch.tsnew file mode 100644index 0000000000..016d1e6c61--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/groupByMismatch.ts@@ -0,0 +1,43 @@+import type { BuilderQuery } from 'types/api/v5/queryRange';++export interface QueryGroupBy {+ queryName: string;+ labels: string[];+}++function signature(labels: string[]): string {+ return [...labels].sort().join('\0');+}++/**+ * Each builder query's group-by labels when they differ; null when they+ * all match. The join keys rows on every query's labels, so any difference+ * leaves no row with values from two queries. Disabled queries count, as a+ * formula over one carries its labels.+ */+export function findGroupByMismatch(+ queries: BuilderQuery[],+): QueryGroupBy[] | null {+ const grouped = queries.map((query) => ({+ queryName: query.name ?? '',+ labels: (query.groupBy ?? []).map((key) => key.name),+ }));+ if (grouped.length < 2) {+ return null;+ }+ const first = signature(grouped[0].labels);+ return grouped.every((query) => signature(query.labels) === first)+ ? null+ : grouped;+}++/** `A by service.name · B by host.name`. */+export function formatGroupByMismatch(mismatch: QueryGroupBy[]): string {+ return mismatch+ .map(({ queryName, labels }) =>+ labels.length > 0+ ? `${queryName} by ${labels.join(', ')}`+ : `${queryName} ungrouped`,+ )+ .join(' · ');+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/messages.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/messages.tsnew file mode 100644index 0000000000..759ae6cbb2--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/messages.ts@@ -0,0 +1,107 @@+import type { PanelStatusDetail } from 'pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelStatus/types';++import { formatGroupByMismatch, type QueryGroupBy } from './groupByMismatch';+import { MAX_PLOTTED_GROUPS } from './prepareData';+import {+ ScatterDimension,+ type ScatterPlotData,+ ScatterPlotDataStatus,+ type StaleDimension,+} from '../types';++export interface ScatterPlotMessage {+ title: string;+ description: string;+}++function pluralizeGroups(count: number): string {+ return count === 1 ? 'group' : 'groups';+}++function mismatchNote(mismatch: QueryGroupBy[]): string {+ return `Queries are grouped by different labels (${formatGroupByMismatch(mismatch)}), so their groups don't line up. Change any query's group by to apply it to all.`;+}++function logAxisNote(count: number): string {+ return `${count} ${pluralizeGroups(count)} with a value ≤ 0 can't go on a log axis`;+}++/** Why returned groups plot nothing; undefined for plain no-data or when something plots. */+export function getScatterPlotEmptyMessage(+ data: ScatterPlotData,+ mismatch: QueryGroupBy[] | null = null,+): ScatterPlotMessage | undefined {+ if (data.totalGroups === 0) {+ return undefined;+ }+ if (data.status === ScatterPlotDataStatus.NeedsSecondValue) {+ return {+ title: 'Add a second aggregation or query',+ description:+ 'Each dot needs two values, one for X and one for Y. Add an aggregation to this query, or another query grouped by the same labels.',+ };+ }+ if (data.drawnGroups > 0) {+ return undefined;+ }+ const title = `0 of ${data.totalGroups} ${pluralizeGroups(data.totalGroups)} plotted`;+ if (data.missingValueGroups === 0) {+ return {+ title,+ description: `${logAxisNote(data.nonPositiveOnLogGroups)}. Switch the axis to symlog to show them.`,+ };+ }+ return {+ title,+ description: mismatch+ ? mismatchNote(mismatch)+ : 'No group has both an X and a Y value. Group every query by exactly the same labels; a group missing from one query has no dot.',+ };+}++const STALE_FALLBACK: Record<ScatterDimension, string> = {+ [ScatterDimension.X]: 'X falls back to Auto',+ [ScatterDimension.Y]: 'Y falls back to Auto',+ [ScatterDimension.Size]: 'every dot is one size',+ [ScatterDimension.Color]: "it's left out of the color",+};++function staleNote({ dimension, key }: StaleDimension): string {+ return `${dimension} uses ${key}, which isn't in the results, so ${STALE_FALLBACK[dimension]}.`;+}++function formatCount(count: number): string {+ return count.toLocaleString('en-US');+}++/** Groups left out and stale dimensions; null when nothing to say or nothing plots. */+export function getScatterPlotWarning(+ data: ScatterPlotData,+ mismatch: QueryGroupBy[] | null = null,+): PanelStatusDetail | null {+ if (data.status !== ScatterPlotDataStatus.Ready || data.drawnGroups === 0) {+ return null;+ }+ const atCap = data.cappedGroups > 0 || data.totalGroups === MAX_PLOTTED_GROUPS;+ const groupsLeftOut = atCap || data.drawnGroups < data.totalGroups;+ const messages = [+ ...data.staleDimensions.map(staleNote),+ atCap && 'Add a filter or narrow the group by to see the rest.',+ data.missingValueGroups > 0 &&+ `${formatCount(data.missingValueGroups)} ${pluralizeGroups(data.missingValueGroups)} missing an X or Y value.`,+ data.missingValueGroups > 0 && mismatch && mismatchNote(mismatch),+ data.nonPositiveOnLogGroups > 0 &&+ `${logAxisNote(data.nonPositiveOnLogGroups)}. Switch the axis to symlog to show them.`,+ ].filter((message): message is string => Boolean(message));+ if (messages.length === 0) {+ return null;+ }+ return {+ message: atCap+ ? `Showing the first ${formatCount(data.drawnGroups)} groups.`+ : groupsLeftOut+ ? `Showing ${formatCount(data.drawnGroups)} of ${formatCount(data.totalGroups)} groups.`+ : "Some dimensions aren't in the results.",+ messages,+ };+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/points.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/points.tsnew file mode 100644index 0000000000..00917c5dca--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/points.ts@@ -0,0 +1,27 @@+import type { DashboardtypesScatterPlotPointsDTO } from 'api/generated/services/sigNoz.schemas';+import {+ DEFAULT_SCATTER_POINT_SIZE,+ type ScatterPointSize,+} from 'lib/uPlotV2/plugins/ScatterPlugin/types';++/** Bounds the spec validates point sizes (px) and opacity against. */+export const POINT_SIZE_BOUNDS = { min: 2, max: 40 } as const;+export const POINT_OPACITY_BOUNDS = { min: 0.1, max: 1 } as const;++export const DEFAULT_POINT_OPACITY = 0.7;++export function resolvePointSize(+ points: DashboardtypesScatterPlotPointsDTO | undefined,+): ScatterPointSize {+ return {+ fixed: points?.size ?? DEFAULT_SCATTER_POINT_SIZE.fixed,+ min: points?.minSize ?? DEFAULT_SCATTER_POINT_SIZE.min,+ max: points?.maxSize ?? DEFAULT_SCATTER_POINT_SIZE.max,+ };+}++export function resolvePointOpacity(+ points: DashboardtypesScatterPlotPointsDTO | undefined,+): number {+ return points?.opacity ?? DEFAULT_POINT_OPACITY;+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/prepareData.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/prepareData.tsnew file mode 100644index 0000000000..15f401527c--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/prepareData.ts@@ -0,0 +1,241 @@+import {+ DashboardtypesAxisScaleDTO,+ type DashboardtypesScatterPlotAxisDTO,+} from 'api/generated/services/sigNoz.schemas';+import type { ScatterSeries } from 'lib/visualization/charts/Scatter/types';+import type { ScatterPointLabel } from 'lib/uPlotV2/plugins/ScatterPlugin/types';+import type {+ PanelTableColumn,+ PanelTableRow,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import { getColumnUnit } from '../../../utils/getColumnUnit';+import { getValueColumnLabels } from '../../../utils/getValueColumnLabels';+import {+ type PrepareScatterPlotDataArgs,+ ScatterDimension,+ type ScatterPlotData,+ ScatterPlotDataStatus,+ type StaleDimension,+} from '../types';++/** Series label when the query has no group by to colour by. */+export const UNGROUPED_SERIES_LABEL = 'All';++/**+ * A finite number, or null. The backend sends NaN/±Inf as the strings+ * `"NaN"`/`"Inf"`/`"-Inf"` and fills join misses with `"n/a"`; none of those+ * may plot, least of all as 0.+ */+function toFiniteNumber(value: unknown): number | null {+ if (typeof value === 'number') {+ return Number.isFinite(value) ? value : null;+ }+ if (typeof value === 'string' && value.trim() !== '') {+ const parsed = Number(value);+ return Number.isFinite(parsed) ? parsed : null;+ }+ return null;+}++function toLabelValue(value: unknown): string {+ return typeof value === 'string' ||+ typeof value === 'number' ||+ typeof value === 'boolean'+ ? String(value)+ : '';+}++function findColumn(+ columns: PanelTableColumn[],+ key: string | undefined,+): PanelTableColumn | undefined {+ return key ? columns.find((column) => column.id === key) : undefined;+}++function isPlaceable(+ value: number,+ axis: DashboardtypesScatterPlotAxisDTO | undefined,+): boolean {+ return axis?.scale !== DashboardtypesAxisScaleDTO.log || value > 0;+}++function getPointLabels(+ row: PanelTableRow,+ groupColumns: PanelTableColumn[],+): ScatterPointLabel[] {+ return groupColumns.map((column) => ({+ key: column.name,+ value: toLabelValue(row.data[column.id]),+ }));+}++/**+ * Dots drawn at most, in the order the query returns its rows. Far more than a+ * plot can tell apart, and a canvas path of a few hundred thousand discs fails+ * to paint at all, taking every series drawn after it with it.+ */+export const MAX_PLOTTED_GROUPS = 10_000;++export const COLOR_LABEL_SEPARATOR = ', ';++/** Quotes a value holding the separator or a quote, so distinct groups never share a label. */+function toColorLabelPart(value: string): string {+ return value.includes(COLOR_LABEL_SEPARATOR) || value.includes('"')+ ? JSON.stringify(value)+ : value;+}++/** The colour group's label, which doubles as its series, colour and legend key. */+function getColorGroupLabel(+ row: PanelTableRow,+ colorColumns: PanelTableColumn[],+): string {+ return colorColumns.length > 0+ ? colorColumns+ .map((column) => toColorLabelPart(toLabelValue(row.data[column.id])))+ .join(COLOR_LABEL_SEPARATOR)+ : UNGROUPED_SERIES_LABEL;+}++/**+ * The selected colour keys the result has; every group-by column when none+ * is selected or none of the selection is left.+ */+function resolveColorColumns(+ groupColumns: PanelTableColumn[],+ keys: string[] | null | undefined,+): PanelTableColumn[] {+ const selected = groupColumns.filter((column) => keys?.includes(column.id));+ return selected.length > 0 ? selected : groupColumns;+}++function findStaleDimensions(+ valueColumns: PanelTableColumn[],+ groupColumns: PanelTableColumn[],+ dimensions: PrepareScatterPlotDataArgs['dimensions'],+): StaleDimension[] {+ const valueKeys = [+ { dimension: ScatterDimension.X, key: dimensions?.x },+ { dimension: ScatterDimension.Y, key: dimensions?.y },+ { dimension: ScatterDimension.Size, key: dimensions?.sizeBy },+ ].filter(+ (entry): entry is StaleDimension =>+ !!entry.key && !findColumn(valueColumns, entry.key),+ );+ const colourKeys = (dimensions?.colorBy ?? [])+ .filter((key) => !findColumn(groupColumns, key))+ .map((key) => ({ dimension: ScatterDimension.Color, key }));+ return [...valueKeys, ...colourKeys];+}++/**+ * One dot per row of the joined scalar table. Unset or stale dimensions fall back+ * to the first two value columns and every group-by label.+ */+export function prepareScatterPlotData({+ table,+ dimensions,+ axes,+ columnUnits,+}: PrepareScatterPlotDataArgs): ScatterPlotData {+ const columns = table?.columns ?? [];+ const rows = table?.rows ?? [];+ const valueColumns = columns.filter((column) => column.isValueColumn);+ const groupColumns = columns.filter((column) => !column.isValueColumn);++ const xColumn = findColumn(valueColumns, dimensions?.x) ?? valueColumns[0];+ const yColumn =+ findColumn(valueColumns, dimensions?.y) ??+ valueColumns.find((column) => column !== xColumn);+ if (!xColumn || !yColumn) {+ return {+ status: ScatterPlotDataStatus.NeedsSecondValue,+ totalGroups: rows.length,+ };+ }+ const sizeColumn = findColumn(valueColumns, dimensions?.sizeBy);+ const colorColumns = resolveColorColumns(groupColumns, dimensions?.colorBy);++ const seriesByLabel = new Map<+ string,+ { series: ScatterSeries; labels: ScatterPointLabel[][] }+ >();+ let drawnGroups = 0;+ let missingValueGroups = 0;+ let nonPositiveOnLogGroups = 0;+ let cappedGroups = 0;++ rows.forEach((row) => {+ const x = toFiniteNumber(row.data[xColumn.id]);+ const y = toFiniteNumber(row.data[yColumn.id]);+ if (x === null || y === null) {+ missingValueGroups += 1;+ return;+ }+ if (!isPlaceable(x, axes?.x) || !isPlaceable(y, axes?.y)) {+ nonPositiveOnLogGroups += 1;+ return;+ }+ if (drawnGroups >= MAX_PLOTTED_GROUPS) {+ cappedGroups += 1;+ return;+ }+ const label = getColorGroupLabel(row, colorColumns);+ let entry = seriesByLabel.get(label);+ if (!entry) {+ entry = {+ series: { label, xs: [], ys: [], ...(sizeColumn && { sizes: [] }) },+ labels: [],+ };+ seriesByLabel.set(label, entry);+ }+ entry.series.xs.push(x);+ entry.series.ys.push(y);+ entry.series.sizes?.push(+ sizeColumn ? toFiniteNumber(row.data[sizeColumn.id]) : null,+ );+ entry.labels.push(getPointLabels(row, groupColumns));+ drawnGroups += 1;+ });++ const entries = [...seriesByLabel.values()];+ const labels = getValueColumnLabels(columns);+ const toChannel = (+ column: PanelTableColumn,+ axisLabel?: string,+ ): { label: string; unit: string | undefined } => ({+ label: axisLabel || (labels[column.id] ?? column.name),+ unit: getColumnUnit(column.id, columnUnits),+ });+ return {+ status: ScatterPlotDataStatus.Ready,+ series: entries.map((entry) => entry.series),+ pointLabels: entries.map((entry) => entry.labels),+ channels: {+ x: toChannel(xColumn, axes?.x?.label),+ y: toChannel(yColumn, axes?.y?.label),+ ...(sizeColumn && { size: toChannel(sizeColumn) }),+ },+ axisQueries: { x: xColumn.queryName, y: yColumn.queryName },+ totalGroups: rows.length,+ drawnGroups,+ missingValueGroups,+ nonPositiveOnLogGroups,+ cappedGroups,+ staleDimensions: findStaleDimensions(valueColumns, groupColumns, dimensions),+ };+}++/** Each colour group's label in row order, without preparing any points. */+export function getColorGroupLabels(+ table: PrepareScatterPlotDataArgs['table'],+ colorBy: string[] | null | undefined,+): string[] {+ const columns = table?.columns ?? [];+ const colorColumns = resolveColorColumns(+ columns.filter((column) => !column.isValueColumn),+ colorBy,+ );+ return (table?.rows ?? []).map((row) => getColorGroupLabel(row, colorColumns));+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/pruneStaleDimensions.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/pruneStaleDimensions.tsnew file mode 100644index 0000000000..0c06073f45--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/pruneStaleDimensions.ts@@ -0,0 +1,64 @@+import {+ type DashboardtypesPanelSpecDTO,+ type DashboardtypesScatterPlotPanelSpecDTO,+ Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType,+ Querybuildertypesv5QueryEnvelopePromQLDTOType,+} from 'api/generated/services/sigNoz.schemas';++import { toQueryEnvelopes } from '../../../../queryV5/buildQueryRangeRequest';+import { getBuilderQueries } from '../../../utils/getBuilderQueries';+import { getTableColumnKeys } from '../../../utils/getTableColumnKeys';++/**+ * Clears bindings to columns the queries no longer produce, so a query edit+ * saves what the preview drew (its fallback columns) instead of a binding the+ * API rejects. ClickHouse SQL and PromQL columns are only known at run time.+ */+export function pruneStaleDimensions(+ spec: DashboardtypesPanelSpecDTO,+): DashboardtypesPanelSpecDTO {+ const { plugin, queries } = spec;+ if (plugin.kind !== 'signoz/ScatterPlotPanel') {+ return spec;+ }+ const hasRuntimeColumns = toQueryEnvelopes(queries).some(+ (envelope) =>+ envelope.type ===+ Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType.clickhouse_sql ||+ envelope.type === Querybuildertypesv5QueryEnvelopePromQLDTOType.promql,+ );+ if (hasRuntimeColumns) {+ return spec;+ }++ const pluginSpec = plugin.spec as DashboardtypesScatterPlotPanelSpecDTO;+ const dimensions = pluginSpec.dimensions ?? {};+ const valueKeys = new Set(getTableColumnKeys(queries));+ const groupKeys = new Set(+ getBuilderQueries(queries).flatMap((query) =>+ (query.groupBy ?? []).map((key) => key.name),+ ),+ );+ const keepValue = (key: string | undefined): string | undefined =>+ key && !valueKeys.has(key) ? '' : key;++ const next = {+ ...dimensions,+ x: keepValue(dimensions.x),+ y: keepValue(dimensions.y),+ sizeBy: keepValue(dimensions.sizeBy),+ colorBy: dimensions.colorBy?.filter((label) => groupKeys.has(label)),+ };+ const isUnchanged =+ next.x === dimensions.x &&+ next.y === dimensions.y &&+ next.sizeBy === dimensions.sizeBy &&+ next.colorBy?.length === dimensions.colorBy?.length;+ if (isUnchanged) {+ return spec;+ }+ return {+ ...spec,+ plugin: { ...plugin, spec: { ...pluginSpec, dimensions: next } },+ };+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/warning.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/warning.tsnew file mode 100644index 0000000000..5ff954cdad--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/ScatterPlotPanel/utils/warning.ts@@ -0,0 +1,18 @@+import type { PanelStatusDetail } from 'pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelStatus/types';+import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import type { PanelOfKind } from '../../../types/rendererProps';+import { getBuilderQueries } from '../../../utils/getBuilderQueries';+import { getScatterPlotData } from './getScatterPlotData';+import { findGroupByMismatch } from './groupByMismatch';+import { getScatterPlotWarning } from './messages';++export function getScatterPlotDataWarning(+ panel: PanelOfKind<'signoz/ScatterPlotPanel'>,+ data: PanelQueryData,+): PanelStatusDetail | null {+ return getScatterPlotWarning(+ getScatterPlotData(data, panel.spec.plugin.spec),+ findGroupByMismatch(getBuilderQueries(panel.spec.queries)),+ );+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/__tests__/tableCsv.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/__tests__/tableCsv.test.tsindex cf8813f9e6..f182684f1a 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/__tests__/tableCsv.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/__tests__/tableCsv.test.ts@@ -79,6 +79,46 @@ describe('buildTableCsvRows', () => {});});+describe('buildTableCsvRows headers', () => {+ it('keeps both of two columns that share a name, under their query labels', () => {+ const rows = buildTableCsvRows({+ table: {+ queryName: 'A',+ legend: '',+ columns: [+ { name: 'service', queryName: '', isValueColumn: false, id: 'service' },+ { name: 'count()', queryName: 'A', isValueColumn: true, id: 'A.count()' },+ { name: 'p99', queryName: 'A', isValueColumn: true, id: 'A.p99' },+ { name: 'count()', queryName: 'B', isValueColumn: true, id: 'B' },+ ],+ rows: [{ data: { service: 'cart', 'A.count()': 120, 'A.p99': 4, B: 3 } }],+ },+ columnUnits: {},+ });++ expect(rows).toStrictEqual([+ { service: 'cart', 'A.count()': '120', p99: '4', 'B.count()': '3' },+ ]);+ });++ it('suffixes a header still shared by two aggregations aliased alike in one query', () => {+ const rows = buildTableCsvRows({+ table: {+ queryName: 'A',+ legend: '',+ columns: [+ { name: 'total', queryName: 'A', isValueColumn: true, id: 'A.count()' },+ { name: 'total', queryName: 'A', isValueColumn: true, id: 'A.p99' },+ ],+ rows: [{ data: { 'A.count()': 120, 'A.p99': 4 } }],+ },+ columnUnits: {},+ });++ expect(rows).toStrictEqual([{ 'A.total': '120', 'A.total (2)': '4' }]);+ });+});+describe('getTableCsvRows', () => {const panel = {spec: { plugin: { spec: { formatting: { columnUnits: { A: 'ms' } } } } },@@ -96,6 +136,23 @@ describe('getTableCsvRows', () => {]);});+ it('exports a scatter plot from the same joined table', () => {+ mockPrepareScalarTables.mockReturnValue([table]);+ const scatter = {+ spec: {+ plugin: {+ kind: 'signoz/ScatterPlotPanel',+ spec: { formatting: { columnUnits: { A: 'ns' } } },+ },+ },+ } as unknown as PanelOfKind<'signoz/ScatterPlotPanel'>;++ expect(getTableCsvRows(scatter, data)).toStrictEqual([+ { service: 'frontend', p99: '1234ns' },+ { service: 'cart', p99: '56ns' },+ ]);+ });+it('returns no rows when the response has no table', () => {mockPrepareScalarTables.mockReturnValue([]);diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/definition.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/definition.tsindex 99a2e1febb..82c33d562d 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/definition.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/definition.ts@@ -35,7 +35,7 @@ export const definition: PanelDefinition<'signoz/TablePanel'> = {},},queryBuilderFields: {},- // The only kind that asks the server to transpose its scalar result into UI rows.+ // Asks the server to transpose its scalar result into UI rows.queryCapabilities: {requestType: Querybuildertypesv5RequestTypeDTO.scalar,formatTableResultForUI: true,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/tableCsv.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/tableCsv.tsindex b058be1278..8cfac53040 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/tableCsv.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/kinds/TablePanel/tableCsv.ts@@ -8,6 +8,7 @@ import { getScalarResults } from 'pages/DashboardPage/DashboardContainer/queryV5import { resolveDecimalPrecision } from '../../utils/chartAppearance/resolvers';import { getColumnUnit } from '../../utils/getColumnUnit';+import { getValueColumnLabels } from '../../utils/getValueColumnLabels';import type { PanelOfKind } from '../../types/rendererProps';import { formatTableCellText } from './tableColumns';@@ -19,6 +20,34 @@ interface BuildTableCsvRowsArgs {decimalPrecision?: PrecisionOption;}+/**+ * Column key → CSV header. Rows are keyed by header, so two columns sharing a+ * name (`count()` on two queries) would collapse into one; those take their+ * query-prefixed label instead. A header still taken after that (two+ * aggregations aliased alike in one query) gets a ` (2)`, ` (3)`… suffix.+ */+function getCsvHeaders(table: PanelTable): Record<string, string> {+ const nameCounts = new Map<string, number>();+ table.columns.forEach((col) =>+ nameCounts.set(col.name, (nameCounts.get(col.name) ?? 0) + 1),+ );+ const labels = getValueColumnLabels(table.columns);+ const taken = new Set<string>();+ return Object.fromEntries(+ table.columns.map((col) => {+ const key = col.id || col.name;+ const collides = (nameCounts.get(col.name) ?? 0) > 1;+ const base = collides ? (labels[key] ?? col.name) : col.name;+ let header = base;+ for (let copy = 2; taken.has(header); copy++) {+ header = `${base} (${copy})`;+ }+ taken.add(header);+ return [key, header];+ }),+ );+}+/*** Flattens a prepared table into CSV rows keyed by column name, reusing the* on-screen cell formatting in display column order. Exports the full result@@ -29,12 +58,13 @@ export function buildTableCsvRows({columnUnits,decimalPrecision,}: BuildTableCsvRowsArgs): Record<string, string>[] {+ const headers = getCsvHeaders(table);return table.rows.map((row) => {const csvRow: Record<string, string> = {};table.columns.forEach((col) => {const key = col.id || col.name;const unit = getColumnUnit(key, columnUnits);- csvRow[col.name] = formatTableCellText(+ csvRow[headers[key]] = formatTableCellText(col,row.data[key],unit,@@ -50,7 +80,7 @@ export function buildTableCsvRows({* reusing the on-screen formatting. Returns [] when the response has no table.*/export function getTableCsvRows(- panel: PanelOfKind<'signoz/TablePanel'>,+ panel: PanelOfKind<'signoz/TablePanel' | 'signoz/ScatterPlotPanel'>,data: PanelQueryData,): Record<string, string>[] {const spec = panel.spec.plugin.spec;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/registry.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/registry.tsindex e3b04d8d48..f316262e12 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/registry.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/registry.ts@@ -4,6 +4,7 @@ import { definition as Heatmap } from './kinds/HeatmapPanel/definition';import { definition as Histogram } from './kinds/HistogramPanel/definition';import { definition as NumberValue } from './kinds/NumberPanel/definition';import { definition as PieChart } from './kinds/PieChartPanel/definition';+import { definition as ScatterPlot } from './kinds/ScatterPlotPanel/definition';import { definition as TimeSeries } from './kinds/TimeSeriesPanel/definition';import { definition as Table } from './kinds/TablePanel/definition';import { definition as List } from './kinds/ListPanel/definition';@@ -25,6 +26,7 @@ export const PANELS: PanelRegistry = {[BarChart.kind]: BarChart,[AreaChart.kind]: AreaChart,[PieChart.kind]: PieChart,+ [ScatterPlot.kind]: ScatterPlot,[Histogram.kind]: Histogram,[Heatmap.kind]: Heatmap,[List.kind]: List,diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/interactions.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/interactions.tsindex e78b973fbe..b2604a1780 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/interactions.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/interactions.ts@@ -38,6 +38,9 @@ export type PanelInteractionMap = Record<PanelKind, object> & {'signoz/TablePanel': { onClick?: (event: DrilldownClickPayload) => void };'signoz/PieChartPanel': { onClick?: (event: DrilldownClickPayload) => void };'signoz/NumberPanel': { onClick?: (event: DrilldownClickPayload) => void };+ 'signoz/ScatterPlotPanel': {+ onClick?: (event: DrilldownClickPayload) => void;+ };};/**diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelDefinition.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelDefinition.tsindex ec3a5396da..8d82ac2683 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelDefinition.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelDefinition.ts@@ -1,5 +1,6 @@import type { ComponentType } from 'react';import {+ type DashboardtypesPanelDTO,type DashboardtypesPanelSpecDTO,TelemetrytypesSignalDTO,} from 'api/generated/services/sigNoz.schemas';@@ -16,9 +17,12 @@ import type {} from './panelCapabilities';import type {BaseRendererProps,+ PanelOfKind,PanelRendererProps,StaticRendererProps,} from './rendererProps';+import type { PanelStatusDetail } from '../../PanelsAndSectionsLayout/Panel/PanelStatus/types';+import type { PanelQueryData } from '../../queryV5/types';/** Export formats offered under the single "Download" action. */export enum DownloadFormat {@@ -124,6 +128,15 @@ export interface QueryPanelDefinition<queryCapabilities: PanelQueryCapabilities;/** Builder fields kept equal across queries: an edit to one query copies to the rest. */syncedQueryBuilderFields?: SyncedQueryBuilderField[];+ /** Non-fatal problems read off the result, shown as the header's warning. */+ getDataWarning?: (+ panel: PanelOfKind<K>,+ data: PanelQueryData,+ ) => PanelStatusDetail | null;+ /** Reconciles the kind's options with the queries a save carries. */+ reconcileWithQueries?: (+ spec: DashboardtypesPanelSpecDTO,+ ) => DashboardtypesPanelSpecDTO;}/**@@ -151,9 +164,13 @@ export type PanelRegistry = { [K in PanelKind]: PanelDefinition<K> };// explicitly rather than via `Omit` over the union, which collapses to common keys.export interface RenderableQueryPanelDefinition extends Omit<QueryPanelDefinition,- 'Renderer'+ 'Renderer' | 'getDataWarning'> {Renderer: ComponentType<BaseRendererProps & AnyPanelInteractionProps>;+ getDataWarning?: (+ panel: DashboardtypesPanelDTO,+ data: PanelQueryData,+ ) => PanelStatusDetail | null;}export type RenderableStaticPanelDefinition = StaticPanelDefinition<PanelKind>;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelKind.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelKind.tsindex 7cb30b205c..ce3ad7eea6 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelKind.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/panelKind.ts@@ -26,6 +26,7 @@ export const PANEL_KIND_TO_PANEL_TYPE: Record<PanelKind, PANEL_TYPES> = {'signoz/ListPanel': PANEL_TYPES.LIST,'signoz/HeatmapPanel': PANEL_TYPES.HEATMAP,'signoz/TextPanel': PANEL_TYPES.TEXT,+ 'signoz/ScatterPlotPanel': PANEL_TYPES.SCATTER,};/**diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/sections.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/sections.tsindex 597d215047..c875f26c35 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/sections.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/types/sections.ts@@ -13,6 +13,10 @@ import type {DashboardtypesLineStyleDTO,DashboardtypesPanelFormattingDTO,DashboardtypesPanelSpecDTO,+ DashboardtypesScatterPlotAxesDTO,+ DashboardtypesScatterPlotDimensionsDTO,+ DashboardtypesScatterPlotPointsDTO,+ DashboardtypesScatterPlotThresholdDTO,DashboardtypesSpanGapsDTO,DashboardtypesStackModeDTO,DashboardtypesTableFormattingDTO,@@ -27,6 +31,7 @@ import {Antenna,BarChart,Columns3,+ Crosshair,Hash,Link2,Palette,@@ -64,6 +69,9 @@ export enum SectionKind {Columns = 'columns',TextLayout = 'presentation',PanelHeader = 'headerOptions',+ Dimensions = 'dimensions',+ /** Scatter Plot's per-axis `axes` shape; `Axes` is the single y-axis shape. */+ ScatterAxes = 'scatterAxes',}/**@@ -82,6 +90,7 @@ export enum ThresholdVariant {/** Union of every threshold element shape stored under `plugin.spec.thresholds`. */export type AnyThreshold =| DashboardtypesThresholdWithLabelDTO+ | DashboardtypesScatterPlotThresholdDTO| DashboardtypesComparisonThresholdDTO| DashboardtypesTableThresholdDTO;@@ -105,6 +114,8 @@ export interface PanelChartAppearanceSlice {spanGaps?: DashboardtypesSpanGapsDTO;/** The heatmap's cell colour ramp. */colors?: DashboardtypesHeatmapColorsDTO;+ /** Scatter Plot's dot size and opacity. */+ points?: DashboardtypesScatterPlotPointsDTO;}/** Superset spanning every kind's visualization DTO. */@@ -135,6 +146,8 @@ export interface SectionSpecMap {[SectionKind.Columns]: TelemetrytypesTelemetryFieldKeyDTO[]; // spec.plugin.spec.selectFields (List)[SectionKind.TextLayout]: DashboardtypesTextPresentationDTO; // spec.plugin.spec.presentation (Text)[SectionKind.PanelHeader]: DashboardtypesHeaderOptionsDTO; // spec.plugin.spec.headerOptions (Text)+ [SectionKind.Dimensions]: DashboardtypesScatterPlotDimensionsDTO; // spec.plugin.spec.dimensions (Scatter Plot)+ [SectionKind.ScatterAxes]: DashboardtypesScatterPlotAxesDTO; // spec.plugin.spec.axes (Scatter Plot)}/**@@ -173,6 +186,8 @@ export interface SectionControls {spanGaps?: boolean;// colors → the heatmap's cell colour ramp; nothing else here applies to a grid.colors?: boolean;+ /** Scatter Plot's dots: one size, or a min/max range when a size column is bound. */+ points?: boolean;};[SectionKind.Buckets]: {count?: boolean;@@ -190,7 +205,8 @@ export interface SectionControls {fillSpans?: boolean;};// Editor discriminator (not a spec field): which threshold variant a kind edits.- [SectionKind.Thresholds]: { variant?: ThresholdVariant };+ // axis → a `label` threshold picks the axis it marks (Scatter Plot).+ [SectionKind.Thresholds]: { variant?: ThresholdVariant; axis?: boolean };}export type ControlledSectionKind = keyof SectionControls;@@ -200,7 +216,9 @@ export type AtomicSectionKind =| SectionKind.ContextLinks| SectionKind.Columns| SectionKind.TextLayout- | SectionKind.PanelHeader;+ | SectionKind.PanelHeader+ | SectionKind.Dimensions+ | SectionKind.ScatterAxes;/** Predicate to hide a section from the current spec; returning true removes it. */export type SectionVisibilityPredicate = (@@ -235,6 +253,8 @@ export const SECTION_METADATA = {[SectionKind.Columns]: { title: 'Columns', icon: Columns3 },[SectionKind.TextLayout]: { title: 'Panel appearance', icon: AlignLeft },[SectionKind.PanelHeader]: { title: 'Panel header', icon: PanelTop },+ [SectionKind.Dimensions]: { title: 'Dimensions', icon: Crosshair },+ [SectionKind.ScatterAxes]: { title: 'Axes', icon: Scale3D },} as const satisfies Record<SectionKind, SectionMetadata>;/**diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/buildPluginSpec.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/buildPluginSpec.test.tsindex b4f973cb16..35a21fef33 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/buildPluginSpec.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/buildPluginSpec.test.ts@@ -1,11 +1,13 @@import {DashboardtypesComparisonOperatorDTO,DashboardtypesFillModeDTO,+ DashboardtypesHeatmapYScaleDTO,DashboardtypesLegendPositionDTO,DashboardtypesLineInterpolationDTO,DashboardtypesLineStyleDTO,type DashboardtypesPanelSpecDTO,DashboardtypesStackModeDTO,+ DashboardtypesThresholdAxisDTO,DashboardtypesThresholdFormatDTO,DashboardtypesTimePreferenceDTO,TelemetrytypesSignalDTO,@@ -312,6 +314,19 @@ describe('buildPluginSpec', () => {});});+ it('carries only the y scale, dropping fields a scatter y axis adds', () => {+ const sections: SectionConfig[] = [+ { kind: SectionKind.Axes, controls: { y: true } },+ ];+ const oldSpec = oldSpecWith({+ axes: { y: { label: 'Latency', softMin: 0, softMax: 100 } },+ });++ expect(buildPluginSpec(sections, { oldSpec }).axes).toStrictEqual({+ y: { scale: DashboardtypesHeatmapYScaleDTO.auto },+ });+ });+it('skips null soft bounds and seeds nothing on a new panel or empty axes', () => {const sections: SectionConfig[] = [{ kind: SectionKind.Axes, controls: { minMax: true, logScale: true } },@@ -535,6 +550,40 @@ describe('buildPluginSpec', () => {});});+ it('carries per-column units between kinds that both key them by column (Table ↔ Scatter Plot)', () => {+ const sections: SectionConfig[] = [+ {+ kind: SectionKind.Formatting,+ controls: { decimals: true, columnUnits: true },+ },+ ];+ const oldSpec = oldSpecWith(+ {+ formatting: {+ columnUnits: { 'A.count()': 'short', 'A.p99(duration_nano)': 'ns' },+ decimalPrecision: 1,+ },+ },+ [builderQueryNamed('A')],+ );++ expect(buildPluginSpec(sections, { oldSpec }).formatting).toStrictEqual({+ decimalPrecision: 1,+ columnUnits: { 'A.count()': 'short', 'A.p99(duration_nano)': 'ns' },+ });+ });++ it('keeps an emptied column unit map empty rather than fanning a unit out', () => {+ const sections: SectionConfig[] = [+ { kind: SectionKind.Formatting, controls: { columnUnits: true } },+ ];+ const oldSpec = oldSpecWith({ formatting: { columnUnits: {} } }, [+ builderQueryNamed('A'),+ ]);++ expect(buildPluginSpec(sections, { oldSpec }).formatting).toBeUndefined();+ });+it('never seeds a panel-wide unit from per-column units (Table → TimeSeries)', () => {const sections: SectionConfig[] = [{ kind: SectionKind.Formatting, controls: { unit: true, decimals: true } },@@ -604,9 +653,10 @@ describe('buildPluginSpec', () => {variant: ThresholdVariant | undefined,thresholds: unknown[],queries: unknown[] = [],+ axis?: boolean,): unknown {const sections: SectionConfig[] = [- { kind: SectionKind.Thresholds, controls: { variant } },+ { kind: SectionKind.Thresholds, controls: { variant, axis } },];return buildPluginSpec(sections, {oldSpec: oldSpecWith({ thresholds }, queries),@@ -701,6 +751,37 @@ describe('buildPluginSpec', () => {).toStrictEqual([{ value: 0, color: '#F1575F' }]);});+ it('drops x thresholds and the axis field for a kind without an axis picker', () => {+ expect(+ switchThresholds(ThresholdVariant.LABEL, [+ { value: 5, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.x },+ { value: 80, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.y },+ ]),+ ).toStrictEqual([{ value: 80, color: '#F1575F' }]);+ expect(+ switchThresholds(ThresholdVariant.COMPARISON, [+ { value: 5, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.x },+ ]),+ ).toBeUndefined();+ });++ it('keeps the axis for a kind with an axis picker, defaulting to y', () => {+ expect(+ switchThresholds(+ ThresholdVariant.LABEL,+ [+ { value: 5, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.x },+ { value: 80, color: '#F1575F' },+ ],+ [],+ true,+ ),+ ).toStrictEqual([+ { value: 5, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.x },+ { value: 80, color: '#F1575F', axis: DashboardtypesThresholdAxisDTO.y },+ ]);+ });+it('seeds nothing for an empty or absent threshold list', () => {expect(switchThresholds(ThresholdVariant.LABEL, [])).toBeUndefined();const sections: SectionConfig[] = [diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/getValueColumnLabels.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/getValueColumnLabels.test.tsnew file mode 100644index 0000000000..3f8398c50e--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/__tests__/getValueColumnLabels.test.ts@@ -0,0 +1,48 @@+import type { PanelTableColumn } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++import { getValueColumnLabels } from '../getValueColumnLabels';++const column = (+ id: string,+ name: string,+ queryName: string,+ isValueColumn = true,+): PanelTableColumn => ({ id, name, queryName, isValueColumn });++describe('getValueColumnLabels', () => {+ it('prefixes only the value columns whose names collide', () => {+ expect(+ getValueColumnLabels([+ column('service.name', 'service.name', '', false),+ column('A.count()', 'count()', 'A'),+ column('A.p99(duration_nano)', 'p99(duration_nano)', 'A'),+ column('B', 'count()', 'B'),+ ]),+ ).toStrictEqual({+ 'A.count()': 'A.count()',+ 'A.p99(duration_nano)': 'p99(duration_nano)',+ B: 'B.count()',+ });+ });++ it('leaves a name that already is the query name bare', () => {+ expect(+ getValueColumnLabels([column('F1', 'F1', 'F1'), column('A', 'A', 'A')]),+ ).toStrictEqual({ F1: 'F1', A: 'A' });+ });++ it('leaves an alias or legend bare', () => {+ expect(+ getValueColumnLabels([+ column('A.count()', 'requests', 'A'),+ column('F1', 'Error rate', 'F1'),+ ]),+ ).toStrictEqual({ 'A.count()': 'requests', F1: 'Error rate' });+ });++ it('leaves a column with no query name bare', () => {+ expect(getValueColumnLabels([column('x', 'x', '')])).toStrictEqual({+ x: 'x',+ });+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/buildPluginSpec.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/buildPluginSpec.tsindex 745f3327f8..ffb87ad46e 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/buildPluginSpec.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/buildPluginSpec.ts@@ -10,6 +10,7 @@ import {DashboardtypesLineStyleDTO,type DashboardtypesPanelSpecDTO,DashboardtypesStackModeDTO,+ DashboardtypesThresholdAxisDTO,DashboardtypesThresholdFormatDTO,DashboardtypesTextAlignDTO,DashboardtypesTimePreferenceDTO,@@ -67,12 +68,14 @@ interface AnyThresholdFields {format?: DashboardtypesThresholdFormatDTO;columnName?: string;label?: string;+ axis?: DashboardtypesThresholdAxisDTO;}/** Remaps a threshold to the target variant, seeding the fields that variant needs to stay functional. */function toThresholdVariant(source: AnyThresholdFields,variant: ThresholdVariant,+ withAxis: boolean,defaultColumnName?: string,): AnyThreshold {const core = {@@ -98,6 +101,7 @@ function toThresholdVariant(return {...core,...(source.label !== undefined && { label: source.label }),+ ...(withAxis && { axis: source.axis ?? DashboardtypesThresholdAxisDTO.y }),};}@@ -219,10 +223,7 @@ const SECTION_SEEDS: SectionSeeds = {old.isLogScale !== undefined && { isLogScale: old.isLogScale }),// Seeded so the control opens on the axis being drawn....(controls.y && {- y: {- ...old.y,- scale: old.y?.scale ?? DashboardtypesHeatmapYScaleDTO.auto,- },+ y: { scale: old.y?.scale ?? DashboardtypesHeatmapYScaleDTO.auto },}),};},@@ -307,6 +308,13 @@ const SECTION_SEEDS: SectionSeeds = {decimalPrecision: old.decimalPrecision,}),};+ // Kinds that both key units per column (Table ↔ Scatter Plot) share the keys.+ if (controls.columnUnits && old?.columnUnits) {+ if (Object.keys(old.columnUnits).length > 0) {+ carried.columnUnits = { ...old.columnUnits };+ }+ return carried;+ }// A panel-wide unit fans out to every value column when the target keys units// per column (→ Table). One-way: `columnUnits` never seed a panel-wide `unit`.const unit = old?.unit;@@ -337,13 +345,16 @@ const SECTION_SEEDS: SectionSeeds = {variant === ThresholdVariant.TABLE? getTableColumnKeys(oldSpec?.queries ?? [])[0]: undefined;- const mapped = old.map((threshold) =>- toThresholdVariant(- threshold as AnyThresholdFields,- variant,- defaultColumnName,- ),- );+ const withAxis = !!controls.axis;+ // Only a kind that picks the axis can place an x threshold.+ const mapped = (old as AnyThresholdFields[])+ .filter(+ (threshold) =>+ withAxis || threshold.axis !== DashboardtypesThresholdAxisDTO.x,+ )+ .map((threshold) =>+ toThresholdVariant(threshold, variant, withAxis, defaultColumnName),+ );return variant === ThresholdVariant.TABLE? mapped.filter((t) => (t as { columnName?: string }).columnName): mapped;diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/__tests__/prepareScatterClickData.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/__tests__/prepareScatterClickData.test.tsnew file mode 100644index 0000000000..4c008b50b4--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/__tests__/prepareScatterClickData.test.ts@@ -0,0 +1,76 @@+import type { BuilderQuery } from 'types/api/v5/queryRange';++import { prepareScatterClickData } from '../prepareScatterClickData';++const builderQuery = (spec: Record<string, unknown>): BuilderQuery =>+ spec as unknown as BuilderQuery;++const QUERIES = [+ builderQuery({+ name: 'A',+ signal: 'traces',+ groupBy: [{ name: 'service.name' }, { name: 'k8s.namespace.name' }],+ }),+ builderQuery({+ name: 'B',+ signal: 'logs',+ groupBy: [{ name: 'service.name' }],+ }),+];++const LABELS = [+ { key: 'service.name', value: 'checkout' },+ { key: 'k8s.namespace.name', value: 'prod' },+];++const click = (+ axisQueries: { x: string; y: string },+ builderQueries = QUERIES,+): ReturnType<typeof prepareScatterClickData> =>+ prepareScatterClickData({+ labels: LABELS,+ label: 'checkout, prod',+ color: '#4E74F8',+ axisQueries,+ builderQueries,+ coordinates: { x: 7, y: 8 },+ timeRange: { startTime: 1, endTime: 2 },+ });++describe('prepareScatterClickData', () => {+ it("follows Y's query and filters to the dot's group", () => {+ expect(click({ x: 'B', y: 'A' })).toStrictEqual({+ coordinates: { x: 7, y: 8 },+ context: {+ queryName: 'A',+ signal: 'traces',+ filters: [+ { filterKey: 'service.name', filterValue: 'checkout', operator: '=' },+ { filterKey: 'k8s.namespace.name', filterValue: 'prod', operator: '=' },+ ],+ timeRange: { startTime: 1, endTime: 2 },+ label: 'checkout, prod',+ seriesColor: '#4E74F8',+ },+ });+ });++ it('keeps only the labels the followed query groups by', () => {+ expect(click({ x: 'A', y: 'B' })?.context).toMatchObject({+ queryName: 'B',+ signal: 'logs',+ filters: [+ { filterKey: 'service.name', filterValue: 'checkout', operator: '=' },+ ],+ });+ });++ it("falls back to X's query when Y's is not a builder query", () => {+ expect(click({ x: 'A', y: 'F1' })?.context.queryName).toBe('A');+ });++ it('returns null when neither axis has a builder query', () => {+ expect(click({ x: 'F1', y: 'F2' })).toBeNull();+ expect(click({ x: 'A', y: 'A' }, [])).toBeNull();+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/prepareScatterClickData.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/prepareScatterClickData.tsnew file mode 100644index 0000000000..f1445c1f25--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/drilldown/prepareScatterClickData.ts@@ -0,0 +1,57 @@+import { isValidQueryName } from 'container/QueryTable/Drilldown/drilldownUtils';+import type { ScatterPointLabel } from 'lib/uPlotV2/plugins/ScatterPlugin/types';+import type { BuilderQuery } from 'types/api/v5/queryRange';++import type { DrilldownClickPayload } from '../../types/drilldown';++import { getGroupByFilters } from './getGroupByFilters';+import { resolveDrilldownSignal } from './signal';++interface PrepareScatterClickDataArgs {+ labels: ScatterPointLabel[];+ /** Legend label. */+ label: string;+ color: string;+ /** Y's query first: a dot is placed by both, but Y is usually what was measured. */+ axisQueries: { x: string; y: string };+ builderQueries: BuilderQuery[];+ coordinates: { x: number; y: number };+ /** The panel's fetched window; a dot summarises all of it. */+ timeRange?: { startTime: number; endTime: number };+}++/** Drilldown filtered to the dot's group, via Y's builder query else X's; null if neither. */+export function prepareScatterClickData({+ labels,+ label,+ color,+ axisQueries,+ builderQueries,+ coordinates,+ timeRange,+}: PrepareScatterClickDataArgs): DrilldownClickPayload | null {+ const queryName = [axisQueries.y, axisQueries.x].find(+ (name) =>+ isValidQueryName(name) &&+ builderQueries.some((query) => query.name === name),+ );+ const builderQuery = builderQueries.find((query) => query.name === queryName);+ if (!queryName || !builderQuery) {+ return null;+ }++ const groupLabels = Object.fromEntries(+ labels.map((point) => [point.key, point.value]),+ );+ return {+ coordinates,+ context: {+ queryName,+ signal: resolveDrilldownSignal(builderQuery),+ filters: getGroupByFilters(groupLabels, builderQuery),+ timeRange,+ label,+ seriesColor: color,+ },+ };+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getJoinedScalarTable.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getJoinedScalarTable.tsnew file mode 100644index 0000000000..28b3660151--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getJoinedScalarTable.ts@@ -0,0 +1,17 @@+import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';+import type {+ PanelQueryData,+ PanelTable,+} from 'pages/DashboardPage/DashboardContainer/queryV5/types';+import { getScalarResults } from 'pages/DashboardPage/DashboardContainer/queryV5/v5ResponseData';++/** V5 joins every query into one scalar result, so the first non-empty table holds every group. */+export function getJoinedScalarTable(+ data: PanelQueryData,+): PanelTable | undefined {+ return prepareScalarTables({+ results: getScalarResults(data.response),+ legendMap: data.legendMap ?? {},+ requestPayload: data.requestPayload,+ }).find((candidate) => candidate.columns.length > 0);+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getValueColumnLabels.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getValueColumnLabels.tsnew file mode 100644index 0000000000..7eea36e874--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getValueColumnLabels.ts@@ -0,0 +1,27 @@+import type { PanelTableColumn } from 'pages/DashboardPage/DashboardContainer/queryV5/types';++/**+ * Value column id → its name, prefixed `queryName.name` only when another value column+ * shares the name, so `count()` on two queries reads apart while a lone value keeps the+ * name its alias or legend gave it.+ */+export function getValueColumnLabels(+ columns: PanelTableColumn[],+): Record<string, string> {+ const valueColumns = columns.filter((column) => column.isValueColumn);+ const nameCounts = new Map<string, number>();+ valueColumns.forEach((column) =>+ nameCounts.set(column.name, (nameCounts.get(column.name) ?? 0) + 1),+ );++ return Object.fromEntries(+ valueColumns.map((column) => [+ column.id || column.name,+ column.queryName &&+ column.name !== column.queryName &&+ (nameCounts.get(column.name) ?? 0) > 1+ ? `${column.queryName}.${column.name}`+ : column.name,+ ]),+ );+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries.ts b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries.tsindex dc3e1893a6..537c229189 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/legendSeries.ts@@ -1,8 +1,13 @@-import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';+import type {+ DashboardtypesPanelDTO,+ DashboardtypesPanelSpecDTO,+} from 'api/generated/services/sigNoz.schemas';import { themeColors } from 'constants/theme';import getLabelName from 'lib/getLabelName';import { generateColor } from 'lib/uPlotLib/utils/generateColor';import { preparePieData } from '../kinds/PieChartPanel/prepareData';+import { getColorGroupLabels } from '../kinds/ScatterPlotPanel/utils/prepareData';+import { getJoinedScalarTable } from './getJoinedScalarTable';import { getBuilderQueries } from './getBuilderQueries';import { resolveSeriesLabelV5 } from './resolveSeriesLabel';import { prepareScalarTables } from 'pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables';@@ -23,6 +28,8 @@ export interface LegendSeries {type PanelQueries = DashboardtypesPanelDTO['spec']['queries'];interface LegendSeriesArgs {+ /** The kind's own spec, for kinds whose labels depend on it. */+ spec: DashboardtypesPanelSpecDTO;queries: PanelQueries;data: PanelQueryData;isDarkMode: boolean;@@ -103,3 +110,24 @@ export function resolveTimeSeriesLegendSeries({(label) => generateColor(label, palette),);}++/** One entry per colour group, labelled the way the renderer labels its series. */+export function resolveScatterLegendSeries({+ spec,+ data,+ isDarkMode,+}: LegendSeriesArgs): LegendSeries[] {+ if (spec.plugin.kind !== 'signoz/ScatterPlotPanel') {+ return [];+ }+ const palette = isDarkMode+ ? themeColors.chartcolors+ : themeColors.lightModeColor;+ return buildLegendSeries(+ getColorGroupLabels(+ getJoinedScalarTable(data),+ spec.plugin.spec.dimensions?.colorBy,+ ),+ (label) => generateColor(label, palette),+ );+}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelHeader/PanelHeader.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelHeader/PanelHeader.tsxindex dfb65ec9b0..29c1b765e7 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelHeader/PanelHeader.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelHeader/PanelHeader.tsx@@ -7,6 +7,7 @@ import type {} from 'api/generated/services/sigNoz.schemas';import cx from 'classnames';import type { PanelTimePreferenceLabel } from 'pages/DashboardPage/DashboardContainer/hooks/resolvePanelTimeWindow';+import { getQueryPanelDefinition } from 'pages/DashboardPage/DashboardContainer/Panels/capabilities';import type { PanelQueryData } from 'pages/DashboardPage/DashboardContainer/queryV5/types';import type { PanelActionsConfig } from '../Panel';@@ -86,6 +87,18 @@ function PanelHeader(props: PanelHeaderProps): JSX.Element {[panel],);+ const queryData = query?.data;+ const dataWarningDetail = useMemo(+ () =>+ queryData+ ? (getQueryPanelDefinition(panel.spec.plugin.kind)?.getDataWarning?.(+ panel,+ queryData,+ ) ?? null)+ : null,+ [queryData, panel],+ );+/*** Hide the entire header when there's no title, description, or status to show,* and the actions menu is suppressed (editor preview).@@ -96,6 +109,7 @@ function PanelHeader(props: PanelHeaderProps): JSX.Element {!errorDetail &&!warningDetail &&!multiQueryWarningDetail &&+ !dataWarningDetail &&hideActions) {return <Fragment />;@@ -151,6 +165,13 @@ function PanelHeader(props: PanelHeaderProps): JSX.Element {testId="panel-status-config-warning"/>)}+ {dataWarningDetail && (+ <PanelStatusPopover+ variant="warning"+ detail={dataWarningDetail}+ testId="panel-status-data-warning"+ />+ )}{/* Renders nothing when no action survives its gates (kind/role/context). */}{!hideActions && (<PanelActionsMenudiff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeBrowser/panelTypeCatalog.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeBrowser/panelTypeCatalog.tsindex 2410706905..b394b41c86 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeBrowser/panelTypeCatalog.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypeBrowser/panelTypeCatalog.ts@@ -43,6 +43,11 @@ const PANEL_TYPE_META: Record<PanelKind, PanelTypeMeta> = {description: 'Compare values across categories',},'signoz/PieChartPanel': { group: 'compare', description: 'Share of a whole' },+ 'signoz/ScatterPlotPanel': {+ group: 'compare',+ description: 'Two values per group, plotted against each other',+ isNew: true,+ },'signoz/HistogramPanel': {group: 'distributions',description: 'Distribution of values into buckets',diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypePreview/panelTypePreviews.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypePreview/panelTypePreviews.tsxindex 5d6c261dcb..6b93a05dba 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypePreview/panelTypePreviews.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/components/PanelTypePreview/panelTypePreviews.tsx@@ -10,6 +10,19 @@ const AREA_FILL = { fill: 'var(--bg-robin-500)', fillOpacity: 0.22 };const RING_TRACK = { stroke: 'var(--l3-background)' };const RING_PRIMARY = { stroke: 'var(--bg-robin-500)' };const RING_SECONDARY = { stroke: 'var(--bg-robin-400)', strokeOpacity: 0.55 };+const DOT_FILL = { fill: 'var(--bg-robin-500)', fillOpacity: 0.55 };++/** `[cx, cy, r]`: a loose up-and-right cloud with one large outlier. */+const SCATTER_DOTS = [+ [14, 34, 2.5],+ [26, 28, 3.5],+ [38, 31, 2],+ [50, 20, 4],+ [62, 24, 2.5],+ [76, 14, 3],+ [88, 18, 2],+ [102, 8, 6],+];const LINE_PATH ='M0 34 12 26 24 30 36 16 48 22 60 10 72 18 84 8 96 14 108 5 120 11';@@ -100,6 +113,13 @@ export const PANEL_TYPE_PREVIEWS: Record<PanelKind, JSX.Element> = {)}</svg>),+ 'signoz/ScatterPlotPanel': (+ <svg viewBox="0 0 120 44" className={styles.svg}>+ {SCATTER_DOTS.map(([cx, cy, r]) => (+ <circle key={cx} cx={cx} cy={cy} r={r} style={DOT_FILL} />+ ))}+ </svg>+ ),'signoz/PieChartPanel': (<svg viewBox="0 0 44 44" className={styles.svg}><circlediff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/__tests__/useDrilldownBreakout.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/__tests__/useDrilldownBreakout.test.tsnew file mode 100644index 0000000000..5e0acf8a13--- /dev/null+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/__tests__/useDrilldownBreakout.test.ts@@ -0,0 +1,45 @@+import { PANEL_TYPES } from 'constants/queryBuilder';+import type { AggregateData } from 'container/QueryTable/Drilldown/useAggregateDrilldown';+import { renderHook } from 'tests/test-utils';+import type { Query } from 'types/api/queryBuilder/queryBuilderData';++import { useDrilldownBreakout } from '../useDrilldownBreakout';++jest.mock('api/common/logEvent', () => jest.fn());+jest.mock('container/QueryTable/Drilldown/tableDrilldownUtils', () => ({+ ...jest.requireActual('container/QueryTable/Drilldown/tableDrilldownUtils'),+ getBreakoutQuery: jest.fn((query: Query) => query),+}));++const QUERY = {+ queryType: 'builder',+ builder: { queryData: [{ queryName: 'A' }], queryFormulas: [] },+} as unknown as Query;+const AGGREGATE = { queryName: 'A', filters: [] } as unknown as AggregateData;++function breakOutFrom(panelType: PANEL_TYPES): PANEL_TYPES {+ const openViewWithQuery = jest.fn();+ const { result } = renderHook(() =>+ useDrilldownBreakout({+ panelId: 'p1',+ v1Query: QUERY,+ panelType,+ aggregateData: AGGREGATE,+ openViewWithQuery,+ onClose: jest.fn(),+ }),+ );+ result.current.onBreakout({ name: 'host.name' } as never);+ return openViewWithQuery.mock.calls[0][2];+}++describe('useDrilldownBreakout', () => {+ it('opens a scatter plot breakout as a table', () => {+ expect(breakOutFrom(PANEL_TYPES.SCATTER)).toBe(PANEL_TYPES.TABLE);+ });++ it('keeps the panel type for the kinds V1 breaks out in place', () => {+ expect(breakOutFrom(PANEL_TYPES.TIME_SERIES)).toBe(PANEL_TYPES.TIME_SERIES);+ expect(breakOutFrom(PANEL_TYPES.VALUE)).toBe(PANEL_TYPES.TABLE);+ });+});diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDownloadPanelCsv.ts b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDownloadPanelCsv.tsindex 452c57dcc1..e4a10680dc 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDownloadPanelCsv.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDownloadPanelCsv.ts@@ -15,9 +15,10 @@ interface UseDownloadPanelCsvArgs {data: PanelQueryData;/*** Whether the kind's definition declares CSV as a downloadable format- * (`actions.download.csv`). Only tables carry tabular data, so this is the- * same gate the menu uses — kept here so the callback stays a no-op when- * invoked for a kind that can't produce CSV.+ * (`actions.download.csv`). Only kinds drawn from a joined scalar table+ * (Table, Scatter Plot) carry tabular data, so this is the same gate the menu+ * uses — kept here so the callback stays a no-op when invoked for a kind that+ * can't produce CSV.*/canDownloadCsv: boolean;}@@ -37,7 +38,10 @@ export function useDownloadPanelCsv({if (!canDownloadCsv) {return;}- const rows = getTableCsvRows(panel as PanelOfKind<'signoz/TablePanel'>, data);+ const rows = getTableCsvRows(+ panel as PanelOfKind<'signoz/TablePanel' | 'signoz/ScatterPlotPanel'>,+ data,+ );if (rows.length === 0) {return;}diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldownBreakout.tsx b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldownBreakout.tsxindex 3354c33314..f31e87ef19 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldownBreakout.tsx+++ b/frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldownBreakout.tsx@@ -1,6 +1,6 @@import { useCallback, useMemo } from 'react';import logEvent from 'api/common/logEvent';-import type { PANEL_TYPES } from 'constants/queryBuilder';+import { PANEL_TYPES } from 'constants/queryBuilder';import { getQueryData } from 'container/QueryTable/Drilldown/drilldownUtils';import {getBreakoutPanelType,@@ -66,7 +66,12 @@ export function useDrilldownBreakout({groupBy,aggregateData.filters ?? [],);- openViewWithQuery(panelId, breakoutQuery, getBreakoutPanelType(panelType));+ // A regrouped query no longer joins the scatter's others; show it as a table.+ const breakoutPanelType =+ panelType === PANEL_TYPES.SCATTER+ ? PANEL_TYPES.TABLE+ : getBreakoutPanelType(panelType);+ openViewWithQuery(panelId, breakoutQuery, breakoutPanelType);onClose();},[aggregateData, v1Query, panelType, panelId, openViewWithQuery, onClose],diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.ts b/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.tsindex 6be59a907a..ad88d819b1 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.ts@@ -11,7 +11,7 @@ import {} from 'constants/queryBuilder';import type { Query } from 'types/api/queryBuilder/queryBuilderData';import { EQueryType } from 'types/common/dashboard';-import { DataSource } from 'types/common/queryBuilder';+import { DataSource, ReduceOperators } from 'types/common/queryBuilder';import {envelopesToQuery,@@ -257,6 +257,35 @@ describe('persesQueryAdapters', () => {expect(envelopes?.[0]?.type).toBe('builder_ai_query');});+ it.each([PANEL_TYPES.TABLE, PANEL_TYPES.SCATTER])(+ 'sends a %s panel metric query as scalar with its reduceTo, which the API requires',+ (panelType) => {+ const metrics = initialQueriesMap[DataSource.METRICS];+ const query: Query = {+ ...metrics,+ builder: {+ ...metrics.builder,+ queryData: metrics.builder.queryData.map((queryData) => ({+ ...queryData,+ // `aggregations` is a union of arrays, which `map` widens.+ aggregations: queryData.aggregations?.map((aggregation) => ({+ ...aggregation,+ reduceTo: ReduceOperators.SUM,+ })) as typeof queryData.aggregations,+ })),+ },+ };++ const [envelope] = toPerses(query, panelType);+ const composite = envelope.spec.plugin.spec as {+ queries: { spec: { aggregations?: { reduceTo?: string }[] } }[];+ };++ expect(envelope.kind).toBe('scalar');+ expect(composite.queries[0].spec.aggregations?.[0]?.reduceTo).toBe('sum');+ },+ );+it('emits a bare signoz/BuilderQuery for a List panel (not a CompositeQuery)', () => {const result = toPerses(initialQueriesMap[DataSource.LOGS],diff --git a/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters.ts b/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters.tsindex aec81d1c9b..f8149a52e3 100644--- a/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters.ts+++ b/frontend/src/pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters.ts@@ -106,6 +106,7 @@ export function panelTypeToRequestType(case PANEL_TYPES.TABLE:case PANEL_TYPES.PIE:case PANEL_TYPES.VALUE:+ case PANEL_TYPES.SCATTER:return Querybuildertypesv5RequestTypeDTO.scalar;case PANEL_TYPES.LIST:return Querybuildertypesv5RequestTypeDTO.raw;diff --git a/frontend/src/utils/explorerUtils.ts b/frontend/src/utils/explorerUtils.tsindex 9aabfa9e1f..f467494514 100644--- a/frontend/src/utils/explorerUtils.ts+++ b/frontend/src/utils/explorerUtils.ts@@ -79,6 +79,7 @@ export const panelTypeToExplorerView: Record<PANEL_TYPES, ExplorerViews> = {[PANEL_TYPES.HEATMAP]: ExplorerViews.TIMESERIES,// Dashboard-only visualisation; explorers never offer it.[PANEL_TYPES.TEXT]: ExplorerViews.LIST,+ [PANEL_TYPES.SCATTER]: ExplorerViews.TABLE,[PANEL_TYPES.EMPTY_WIDGET]: ExplorerViews.LIST,};diff --git a/pkg/types/dashboardtypes/perses_dashboard_data.go b/pkg/types/dashboardtypes/perses_dashboard_data.goindex a0cda36436..8ccc0c6cb1 100644--- a/pkg/types/dashboardtypes/perses_dashboard_data.go+++ b/pkg/types/dashboardtypes/perses_dashboard_data.go@@ -123,10 +123,22 @@ func (d *DashboardSpec) validatePanels() error {return err}}+ // validatePanelQueryCount left exactly one query for a spec that reads it.+ if spec, ok := panel.Spec.Plugin.Spec.(queryBoundPanelSpec); ok {+ if err := spec.validateAgainstQuery(panel.Spec.Queries[0], path+".spec.plugin.spec"); err != nil {+ return err+ }+ }}return nil}+// queryBoundPanelSpec is a panel spec with fields that depend on the panel's+// query. It is checked after the query itself validates.+type queryBoundPanelSpec interface {+ validateAgainstQuery(query Query, path string) error+}+func validatePanelQueryCount(queries []Query, panelKind PanelPluginKind, path string) error {if queries == nil {return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.spec.queries: is required and must not be null; use [] for a panel that renders without a query", path)diff --git a/pkg/types/dashboardtypes/perses_dashboard_test.go b/pkg/types/dashboardtypes/perses_dashboard_test.goindex 8eab6a845f..92ae776bb3 100644--- a/pkg/types/dashboardtypes/perses_dashboard_test.go+++ b/pkg/types/dashboardtypes/perses_dashboard_test.go@@ -1870,6 +1870,344 @@ func TestInvalidateAreaChartPanelSpecValues(t *testing.T) {}}+func TestScatterPlotPanelDefaults(t *testing.T) {+ data := []byte(`{+ "variables": [],+ "panels": {+ "p1": {+ "kind": "Panel",+ "spec": {+ "links": [],+ "plugin": {+ "kind": "signoz/ScatterPlotPanel",+ "spec": {}+ },+ "queries": [{"kind": "scalar", "spec": {"plugin": {"kind": "signoz/ClickHouseSQL", "spec": {"name": "A", "query": "SELECT 1"}}}}]+ }+ }+ },+ "links": [],+ "layouts": []+ }`)+ d, err := unmarshalDashboard(data)+ require.NoError(t, err, "unmarshal and validate failed")++ require.IsType(t, &ScatterPlotPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)+ spec := d.Panels["p1"].Spec.Plugin.Spec.(*ScatterPlotPanelSpec)++ assert.Empty(t, spec.Dimensions.X, "an omitted x stays empty so the renderer picks the first value column")+ assert.Empty(t, spec.Dimensions.Y, "an omitted y stays empty so the renderer picks the second value column")+ assert.Empty(t, spec.Dimensions.ColorBy, "an omitted colorBy stays empty so the renderer colours by every group-by label")+ assert.Equal(t, "auto", spec.Axes.X.Scale.ValueOrDefault(), "expected x scale default auto")+ assert.Equal(t, "auto", spec.Axes.Y.Scale.ValueOrDefault(), "expected y scale default auto")+ assert.Nil(t, spec.Axes.X.SoftMin, "expected x softMin unset")+ assert.Equal(t, "2", spec.Formatting.DecimalPrecision.ValueOrDefault(), "expected DecimalPrecision default 2")+ assert.Equal(t, "global_time", spec.Visualization.TimePreference.ValueOrDefault(), "expected TimePreference default global_time")+ assert.Equal(t, "bottom", spec.Legend.Position.ValueOrDefault(), "expected LegendPosition default bottom")++ output, err := json.Marshal(d)+ require.NoError(t, err, "marshal dashboard failed")+ assert.Contains(t, string(output), `"axes":{"x":{"softMin":null,"softMax":null,"scale":"auto","label":""},"y":{"softMin":null,"softMax":null,"scale":"auto","label":""}}`, "expected default axes in stored/response JSON")+ assert.Contains(t, string(output), `"dimensions":{"x":"","y":"","sizeBy":"","colorBy":null}`, "expected empty dimensions in stored/response JSON")+ assert.Contains(t, string(output), `"chartAppearance":{"points":{"size":null,"minSize":null,"maxSize":null,"opacity":null}}`, "omitted point settings stay null so the renderer applies its defaults")+}++func TestValidateScatterPlotDashboard(t *testing.T) {+ data, err := os.ReadFile("testdata/perses_scatter_plot_panel.json")+ require.NoError(t, err, "reading example file")++ spec, err := unmarshalDashboard(data)+ require.NoError(t, err, "unmarshal and validate failed")++ require.IsType(t, &ScatterPlotPanelSpec{}, spec.Panels["p1"].Spec.Plugin.Spec)+ panelSpec := spec.Panels["p1"].Spec.Plugin.Spec.(*ScatterPlotPanelSpec)+ softMin, softMax := 0.0, 1000.0+ size, minSize, maxSize, opacity := PointDiameter(8), PointDiameter(4), PointDiameter(24), PointOpacity(0.1)+ assert.Equal(t, &ScatterPlotPanelSpec{+ Visualization: BasicVisualization{TimePreference: TimePreferenceLast1Hr},+ Dimensions: ScatterPlotDimensions{X: "A.count()", Y: "A.p99(duration_nano)", SizeBy: "A.countIf(has_error = true)", ColorBy: []string{"k8s.namespace.name", "k8s.pod.name"}},+ Formatting: TableFormatting{ColumnUnits: map[string]string{"A.p99(duration_nano)": "ns"}, DecimalPrecision: PrecisionOption1},+ Axes: ScatterPlotAxes{+ X: ScatterPlotAxis{SoftMin: &softMin, Scale: AxisScaleLog, Label: "Throughput"},+ Y: ScatterPlotAxis{SoftMax: &softMax, Scale: AxisScaleSymlog, Label: "p99 latency"},+ },+ ChartAppearance: ScatterPlotChartAppearance{Points: ScatterPlotPoints{Size: &size, MinSize: &minSize, MaxSize: &maxSize, Opacity: &opacity}},+ Legend: Legend{Position: LegendPositionRight, Mode: LegendModeList, CustomColors: map[string]string{"checkout": "#1f77b4"}},+ Thresholds: []ScatterPlotThreshold{+ {ThresholdWithLabel: ThresholdWithLabel{Value: 300, Unit: "ms", Color: "#f00", Label: "p99 SLO"}, Axis: ThresholdAxisY},+ {ThresholdWithLabel: ThresholdWithLabel{Value: 50, Color: "#0f0"}, Axis: ThresholdAxisX},+ },+ }, panelSpec)++ dashboard := &DashboardV2{Spec: *spec}+ request, err := dashboard.GetPanelQuery(1, 2, "p1")+ require.NoError(t, err, "building the panel's query failed")+ assert.Equal(t, qb.RequestTypeScalar, request.RequestType)+ require.NotNil(t, request.FormatOptions)+ assert.True(t, request.FormatOptions.FormatTableResultForUI, "scatter rows are joined the way a table's are")++ require.Len(t, request.CompositeQuery.Queries, 1)+ query, ok := request.CompositeQuery.Queries[0].Spec.(qb.QueryBuilderQuery[qb.TraceAggregation])+ require.True(t, ok, "expected a traces builder query")+ assert.Len(t, query.Aggregations, 3)+ assert.Len(t, query.GroupBy, 2)++ assert.NoError(t, request.Validate(), "the request built from the panel is not a valid scalar request")++ // the panel read back out of storage draws the same scatter plot+ stored, err := json.Marshal(spec)+ require.NoError(t, err, "marshal dashboard failed")+ reread, err := unmarshalDashboard(stored)+ require.NoError(t, err, "the stored dashboard does not validate")+ assert.Equal(t, panelSpec, reread.Panels["p1"].Spec.Plugin.Spec)+ rereadRequest, err := (&DashboardV2{Spec: *reread}).GetPanelQuery(1, 2, "p1")+ require.NoError(t, err, "building the stored panel's query failed")+ assert.Equal(t, request, rereadRequest)+}++func TestInvalidateScatterPlotPanelSpecValues(t *testing.T) {+ testCases := []struct {+ name string+ panelKind string+ panelSpec string+ expectedErrorSubstring string+ }{+ {+ name: "AxisScale_Unknown_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"axes": {"x": {"scale": "sqrt"}}}`,+ expectedErrorSubstring: "invalid axis scale \"sqrt\": must be `auto`, `linear`, `log`, or `symlog`",+ },+ {+ name: "AxisScale_NonString_UnmarshalError",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"axes": {"y": {"scale": true}}}`,+ expectedErrorSubstring: "cannot unmarshal bool",+ },+ {+ name: "Axis_IsLogScale_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"axes": {"x": {"isLogScale": true}}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "Axes_SingleAxisShape_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"axes": {"softMin": 0}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "ThresholdAxis_Unknown_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"thresholds": [{"value": 1, "color": "#f00", "axis": "z"}]}`,+ expectedErrorSubstring: "invalid threshold axis \"z\": must be `x` or `y`",+ },+ {+ name: "Dimensions_UnknownKey_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"dimensions": {"z": "A"}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "PointSize_BelowMinimum_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"size": 1}}}`,+ expectedErrorSubstring: "invalid point diameter 1: must be a whole number between 2 and 40",+ },+ {+ name: "PointMaxSize_AboveMaximum_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"maxSize": 41}}}`,+ expectedErrorSubstring: "invalid point diameter 41",+ },+ {+ name: "PointMinSize_Fractional_UnmarshalError",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"minSize": 4.5}}}`,+ expectedErrorSubstring: "cannot unmarshal number 4.5",+ },+ {+ name: "PointMinSize_AboveMaxSize_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"minSize": 20, "maxSize": 10}}}`,+ expectedErrorSubstring: "minSize 20 must not exceed maxSize 10",+ },+ {+ name: "PointMaxSize_BelowDefaultMinSize_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"maxSize": 2}}}`,+ expectedErrorSubstring: "minSize 4 must not exceed maxSize 2",+ },+ {+ name: "PointMinSize_AboveDefaultMaxSize_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"minSize": 40}}}`,+ expectedErrorSubstring: "minSize 40 must not exceed maxSize 24",+ },+ {+ name: "PointOpacity_BelowFloor_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"opacity": 0.05}}}`,+ expectedErrorSubstring: "invalid point opacity 0.05: must be between 0.1 and 1",+ },+ {+ name: "PointOpacity_Percentage_Invalid",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"opacity": 70}}}`,+ expectedErrorSubstring: "invalid point opacity 70",+ },+ {+ name: "Points_MisspelledField_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"points": {"opactiy": 0.5}}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "ChartAppearance_FillOpacity_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"chartAppearance": {"fillOpacity": 0.5}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "ColorBy_String_UnmarshalError",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"dimensions": {"colorBy": "service.name"}}`,+ expectedErrorSubstring: "cannot unmarshal string",+ },+ {+ name: "Formatting_PanelUnit_UnknownField",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"formatting": {"unit": "ms"}}`,+ expectedErrorSubstring: "unknown field",+ },+ {+ name: "Threshold_NoColor_Required",+ panelKind: "signoz/ScatterPlotPanel",+ panelSpec: `{"thresholds": [{"value": 300}]}`,+ expectedErrorSubstring: "Color' Error:Field validation for 'Color' failed on the 'required' tag",+ },+ {+ name: "TimeSeriesAxes_Scale_UnknownField",+ panelKind: "signoz/TimeSeriesPanel",+ panelSpec: `{"axes": {"scale": "log"}}`,+ expectedErrorSubstring: "unknown field",+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ data := []byte(`{+ "variables": [],+ "panels": {+ "p1": {+ "kind": "Panel",+ "spec": {+ "links": [],+ "plugin": {"kind": "` + testCase.panelKind + `", "spec": ` + testCase.panelSpec + `},+ "queries": [{"kind": "scalar", "spec": {"plugin": {"kind": "signoz/ClickHouseSQL", "spec": {"name": "A", "query": "SELECT 1"}}}}]+ }+ }+ },+ "links": [],+ "layouts": []+ }`)+ _, err := unmarshalDashboard(data)+ require.Error(t, err, "expected the spec to be rejected")+ assert.Contains(t, err.Error(), testCase.expectedErrorSubstring, "unexpected error message: %s", err.Error())+ })+ }+}++func TestScatterPlotDimensionsBindToQuery(t *testing.T) {+ testCases := []struct {+ name string+ queryPlugin string+ dimensions string+ expectedErrorSubstring string+ }{+ {+ name: "MultiAggregationQuery_BareQueryName_NotAValueColumn",+ queryPlugin: `{"kind": "signoz/BuilderQuery", "spec": {"name": "A", "signal": "traces", "aggregations": [{"expression": "count()"}, {"expression": "p99(duration_nano)"}]}}`,+ dimensions: `{"x": "A"}`,+ expectedErrorSubstring: "dimensions.x: \"A\" is not a value column of the panel's query; value columns: `A.count()`, `A.p99(duration_nano)`",+ },+ {+ name: "ColorBy_NotAGroupByKey_Rejected",+ queryPlugin: `{"kind": "signoz/BuilderQuery", "spec": {"name": "A", "signal": "traces", "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "service.name"}]}}`,+ dimensions: `{"colorBy": ["service.name", "k8s.pod.name"]}`,+ expectedErrorSubstring: "dimensions.colorBy: \"k8s.pod.name\" is not a group-by key of the panel's query; group-by keys: `service.name`",+ },+ {+ name: "Formula_ValueColumn_CarriesDisabledQueryLabels",+ queryPlugin: `{"kind": "signoz/CompositeQuery", "spec": {"queries": [+ {"type": "builder_query", "spec": {"name": "A", "signal": "traces", "disabled": true, "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "service.name"}]}},+ {"type": "builder_query", "spec": {"name": "B", "signal": "traces", "disabled": true, "aggregations": [{"expression": "countIf(has_error = true)"}], "groupBy": [{"name": "service.name"}]}},+ {"type": "builder_formula", "spec": {"name": "F1", "expression": "B / A"}}+ ]}}`,+ dimensions: `{"x": "F1", "colorBy": ["service.name"]}`,+ },+ {+ name: "ClickHouseQuery_ColumnsUnknownUntilRunTime_BindingsUnchecked",+ queryPlugin: `{"kind": "signoz/ClickHouseSQL", "spec": {"name": "A", "query": "SELECT 1"}}`,+ dimensions: `{"x": "throughput", "colorBy": ["pod"]}`,+ },+ {+ name: "Queries_DifferentGroupBy_Rejected",+ queryPlugin: `{"kind": "signoz/CompositeQuery", "spec": {"queries": [+ {"type": "builder_query", "spec": {"name": "A", "signal": "traces", "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "service.name"}]}},+ {"type": "builder_query", "spec": {"name": "B", "signal": "traces", "aggregations": [{"expression": "p99(duration_nano)"}], "groupBy": [{"name": "k8s.pod.name"}]}}+ ]}}`,+ dimensions: `{"x": "A", "y": "B"}`,+ expectedErrorSubstring: "queries must group by the same keys so their rows join into dots; \"A\" groups by [`service.name`], \"B\" groups by [`k8s.pod.name`]",+ },+ {+ name: "Queries_SameGroupByDifferentOrder_Accepted",+ queryPlugin: `{"kind": "signoz/CompositeQuery", "spec": {"queries": [+ {"type": "builder_query", "spec": {"name": "A", "signal": "traces", "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "service.name"}, {"name": "k8s.pod.name"}]}},+ {"type": "builder_query", "spec": {"name": "B", "signal": "traces", "aggregations": [{"expression": "p99(duration_nano)"}], "groupBy": [{"name": "k8s.pod.name"}, {"name": "service.name"}]}}+ ]}}`,+ dimensions: `{"x": "A", "y": "B", "colorBy": ["service.name"]}`,+ },+ {+ name: "Queries_DisabledUnreadQueryDifferentGroupBy_Rejected",+ queryPlugin: `{"kind": "signoz/CompositeQuery", "spec": {"queries": [+ {"type": "builder_query", "spec": {"name": "A", "signal": "traces", "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "service.name"}]}},+ {"type": "builder_query", "spec": {"name": "B", "signal": "traces", "aggregations": [{"expression": "p99(duration_nano)"}], "groupBy": [{"name": "service.name"}]}},+ {"type": "builder_query", "spec": {"name": "C", "signal": "traces", "disabled": true, "aggregations": [{"expression": "count()"}], "groupBy": [{"name": "k8s.pod.name"}]}}+ ]}}`,+ dimensions: `{"x": "A", "y": "B"}`,+ expectedErrorSubstring: "\"A\" groups by [`service.name`], \"C\" groups by [`k8s.pod.name`]",+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ data := []byte(`{+ "variables": [],+ "panels": {+ "p1": {+ "kind": "Panel",+ "spec": {+ "links": [],+ "plugin": {"kind": "signoz/ScatterPlotPanel", "spec": {"dimensions": ` + testCase.dimensions + `}},+ "queries": [{"kind": "scalar", "spec": {"plugin": ` + testCase.queryPlugin + `}}]+ }+ }+ },+ "links": [],+ "layouts": []+ }`)+ _, err := unmarshalDashboard(data)+ if testCase.expectedErrorSubstring == "" {+ assert.NoError(t, err)+ return+ }+ require.Error(t, err, "expected the binding to be rejected")+ assert.Contains(t, err.Error(), testCase.expectedErrorSubstring, "unexpected error message: %s", err.Error())+ })+ }+}+func TestNumberPanelDefaults(t *testing.T) {data := []byte(`{"variables": [],@@ -2228,7 +2566,7 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {switch panelKind {case "signoz/ListPanel":return "raw"- case "signoz/TablePanel", "signoz/NumberPanel", "signoz/PieChartPanel", "signoz/HistogramPanel":+ case "signoz/TablePanel", "signoz/NumberPanel", "signoz/PieChartPanel", "signoz/HistogramPanel", "signoz/ScatterPlotPanel":return "scalar"default:return "time_series"@@ -2272,14 +2610,18 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {{"List+Builder", mkQuery("signoz/ListPanel", "signoz/BuilderQuery", `{"name":"A","signal":"logs"}`), false},{"TimeSeries+AIBuilder", mkQuery("signoz/TimeSeriesPanel", "signoz/AIBuilderQuery", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},{"List+AIBuilder", mkQuery("signoz/ListPanel", "signoz/AIBuilderQuery", `{"name":"A"}`), false},+ {"ScatterPlot+ClickHouse", mkQuery("signoz/ScatterPlotPanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), false},// Top-level: rejected{"Table+PromQL", mkQuery("signoz/TablePanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},+ {"ScatterPlot+PromQL", mkQuery("signoz/ScatterPlotPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},+ {"ScatterPlot+TraceOperator", mkQuery("signoz/ScatterPlotPanel", "signoz/TraceOperator", `{"name":"T1","expression":"A => B"}`), true},{"List+ClickHouse", mkQuery("signoz/ListPanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), true},{"List+PromQL", mkQuery("signoz/ListPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},{"List+Composite", mkQuery("signoz/ListPanel", "signoz/CompositeQuery", `{"queries":[]}`), true},{"List+Formula", mkQuery("signoz/ListPanel", "signoz/Formula", `{"name":"F1","expression":"A+B"}`), true},// Composite sub-queries{"Table+Composite(promql)", mkComposite("signoz/TablePanel", "promql", `{"name":"A","query":"up"}`), true},+ {"ScatterPlot+Composite(promql)", mkComposite("signoz/ScatterPlotPanel", "promql", `{"name":"A","query":"up"}`), true},{"Table+Composite(clickhouse)", mkComposite("signoz/TablePanel", "clickhouse_sql", `{"name":"A","query":"SELECT 1"}`), false},{"Table+Composite(builder_ai)", mkComposite("signoz/TablePanel", "builder_ai_query", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},}diff --git a/pkg/types/dashboardtypes/perses_plugin_wrappers.go b/pkg/types/dashboardtypes/perses_plugin_wrappers.goindex c9a21a8523..b8d8e27aa8 100644--- a/pkg/types/dashboardtypes/perses_plugin_wrappers.go+++ b/pkg/types/dashboardtypes/perses_plugin_wrappers.go@@ -28,16 +28,17 @@ type PanelPlugin struct {// (and strips the duplicate parent properties) after reflection.func (PanelPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {return markDiscriminator(s, "kind", map[string]string{- string(PanelKindTimeSeries): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec"),- string(PanelKindBarChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec"),- string(PanelKindAreaChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec"),- string(PanelKindNumber): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec"),- string(PanelKindPieChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec"),- string(PanelKindTable): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec"),- string(PanelKindHistogram): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec"),- string(PanelKindList): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec"),- string(PanelKindText): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec"),- string(PanelKindHeatmap): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec"),+ string(PanelKindTimeSeries): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec"),+ string(PanelKindBarChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec"),+ string(PanelKindAreaChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec"),+ string(PanelKindNumber): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec"),+ string(PanelKindPieChart): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec"),+ string(PanelKindTable): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec"),+ string(PanelKindHistogram): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec"),+ string(PanelKindList): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec"),+ string(PanelKindText): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec"),+ string(PanelKindHeatmap): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHeatmapPanelSpec"),+ string(PanelKindScatterPlot): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesScatterPlotPanelSpec"),})}@@ -71,6 +72,7 @@ func (PanelPlugin) JSONSchemaOneOf() []any {PanelPluginVariant[ListPanelSpec]{Kind: string(PanelKindList)},PanelPluginVariant[TextPanelSpec]{Kind: string(PanelKindText)},PanelPluginVariant[HeatmapPanelSpec]{Kind: string(PanelKindHeatmap)},+ PanelPluginVariant[ScatterPlotPanelSpec]{Kind: string(PanelKindScatterPlot)},}}@@ -234,16 +236,17 @@ func (v VariablePluginVariant[S]) PrepareJSONSchema(s *jsonschema.Schema) errorvar (panelPluginSpecs = map[PanelPluginKind]func() any{- PanelKindTimeSeries: func() any { return new(TimeSeriesPanelSpec) },- PanelKindBarChart: func() any { return new(BarChartPanelSpec) },- PanelKindAreaChart: func() any { return new(AreaChartPanelSpec) },- PanelKindNumber: func() any { return new(NumberPanelSpec) },- PanelKindPieChart: func() any { return new(PieChartPanelSpec) },- PanelKindTable: func() any { return new(TablePanelSpec) },- PanelKindHistogram: func() any { return new(HistogramPanelSpec) },- PanelKindList: func() any { return new(ListPanelSpec) },- PanelKindText: func() any { return new(TextPanelSpec) },- PanelKindHeatmap: func() any { return new(HeatmapPanelSpec) },+ PanelKindTimeSeries: func() any { return new(TimeSeriesPanelSpec) },+ PanelKindBarChart: func() any { return new(BarChartPanelSpec) },+ PanelKindAreaChart: func() any { return new(AreaChartPanelSpec) },+ PanelKindNumber: func() any { return new(NumberPanelSpec) },+ PanelKindPieChart: func() any { return new(PieChartPanelSpec) },+ PanelKindTable: func() any { return new(TablePanelSpec) },+ PanelKindHistogram: func() any { return new(HistogramPanelSpec) },+ PanelKindList: func() any { return new(ListPanelSpec) },+ PanelKindText: func() any { return new(TextPanelSpec) },+ PanelKindHeatmap: func() any { return new(HeatmapPanelSpec) },+ PanelKindScatterPlot: func() any { return new(ScatterPlotPanelSpec) },}queryPluginSpecs = map[QueryPluginKind]func() any{QueryKindBuilder: func() any { return new(BuilderQuerySpec) },@@ -260,16 +263,17 @@ var (VariableKindCustom: func() any { return new(CustomVariableSpec) },}allowedQueryKinds = map[PanelPluginKind][]QueryPluginKind{- PanelKindTimeSeries: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},- PanelKindBarChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},- PanelKindAreaChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},- PanelKindNumber: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},- PanelKindHistogram: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},- PanelKindPieChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},- PanelKindTable: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},- PanelKindList: {QueryKindBuilder, QueryKindAIBuilder},- PanelKindText: {},- PanelKindHeatmap: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindTimeSeries: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindBarChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindAreaChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindNumber: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindHistogram: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindPieChart: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},+ PanelKindTable: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},+ PanelKindList: {QueryKindBuilder, QueryKindAIBuilder},+ PanelKindText: {},+ PanelKindHeatmap: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL},+ PanelKindScatterPlot: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindClickHouseSQL},})diff --git a/pkg/types/dashboardtypes/perses_public_dashboard.go b/pkg/types/dashboardtypes/perses_public_dashboard.goindex 29e91f0b76..625b181b04 100644--- a/pkg/types/dashboardtypes/perses_public_dashboard.go+++ b/pkg/types/dashboardtypes/perses_public_dashboard.go@@ -221,7 +221,7 @@ func (d *DashboardV2) GetPanelQuery(startTime, endTime uint64, panelKey string)CompositeQuery: composite,FormatOptions: &qb.FormatOptions{FillGaps: fillGaps,- FormatTableResultForUI: panel.Spec.Plugin.Kind == PanelKindTable,+ FormatTableResultForUI: panel.Spec.Plugin.Kind == PanelKindTable || panel.Spec.Plugin.Kind == PanelKindScatterPlot,},}, nil}diff --git a/pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.go b/pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.goindex 66c1394340..df6ab0c6b1 100644--- a/pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.go+++ b/pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.go@@ -251,34 +251,38 @@ func TestDashboardV2GetPanelQuery(t *testing.T) {assert.Equal(t, telemetrytypes.SignalTraces, spec.Signal)})- t.Run("sets FormatTableResultForUI only for table panels", func(t *testing.T) {- dashboard := &DashboardV2{- Spec: DashboardSpec{- Panels: map[string]*Panel{- "panel-1": {- Spec: PanelSpec{- Plugin: PanelPlugin{Kind: PanelKindTable},- Queries: []Query{- {- Kind: qb.RequestTypeScalar,- Spec: QuerySpec{- Plugin: QueryPlugin{- Kind: QueryKindBuilder,- Spec: &BuilderQuerySpec{Spec: qb.QueryBuilderQuery[qb.MetricAggregation]{Name: "A"}},+ t.Run("sets FormatTableResultForUI for panels that join scalar rows", func(t *testing.T) {+ for _, kind := range []PanelPluginKind{PanelKindTable, PanelKindScatterPlot} {+ t.Run(string(kind), func(t *testing.T) {+ dashboard := &DashboardV2{+ Spec: DashboardSpec{+ Panels: map[string]*Panel{+ "panel-1": {+ Spec: PanelSpec{+ Plugin: PanelPlugin{Kind: kind},+ Queries: []Query{+ {+ Kind: qb.RequestTypeScalar,+ Spec: QuerySpec{+ Plugin: QueryPlugin{+ Kind: QueryKindBuilder,+ Spec: &BuilderQuerySpec{Spec: qb.QueryBuilderQuery[qb.MetricAggregation]{Name: "A"}},+ },+ },},},},},},},- },- },- }+ }- req, err := dashboard.GetPanelQuery(1, 2, "panel-1")- require.NoError(t, err)- require.NotNil(t, req.FormatOptions)- assert.True(t, req.FormatOptions.FormatTableResultForUI)+ req, err := dashboard.GetPanelQuery(1, 2, "panel-1")+ require.NoError(t, err)+ require.NotNil(t, req.FormatOptions)+ assert.True(t, req.FormatOptions.FormatTableResultForUI)+ })+ }})t.Run("sets FillGaps from the panel visualization", func(t *testing.T) {diff --git a/pkg/types/dashboardtypes/perses_signoz_plugins.go b/pkg/types/dashboardtypes/perses_signoz_plugins.goindex 3fe2f79912..5ede88fd72 100644--- a/pkg/types/dashboardtypes/perses_signoz_plugins.go+++ b/pkg/types/dashboardtypes/perses_signoz_plugins.go@@ -1,7 +1,10 @@package dashboardtypesimport (+ "bytes""encoding/json"+ "maps"+ "slices""strconv""github.com/SigNoz/signoz/pkg/errors"@@ -186,20 +189,21 @@ func (AIBuilderQuerySpec) PrepareJSONSchema(s *jsonschema.Schema) error {type PanelPluginKind stringconst (- PanelKindTimeSeries PanelPluginKind = "signoz/TimeSeriesPanel"- PanelKindBarChart PanelPluginKind = "signoz/BarChartPanel"- PanelKindAreaChart PanelPluginKind = "signoz/AreaChartPanel"- PanelKindNumber PanelPluginKind = "signoz/NumberPanel"- PanelKindPieChart PanelPluginKind = "signoz/PieChartPanel"- PanelKindTable PanelPluginKind = "signoz/TablePanel"- PanelKindHistogram PanelPluginKind = "signoz/HistogramPanel"- PanelKindList PanelPluginKind = "signoz/ListPanel"- PanelKindText PanelPluginKind = "signoz/TextPanel"- PanelKindHeatmap PanelPluginKind = "signoz/HeatmapPanel"+ PanelKindTimeSeries PanelPluginKind = "signoz/TimeSeriesPanel"+ PanelKindBarChart PanelPluginKind = "signoz/BarChartPanel"+ PanelKindAreaChart PanelPluginKind = "signoz/AreaChartPanel"+ PanelKindNumber PanelPluginKind = "signoz/NumberPanel"+ PanelKindPieChart PanelPluginKind = "signoz/PieChartPanel"+ PanelKindTable PanelPluginKind = "signoz/TablePanel"+ PanelKindHistogram PanelPluginKind = "signoz/HistogramPanel"+ PanelKindList PanelPluginKind = "signoz/ListPanel"+ PanelKindText PanelPluginKind = "signoz/TextPanel"+ PanelKindHeatmap PanelPluginKind = "signoz/HeatmapPanel"+ PanelKindScatterPlot PanelPluginKind = "signoz/ScatterPlotPanel")func (PanelPluginKind) Enum() []any {- return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindAreaChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList, PanelKindText, PanelKindHeatmap}+ return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindAreaChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList, PanelKindText, PanelKindHeatmap, PanelKindScatterPlot}}func (k PanelPluginKind) rendersWithoutQuery() bool {@@ -349,6 +353,148 @@ type TextPanelSpec struct {HeaderOptions HeaderOptions `json:"headerOptions" description:"Whether the panel header is shown."`}+type ScatterPlotPanelSpec struct {+ Visualization BasicVisualization `json:"visualization" description:"The time range the groups are computed over."`+ Dimensions ScatterPlotDimensions `json:"dimensions" description:"Which result columns place, size and color the dots. Each dot is one row of the joined scalar result: one group."`+ Formatting TableFormatting `json:"formatting" description:"Per-column units and decimal precision. The x and y columns' units label their axes; every bound column's unit shows in the tooltip."`+ Axes ScatterPlotAxes `json:"axes" description:"Title, bounds and scale of each axis."`+ ChartAppearance ScatterPlotChartAppearance `json:"chartAppearance" description:"Dot drawing options."`+ Legend Legend `json:"legend" description:"Legend placement and series colors. A series is one color group, labeled by its colorBy values joined with a comma, or All when nothing is grouped."`+ Thresholds []ScatterPlotThreshold `json:"thresholds" validate:"dive" description:"Reference lines drawn at fixed values across the x or y axis."`+}++func (s *ScatterPlotPanelSpec) validateAgainstQuery(query Query, path string) error {+ composite, err := query.Spec.Plugin.buildV5CompositeQueryFromPlugin()+ if err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s.dimensions: %s", path, err.Error())+ }+ keys, known := composite.CollectResultColumnKeys()+ if !known {+ return nil+ }+ if err := s.validateQueriesShareGroupBy(composite, path); err != nil {+ return err+ }+ if err := s.validateValueDimensions(keys, path); err != nil {+ return err+ }+ if err := s.validateColorDimensions(keys, path); err != nil {+ return err+ }+ return nil+}++// Order is ignored since rows join on sorted labels; disabled queries count, as formulas carry their keys.+func (*ScatterPlotPanelSpec) validateQueriesShareGroupBy(composite qb.CompositeQuery, path string) error {+ var queries []qb.QueryEnvelope+ for _, envelope := range composite.Queries {+ if envelope.GetType() != qb.QueryTypeFormula {+ queries = append(queries, envelope)+ }+ }+ for i := 1; i < len(queries); i++ {+ first, other := groupByKeyNames(queries[0]), groupByKeyNames(queries[i])+ if !slices.Equal(first, other) {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s: queries must group by the same keys so their rows join into dots; %q groups by [%s], %q groups by [%s]", path, queries[0].GetQueryName(), allowedValuesForKind(first), queries[i].GetQueryName(), allowedValuesForKind(other))+ }+ }+ return nil+}++func (s *ScatterPlotPanelSpec) validateValueDimensions(keys qb.ResultColumnKeys, path string) error {+ for _, binding := range []struct{ field, key string }{{"x", s.Dimensions.X}, {"y", s.Dimensions.Y}, {"sizeBy", s.Dimensions.SizeBy}} {+ // Empty is unset: the renderer picks a column or a fixed size.+ if binding.key == "" {+ continue+ }+ if _, ok := keys.Aggregations[binding.key]; !ok {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.dimensions.%s: %q is not a value column of the panel's query; value columns: %s", path, binding.field, binding.key, allowedValuesForKind(slices.Sorted(maps.Keys(keys.Aggregations))))+ }+ }+ return nil+}++func (s *ScatterPlotPanelSpec) validateColorDimensions(keys qb.ResultColumnKeys, path string) error {+ for _, label := range s.Dimensions.ColorBy {+ if _, ok := keys.Groups[label]; !ok {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.dimensions.colorBy: %q is not a group-by key of the panel's query; group-by keys: %s", path, label, allowedValuesForKind(slices.Sorted(maps.Keys(keys.Groups))))+ }+ }+ return nil+}++func groupByKeyNames(envelope qb.QueryEnvelope) []string {+ names := make([]string, 0, len(envelope.GetGroupBy()))+ for _, key := range envelope.GetGroupBy() {+ names = append(names, key.Name)+ }+ slices.Sort(names)+ return names+}++// ScatterPlotDimensions binds result columns to what a dot encodes. Value columns+// use the Table column key, so formatting.columnUnits carries over between the+// two kinds.+type ScatterPlotDimensions struct {+ X string `json:"x" description:"Value column key (queryName, or queryName.expression for a multi-aggregation query) plotted on the x axis. Empty, or a key the result lacks, uses the first value column."`+ Y string `json:"y" description:"Value column key plotted on the y axis. Empty, or a key the result lacks, uses the first value column x does not use."`+ SizeBy string `json:"sizeBy" description:"Value column key that scales each dot's area between chartAppearance.points.minSize and maxSize. Empty draws every dot at chartAppearance.points.size, as does a dot with no value."`+ ColorBy []string `json:"colorBy" description:"Group-by label names (e.g. k8s.namespace.name) whose combined values color the dots and drive the legend. Empty colors by every group-by label."`+}++type ScatterPlotAxes struct {+ X ScatterPlotAxis `json:"x" description:"The axis dimensions.x is plotted along."`+ Y ScatterPlotAxis `json:"y" description:"The axis dimensions.y is plotted along."`+}++type ScatterPlotAxis struct {+ SoftMin *float64 `json:"softMin" description:"The lowest value the axis always shows; data below it still extends the axis, as does a threshold on it. Null fits the data. A log axis ignores a bound at or below zero."`+ SoftMax *float64 `json:"softMax" description:"The highest value the axis always shows; data above it still extends the axis, as does a threshold on it. Null fits the data."`+ Scale AxisScale `json:"scale" description:"auto (default) uses log, or symlog when values include zero or negatives, when that spreads the dots clearly more than linear does; otherwise linear. log cannot place a value at or below zero and leaves that dot out; symlog is log-like but places it."`+ Label string `json:"label" description:"Axis title. Empty draws none; the tooltip still names the column."`+}++type ScatterPlotChartAppearance struct {+ Points ScatterPlotPoints `json:"points" description:"Dot size and opacity."`+}++// ScatterPlotPoints keeps the fixed size and the size range side by side so+// binding or unbinding dimensions.sizeBy restores the other's last setting. Nil+// fields resolve to the renderer default.+type ScatterPlotPoints struct {+ Size *PointDiameter `json:"size" description:"Diameter of every dot when dimensions.sizeBy is unset, in CSS pixels from 2 to 40. Null means 6."`+ MinSize *PointDiameter `json:"minSize" description:"Diameter of the smallest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 4."`+ MaxSize *PointDiameter `json:"maxSize" description:"Diameter of the largest dot when dimensions.sizeBy is set, in CSS pixels from 2 to 40. Null means 24."`+ Opacity *PointOpacity `json:"opacity" description:"Fill opacity of every dot, from 0.1 to 1. Null means 0.7."`+}++func (p *ScatterPlotPoints) UnmarshalJSON(data []byte) error {+ dec := json.NewDecoder(bytes.NewReader(data))+ dec.DisallowUnknownFields()+ type alias ScatterPlotPoints+ var tmp alias+ if err := dec.Decode(&tmp); err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid points")+ }+ *p = ScatterPlotPoints(tmp)+ return p.validate()+}++// Null bounds are compared at their renderer defaults, so one-sided settings can't invert the range.+func (p ScatterPlotPoints) validate() error {+ minSize, maxSize := defaultPointMinSize, defaultPointMaxSize+ if p.MinSize != nil {+ minSize = *p.MinSize+ }+ if p.MaxSize != nil {+ maxSize = *p.MaxSize+ }+ if minSize > maxSize {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid points: minSize %d must not exceed maxSize %d", minSize, maxSize)+ }+ return nil+}+type TextPresentation struct {TextAlign TextAlign `json:"textAlign" description:"Horizontal alignment: left (default), center or right."`VerticalAlign VerticalAlign `json:"verticalAlign" description:"Vertical alignment: top (default), center or bottom."`@@ -430,6 +576,11 @@ type ComparisonThreshold struct {Format ThresholdFormat `json:"format" description:"What the color is applied to: text (default) or background."`}+type ScatterPlotThreshold struct {+ ThresholdWithLabel+ Axis ThresholdAxis `json:"axis" description:"The axis the line marks: y (default) draws it horizontally, x vertically. Unit converts against that axis's column unit, and the axis extends to keep the line in view."`+}+type TableThreshold struct {ComparisonThresholdColumnName string `json:"columnName" validate:"required" required:"true" description:"The key of the value column the rule applies to: the query name for a builder query with one aggregation (A), the query name dotted with the aggregation expression for several (A.count()), or the SQL alias for a ClickHouse SQL column. Group-by columns are never colored, and aggregation aliases are display labels, not keys."`@@ -715,6 +866,86 @@ func (ls *LineStyle) UnmarshalJSON(data []byte) error {}}+// AxisScale `auto` leaves the choice to the renderer; `symlog` is log-like but+// defined at and below zero.+type AxisScale struct{ valuer.String }++var (+ AxisScaleAuto = AxisScale{valuer.NewString("auto")} // default+ AxisScaleLinear = AxisScale{valuer.NewString("linear")}+ AxisScaleLog = AxisScale{valuer.NewString("log")}+ AxisScaleSymlog = AxisScale{valuer.NewString("symlog")}+)++func (AxisScale) Enum() []any {+ return []any{AxisScaleAuto, AxisScaleLinear, AxisScaleLog, AxisScaleSymlog}+}++func (as AxisScale) ValueOrDefault() string {+ if as.IsZero() {+ return AxisScaleAuto.StringValue()+ }+ return as.StringValue()+}++func (as AxisScale) MarshalJSON() ([]byte, error) {+ return json.Marshal(as.ValueOrDefault())+}++func (as *AxisScale) UnmarshalJSON(data []byte) error {+ var v string+ if err := json.Unmarshal(data, &v); err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid axis scale: must be a string, one of `auto`, `linear`, `log`, or `symlog`")+ }+ val := AxisScale{valuer.NewString(v)}+ switch val {+ case AxisScaleAuto, AxisScaleLinear, AxisScaleLog, AxisScaleSymlog:+ *as = val+ return nil+ default:+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid axis scale %q: must be `auto`, `linear`, `log`, or `symlog`", v)+ }+}++// ThresholdAxis is the axis a scatter plot threshold line marks: `y` draws it+// horizontally, `x` vertically.+type ThresholdAxis struct{ valuer.String }++var (+ ThresholdAxisX = ThresholdAxis{valuer.NewString("x")}+ ThresholdAxisY = ThresholdAxis{valuer.NewString("y")} // default+)++func (ThresholdAxis) Enum() []any {+ return []any{ThresholdAxisX, ThresholdAxisY}+}++func (ta ThresholdAxis) ValueOrDefault() string {+ if ta.IsZero() {+ return ThresholdAxisY.StringValue()+ }+ return ta.StringValue()+}++func (ta ThresholdAxis) MarshalJSON() ([]byte, error) {+ return json.Marshal(ta.ValueOrDefault())+}++func (ta *ThresholdAxis) UnmarshalJSON(data []byte) error {+ var v string+ if err := json.Unmarshal(data, &v); err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid threshold axis: must be a string, one of `x` or `y`")+ }+ val := ThresholdAxis{valuer.NewString(v)}+ switch val {+ case ThresholdAxisX, ThresholdAxisY:+ *ta = val+ return nil+ default:+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid threshold axis %q: must be `x` or `y`", v)+ }+}+type FillMode struct{ valuer.String }var (@@ -853,6 +1084,56 @@ func (o *FillOpacity) UnmarshalJSON(data []byte) error {return nil}+const (+ minPointDiameter = 2+ maxPointDiameter = 40++ defaultPointMinSize PointDiameter = 4+ defaultPointMaxSize PointDiameter = 24+)++// PointDiameter is a scatter dot's diameter in whole CSS pixels.+type PointDiameter int++func (PointDiameter) PrepareJSONSchema(s *jsonschema.Schema) error {+ s.WithMinimum(minPointDiameter).WithMaximum(maxPointDiameter)+ return nil+}++func (d *PointDiameter) UnmarshalJSON(data []byte) error {+ var v int+ if err := json.Unmarshal(data, &v); err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid point diameter: must be a whole number between %d and %d", minPointDiameter, maxPointDiameter)+ }+ if v < minPointDiameter || v > maxPointDiameter {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid point diameter %d: must be a whole number between %d and %d", v, minPointDiameter, maxPointDiameter)+ }+ *d = PointDiameter(v)+ return nil+}++const minPointOpacity = 0.1++// PointOpacity is a scatter dot's fill alpha. The floor keeps a dot visible.+type PointOpacity float64++func (PointOpacity) PrepareJSONSchema(s *jsonschema.Schema) error {+ s.WithMinimum(minPointOpacity).WithMaximum(1)+ return nil+}++func (o *PointOpacity) UnmarshalJSON(data []byte) error {+ var v float64+ if err := json.Unmarshal(data, &v); err != nil {+ return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid point opacity: must be a number between %v and 1", minPointOpacity)+ }+ if v < minPointOpacity || v > 1 {+ return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid point opacity %v: must be between %v and 1", v, minPointOpacity)+ }+ *o = PointOpacity(v)+ return nil+}+type SpanGaps struct {FillOnlyBelow bool `json:"fillOnlyBelow" description:"Controls whether lines connect across null values. When false (default), all gaps are connected. When true, only gaps smaller than fillLessThan are connected."`FillLessThan string `json:"fillLessThan" description:"The largest gap still connected when fillOnlyBelow is true; longer gaps are left disconnected. Required in that case, as a positive Prometheus duration such as 30s, 5m or 1d."`@@ -1141,6 +1422,7 @@ func (p *HeatmapPalette) UnmarshalJSON(data []byte) error {}}+// todo(@namanv3): remove and use AxisScale everywhere.type HeatmapYScale struct{ valuer.String }var (diff --git a/pkg/types/dashboardtypes/testdata/perses_scatter_plot_panel.json b/pkg/types/dashboardtypes/testdata/perses_scatter_plot_panel.jsonnew file mode 100644index 0000000000..3c7c412084--- /dev/null+++ b/pkg/types/dashboardtypes/testdata/perses_scatter_plot_panel.json@@ -0,0 +1,134 @@+{+ "display": {+ "name": "service health",+ "description": "throughput against tail latency per pod"+ },+ "variables": [],+ "panels": {+ "p1": {+ "kind": "Panel",+ "spec": {+ "display": {+ "name": "throughput vs p99",+ "description": ""+ },+ "plugin": {+ "kind": "signoz/ScatterPlotPanel",+ "spec": {+ "visualization": {+ "timePreference": "last_1_hr"+ },+ "dimensions": {+ "x": "A.count()",+ "y": "A.p99(duration_nano)",+ "sizeBy": "A.countIf(has_error = true)",+ "colorBy": ["k8s.namespace.name", "k8s.pod.name"]+ },+ "formatting": {+ "columnUnits": {+ "A.p99(duration_nano)": "ns"+ },+ "decimalPrecision": "1"+ },+ "axes": {+ "x": {+ "softMin": 0,+ "softMax": null,+ "scale": "log",+ "label": "Throughput"+ },+ "y": {+ "softMin": null,+ "softMax": 1000,+ "scale": "symlog",+ "label": "p99 latency"+ }+ },+ "chartAppearance": {+ "points": {+ "size": 8,+ "minSize": 4,+ "maxSize": 24,+ "opacity": 0.1+ }+ },+ "legend": {+ "position": "right",+ "mode": "list",+ "customColors": {+ "checkout": "#1f77b4"+ }+ },+ "thresholds": [+ {+ "value": 300,+ "unit": "ms",+ "color": "#f00",+ "label": "p99 SLO",+ "axis": "y"+ },+ {+ "value": 50,+ "color": "#0f0",+ "axis": "x"+ }+ ]+ }+ },+ "links": [],+ "queries": [+ {+ "kind": "scalar",+ "spec": {+ "plugin": {+ "kind": "signoz/BuilderQuery",+ "spec": {+ "name": "A",+ "signal": "traces",+ "aggregations": [+ {+ "expression": "count()"+ },+ {+ "expression": "p99(duration_nano)"+ },+ {+ "expression": "countIf(has_error = true)"+ }+ ],+ "groupBy": [+ {+ "name": "k8s.namespace.name"+ },+ {+ "name": "k8s.pod.name"+ }+ ]+ }+ }+ }+ }+ ]+ }+ }+ },+ "links": [],+ "layouts": [+ {+ "kind": "Grid",+ "spec": {+ "items": [+ {+ "x": 0,+ "y": 0,+ "width": 12,+ "height": 8,+ "content": {+ "$ref": "#/spec/panels/p1"+ }+ }+ ]+ }+ }+ ]+}diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/req.go b/pkg/types/querybuildertypes/querybuildertypesv5/req.goindex c79f7ca735..bd2833658b 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/req.go+++ b/pkg/types/querybuildertypes/querybuildertypesv5/req.go@@ -263,6 +263,48 @@ type CompositeQuery struct {Queries []QueryEnvelope `json:"queries" description:"The queries to run, each wrapped in a type-discriminated envelope. Names must be unique; formulas and trace operators reference other queries by name."`}+// ResultColumnKeys is what a scalar query yields per row, keyed the way the+// UI keys columns: an aggregation column is the query name, or+// queryName.expression when the query has several aggregations; a group+// column is a group-by key name.+type ResultColumnKeys struct {+ Aggregations map[string]struct{}+ Groups map[string]struct{}+}++// CollectResultColumnKeys reports false when a query's columns are only known+// at run time, as for ClickHouse SQL and PromQL. A disabled query yields no+// aggregation column but keeps its group columns, since a formula over it+// still carries them.+func (c *CompositeQuery) CollectResultColumnKeys() (ResultColumnKeys, bool) {+ keys := ResultColumnKeys{Aggregations: map[string]struct{}{}, Groups: map[string]struct{}{}}+ for _, envelope := range c.Queries {+ if envelope.GetType() == QueryTypeClickHouseSQL || envelope.GetType() == QueryTypePromQL {+ return ResultColumnKeys{}, false+ }+ for _, key := range envelope.GetGroupBy() {+ keys.Groups[key.Name] = struct{}{}+ }+ if envelope.IsDisabled() {+ continue+ }+ expressions := envelope.GetAggregationExpressions()+ if len(expressions) <= 1 {+ keys.Aggregations[envelope.GetQueryName()] = struct{}{}+ continue+ }+ for _, expression := range expressions {+ // Metric aggregations have no expression and are keyed by the query name alone.+ if expression == "" {+ keys.Aggregations[envelope.GetQueryName()] = struct{}{}+ continue+ }+ keys.Aggregations[envelope.GetQueryName()+"."+expression] = struct{}{}+ }+ }+ return keys, true+}+// PrepareJSONSchema adds description to the CompositeQuery schema.func (c *CompositeQuery) PrepareJSONSchema(schema *jsonschema.Schema) error {schema.WithDescription("Composite query containing one or more query envelopes. Each query envelope specifies its type and corresponding spec.")diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/req_getters.go b/pkg/types/querybuildertypes/querybuildertypesv5/req_getters.goindex 90b54dae15..136c3f7e88 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/req_getters.go+++ b/pkg/types/querybuildertypes/querybuildertypesv5/req_getters.go@@ -225,6 +225,34 @@ func (q *QueryEnvelope) GetGroupBy() []GroupByKey {return nil}+// GetAggregationExpressions returns one entry per aggregation. A metric+// aggregation has no expression, so it contributes an empty entry.+func (q *QueryEnvelope) GetAggregationExpressions() []string {+ switch spec := q.Spec.(type) {+ case QueryBuilderTraceOperator:+ expressions := make([]string, len(spec.Aggregations))+ for i, aggregation := range spec.Aggregations {+ expressions[i] = aggregation.Expression+ }+ return expressions+ case QueryBuilderQuery[TraceAggregation]:+ expressions := make([]string, len(spec.Aggregations))+ for i, aggregation := range spec.Aggregations {+ expressions[i] = aggregation.Expression+ }+ return expressions+ case QueryBuilderQuery[LogAggregation]:+ expressions := make([]string, len(spec.Aggregations))+ for i, aggregation := range spec.Aggregations {+ expressions[i] = aggregation.Expression+ }+ return expressions+ case QueryBuilderQuery[MetricAggregation]:+ return make([]string, len(spec.Aggregations))+ }+ return nil+}+// GetFilter returns the filter.func (q *QueryEnvelope) GetFilter() *Filter {switch spec := q.Spec.(type) {diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/req_test.go b/pkg/types/querybuildertypes/querybuildertypesv5/req_test.goindex cfe06f2f53..931f6ed497 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/req_test.go+++ b/pkg/types/querybuildertypes/querybuildertypesv5/req_test.go@@ -1903,3 +1903,72 @@ func TestQueryRangeRequest_StepIntervalForQuery(t *testing.T) {})}}++func TestCompositeQueryCollectResultColumnKeys(t *testing.T) {+ testCases := []struct {+ name string+ composite CompositeQuery+ expectedKeys ResultColumnKeys+ expectedKnown bool+ }{+ {+ name: "SingleAggregation_KeyedByQueryName",+ composite: CompositeQuery{Queries: []QueryEnvelope{{Type: QueryTypeBuilder, Spec: QueryBuilderQuery[TraceAggregation]{+ Name: "A",+ Aggregations: []TraceAggregation{{Expression: "count()"}},+ GroupBy: []GroupByKey{{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "service.name"}}},+ }}}},+ expectedKeys: ResultColumnKeys{Aggregations: map[string]struct{}{"A": {}}, Groups: map[string]struct{}{"service.name": {}}},+ expectedKnown: true,+ },+ {+ name: "SeveralAggregations_KeyedByQueryNameAndExpression",+ composite: CompositeQuery{Queries: []QueryEnvelope{{Type: QueryTypeBuilder, Spec: QueryBuilderQuery[LogAggregation]{+ Name: "A",+ Aggregations: []LogAggregation{{Expression: "count()"}, {Expression: "p99(duration_nano)"}},+ }}}},+ expectedKeys: ResultColumnKeys{Aggregations: map[string]struct{}{"A.count()": {}, "A.p99(duration_nano)": {}}, Groups: map[string]struct{}{}},+ expectedKnown: true,+ },+ {+ name: "SeveralMetricAggregations_KeyedByQueryName",+ composite: CompositeQuery{Queries: []QueryEnvelope{{Type: QueryTypeBuilder, Spec: QueryBuilderQuery[MetricAggregation]{+ Name: "A",+ Aggregations: []MetricAggregation{{MetricName: "http.server.request.count"}, {MetricName: "http.server.request.duration"}},+ }}}},+ expectedKeys: ResultColumnKeys{Aggregations: map[string]struct{}{"A": {}}, Groups: map[string]struct{}{}},+ expectedKnown: true,+ },+ {+ name: "DisabledQuery_NoAggregation_GroupsKeptForFormula",+ composite: CompositeQuery{Queries: []QueryEnvelope{+ {Type: QueryTypeBuilder, Spec: QueryBuilderQuery[MetricAggregation]{+ Name: "A",+ Disabled: true,+ Aggregations: []MetricAggregation{{MetricName: "http.server.request.count"}},+ GroupBy: []GroupByKey{{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "service.name"}}},+ }},+ {Type: QueryTypeFormula, Spec: QueryBuilderFormula{Name: "F1", Expression: "A * 2"}},+ }},+ expectedKeys: ResultColumnKeys{Aggregations: map[string]struct{}{"F1": {}}, Groups: map[string]struct{}{"service.name": {}}},+ expectedKnown: true,+ },+ {+ name: "ClickHouseQuery_ColumnsUnknownUntilRunTime",+ composite: CompositeQuery{Queries: []QueryEnvelope{{Type: QueryTypeClickHouseSQL, Spec: ClickHouseQuery{+ Name: "A",+ Query: "SELECT 1",+ }}}},+ expectedKeys: ResultColumnKeys{},+ expectedKnown: false,+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ keys, known := testCase.composite.CollectResultColumnKeys()+ assert.Equal(t, testCase.expectedKnown, known)+ assert.Equal(t, testCase.expectedKeys, keys)+ })+ }+}