chore: added disk usage

frontend/__mocks__/uplotMock.ts

@@ -12,8 +12,6 @@ export interface MockUPlotInstance {
 export interface MockUPlotPaths {
 	spline: jest.Mock;
 	bars: jest.Mock;
-	linear: jest.Mock;
-	stepped: jest.Mock;
 }
 
 // Create mock instance methods
@@ -25,20 +23,10 @@ const createMockUPlotInstance = (): MockUPlotInstance => ({
 	setSeries: jest.fn(),
 });
 
-// Path builder: (self, seriesIdx, idx0, idx1) => paths or null
-const createMockPathBuilder = (): jest.Mock =>
-	jest.fn(() => ({
-		stroke: jest.fn(),
-		fill: jest.fn(),
-		clip: jest.fn(),
-	}));
-
-// Create mock paths - linear, spline, stepped needed by UPlotSeriesBuilder.getPathBuilder
-const mockPaths = {
-	spline: jest.fn(() => createMockPathBuilder()),
-	bars: jest.fn(() => createMockPathBuilder()),
-	linear: jest.fn(() => createMockPathBuilder()),
-	stepped: jest.fn((opts?: { align?: number }) => createMockPathBuilder()),
+// Create mock paths
+const mockPaths: MockUPlotPaths = {
+	spline: jest.fn(),
+	bars: jest.fn(),
 };
 
 // Mock static methods

frontend/src/api/infraMonitoring/getHostLists.ts

@@ -39,6 +39,7 @@ export interface HostData {
 	waitTimeSeries: TimeSeries;
 	load15: number;
 	load15TimeSeries: TimeSeries;
+	filesystem: number;
 }
 
 export interface HostListResponse {

frontend/src/components/HostMetricsDetail/HostMetricsDetail.styles.scss

@@ -48,7 +48,7 @@
 			.labels-row,
 			.values-row {
 				display: grid;
-				grid-template-columns: 1fr 1.5fr 1.5fr 1.5fr;
+				grid-template-columns: 1fr 1.5fr 1.5fr 1.5fr 1.5fr;
 				gap: 30px;
 				align-items: center;
 			}

frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx

@@ -426,6 +426,12 @@ function HostMetricsDetails({
 								>
 									MEMORY USAGE
 								</Typography.Text>
+								<Typography.Text
+									type="secondary"
+									className="host-details-metadata-label"
+								>
+									DISK USAGE
+								</Typography.Text>
 							</div>
 
 							<div className="values-row">
@@ -478,6 +484,23 @@ function HostMetricsDetails({
 										className="progress-bar"
 									/>
 								</div>
+								<div className="progress-container">
+									<Progress
+										percent={Number((host.filesystem * 100).toFixed(1))}
+										size="small"
+										strokeColor={((): string => {
+											const filesystemPercent = Number((host.filesystem * 100).toFixed(1));
+											if (filesystemPercent >= 90) {
+												return Color.BG_CHERRY_500;
+											}
+											if (filesystemPercent >= 60) {
+												return Color.BG_AMBER_500;
+											}
+											return Color.BG_FOREST_500;
+										})()}
+										className="progress-bar"
+									/>
+								</div>
 							</div>
 						</div>
 					</div>

frontend/src/container/InfraMonitoringHosts/utils.tsx

@@ -27,6 +27,7 @@ export interface HostRowData {
 	hostName: string;
 	cpu: React.ReactNode;
 	memory: React.ReactNode;
+	filesystem: React.ReactNode;
 	wait: string;
 	load15: number;
 	active: React.ReactNode;
@@ -108,6 +109,14 @@ export const getHostsListColumns = (): ColumnType<HostRowData>[] => [
 		sorter: true,
 		align: 'right',
 	},
+	{
+		title: <div className="column-header-right">Disk Usage</div>,
+		dataIndex: 'filesystem',
+		key: 'filesystem',
+		width: 100,
+		sorter: true,
+		align: 'right',
+	},
 	{
 		title: <div className="column-header-right">IOWait</div>,
 		dataIndex: 'wait',
@@ -178,6 +187,26 @@ export const formatDataForTable = (data: HostData[]): HostRowData[] =>
 				/>
 			</div>
 		),
+		filesystem: (
+			<div className="progress-container">
+				<Progress
+					percent={Number((host.filesystem * 100).toFixed(1))}
+					strokeLinecap="butt"
+					size="small"
+					strokeColor={((): string => {
+						const filesystemPercent = Number((host.filesystem * 100).toFixed(1));
+						if (filesystemPercent >= 90) {
+							return Color.BG_CHERRY_500;
+						}
+						if (filesystemPercent >= 60) {
+							return Color.BG_AMBER_500;
+						}
+						return Color.BG_FOREST_500;
+					})()}
+					className="progress-bar"
+				/>
+			</div>
+		),
 		wait: `${Number((host.wait * 100).toFixed(1))}%`,
 		load15: host.load15,
 	}));

frontend/src/container/LogDetailedView/InfraMetrics/constants.ts

@@ -1623,6 +1623,9 @@ export const getHostQueryPayload = (
 	const diskPendingKey = dotMetricsEnabled
 		? 'system.disk.pending_operations'
 		: 'system_disk_pending_operations';
+	const fsUsageKey = dotMetricsEnabled
+		? 'system.filesystem.usage'
+		: 'system_filesystem_usage';
 
 	return [
 		{
@@ -2558,6 +2561,143 @@ export const getHostQueryPayload = (
 			start,
 			end,
 		},
+		{
+			selectedTime: 'GLOBAL_TIME',
+			graphType: PANEL_TYPES.TIME_SERIES,
+			query: {
+				builder: {
+					queryData: [
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'system_filesystem_usage--float64--Gauge--true',
+
+								key: fsUsageKey,
+								type: 'Gauge',
+							},
+							aggregateOperator: 'avg',
+							dataSource: DataSource.METRICS,
+							disabled: true,
+							expression: 'A',
+							filters: {
+								items: [
+									{
+										id: 'fs_f1',
+										key: {
+											dataType: DataTypes.String,
+											id: 'host_name--string--tag--false',
+
+											key: hostNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: hostName,
+									},
+									{
+										id: 'fs_f2',
+										key: {
+											dataType: DataTypes.String,
+											id: 'state--string--tag--false',
+
+											key: 'state',
+											type: 'tag',
+										},
+										op: '=',
+										value: 'used',
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [
+								{
+									dataType: DataTypes.String,
+									id: 'mountpoint--string--tag--false',
+
+									key: 'mountpoint',
+									type: 'tag',
+								},
+							],
+							having: [],
+							legend: '{{mountpoint}}',
+							limit: null,
+							orderBy: [],
+							queryName: 'A',
+							reduceTo: ReduceOperators.AVG,
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'avg',
+						},
+						{
+							aggregateAttribute: {
+								dataType: DataTypes.Float64,
+								id: 'system_filesystem_usage--float64--Gauge--true',
+
+								key: fsUsageKey,
+								type: 'Gauge',
+							},
+							aggregateOperator: 'avg',
+							dataSource: DataSource.METRICS,
+							disabled: true,
+							expression: 'B',
+							filters: {
+								items: [
+									{
+										id: 'fs_f3',
+										key: {
+											dataType: DataTypes.String,
+											id: 'host_name--string--tag--false',
+
+											key: hostNameKey,
+											type: 'tag',
+										},
+										op: '=',
+										value: hostName,
+									},
+								],
+								op: 'AND',
+							},
+							functions: [],
+							groupBy: [
+								{
+									dataType: DataTypes.String,
+									id: 'mountpoint--string--tag--false',
+
+									key: 'mountpoint',
+									type: 'tag',
+								},
+							],
+							having: [],
+							legend: '{{mountpoint}}',
+							limit: null,
+							orderBy: [],
+							queryName: 'B',
+							reduceTo: ReduceOperators.AVG,
+							spaceAggregation: 'sum',
+							stepInterval: 60,
+							timeAggregation: 'avg',
+						},
+					],
+					queryFormulas: [
+						{
+							disabled: false,
+							expression: 'A/B',
+							legend: '{{mountpoint}}',
+							queryName: 'F1',
+						},
+					],
+					queryTraceOperator: [],
+				},
+				clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
+				id: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
+				promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
+				queryType: EQueryType.QUERY_BUILDER,
+			},
+			variables: {},
+			formatForWeb: false,
+			start,
+			end,
+		},
 	];
 };
 
@@ -2632,5 +2772,5 @@ export const hostWidgetInfo = [
 	{ title: 'System disk io (bytes transferred)', yAxisUnit: 'bytes' },
 	{ title: 'System disk operations/s', yAxisUnit: 'short' },
 	{ title: 'Queue size', yAxisUnit: 'short' },
-	{ title: 'Disk operations time', yAxisUnit: 's' },
+	{ title: 'Disk Usage', yAxisUnit: 'percentunit' },
 ];

frontend/src/lib/uPlotV2/config/__tests__/UPlotAxisBuilder.test.ts

@@ -1,356 +0,0 @@
-import { getToolTipValue } from 'components/Graph/yAxisConfig';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { uPlotXAxisValuesFormat } from 'lib/uPlotLib/utils/constants';
-import getGridColor from 'lib/uPlotLib/utils/getGridColor';
-import type uPlot from 'uplot';
-
-import type { AxisProps } from '../types';
-import { UPlotAxisBuilder } from '../UPlotAxisBuilder';
-
-jest.mock('components/Graph/yAxisConfig', () => ({
-	getToolTipValue: jest.fn(),
-}));
-
-const createAxisProps = (overrides: Partial<AxisProps> = {}): AxisProps => ({
-	scaleKey: 'x',
-	label: 'Time',
-	isDarkMode: false,
-	show: true,
-	...overrides,
-});
-
-describe('UPlotAxisBuilder', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('builds basic axis config with defaults', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-				label: 'Time',
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.scale).toBe('x');
-		expect(config.label).toBe('Time');
-		expect(config.show).toBe(true);
-		expect(config.side).toBe(2);
-		expect(config.gap).toBe(5);
-
-		// Default grid and ticks are created
-		expect(config.grid).toEqual({
-			stroke: getGridColor(false),
-			width: 0.2,
-			show: true,
-		});
-		expect(config.ticks).toEqual({
-			width: 0.3,
-			show: true,
-		});
-	});
-
-	it('merges custom grid config over defaults and respects isDarkMode and isLogScale', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				isDarkMode: true,
-				isLogScale: true,
-				grid: {
-					width: 1,
-				},
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.grid).toEqual({
-			// stroke falls back to theme-based default when not provided
-			stroke: getGridColor(true),
-			// provided width overrides default
-			width: 1,
-			// show falls back to default when not provided
-			show: true,
-		});
-	});
-
-	it('uses provided ticks config when present and falls back to defaults otherwise', () => {
-		const customTicks = { width: 1, show: false };
-		const withTicks = new UPlotAxisBuilder(
-			createAxisProps({
-				ticks: customTicks,
-			}),
-		);
-		const withoutTicks = new UPlotAxisBuilder(createAxisProps());
-
-		expect(withTicks.getConfig().ticks).toBe(customTicks);
-		expect(withoutTicks.getConfig().ticks).toEqual({
-			width: 0.3,
-			show: true,
-		});
-	});
-
-	it('uses time-based X-axis values formatter for time-series like panels', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-				panelType: PANEL_TYPES.TIME_SERIES,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.values).toBe(uPlotXAxisValuesFormat);
-	});
-
-	it('does not attach X-axis datetime formatter when panel type is not supported', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-				panelType: PANEL_TYPES.LIST, // not in PANEL_TYPES_WITH_X_AXIS_DATETIME_FORMAT
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.values).toBeUndefined();
-	});
-
-	it('builds Y-axis values formatter that delegates to getToolTipValue', () => {
-		const yBuilder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'y',
-				yAxisUnit: 'ms',
-				decimalPrecision: 3,
-			}),
-		);
-
-		const config = yBuilder.getConfig();
-		expect(typeof config.values).toBe('function');
-
-		(getToolTipValue as jest.Mock).mockImplementation(
-			(value: string, unit?: string, precision?: unknown) =>
-				`formatted:${value}:${unit}:${precision}`,
-		);
-
-		// Simulate uPlot calling the values formatter
-		const valuesFn = (config.values as unknown) as (
-			self: uPlot,
-			vals: unknown[],
-		) => string[];
-		const result = valuesFn({} as uPlot, [1, null, 2, Number.NaN]);
-
-		expect(getToolTipValue).toHaveBeenCalledTimes(2);
-		expect(getToolTipValue).toHaveBeenNthCalledWith(1, '1', 'ms', 3);
-		expect(getToolTipValue).toHaveBeenNthCalledWith(2, '2', 'ms', 3);
-
-		// Null/NaN values should map to empty strings
-		expect(result).toEqual(['formatted:1:ms:3', '', 'formatted:2:ms:3', '']);
-	});
-
-	it('adds dynamic size calculator only for Y-axis when size is not provided', () => {
-		const yBuilder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'y',
-			}),
-		);
-		const xBuilder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-			}),
-		);
-
-		const yConfig = yBuilder.getConfig();
-		const xConfig = xBuilder.getConfig();
-
-		expect(typeof yConfig.size).toBe('function');
-		expect(xConfig.size).toBeUndefined();
-	});
-
-	it('uses explicit size function when provided', () => {
-		const sizeFn: uPlot.Axis.Size = jest.fn(() => 100) as uPlot.Axis.Size;
-
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'y',
-				size: sizeFn,
-			}),
-		);
-
-		const config = builder.getConfig();
-		expect(config.size).toBe(sizeFn);
-	});
-
-	it('builds stroke color based on stroke and isDarkMode', () => {
-		const explicitStroke = new UPlotAxisBuilder(
-			createAxisProps({
-				stroke: '#ff0000',
-			}),
-		);
-		const darkStroke = new UPlotAxisBuilder(
-			createAxisProps({
-				stroke: undefined,
-				isDarkMode: true,
-			}),
-		);
-		const lightStroke = new UPlotAxisBuilder(
-			createAxisProps({
-				stroke: undefined,
-				isDarkMode: false,
-			}),
-		);
-
-		expect(explicitStroke.getConfig().stroke).toBe('#ff0000');
-		expect(darkStroke.getConfig().stroke).toBe('white');
-		expect(lightStroke.getConfig().stroke).toBe('black');
-	});
-
-	it('uses explicit values formatter when provided', () => {
-		const customValues: uPlot.Axis.Values = jest.fn(() => ['a', 'b', 'c']);
-
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'y',
-				values: customValues,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.values).toBe(customValues);
-	});
-
-	it('returns undefined values for scaleKey neither x nor y', () => {
-		const builder = new UPlotAxisBuilder(createAxisProps({ scaleKey: 'custom' }));
-
-		const config = builder.getConfig();
-
-		expect(config.values).toBeUndefined();
-	});
-
-	it('omits stroke when stroke and isDarkMode are both undefined', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'custom',
-				stroke: undefined,
-				isDarkMode: undefined,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.stroke).toBeUndefined();
-	});
-
-	it('includes space in config when provided', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({ scaleKey: 'y', space: 50 }),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.space).toBe(50);
-	});
-
-	it('includes PANEL_TYPES.BAR and PANEL_TYPES.PIE in X-axis datetime formatter', () => {
-		const barBuilder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-				panelType: PANEL_TYPES.BAR,
-			}),
-		);
-		const pieBuilder = new UPlotAxisBuilder(
-			createAxisProps({
-				scaleKey: 'x',
-				panelType: PANEL_TYPES.PIE,
-			}),
-		);
-
-		expect(barBuilder.getConfig().values).toBe(uPlotXAxisValuesFormat);
-		expect(pieBuilder.getConfig().values).toBe(uPlotXAxisValuesFormat);
-	});
-
-	it('invokes Y-axis size calculator and delegates to getExistingAxisSize when cycleNum > 1', () => {
-		const builder = new UPlotAxisBuilder(createAxisProps({ scaleKey: 'y' }));
-
-		const config = builder.getConfig();
-		const sizeFn = config.size;
-		expect(typeof sizeFn).toBe('function');
-
-		const mockAxis = {
-			_size: 80,
-			ticks: { size: 10 },
-			font: ['12px sans-serif'],
-		};
-		const mockSelf = ({
-			axes: [mockAxis],
-			ctx: { measureText: jest.fn(() => ({ width: 60 })), font: '' },
-		} as unknown) as uPlot;
-
-		const result = (sizeFn as (
-			s: uPlot,
-			v: string[],
-			a: number,
-			c: number,
-		) => number)(
-			mockSelf,
-			['100', '200'],
-			0,
-			2, // cycleNum > 1
-		);
-
-		expect(result).toBe(80);
-	});
-
-	it('invokes Y-axis size calculator and computes from text width when cycleNum <= 1', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({ scaleKey: 'y', gap: 8 }),
-		);
-
-		const config = builder.getConfig();
-		const sizeFn = config.size;
-		expect(typeof sizeFn).toBe('function');
-
-		const mockAxis = {
-			ticks: { size: 12 },
-			font: ['12px sans-serif'],
-		};
-		const measureText = jest.fn(() => ({ width: 48 }));
-		const mockSelf = ({
-			axes: [mockAxis],
-			ctx: {
-				measureText,
-				get font() {
-					return '';
-				},
-				set font(_v: string) {
-					/* noop */
-				},
-			},
-		} as unknown) as uPlot;
-
-		const result = (sizeFn as (
-			s: uPlot,
-			v: string[],
-			a: number,
-			c: number,
-		) => number)(mockSelf, ['10', '2000ms'], 0, 0);
-
-		expect(measureText).toHaveBeenCalledWith('2000ms');
-		expect(result).toBeGreaterThanOrEqual(12 + 8);
-	});
-
-	it('merge updates axis props', () => {
-		const builder = new UPlotAxisBuilder(
-			createAxisProps({ scaleKey: 'y', label: 'Original' }),
-		);
-
-		builder.merge({ label: 'Merged', yAxisUnit: 'bytes' });
-
-		const config = builder.getConfig();
-
-		expect(config.label).toBe('Merged');
-		expect(config.values).toBeDefined();
-	});
-});

frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.ts

@@ -1,331 +0,0 @@
-import uPlot from 'uplot';
-
-import type { SeriesProps } from '../types';
-import { DrawStyle, SelectionPreferencesSource } from '../types';
-import { UPlotConfigBuilder } from '../UPlotConfigBuilder';
-
-// Mock only the real boundary that hits localStorage
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-	}),
-);
-
-const getStoredSeriesVisibilityMock = jest.requireMock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-) as {
-	getStoredSeriesVisibility: jest.Mock;
-};
-
-describe('UPlotConfigBuilder', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	const createSeriesProps = (
-		overrides: Partial<SeriesProps> = {},
-	): SeriesProps => ({
-		scaleKey: 'y',
-		label: 'Requests',
-		colorMapping: {},
-		drawStyle: DrawStyle.Line,
-		...overrides,
-	});
-
-	it('returns correct save selection preference flag from constructor args', () => {
-		const builder = new UPlotConfigBuilder({
-			shouldSaveSelectionPreference: true,
-		});
-
-		expect(builder.getShouldSaveSelectionPreference()).toBe(true);
-	});
-
-	it('returns widgetId from constructor args', () => {
-		const builder = new UPlotConfigBuilder({ widgetId: 'widget-123' });
-
-		expect(builder.getWidgetId()).toBe('widget-123');
-	});
-
-	it('sets tzDate from constructor and includes it in config', () => {
-		const tzDate = (ts: number): Date => new Date(ts);
-		const builder = new UPlotConfigBuilder({ tzDate });
-
-		const config = builder.getConfig();
-
-		expect(config.tzDate).toBe(tzDate);
-	});
-
-	it('does not call onDragSelect for click without drag (width === 0)', () => {
-		const onDragSelect = jest.fn();
-		const builder = new UPlotConfigBuilder({ onDragSelect });
-
-		const config = builder.getConfig();
-		const setSelectHooks = config.hooks?.setSelect ?? [];
-		expect(setSelectHooks.length).toBe(1);
-
-		const uplotInstance = ({
-			select: { left: 10, width: 0 },
-			posToVal: jest.fn(),
-		} as unknown) as uPlot;
-
-		// Simulate uPlot calling the hook
-		const setSelectHook = setSelectHooks[0];
-		expect(setSelectHook).toBeDefined();
-		if (!setSelectHook) {
-			throw new Error('Expected setSelect hook to be registered');
-		}
-		setSelectHook(uplotInstance);
-
-		expect(onDragSelect).not.toHaveBeenCalled();
-	});
-
-	it('calls onDragSelect with start and end times in milliseconds for a drag selection', () => {
-		const onDragSelect = jest.fn();
-		const builder = new UPlotConfigBuilder({ onDragSelect });
-
-		const config = builder.getConfig();
-		const setSelectHooks = config.hooks?.setSelect ?? [];
-		expect(setSelectHooks.length).toBe(1);
-
-		const posToVal = jest
-			.fn()
-			// left position
-			.mockReturnValueOnce(100)
-			// left + width
-			.mockReturnValueOnce(110);
-
-		const uplotInstance = ({
-			select: { left: 50, width: 20 },
-			posToVal,
-		} as unknown) as uPlot;
-
-		const setSelectHook = setSelectHooks[0];
-		expect(setSelectHook).toBeDefined();
-		if (!setSelectHook) {
-			throw new Error('Expected setSelect hook to be registered');
-		}
-		setSelectHook(uplotInstance);
-
-		expect(onDragSelect).toHaveBeenCalledTimes(1);
-		// 100 and 110 seconds converted to milliseconds
-		expect(onDragSelect).toHaveBeenCalledWith(100_000, 110_000);
-	});
-
-	it('adds and removes hooks via addHook, and exposes them through getConfig', () => {
-		const builder = new UPlotConfigBuilder();
-		const drawHook = jest.fn();
-
-		const remove = builder.addHook('draw', drawHook as uPlot.Hooks.Defs['draw']);
-
-		let config = builder.getConfig();
-		expect(config.hooks?.draw).toContain(drawHook);
-
-		// Remove and ensure it no longer appears in config
-		remove();
-		config = builder.getConfig();
-		expect(config.hooks?.draw ?? []).not.toContain(drawHook);
-	});
-
-	it('adds axes, scales, and series and wires them into the final config', () => {
-		const builder = new UPlotConfigBuilder();
-
-		// Add axis and scale
-		builder.addAxis({ scaleKey: 'y', label: 'Requests' });
-		builder.addScale({ scaleKey: 'y' });
-
-		// Add two series – legend indices should start from 1 (0 is the timestamp series)
-		builder.addSeries(createSeriesProps({ label: 'Requests' }));
-		builder.addSeries(createSeriesProps({ label: 'Errors' }));
-
-		const config = builder.getConfig();
-
-		// Axes
-		expect(config.axes).toHaveLength(1);
-		expect(config.axes?.[0].scale).toBe('y');
-
-		// Scales are returned as an object keyed by scaleKey
-		expect(config.scales).toBeDefined();
-		expect(Object.keys(config.scales ?? {})).toContain('y');
-
-		// Series: base timestamp + 2 data series
-		expect(config.series).toHaveLength(3);
-		// Base series (index 0) has a value formatter that returns empty string
-		const baseSeries = config.series?.[0] as { value?: () => string };
-		expect(typeof baseSeries?.value).toBe('function');
-		expect(baseSeries?.value?.()).toBe('');
-
-		// Legend items align with series and carry label and color from series config
-		const legendItems = builder.getLegendItems();
-		expect(Object.keys(legendItems)).toEqual(['1', '2']);
-		expect(legendItems[1].seriesIndex).toBe(1);
-		expect(legendItems[1].label).toBe('Requests');
-		expect(legendItems[2].label).toBe('Errors');
-	});
-
-	it('merges axis when addAxis is called twice with same scaleKey', () => {
-		const builder = new UPlotConfigBuilder();
-
-		builder.addAxis({ scaleKey: 'y', label: 'Requests' });
-		builder.addAxis({ scaleKey: 'y', label: 'Updated Label', show: false });
-
-		const config = builder.getConfig();
-
-		expect(config.axes).toHaveLength(1);
-		expect(config.axes?.[0].label).toBe('Updated Label');
-		expect(config.axes?.[0].show).toBe(false);
-	});
-
-	it('merges scale when addScale is called twice with same scaleKey', () => {
-		const builder = new UPlotConfigBuilder();
-
-		builder.addScale({ scaleKey: 'y', min: 0 });
-		builder.addScale({ scaleKey: 'y', max: 100 });
-
-		const config = builder.getConfig();
-
-		// Only one scale entry for 'y' (merge path used, no duplicate added)
-		expect(config.scales).toBeDefined();
-		expect(Object.keys(config.scales ?? {})).toEqual(['y']);
-		expect(config.scales?.y?.range).toBeDefined();
-	});
-
-	it('restores visibility state from localStorage when selectionPreferencesSource is LOCAL_STORAGE', () => {
-		const visibilityMap = new Map<string, boolean>([
-			['Requests', true],
-			['Errors', false],
-		]);
-
-		getStoredSeriesVisibilityMock.getStoredSeriesVisibility.mockReturnValue(
-			visibilityMap,
-		);
-
-		const builder = new UPlotConfigBuilder({
-			widgetId: 'widget-1',
-			selectionPreferencesSource: SelectionPreferencesSource.LOCAL_STORAGE,
-		});
-
-		builder.addSeries(createSeriesProps({ label: 'Requests' }));
-		builder.addSeries(createSeriesProps({ label: 'Errors' }));
-
-		const legendItems = builder.getLegendItems();
-
-		// When any series is hidden, legend visibility is driven by the stored map
-		expect(legendItems[1].show).toBe(true);
-		expect(legendItems[2].show).toBe(false);
-
-		const config = builder.getConfig();
-		const [, firstSeries, secondSeries] = config.series ?? [];
-
-		expect(firstSeries?.show).toBe(true);
-		expect(secondSeries?.show).toBe(false);
-	});
-
-	it('does not attempt to read stored visibility when using in-memory preferences', () => {
-		const builder = new UPlotConfigBuilder({
-			widgetId: 'widget-1',
-			selectionPreferencesSource: SelectionPreferencesSource.IN_MEMORY,
-		});
-
-		builder.addSeries(createSeriesProps({ label: 'Requests' }));
-
-		builder.getLegendItems();
-		builder.getConfig();
-
-		expect(
-			getStoredSeriesVisibilityMock.getStoredSeriesVisibility,
-		).not.toHaveBeenCalled();
-	});
-
-	it('adds thresholds only once per scale key', () => {
-		const builder = new UPlotConfigBuilder();
-
-		const thresholdsOptions = {
-			scaleKey: 'y',
-			thresholds: [{ thresholdValue: 100 }],
-		};
-
-		builder.addThresholds(thresholdsOptions);
-		builder.addThresholds(thresholdsOptions);
-
-		const config = builder.getConfig();
-		const drawHooks = config.hooks?.draw ?? [];
-
-		// Only a single draw hook should be registered for the same scaleKey
-		expect(drawHooks.length).toBe(1);
-	});
-
-	it('merges cursor configuration with defaults instead of replacing them', () => {
-		const builder = new UPlotConfigBuilder();
-
-		builder.setCursor({
-			drag: { setScale: false },
-		});
-
-		const config = builder.getConfig();
-
-		expect(config.cursor?.drag?.setScale).toBe(false);
-		// Points configuration from DEFAULT_CURSOR_CONFIG should still be present
-		expect(config.cursor?.points).toBeDefined();
-	});
-
-	it('adds plugins and includes them in config', () => {
-		const builder = new UPlotConfigBuilder();
-		const plugin: uPlot.Plugin = {
-			opts: (): void => {},
-			hooks: {},
-		};
-
-		builder.addPlugin(plugin);
-
-		const config = builder.getConfig();
-
-		expect(config.plugins).toContain(plugin);
-	});
-
-	it('sets bands and includes them in config', () => {
-		const builder = new UPlotConfigBuilder();
-		const bands: uPlot.Band[] = [{ series: [1, 2], fill: (): string => '#000' }];
-
-		builder.setBands(bands);
-
-		const config = builder.getConfig();
-
-		expect(config.bands).toEqual(bands);
-	});
-
-	it('sets padding, legend, focus, select, tzDate and includes them in config', () => {
-		const tzDate = (ts: number): Date => new Date(ts);
-		const builder = new UPlotConfigBuilder();
-
-		builder.setPadding([10, 20, 30, 40]);
-		builder.setLegend({ show: true, live: true });
-		builder.setFocus({ alpha: 0.5 });
-		builder.setSelect({ left: 0, width: 0, top: 0, height: 0 });
-		builder.setTzDate(tzDate);
-
-		const config = builder.getConfig();
-
-		expect(config.padding).toEqual([10, 20, 30, 40]);
-		expect(config.legend).toEqual({ show: true, live: true });
-		expect(config.focus).toEqual({ alpha: 0.5 });
-		expect(config.select).toEqual({ left: 0, width: 0, top: 0, height: 0 });
-		expect(config.tzDate).toBe(tzDate);
-	});
-
-	it('does not include plugins when none added', () => {
-		const builder = new UPlotConfigBuilder();
-
-		const config = builder.getConfig();
-
-		expect(config.plugins).toBeUndefined();
-	});
-
-	it('does not include bands when empty', () => {
-		const builder = new UPlotConfigBuilder();
-
-		const config = builder.getConfig();
-
-		expect(config.bands).toBeUndefined();
-	});
-});

frontend/src/lib/uPlotV2/config/__tests__/UPlotScaleBuilder.test.ts

@@ -1,235 +0,0 @@
-import type uPlot from 'uplot';
-
-import * as scaleUtils from '../../utils/scale';
-import type { ScaleProps } from '../types';
-import { DistributionType } from '../types';
-import { UPlotScaleBuilder } from '../UPlotScaleBuilder';
-
-const createScaleProps = (overrides: Partial<ScaleProps> = {}): ScaleProps => ({
-	scaleKey: 'y',
-	time: false,
-	auto: undefined,
-	min: undefined,
-	max: undefined,
-	softMin: undefined,
-	softMax: undefined,
-	distribution: DistributionType.Linear,
-	...overrides,
-});
-
-describe('UPlotScaleBuilder', () => {
-	const getFallbackMinMaxSpy = jest.spyOn(
-		scaleUtils,
-		'getFallbackMinMaxTimeStamp',
-	);
-
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('initializes softMin/softMax correctly when both are 0 (treated as unset)', () => {
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				softMin: 0,
-				softMax: 0,
-			}),
-		);
-
-		// Non-time scale so config path uses thresholds pipeline; we just care that
-		// adjustSoftLimitsWithThresholds receives null soft limits instead of 0/0.
-		const adjustSpy = jest.spyOn(scaleUtils, 'adjustSoftLimitsWithThresholds');
-
-		builder.getConfig();
-
-		expect(adjustSpy).toHaveBeenCalledWith(null, null, undefined, undefined);
-	});
-
-	it('handles time scales using explicit min/max and rounds max down to the previous minute', () => {
-		const min = 1_700_000_000; // seconds
-		const max = 1_700_000_600; // seconds
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				scaleKey: 'x',
-				time: true,
-				min,
-				max,
-			}),
-		);
-
-		const config = builder.getConfig();
-		const xScale = config.x;
-
-		expect(xScale.time).toBe(true);
-		expect(xScale.auto).toBe(false);
-		expect(Array.isArray(xScale.range)).toBe(true);
-
-		const [resolvedMin, resolvedMax] = xScale.range as [number, number];
-
-		// min is passed through
-		expect(resolvedMin).toBe(min);
-
-		// max is coerced to "endTime - 1 minute" and rounded down to minute precision
-		const oneMinuteAgoTimestamp = (max - 60) * 1000;
-		const currentDate = new Date(oneMinuteAgoTimestamp);
-		currentDate.setSeconds(0);
-		currentDate.setMilliseconds(0);
-		const expectedMax = Math.floor(currentDate.getTime() / 1000);
-
-		expect(resolvedMax).toBe(expectedMax);
-	});
-
-	it('falls back to getFallbackMinMaxTimeStamp when time scale has no min/max', () => {
-		getFallbackMinMaxSpy.mockReturnValue({
-			fallbackMin: 100,
-			fallbackMax: 200,
-		});
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				scaleKey: 'x',
-				time: true,
-				min: undefined,
-				max: undefined,
-			}),
-		);
-
-		const config = builder.getConfig();
-		const [resolvedMin, resolvedMax] = config.x.range as [number, number];
-
-		expect(getFallbackMinMaxSpy).toHaveBeenCalled();
-		expect(resolvedMin).toBe(100);
-		// max is aligned to "fallbackMax - 60 seconds" minute boundary
-		expect(resolvedMax).toBeLessThanOrEqual(200);
-		expect(resolvedMax).toBeGreaterThan(100);
-	});
-
-	it('pipes limits through soft-limit adjustment and log-scale normalization before range config', () => {
-		const adjustSpy = jest.spyOn(scaleUtils, 'adjustSoftLimitsWithThresholds');
-		const normalizeSpy = jest.spyOn(scaleUtils, 'normalizeLogScaleLimits');
-		const getRangeConfigSpy = jest.spyOn(scaleUtils, 'getRangeConfig');
-
-		const thresholds = {
-			scaleKey: 'y',
-			thresholds: [{ thresholdValue: 10 }],
-			yAxisUnit: 'ms',
-		};
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				softMin: 1,
-				softMax: 5,
-				min: 0,
-				max: 100,
-				distribution: DistributionType.Logarithmic,
-				thresholds,
-				logBase: 2,
-				padMinBy: 0.1,
-				padMaxBy: 0.2,
-			}),
-		);
-
-		builder.getConfig();
-
-		expect(adjustSpy).toHaveBeenCalledWith(1, 5, thresholds.thresholds, 'ms');
-		expect(normalizeSpy).toHaveBeenCalledWith({
-			distr: DistributionType.Logarithmic,
-			logBase: 2,
-			limits: {
-				min: 0,
-				max: 100,
-				softMin: expect.anything(),
-				softMax: expect.anything(),
-			},
-		});
-		expect(getRangeConfigSpy).toHaveBeenCalled();
-	});
-
-	it('computes distribution config for non-time scales and wires range function when range is not provided', () => {
-		const createRangeFnSpy = jest.spyOn(scaleUtils, 'createRangeFunction');
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				scaleKey: 'y',
-				time: false,
-				distribution: DistributionType.Linear,
-			}),
-		);
-
-		const config = builder.getConfig();
-		const yScale = config.y;
-
-		expect(createRangeFnSpy).toHaveBeenCalled();
-
-		// range should be a function when not provided explicitly
-		expect(typeof yScale.range).toBe('function');
-
-		// distribution config should be applied
-		expect(yScale.distr).toBeDefined();
-		expect(yScale.log).toBeDefined();
-	});
-
-	it('respects explicit range function when provided on props', () => {
-		const explicitRange: uPlot.Scale.Range = jest.fn(() => [
-			0,
-			10,
-		]) as uPlot.Scale.Range;
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				scaleKey: 'y',
-				range: explicitRange,
-			}),
-		);
-
-		const config = builder.getConfig();
-		const yScale = config.y;
-
-		expect(yScale.range).toBe(explicitRange);
-	});
-
-	it('derives auto flag when not explicitly provided, based on hasFixedRange and time', () => {
-		const getRangeConfigSpy = jest.spyOn(scaleUtils, 'getRangeConfig');
-
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				min: 0,
-				max: 100,
-				time: false,
-			}),
-		);
-
-		const config = builder.getConfig();
-		const yScale = config.y;
-
-		expect(getRangeConfigSpy).toHaveBeenCalled();
-		// For non-time scale with fixed min/max, hasFixedRange is true → auto should remain false
-		expect(yScale.auto).toBe(false);
-	});
-
-	it('merge updates internal min/max/soft limits while preserving other props', () => {
-		const builder = new UPlotScaleBuilder(
-			createScaleProps({
-				scaleKey: 'y',
-				min: 0,
-				max: 10,
-				softMin: 1,
-				softMax: 9,
-				time: false,
-			}),
-		);
-
-		builder.merge({
-			min: 2,
-			softMax: undefined,
-		});
-
-		const config = builder.getConfig();
-		const yScale = config.y;
-
-		// We can't read private fields directly, but we can assert that rangeConfig
-		// has been recomputed using the merged values by checking that createRangeFunction
-		// is still called without throwing and returns a working range function.
-		expect(typeof yScale.range).toBe('function');
-	});
-});

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

@@ -1,309 +0,0 @@
-import { themeColors } from 'constants/theme';
-import uPlot from 'uplot';
-
-import type { SeriesProps } from '../types';
-import {
-	DrawStyle,
-	LineInterpolation,
-	LineStyle,
-	VisibilityMode,
-} from '../types';
-import { UPlotSeriesBuilder } from '../UPlotSeriesBuilder';
-
-const createBaseProps = (
-	overrides: Partial<SeriesProps> = {},
-): SeriesProps => ({
-	scaleKey: 'y',
-	label: 'Requests',
-	colorMapping: {},
-	drawStyle: DrawStyle.Line,
-	isDarkMode: false,
-	...overrides,
-});
-
-describe('UPlotSeriesBuilder', () => {
-	it('maps basic props into uPlot series config', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				label: 'Latency',
-				spanGaps: true,
-				show: false,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.scale).toBe('y');
-		expect(config.label).toBe('Latency');
-		expect(config.spanGaps).toBe(true);
-		expect(config.show).toBe(false);
-		expect(config.pxAlign).toBe(true);
-		expect(typeof config.value).toBe('function');
-	});
-
-	it('uses explicit lineColor when provided, regardless of mapping', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				lineColor: '#ff00ff',
-				colorMapping: { Requests: '#00ff00' },
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.stroke).toBe('#ff00ff');
-	});
-
-	it('falls back to theme colors when no label is provided', () => {
-		const darkBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				label: undefined,
-				isDarkMode: true,
-				lineColor: undefined,
-			}),
-		);
-		const lightBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				label: undefined,
-				isDarkMode: false,
-				lineColor: undefined,
-			}),
-		);
-
-		const darkConfig = darkBuilder.getConfig();
-		const lightConfig = lightBuilder.getConfig();
-
-		expect(darkConfig.stroke).toBe(themeColors.white);
-		expect(lightConfig.stroke).toBe(themeColors.black);
-	});
-
-	it('uses colorMapping when available and no explicit lineColor is provided', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				label: 'Requests',
-				colorMapping: { Requests: '#123456' },
-				lineColor: undefined,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.stroke).toBe('#123456');
-	});
-
-	it('passes through a custom pathBuilder when provided', () => {
-		const customPaths = (jest.fn() as unknown) as uPlot.Series.PathBuilder;
-
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				pathBuilder: customPaths,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.paths).toBe(customPaths);
-	});
-
-	it('disables line paths when drawStyle is Points, but still renders points', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Points,
-				pointSize: 4,
-				lineWidth: 2,
-				lineColor: '#aa00aa',
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(typeof config.paths).toBe('function');
-		expect(config.paths && config.paths({} as uPlot, 1, 0, 10)).toBeNull();
-
-		expect(config.points).toBeDefined();
-		expect(config.points?.stroke).toBe('#aa00aa');
-		expect(config.points?.fill).toBe('#aa00aa');
-		expect(config.points?.show).toBe(true);
-		expect(config.points?.size).toBe(4);
-	});
-
-	it('derives point size based on lineWidth and pointSize', () => {
-		const smallPointsBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				lineWidth: 4,
-				pointSize: 2,
-			}),
-		);
-		const largePointsBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				lineWidth: 2,
-				pointSize: 4,
-			}),
-		);
-
-		const smallConfig = smallPointsBuilder.getConfig();
-		const largeConfig = largePointsBuilder.getConfig();
-
-		expect(smallConfig.points?.size).toBeUndefined();
-		expect(largeConfig.points?.size).toBe(4);
-	});
-
-	it('uses pointsBuilder when provided instead of default visibility logic', () => {
-		const pointsBuilder: uPlot.Series.Points.Show = jest.fn(
-			() => true,
-		) as uPlot.Series.Points.Show;
-
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				pointsBuilder,
-				drawStyle: DrawStyle.Line,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.show).toBe(pointsBuilder);
-	});
-
-	it('respects VisibilityMode for point visibility when no custom pointsBuilder is given', () => {
-		const neverPointsBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				showPoints: VisibilityMode.Never,
-			}),
-		);
-		const alwaysPointsBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				showPoints: VisibilityMode.Always,
-			}),
-		);
-
-		const neverConfig = neverPointsBuilder.getConfig();
-		const alwaysConfig = alwaysPointsBuilder.getConfig();
-
-		expect(neverConfig.points?.show).toBe(false);
-		expect(alwaysConfig.points?.show).toBe(true);
-	});
-
-	it('applies LineStyle.Dashed and lineCap to line config', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				lineStyle: LineStyle.Dashed,
-				lineCap: 'round' as CanvasLineCap,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.dash).toEqual([10, 10]);
-		expect(config.cap).toBe('round');
-	});
-
-	it('builds default paths for Line drawStyle and invokes the path builder', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				lineInterpolation: LineInterpolation.Linear,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(typeof config.paths).toBe('function');
-		const result = config.paths?.({} as uPlot, 1, 0, 10);
-		expect(result).toBeDefined();
-	});
-
-	it('uses StepBefore and StepAfter interpolation for line paths', () => {
-		const stepBeforeBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				lineInterpolation: LineInterpolation.StepBefore,
-			}),
-		);
-		const stepAfterBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				lineInterpolation: LineInterpolation.StepAfter,
-			}),
-		);
-
-		const stepBeforeConfig = stepBeforeBuilder.getConfig();
-		const stepAfterConfig = stepAfterBuilder.getConfig();
-
-		expect(typeof stepBeforeConfig.paths).toBe('function');
-		expect(typeof stepAfterConfig.paths).toBe('function');
-		expect(stepBeforeConfig.paths?.({} as uPlot, 1, 0, 5)).toBeDefined();
-		expect(stepAfterConfig.paths?.({} as uPlot, 1, 0, 5)).toBeDefined();
-	});
-
-	it('defaults to spline interpolation when lineInterpolation is Spline or undefined', () => {
-		const splineBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				lineInterpolation: LineInterpolation.Spline,
-			}),
-		);
-		const defaultBuilder = new UPlotSeriesBuilder(
-			createBaseProps({ drawStyle: DrawStyle.Line }),
-		);
-
-		const splineConfig = splineBuilder.getConfig();
-		const defaultConfig = defaultBuilder.getConfig();
-
-		expect(typeof splineConfig.paths).toBe('function');
-		expect(typeof defaultConfig.paths).toBe('function');
-	});
-
-	it('coerces non-boolean spanGaps to false', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({ spanGaps: undefined }),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.spanGaps).toBe(false);
-	});
-
-	it('preserves spanGaps true when provided as boolean', () => {
-		const builder = new UPlotSeriesBuilder(createBaseProps({ spanGaps: true }));
-
-		const config = builder.getConfig();
-
-		expect(config.spanGaps).toBe(true);
-	});
-
-	it('uses generateColor when label has no colorMapping and no lineColor', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				label: 'CustomSeries',
-				colorMapping: {},
-				lineColor: undefined,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.stroke).toBeDefined();
-		expect(typeof config.stroke).toBe('string');
-		expect((config.stroke as string).length).toBeGreaterThan(0);
-	});
-
-	it('passes through pointsFilter when provided', () => {
-		const pointsFilter: uPlot.Series.Points.Filter = jest.fn(
-			(_self, _seriesIdx, _show) => null,
-		);
-
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				pointsFilter,
-				drawStyle: DrawStyle.Line,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBe(pointsFilter);
-	});
-});

pkg/query-service/app/inframetrics/common.go

@@ -10,6 +10,7 @@ import (
 )
 
 var dotMetricMap = map[string]string{
+	"system_filesystem_usage":               "system.filesystem.usage",
 	"system_cpu_time":                       "system.cpu.time",
 	"system_memory_usage":                   "system.memory.usage",
 	"system_cpu_load_average_15m":           "system.cpu.load_average.15m",

pkg/query-service/app/inframetrics/hosts.go

@@ -2,6 +2,7 @@ package inframetrics
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math"
@@ -53,10 +54,11 @@ var (
 	}
 
 	queryNamesForTopHosts = map[string][]string{
-		"cpu":    {"A", "B", "F1"},
-		"memory": {"C", "D", "F2"},
-		"wait":   {"E", "F", "F3"},
-		"load15": {"G"},
+		"cpu":        {"A", "B", "F1"},
+		"memory":     {"C", "D", "F2"},
+		"wait":       {"E", "F", "F3"},
+		"load15":     {"G"},
+		"filesystem": {"H", "I", "F4"},
 	}
 
 	// TODO(srikanthccv): remove hardcoded metric name and support keys from any system metric
@@ -67,10 +69,11 @@ var (
 		GetDotMetrics("os_type"),
 	}
 	metricNamesForHosts = map[string]string{
-		"cpu":    GetDotMetrics("system_cpu_time"),
-		"memory": GetDotMetrics("system_memory_usage"),
-		"load15": GetDotMetrics("system_cpu_load_average_15m"),
-		"wait":   GetDotMetrics("system_cpu_time"),
+		"cpu":        GetDotMetrics("system_cpu_time"),
+		"memory":     GetDotMetrics("system_memory_usage"),
+		"load15":     GetDotMetrics("system_cpu_load_average_15m"),
+		"wait":       GetDotMetrics("system_cpu_time"),
+		"filesystem": GetDotMetrics("system_filesystem_usage"),
 	}
 )
 
@@ -386,6 +389,11 @@ func (h *HostsRepo) IsSendingK8SAgentMetrics(ctx context.Context, req model.Host
 	return maps.Keys(clusterNames), maps.Keys(nodeNames), nil
 }
 
+func marshalInterface(inter any) string {
+	b, _ := json.Marshal(inter)
+	return string(b)
+}
+
 func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req model.HostListRequest) (model.HostListResponse, error) {
 	resp := model.HostListResponse{}
 
@@ -479,11 +487,15 @@ func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req mode
 		}
 	}
 
+	fmt.Println("======> printing query: ", marshalInterface(query.CompositeQuery.BuilderQueries))
+
 	queryResponse, _, err := h.querierV2.QueryRange(ctx, orgID, query)
 	if err != nil {
 		return resp, err
 	}
 
+	// fmt.Println("====> queryResponse:", marshalInterface(queryResponse))
+
 	formattedResponse, err := postprocess.PostProcessResult(queryResponse, query)
 	if err != nil {
 		return resp, err
@@ -494,10 +506,11 @@ func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req mode
 	for _, result := range formattedResponse {
 		for _, row := range result.Table.Rows {
 			record := model.HostListRecord{
-				CPU:    -1,
-				Memory: -1,
-				Wait:   -1,
-				Load15: -1,
+				CPU:        -1,
+				Memory:     -1,
+				Wait:       -1,
+				Load15:     -1,
+				Filesystem: -1,
 			}
 
 			if hostName, ok := row.Data[hostNameAttrKey].(string); ok {
@@ -516,6 +529,9 @@ func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req mode
 			if load15, ok := row.Data["G"].(float64); ok {
 				record.Load15 = load15
 			}
+			if filesystem, ok := row.Data["F4"].(float64); ok {
+				record.Filesystem = filesystem
+			}
 			record.Meta = map[string]string{}
 			if _, ok := hostAttrs[record.HostName]; ok {
 				record.Meta = hostAttrs[record.HostName]

pkg/query-service/app/inframetrics/hosts_query.go

@@ -269,42 +269,130 @@ var HostsTableListQuery = v3.QueryRangeParamsV3{
 					Items:    []v3.FilterItem{},
 				},
 			},
-			"G": {
-				QueryName:  "G",
-				DataSource: v3.DataSourceMetrics,
-				AggregateAttribute: v3.AttributeKey{
-					Key:      metricNamesForHosts["load15"],
-					DataType: v3.AttributeKeyDataTypeFloat64,
-				},
-				Temporality: v3.Unspecified,
-				Filters: &v3.FilterSet{
-					Operator: "AND",
-					Items: []v3.FilterItem{
-						{
-							Key: v3.AttributeKey{
-								Key:      hostNameAttrKey,
-								DataType: v3.AttributeKeyDataTypeString,
-								Type:     v3.AttributeKeyTypeResource,
-							},
-							Operator: v3.FilterOperatorNotContains,
-							Value:    agentNameToIgnore,
-						},
-					},
-				},
-				GroupBy: []v3.AttributeKey{
-					{
-						Key:      hostNameAttrKey,
-						DataType: v3.AttributeKeyDataTypeString,
-						Type:     v3.AttributeKeyTypeResource,
-					},
-				},
-				Expression:       "G",
-				ReduceTo:         v3.ReduceToOperatorAvg,
-				TimeAggregation:  v3.TimeAggregationAvg,
-				SpaceAggregation: v3.SpaceAggregationSum,
-				Disabled:         false,
-				Legend:           "CPU Load Average (15m)",
+		"G": {
+			QueryName:  "G",
+			DataSource: v3.DataSourceMetrics,
+			AggregateAttribute: v3.AttributeKey{
+				Key:      metricNamesForHosts["load15"],
+				DataType: v3.AttributeKeyDataTypeFloat64,
 			},
+			Temporality: v3.Unspecified,
+			Filters: &v3.FilterSet{
+				Operator: "AND",
+				Items: []v3.FilterItem{
+					{
+						Key: v3.AttributeKey{
+							Key:      hostNameAttrKey,
+							DataType: v3.AttributeKeyDataTypeString,
+							Type:     v3.AttributeKeyTypeResource,
+						},
+						Operator: v3.FilterOperatorNotContains,
+						Value:    agentNameToIgnore,
+					},
+				},
+			},
+			GroupBy: []v3.AttributeKey{
+				{
+					Key:      hostNameAttrKey,
+					DataType: v3.AttributeKeyDataTypeString,
+					Type:     v3.AttributeKeyTypeResource,
+				},
+			},
+			Expression:       "G",
+			ReduceTo:         v3.ReduceToOperatorAvg,
+			TimeAggregation:  v3.TimeAggregationAvg,
+			SpaceAggregation: v3.SpaceAggregationSum,
+			Disabled:         false,
+			Legend:           "CPU Load Average (15m)",
+		},
+		"H": {
+			QueryName:  "H",
+			DataSource: v3.DataSourceMetrics,
+			AggregateAttribute: v3.AttributeKey{
+				Key:      metricNamesForHosts["filesystem"],
+				DataType: v3.AttributeKeyDataTypeFloat64,
+			},
+			Temporality: v3.Cumulative,
+			Filters: &v3.FilterSet{
+				Operator: "AND",
+				Items: []v3.FilterItem{
+					{
+						Key: v3.AttributeKey{
+							Key:      "state",
+							DataType: v3.AttributeKeyDataTypeString,
+							Type:     v3.AttributeKeyTypeTag,
+						},
+						Operator: v3.FilterOperatorEqual,
+						Value:    "used",
+					},
+					{
+						Key: v3.AttributeKey{
+							Key:      hostNameAttrKey,
+							DataType: v3.AttributeKeyDataTypeString,
+							Type:     v3.AttributeKeyTypeResource,
+						},
+						Operator: v3.FilterOperatorNotContains,
+						Value:    agentNameToIgnore,
+					},
+				},
+			},
+			GroupBy: []v3.AttributeKey{
+				{
+					Key:      hostNameAttrKey,
+					DataType: v3.AttributeKeyDataTypeString,
+					Type:     v3.AttributeKeyTypeResource,
+				},
+			},
+			Expression:       "H",
+			ReduceTo:         v3.ReduceToOperatorAvg,
+			TimeAggregation:  v3.TimeAggregationAvg,
+			SpaceAggregation: v3.SpaceAggregationSum,
+			Disabled:         true,
+		},
+		"I": {
+			QueryName:  "I",
+			DataSource: v3.DataSourceMetrics,
+			AggregateAttribute: v3.AttributeKey{
+				Key:      metricNamesForHosts["filesystem"],
+				DataType: v3.AttributeKeyDataTypeFloat64,
+			},
+			Temporality: v3.Cumulative,
+			Filters: &v3.FilterSet{
+				Operator: "AND",
+				Items: []v3.FilterItem{
+					{
+						Key: v3.AttributeKey{
+							Key:      hostNameAttrKey,
+							DataType: v3.AttributeKeyDataTypeString,
+							Type:     v3.AttributeKeyTypeResource,
+						},
+						Operator: v3.FilterOperatorNotContains,
+						Value:    agentNameToIgnore,
+					},
+				},
+			},
+			GroupBy: []v3.AttributeKey{
+				{
+					Key:      hostNameAttrKey,
+					DataType: v3.AttributeKeyDataTypeString,
+					Type:     v3.AttributeKeyTypeResource,
+				},
+			},
+			Expression:       "I",
+			ReduceTo:         v3.ReduceToOperatorAvg,
+			TimeAggregation:  v3.TimeAggregationAvg,
+			SpaceAggregation: v3.SpaceAggregationSum,
+			Disabled:         true,
+		},
+		"F4": {
+			QueryName:  "F4",
+			Expression: "H/I",
+			Legend:     "Disk Usage (%)",
+			Filters: &v3.FilterSet{
+				Operator: "AND",
+				Items:    []v3.FilterItem{},
+			},
+		},
 		},
 		PanelType: v3.PanelTypeTable,
 		QueryType: v3.QueryTypeBuilder,

pkg/query-service/model/infra.go

@@ -26,14 +26,15 @@ type HostListRequest struct {
 }
 
 type HostListRecord struct {
-	HostName string            `json:"hostName"`
-	Active   bool              `json:"active"`
-	OS       string            `json:"os"`
-	CPU      float64           `json:"cpu"`
-	Memory   float64           `json:"memory"`
-	Wait     float64           `json:"wait"`
-	Load15   float64           `json:"load15"`
-	Meta     map[string]string `json:"meta"`
+	HostName   string            `json:"hostName"`
+	Active     bool              `json:"active"`
+	OS         string            `json:"os"`
+	CPU        float64           `json:"cpu"`
+	Memory     float64           `json:"memory"`
+	Wait       float64           `json:"wait"`
+	Load15     float64           `json:"load15"`
+	Filesystem float64           `json:"filesystem"`
+	Meta       map[string]string `json:"meta"`
 }
 
 type HostListResponse struct {
@@ -64,6 +65,10 @@ func (r *HostListResponse) SortBy(orderBy *v3.OrderBy) {
 		sort.Slice(r.Records, func(i, j int) bool {
 			return r.Records[i].Wait > r.Records[j].Wait
 		})
+	case "filesystem":
+		sort.Slice(r.Records, func(i, j int) bool {
+			return r.Records[i].Filesystem > r.Records[j].Filesystem
+		})
 	}
 	// the default is descending
 	if orderBy.Order == v3.DirectionAsc {