feat: adding mysql GCP service

frontend/src/container/OptionsMenu/__test__/useOptionsMenu.test.ts

@@ -387,42 +387,4 @@ describe('useOptionsMenu', () => {
 			expect(remaining).toHaveLength(seedColumns.length);
 		});
 	});
-
-	describe('fieldsSelector.value drops legacy columns without a name', () => {
-		it('excludes entries missing name while keeping valid columns', () => {
-			(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
-				data: { data: { data: { keys: {} } } },
-				isFetching: false,
-			});
-			(usePreferenceContext as jest.Mock).mockReturnValue({
-				traces: {
-					preferences: {
-						columns: [
-							{ name: 'body', fieldContext: 'log' },
-							{ key: 'legacy-key-no-name', fieldContext: 'log' },
-							{ name: 'timestamp', fieldContext: 'log' },
-						],
-						formatting: { format: 'table', maxLines: 1, fontSize: 'small' },
-					},
-					updateColumns: mockUpdateColumns,
-					updateFormatting: mockUpdateFormatting,
-				},
-				logs: {
-					preferences: { columns: [], formatting: {} },
-					updateColumns: mockUpdateColumns,
-					updateFormatting: mockUpdateFormatting,
-				},
-			});
-
-			const { result } = renderHook(() =>
-				useOptionsMenu({
-					dataSource: DataSource.TRACES,
-					aggregateOperator: 'count',
-				}),
-			);
-
-			const fields = result.current.config.fieldsSelector?.value ?? [];
-			expect(fields.map((f) => f.name)).toStrictEqual(['body', 'timestamp']);
-		});
-	});
 });

frontend/src/container/OptionsMenu/useOptionsMenu.ts

@@ -399,7 +399,7 @@ const useOptionsMenu = ({
 				onReorder: reorderSelectColumns,
 			},
 			fieldsSelector: {
-				value: preferences?.columns?.filter((item) => has(item, 'name')) ?? [],
+				value: preferences?.columns ?? [],
 				onFieldsChange: updateColumns,
 			},
 			format: {

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/ValueSelector.test.tsx

@@ -182,56 +182,4 @@ describe('ValueSelector', () => {
 			});
 		});
 	});
-
-	describe('opening and closing without touching the list', () => {
-		function renderWith(
-			selection: VariableSelection,
-			options: string[],
-		): jest.Mock {
-			const onChange = jest.fn();
-			render(
-				<TooltipProvider>
-					<ValueSelector
-						options={options}
-						variableType="dynamic"
-						multiSelect
-						showAllOption
-						selection={selection}
-						onChange={onChange}
-						emptyFallback={{ value: [], allSelected: false }}
-						testId="variable-select-env"
-					/>
-				</TooltipProvider>,
-			);
-			return onChange;
-		}
-
-		async function openThenClose(): Promise<void> {
-			const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
-			const control = screen.getByTestId('variable-select-env');
-			await user.click(control.querySelector('input') as HTMLInputElement);
-			await user.keyboard('{Escape}');
-		}
-
-		it('does not promote a pick that covers every available option to ALL', async () => {
-			// A narrow time range can leave only the selected value in the list. That is
-			// still an explicit pick, not "everything, always".
-			const onChange = renderWith(
-				{ value: ['checkout-service-prod'], allSelected: false },
-				['checkout-service-prod'],
-			);
-
-			await openThenClose();
-
-			expect(onChange).not.toHaveBeenCalled();
-		});
-
-		it('does not rewrite a dynamic ALL into concrete values', async () => {
-			const onChange = renderWith({ value: null, allSelected: true }, OPTIONS);
-
-			await openThenClose();
-
-			expect(onChange).not.toHaveBeenCalled();
-		});
-	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/resolveVariableSelection.test.ts

@@ -145,133 +145,6 @@ describe('reconcileWithOptions', () => {
 			),
 		).toBeNull();
 	});
-
-	describe('preserveSelection (options moved on their own — time range, reload)', () => {
-		const multi = model({
-			type: 'DYNAMIC',
-			multiSelect: true,
-			showAllOption: true,
-			dynamicAttribute: 'service.name',
-		});
-
-		it('keeps a multi-select pick the new option list no longer offers', () => {
-			expect(
-				reconcileWithOptions(multi, { value: ['frontend'], allSelected: false }, [
-					'backend',
-					'cart',
-				]),
-			).toStrictEqual({ value: null, allSelected: true });
-
-			expect(
-				reconcileWithOptions(
-					multi,
-					{ value: ['frontend'], allSelected: false },
-					['backend', 'cart'],
-					{ preserveSelection: true },
-				),
-			).toBeNull();
-		});
-
-		it('still materializes ALL, which must track the option list', () => {
-			expect(
-				reconcileWithOptions(
-					model({ type: 'QUERY', multiSelect: true, showAllOption: true }),
-					{ value: ['a'], allSelected: true },
-					['a', 'b'],
-					{ preserveSelection: true },
-				),
-			).toStrictEqual({ value: ['a', 'b'], allSelected: true });
-		});
-
-		it('still fills the default when nothing is selected yet', () => {
-			expect(
-				reconcileWithOptions(multi, { value: [], allSelected: false }, ['a', 'b'], {
-					preserveSelection: true,
-				}),
-			).toStrictEqual({ value: null, allSelected: true });
-		});
-	});
-
-	// A typed value is in no option list, so no refetch can invalidate it.
-	describe('customValues (typed in, never offered by the data)', () => {
-		const multi = model({
-			type: 'DYNAMIC',
-			multiSelect: true,
-			showAllOption: true,
-			dynamicAttribute: 'service.name',
-		});
-
-		it('keeps them through a re-scope that drops a fetched value', () => {
-			expect(
-				reconcileWithOptions(
-					multi,
-					{
-						value: ['frontend', 'typed-in'],
-						allSelected: false,
-						customValues: ['typed-in'],
-					},
-					['backend', 'cart'],
-				),
-			).toStrictEqual({
-				value: ['typed-in'],
-				allSelected: false,
-				customValues: ['typed-in'],
-			});
-		});
-
-		it('never re-defaults a selection made only of them', () => {
-			expect(
-				reconcileWithOptions(
-					multi,
-					{ value: ['typed-in'], allSelected: false, customValues: ['typed-in'] },
-					['backend', 'cart'],
-				),
-			).toBeNull();
-		});
-
-		// An inert marker is not worth a store write + dependent refetch to prune.
-		it('leaves a stale marker alone when it drops nothing', () => {
-			expect(
-				reconcileWithOptions(
-					multi,
-					{
-						value: ['frontend', 'typed-in'],
-						allSelected: false,
-						customValues: ['typed-in', 'removed-earlier'],
-					},
-					['frontend'],
-				),
-			).toBeNull();
-		});
-
-		it('prunes markers for values it does drop', () => {
-			expect(
-				reconcileWithOptions(
-					multi,
-					{
-						value: ['stale', 'typed-in'],
-						allSelected: false,
-						customValues: ['typed-in'],
-					},
-					['frontend'],
-				),
-			).toStrictEqual({
-				value: ['typed-in'],
-				allSelected: false,
-				customValues: ['typed-in'],
-			});
-		});
-
-		it('still drops an unmarked value the list no longer offers', () => {
-			expect(
-				reconcileWithOptions(
-					multi,
-					{ value: ['frontend', 'stale'], allSelected: false },
-					['frontend'],
-				),
-			).toStrictEqual({ value: ['frontend'], allSelected: false });
-		});
-	});
 });
 
 describe('configuredDefaultValue', () => {

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/selectionUtils.test.ts

@@ -1,91 +0,0 @@
-import type { VariableSelection } from '../selectionTypes';
-import { selectionFromCommittedValues } from '../utils/selectionUtils';
-
-const OPTIONS = ['checkout', 'payments', 'cart'];
-const FALLBACK: VariableSelection = { value: null, allSelected: true };
-
-function commit(
-	values: string[],
-	overrides: Partial<Parameters<typeof selectionFromCommittedValues>[0]> = {},
-): VariableSelection {
-	return selectionFromCommittedValues({
-		values,
-		options: OPTIONS,
-		showAllOption: true,
-		emptyFallback: FALLBACK,
-		...overrides,
-	});
-}
-
-// What a multi-select commit resolves to. The option list is known only here, so this
-// is the one place a typed value can be recognised.
-describe('selectionFromCommittedValues', () => {
-	it('marks values the option list did not offer as typed in', () => {
-		expect(commit(['checkout', 'typed-in'])).toStrictEqual({
-			value: ['checkout', 'typed-in'],
-			allSelected: false,
-			customValues: ['typed-in'],
-		});
-	});
-
-	it('marks a selection made only of typed-in values', () => {
-		expect(commit(['a', 'b'])).toStrictEqual({
-			value: ['a', 'b'],
-			allSelected: false,
-			customValues: ['a', 'b'],
-		});
-	});
-
-	it('records no marker when every pick came from the list', () => {
-		expect(commit(['checkout', 'cart'])).toStrictEqual({
-			value: ['checkout', 'cart'],
-			allSelected: false,
-		});
-	});
-
-	it('reads a set covering every option as ALL', () => {
-		expect(commit(OPTIONS)).toStrictEqual({
-			value: OPTIONS,
-			allSelected: true,
-		});
-	});
-
-	// ALL re-materializes to the option set, so recording this as ALL would drop the
-	// typed value on the next refetch.
-	it('does not read every option PLUS a typed value as ALL', () => {
-		expect(commit([...OPTIONS, 'typed-in'])).toStrictEqual({
-			value: [...OPTIONS, 'typed-in'],
-			allSelected: false,
-			customValues: ['typed-in'],
-		});
-	});
-
-	// Derived from the values + options at commit time, never from the old selection.
-	it('recomputes the marker: a typed value the data now offers is a normal pick', () => {
-		expect(
-			commit(['checkout', 'was-typed'], {
-				options: [...OPTIONS, 'was-typed'],
-			}),
-		).toStrictEqual({ value: ['checkout', 'was-typed'], allSelected: false });
-	});
-
-	it('does not read it as ALL when the variable offers no ALL', () => {
-		expect(commit(OPTIONS, { showAllOption: false })).toStrictEqual({
-			value: OPTIONS,
-			allSelected: false,
-		});
-	});
-
-	it('resolves an empty commit to the variable fallback', () => {
-		expect(commit([])).toBe(FALLBACK);
-	});
-
-	it('marks everything while the options have not arrived', () => {
-		// Nothing to judge against yet; erring this way keeps a value rather than dropping it.
-		expect(commit(['typed-in'], { options: [] })).toStrictEqual({
-			value: ['typed-in'],
-			allSelected: false,
-			customValues: ['typed-in'],
-		});
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/useAutoSelect.test.tsx

@@ -4,8 +4,6 @@ import {
 	emptyVariableFormModel,
 	type VariableFormModel,
 } from '../../DashboardSettings/Variables/variableFormModel';
-import { VariableCycleReason } from '../../store/slices/variableFetchSlice';
-import { useDashboardStore } from '../../store/useDashboardStore';
 import type { VariableSelection } from '../selectionTypes';
 import { useAutoSelect } from '../hooks/useAutoSelect';
 
@@ -17,11 +15,7 @@ function run(
 	variable: VariableFormModel,
 	options: string[],
 	selection: VariableSelection,
-	cycleReason?: VariableCycleReason,
 ): VariableSelection | undefined {
-	useDashboardStore.setState({
-		variableCycleReasons: cycleReason ? { [variable.name]: cycleReason } : {},
-	});
 	const onAutoSelect = jest.fn();
 	renderHook(() => useAutoSelect(variable, options, selection, onAutoSelect));
 	return onAutoSelect.mock.calls[0]?.[0];
@@ -76,13 +70,11 @@ describe('useAutoSelect', () => {
 		expect(next).toStrictEqual({ value: ['a', 'b'], allSelected: true });
 	});
 
-	// Re-scoped options only — a time-range refetch must NOT re-default; see below.
-	it('re-scoped: falls back to ALL, not the first option, when every selected value is gone', () => {
+	it('falls back to ALL, not the first option, when every selected value is gone', () => {
 		const next = run(
 			model({ type: 'QUERY', multiSelect: true, showAllOption: true }),
 			['x', 'y'],
 			{ value: ['a', 'b'], allSelected: false },
-			VariableCycleReason.ValueCascade,
 		);
 		expect(next).toStrictEqual({ value: ['x', 'y'], allSelected: true });
 	});
@@ -110,23 +102,20 @@ describe('useAutoSelect', () => {
 		expect(next).toStrictEqual({ value: ['b'], allSelected: false });
 	});
 
-	it('re-scoped: keeps the still-valid subset of a multi-select', () => {
+	it('keeps the still-valid subset of a multi-select when options re-scope', () => {
 		const next = run(
 			model({ type: 'QUERY', multiSelect: true }),
 			['a', 'b', 'd'],
 			{ value: ['a', 'b', 'c'], allSelected: false },
-			VariableCycleReason.ValueCascade,
 		);
 		expect(next).toStrictEqual({ value: ['a', 'b'], allSelected: false });
 	});
 
-	it('re-scoped: re-defaults a multi-select when none of the selected values remain', () => {
-		const next = run(
-			model({ type: 'QUERY', multiSelect: true }),
-			['x', 'y'],
-			{ value: ['a', 'b'], allSelected: false },
-			VariableCycleReason.ValueCascade,
-		);
+	it('re-defaults a multi-select when none of the selected values remain', () => {
+		const next = run(model({ type: 'QUERY', multiSelect: true }), ['x', 'y'], {
+			value: ['a', 'b'],
+			allSelected: false,
+		});
 		expect(next).toStrictEqual({ value: ['x'], allSelected: false });
 	});
 
@@ -162,45 +151,4 @@ describe('useAutoSelect', () => {
 		});
 		expect(next).toBeUndefined();
 	});
-
-	describe('by cycle reason', () => {
-		const service = model({
-			name: 'service',
-			type: 'DYNAMIC',
-			multiSelect: true,
-			showAllOption: true,
-			dynamicAttribute: 'service.name',
-		});
-		const gone: VariableSelection = { value: ['frontend'], allSelected: false };
-
-		it('keeps the selection when a full cycle refetched the options', () => {
-			// The new window has no data for the selected service — no reason to widen to ALL.
-			const next = run(
-				service,
-				['backend', 'cart'],
-				gone,
-				VariableCycleReason.FullCycle,
-			);
-			expect(next).toBeUndefined();
-		});
-
-		it('re-scopes the selection when a value cascade refetched the options', () => {
-			const next = run(
-				service,
-				['backend', 'cart'],
-				gone,
-				VariableCycleReason.ValueCascade,
-			);
-			expect(next).toStrictEqual({ value: null, allSelected: true });
-		});
-
-		it('reconciles a variable with no cycle of its own (custom definition change)', () => {
-			const next = run(
-				model({ name: 'env', type: 'CUSTOM', multiSelect: true }),
-				['staging', 'prod'],
-				{ value: ['dev'], allSelected: false },
-			);
-			expect(next).toStrictEqual({ value: ['staging'], allSelected: false });
-		});
-	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/__tests__/useVariableSelection.test.tsx

@@ -13,11 +13,11 @@ jest.mock('nuqs', () => ({
 	useQueryState: (): unknown => [null, jest.fn()],
 }));
 
-const mockGlobalTime = { minTime: 1, maxTime: 2, selectedTime: '5m' };
-
 jest.mock('react-redux', () => ({
 	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({ globalTime: mockGlobalTime }),
+		selector({
+			globalTime: { minTime: 1, maxTime: 2, selectedTime: '5m' },
+		}),
 }));
 
 jest.mock('../../DashboardSettings/Variables/variableAdapters', () => ({
@@ -150,57 +150,3 @@ describe('useVariableSelection — setSelection', () => {
 		expect(svcCycleId()).toBe(before + 1);
 	});
 });
-
-describe('useVariableSelection — what a time-range change enqueues', () => {
-	// Longer than FETCH_CYCLE_DEBOUNCE_MS, which the hook keeps private.
-	const PAST_DEBOUNCE = 400;
-
-	function reasons(): Record<string, string> {
-		return useDashboardStore.getState().variableCycleReasons;
-	}
-
-	beforeEach(() => {
-		jest.useFakeTimers();
-		mockGlobalTime.selectedTime = '5m';
-		useDashboardStore.setState({
-			variableValues: {},
-			variableFetchStates: {},
-			variableLastUpdated: {},
-			variableCycleIds: {},
-			variableCycleReasons: {},
-			variableResolvedEmpty: {},
-			variableFetchContext: null,
-			lastFetchAllKey: null,
-		});
-	});
-
-	afterEach(() => {
-		jest.useRealTimers();
-	});
-
-	// The tag is what stops the reconcile re-defaulting a user's selection.
-	it('tags every variable as a full cycle, overriding an earlier cascade tag', () => {
-		const { result, rerender } = renderHook(() =>
-			useVariableSelection(dashboard),
-		);
-
-		act(() => {
-			jest.advanceTimersByTime(PAST_DEBOUNCE);
-		});
-		expect(reasons()).toStrictEqual({ env: 'full-cycle', svc: 'full-cycle' });
-
-		// A value change re-scopes the dependent's options: it may drop what no longer applies.
-		act(() => {
-			result.current.setSelection('env', { value: ['prod'], allSelected: false });
-		});
-		expect(reasons().svc).toBe('value-cascade');
-
-		mockGlobalTime.selectedTime = '30m';
-		rerender();
-		act(() => {
-			jest.advanceTimersByTime(PAST_DEBOUNCE);
-		});
-
-		expect(reasons()).toStrictEqual({ env: 'full-cycle', svc: 'full-cycle' });
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/components/selectors/ValueSelector.tsx

@@ -6,7 +6,6 @@ import { DashboardDetailEvents } from 'pages/DashboardPageV2/constants/events';
 
 import type { VariableSelection } from '../../selectionTypes';
 import { areSelectionsEqual } from '../../utils/resolveVariableSelection';
-import { selectionFromCommittedValues } from '../../utils/selectionUtils';
 import OverflowValuesTooltip from './OverflowValuesTooltip';
 import styles from '../../VariablesBar.module.scss';
 
@@ -76,23 +75,13 @@ function ValueSelector({
 		options.every((option) => draft.includes(option));
 
 	const commit = (values: string[]): void => {
-		// A close that left the list as it opened commits nothing — else a pick covering
-		// every option this window offers would be promoted to a standing ALL.
-		if (
-			areSelectionsEqual(
-				{ value: values, allSelected: false },
-				{ value: committedValues, allSelected: false },
-			)
-		) {
-			return;
-		}
-
-		const next = selectionFromCommittedValues({
-			values,
-			options,
-			showAllOption,
-			emptyFallback,
-		});
+		// CustomMultiSelect emits the full value set when ALL is picked.
+		const isAll =
+			showAllOption &&
+			options.length > 0 &&
+			options.every((option) => values.includes(option));
+		const next: VariableSelection =
+			values.length === 0 ? emptyFallback : { value: values, allSelected: isAll };
 
 		// Closing without actually changing the selection must not re-fire onChange —
 		// that would needlessly re-cascade to dependent variables/panels.

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/hooks/useAutoSelect.ts

@@ -1,11 +1,6 @@
 import { useEffect } from 'react';
 
 import type { VariableFormModel } from '../../DashboardSettings/Variables/variableFormModel';
-import {
-	selectVariableCycleReason,
-	VariableCycleReason,
-} from '../../store/slices/variableFetchSlice';
-import { useDashboardStore } from '../../store/useDashboardStore';
 import { reconcileWithOptions } from '../utils/resolveVariableSelection';
 import type { VariableSelection } from '../selectionTypes';
 
@@ -14,9 +9,6 @@ import type { VariableSelection } from '../selectionTypes';
  * `onAutoSelect` only when the value must change. The reconcile rule lives in
  * {@link reconcileWithOptions} (shared with seed + payload defaulting) so the bar
  * and the panel query can never disagree about a variable's default.
- *
- * Only a value cascade may re-default the selection; a full cycle (time range,
- * reload) leaves the user's pick alone. Types with no cycle of their own reconcile.
  */
 export function useAutoSelect(
 	variable: VariableFormModel,
@@ -24,14 +16,8 @@ export function useAutoSelect(
 	selection: VariableSelection,
 	onAutoSelect: (selection: VariableSelection) => void,
 ): void {
-	const cycleReason = useDashboardStore(
-		selectVariableCycleReason(variable.name),
-	);
-
 	useEffect(() => {
-		const next = reconcileWithOptions(variable, selection, options, {
-			preserveSelection: cycleReason === VariableCycleReason.FullCycle,
-		});
+		const next = reconcileWithOptions(variable, selection, options);
 		if (next) {
 			onAutoSelect(next);
 		}

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/selectionTypes.ts

@@ -10,11 +10,6 @@ export interface VariableSelection {
 	value: SelectedVariableValue;
 	/** True when every option is selected ("ALL"); for dynamic vars value may be null. */
 	allSelected: boolean;
-	/**
-	 * Entries of `value` the user typed rather than picked. Never in any option list,
-	 * so the reconcile keeps them instead of reading them as invalid.
-	 */
-	customValues?: string[];
 }
 
 /** Selected values for a dashboard's variables, keyed by variable name. */

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/utils/resolveVariableSelection.ts

@@ -134,23 +134,12 @@ export function resolveDefaultSelection(
 	return { value: model.multiSelect ? [] : '', allSelected: false };
 }
 
-interface ReconcileOptions {
-	/**
-	 * Set when no other variable caused this refetch (time-range change, reload): the
-	 * selection then outranks the options and is kept as-is. Leave false for a
-	 * dependency cascade, where a selection that no longer applies must give way.
-	 */
-	preserveSelection?: boolean;
-}
-
 /**
  * Reconciles a variable's current selection against its freshly-fetched options.
  * Returns the next selection, or null when nothing should change (a valid pick is
  * left untouched — local-first). Behaviour, in order:
  * - materialize ALL to the full option set (query/custom);
- * - keep a multi-select selection outright when `preserveSelection` is set;
- * - keep a still-valid multi-select subset, dropping only entries the list no longer
- *   offers and the user did not type in (`customValues`);
+ * - keep a still-valid multi-select subset, dropping only invalid entries;
  * - otherwise auto-pick the default (or first option) so dependent variables and
  *   panels always resolve against a usable value.
  */
@@ -158,7 +147,6 @@ export function reconcileWithOptions(
 	model: VariableFormModel,
 	current: VariableSelection,
 	options: string[],
-	{ preserveSelection = false }: ReconcileOptions = {},
 ): VariableSelection | null {
 	if (options.length === 0) {
 		return null;
@@ -173,31 +161,13 @@ export function reconcileWithOptions(
 		Array.isArray(current.value) &&
 		current.value.length > 0
 	) {
-		// A pick this window has no data for is still the user's filter; re-defaulting it
-		// here is what widened a single pick to ALL on every time-range change.
-		if (preserveSelection) {
-			return null;
-		}
-
-		// A typed value is in no option list, so it is never "no longer offered".
-		const custom = new Set(current.customValues ?? []);
-		const valid = current.value
-			.map(String)
-			.filter((c) => options.includes(c) || custom.has(c));
-
+		const valid = current.value.map(String).filter((c) => options.includes(c));
 		if (valid.length === current.value.length) {
 			return null;
 		}
-		if (valid.length === 0) {
-			return fillDefault(model, options);
-		}
-
-		const customValues = valid.filter((v) => custom.has(v));
-		return {
-			value: valid,
-			allSelected: false,
-			...(customValues.length > 0 && { customValues }),
-		};
+		return valid.length > 0
+			? { value: valid, allSelected: false }
+			: fillDefault(model, options);
 	}
 
 	if (!model.multiSelect) {

frontend/src/pages/DashboardPageV2/DashboardContainer/VariablesBar/utils/selectionUtils.ts

@@ -47,43 +47,6 @@ export function hasUsableValue(
 	return value !== '' && value !== null && value !== undefined;
 }
 
-interface CommittedValues {
-	values: string[];
-	options: string[];
-	showAllOption: boolean;
-	emptyFallback: VariableSelection;
-}
-
-/**
- * The selection a multi-select commit resolves to. Options are known only here, so
- * this is where a value the list never offered is recorded as typed in.
- */
-export function selectionFromCommittedValues({
-	values,
-	options,
-	showAllOption,
-	emptyFallback,
-}: CommittedValues): VariableSelection {
-	if (values.length === 0) {
-		return emptyFallback;
-	}
-
-	const customValues = values.filter((value) => !options.includes(value));
-	// ALL re-materializes to the option set, so a set carrying a typed value is not ALL
-	// — the next refetch would expand it back and drop what the user typed.
-	const allSelected =
-		showAllOption &&
-		options.length > 0 &&
-		customValues.length === 0 &&
-		options.every((option) => values.includes(option));
-
-	return {
-		value: values,
-		allSelected,
-		...(customValues.length > 0 && { customValues }),
-	};
-}
-
 /** Flatten the selection map into the `{ name: value }` payload a query expects. */
 export function selectionToPayload(
 	selection: VariableSelectionMap,

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/__tests__/variableFetchSlice.test.ts

@@ -34,7 +34,6 @@ function reset(names: string[], context: VariableFetchContext): void {
 		variableFetchStates: {},
 		variableLastUpdated: {},
 		variableCycleIds: {},
-		variableCycleReasons: {},
 		variableFetchContext: null,
 	});
 	store().initVariableFetch(names, context);
@@ -134,33 +133,6 @@ describe('variableFetchSlice', () => {
 		expect(states().q1).toBe('error');
 		expect(states().q2).toBe('idle');
 	});
-
-	// The reason is what tells the post-fetch reconcile whether it may re-default a
-	// selection: a full cycle must not, a value cascade must.
-	it('tags a full cycle, then re-tags only the cascaded variables', () => {
-		store().enqueueFetchAll();
-		expect(store().variableCycleReasons).toStrictEqual({
-			q1: 'full-cycle',
-			q2: 'full-cycle',
-			d1: 'full-cycle',
-			d2: 'full-cycle',
-		});
-
-		resolve('q1');
-		store().enqueueDescendants('q1');
-		expect(store().variableCycleReasons).toStrictEqual({
-			q1: 'full-cycle',
-			q2: 'value-cascade',
-			d1: 'full-cycle',
-			d2: 'full-cycle',
-		});
-	});
-
-	it('drops the reason for a variable that no longer exists', () => {
-		store().enqueueFetchAll();
-		store().initVariableFetch(['q1'], context);
-		expect(store().variableCycleReasons).toStrictEqual({ q1: 'full-cycle' });
-	});
 });
 
 describe('variableFetchSlice — query depends on a dynamic', () => {

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/variableFetchSlice.ts

@@ -9,7 +9,6 @@ import {
 	type FetchMaps,
 	isVariableInActiveFetchState,
 	resolveFetchState,
-	VariableCycleReason,
 	VariableFetchState,
 } from './variableFetchSlice.utils';
 
@@ -31,10 +30,7 @@ function queryParentsHaveValues(
 	);
 }
 
-export {
-	VariableCycleReason,
-	VariableFetchState,
-} from './variableFetchSlice.utils';
+export { VariableFetchState } from './variableFetchSlice.utils';
 
 /**
  * Runtime fetch orchestration for dashboard variables — native port of V1's
@@ -49,8 +45,6 @@ export interface VariableFetchSlice {
 	variableFetchStates: Record<string, VariableFetchState>;
 	variableLastUpdated: Record<string, number>;
 	variableCycleIds: Record<string, number>;
-	/** Why each variable's current cycle was enqueued, read by the post-fetch reconcile. */
-	variableCycleReasons: Record<string, VariableCycleReason>;
 	/**
 	 * Whether a QUERY/DYNAMIC variable settled its fetch with zero options (so it
 	 * will never get a value). Lets a dependent panel fall through to "no data"
@@ -112,7 +106,6 @@ export const createVariableFetchSlice: StateCreator<
 	variableFetchStates: {},
 	variableLastUpdated: {},
 	variableCycleIds: {},
-	variableCycleReasons: {},
 	variableResolvedEmpty: {},
 	variableFetchContext: null,
 	lastFetchAllKey: null,
@@ -122,7 +115,6 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: {},
 			variableLastUpdated: {},
 			variableCycleIds: {},
-			variableCycleReasons: {},
 			variableResolvedEmpty: {},
 			variableFetchContext: null,
 			lastFetchAllKey: null,
@@ -140,7 +132,6 @@ export const createVariableFetchSlice: StateCreator<
 	initVariableFetch: (names, context): void => {
 		const maps = cloneMaps(get());
 		const resolvedEmpty = { ...get().variableResolvedEmpty };
-		const reasons = { ...get().variableCycleReasons };
 		names.forEach((name) => {
 			if (!maps.states[name]) {
 				maps.states[name] = VariableFetchState.Idle;
@@ -153,14 +144,12 @@ export const createVariableFetchSlice: StateCreator<
 				delete maps.lastUpdated[name];
 				delete maps.cycleIds[name];
 				delete resolvedEmpty[name];
-				delete reasons[name];
 			}
 		});
 		set({
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
-			variableCycleReasons: reasons,
 			variableResolvedEmpty: resolvedEmpty,
 			variableFetchContext: context,
 		});
@@ -182,11 +171,6 @@ export const createVariableFetchSlice: StateCreator<
 			dynamicVariableOrder,
 		} = variableFetchContext;
 		const maps = cloneMaps(get());
-		const reasons = { ...get().variableCycleReasons };
-		const bump = (name: string): void => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
-			reasons[name] = VariableCycleReason.FullCycle;
-		};
 
 		// Query variables wait only for their QUERY parents. A DYNAMIC parent does not
 		// gate: its option fetch feeds only its own dropdown, while its selected value
@@ -194,7 +178,7 @@ export const createVariableFetchSlice: StateCreator<
 		// dependent query substitutes it immediately and refetches via the cascade if
 		// it later changes. Text/custom parents resolve synchronously, so nothing waits.
 		queryVariableOrder.forEach((name) => {
-			bump(name);
+			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
 			const parents = dependencyData.parentGraph[name] || [];
 			const hasQueryParents = parents.some((p) => variableTypes[p] === 'QUERY');
 			maps.states[name] = hasQueryParents
@@ -208,7 +192,7 @@ export const createVariableFetchSlice: StateCreator<
 		const orderedQuery = new Set(queryVariableOrder);
 		Object.keys(variableTypes).forEach((name) => {
 			if (variableTypes[name] === 'QUERY' && !orderedQuery.has(name)) {
-				bump(name);
+				maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
 				maps.states[name] = resolveFetchState(maps, name);
 			}
 		});
@@ -219,7 +203,7 @@ export const createVariableFetchSlice: StateCreator<
 		// populate fast even when query variables are slow; a sibling selection change
 		// later refetches them via `enqueueDescendantsBatch`.
 		dynamicVariableOrder.forEach((name) => {
-			bump(name);
+			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
 			maps.states[name] = resolveFetchState(maps, name);
 		});
 
@@ -227,7 +211,6 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
-			variableCycleReasons: reasons,
 			lastFetchAllKey: key ?? get().lastFetchAllKey,
 		});
 	},
@@ -307,11 +290,6 @@ export const createVariableFetchSlice: StateCreator<
 		const { dependencyData, variableTypes, dynamicVariableOrder } =
 			variableFetchContext;
 		const maps = cloneMaps(get());
-		const reasons = { ...get().variableCycleReasons };
-		const bump = (name: string): void => {
-			maps.cycleIds[name] = (maps.cycleIds[name] || 0) + 1;
-			reasons[name] = VariableCycleReason.ValueCascade;
-		};
 		const changed = new Set(names);
 		// Callers commit values before this runs, so the gate sees the new parent values.
 		const selection = selectVariableValues(get().dashboardId)(get());
@@ -327,7 +305,7 @@ export const createVariableFetchSlice: StateCreator<
 			});
 		});
 		queryDescendants.forEach((desc) => {
-			bump(desc);
+			maps.cycleIds[desc] = (maps.cycleIds[desc] || 0) + 1;
 			maps.states[desc] = queryParentsHaveValues(
 				desc,
 				variableFetchContext,
@@ -344,7 +322,7 @@ export const createVariableFetchSlice: StateCreator<
 			dynamicVariableOrder
 				.filter((dynName) => !changed.has(dynName))
 				.forEach((dynName) => {
-					bump(dynName);
+					maps.cycleIds[dynName] = (maps.cycleIds[dynName] || 0) + 1;
 					maps.states[dynName] = resolveFetchState(maps, dynName);
 				});
 		}
@@ -353,7 +331,6 @@ export const createVariableFetchSlice: StateCreator<
 			variableFetchStates: maps.states,
 			variableLastUpdated: maps.lastUpdated,
 			variableCycleIds: maps.cycleIds,
-			variableCycleReasons: reasons,
 		});
 	},
 });
@@ -370,12 +347,6 @@ export const selectVariableCycleId =
 	(state: DashboardStore): number =>
 		state.variableCycleIds[name] ?? 0;
 
-/** Selector: why a variable's cycle was enqueued. Undefined for types that never fetch. */
-export const selectVariableCycleReason =
-	(name: string) =>
-	(state: DashboardStore): VariableCycleReason | undefined =>
-		state.variableCycleReasons[name];
-
 /** Selector: whether a variable has completed at least one fetch. */
 export const selectVariableFetchedOnce =
 	(name: string) =>

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/variableFetchSlice.utils.ts

@@ -7,14 +7,6 @@ export enum VariableFetchState {
 	Error = 'error',
 }
 
-/** Why a cycle was started — only a cascade may re-default a user's selection. */
-export enum VariableCycleReason {
-	/** `enqueueFetchAll`: load, time-range or variable-order change. */
-	FullCycle = 'full-cycle',
-	/** `enqueueDescendantsBatch`: a parent or sibling variable's value changed. */
-	ValueCascade = 'value-cascade',
-}
-
 /** Mutable clones a fetch action works over before committing back in one `set`. */
 export interface FetchMaps {
 	states: Record<string, VariableFetchState>;

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudsql_mysql/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#aecbfa;}.cls-1,.cls-2,.cls-3{fill-rule:evenodd;}.cls-2{fill:#669df6;}.cls-3{fill:#4285f4;}</style></defs><title>Icon_24px_SQL_Color</title><g data-name="Product Icons"><g ><polygon class="cls-1" points="4.67 10.44 4.67 13.45 12 17.35 12 14.34 4.67 10.44"/><polygon class="cls-1" points="4.67 15.09 4.67 18.1 12 22 12 18.99 4.67 15.09"/><polygon class="cls-2" points="12 17.35 19.33 13.45 19.33 10.44 12 14.34 12 17.35"/><polygon class="cls-2" points="12 22 19.33 18.1 19.33 15.09 12 18.99 12 22"/><polygon class="cls-3" points="19.33 8.91 19.33 5.9 12 2 12 5.01 19.33 8.91"/><polygon class="cls-2" points="12 2 4.67 5.9 4.67 8.91 12 5.01 12 2"/><polygon class="cls-1" points="4.67 5.87 4.67 8.89 12 12.79 12 9.77 4.67 5.87"/><polygon class="cls-2" points="12 12.79 19.33 8.89 19.33 5.87 12 9.77 12 12.79"/></g></g></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudsql_mysql/integration.json

@@ -0,0 +1,136 @@
+{
+  "id": "cloudsql_mysql",
+  "title": "GCP Cloud SQL for MySQL",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supportedSignals": {
+    "metrics": true,
+    "logs": true
+  },
+  "dataCollected": {
+    "metrics": [
+      {
+        "name": "cloudsql.googleapis.com/database/up",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/instance_state",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/replication/replica_lag",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/cpu/utilization",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/memory/utilization",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/disk/utilization",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/network/connections",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/queries",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/dml_operations_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/threads",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/innodb/buffer_pool_reads_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/innodb/buffer_pool_read_requests_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/slow_queries_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/aborted_connects_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/innodb/deadlocks_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/mysql/innodb/row_lock_waits_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/disk/read_ops_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "cloudsql.googleapis.com/database/disk/write_ops_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetryCollectionStrategy": {
+    "gcp": {}
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "GCP Cloud SQL for MySQL Overview",
+        "description": "Overview of GCP Cloud SQL for MySQL metrics",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudsql_mysql/overview.md

@@ -0,0 +1,3 @@
+### Monitor GCP Cloud SQL for MySQL with SigNoz
+
+Collect key GCP Cloud SQL for MySQL metrics and view them with an out of the box dashboard.

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudsql_postgres/assets/dashboards/overview.json

@@ -784,40 +784,57 @@
             {
               "kind": "time_series",
               "spec": {
-                "name": "A",
                 "plugin": {
-                  "kind": "signoz/BuilderQuery",
+                  "kind": "signoz/CompositeQuery",
                   "spec": {
-                    "name": "A",
-                    "signal": "metrics",
-                    "source": "",
-                    "aggregations": [
+                    "queries": [
                       {
-                        "metricName": "cloudsql.googleapis.com/database/cpu/utilization",
-                        "temporality": "",
-                        "timeAggregation": "max",
-                        "spaceAggregation": "max",
-                        "reduceTo": "avg"
-                      }
-                    ],
-                    "disabled": false,
-                    "filter": {
-                      "expression": "project_id = $project_id AND database_id in $database_id AND gcp.resource_type = 'cloudsql_database' "
-                    },
-                    "groupBy": [
+                        "type": "builder_query",
+                        "spec": {
+                          "name": "A",
+                          "stepInterval": 0,
+                          "signal": "metrics",
+                          "source": "",
+                          "aggregations": [
+                            {
+                              "metricName": "cloudsql.googleapis.com/database/cpu/utilization",
+                              "temporality": "",
+                              "timeAggregation": "max",
+                              "spaceAggregation": "max",
+                              "reduceTo": ""
+                            }
+                          ],
+                          "disabled": false,
+                          "filter": {
+                            "expression": "project_id = $project_id AND database_id in $database_id AND gcp.resource_type = 'cloudsql_database' "
+                          },
+                          "groupBy": [
+                            {
+                              "name": "database_id",
+                              "signal": "",
+                              "fieldContext": "attribute",
+                              "fieldDataType": "string"
+                            }
+                          ],
+                          "order": null,
+                          "selectFields": null,
+                          "secondaryAggregations": null,
+                          "functions": null,
+                          "legend": "{{database_id}}"
+                        }
+                      },
                       {
-                        "name": "database_id",
-                        "signal": "",
-                        "fieldContext": "attribute",
-                        "fieldDataType": "string"
+                        "type": "builder_formula",
+                        "spec": {
+                          "name": "F1",
+                          "expression": "100 * A",
+                          "disabled": false,
+                          "order": null,
+                          "functions": null,
+                          "legend": "{{database_id}}"
+                        }
                       }
-                    ],
-                    "order": [],
-                    "having": {
-                      "expression": ""
-                    },
-                    "functions": [],
-                    "legend": "{{database_id}}"
+                    ]
                   }
                 }
               }
@@ -1417,4 +1434,4 @@
     "refreshInterval": "",
     "links": []
   }
-}
+}

pkg/types/cloudintegrationtypes/serviceid.go

@@ -46,6 +46,7 @@ var (
 	GCPServiceComputeEngine    = ServiceID{valuer.NewString("computeengine")}
 	GCPServiceGKE              = ServiceID{valuer.NewString("gke")}
 	GCPServiceCloudStorage     = ServiceID{valuer.NewString("cloudstorage")}
+	GCPServiceCloudSQLMySQL    = ServiceID{valuer.NewString("cloudsql_mysql")}
 )
 
 func (ServiceID) Enum() []any {
@@ -82,6 +83,7 @@ func (ServiceID) Enum() []any {
 		GCPServiceComputeEngine,
 		GCPServiceGKE,
 		GCPServiceCloudStorage,
+		GCPServiceCloudSQLMySQL,
 	}
 }
 
@@ -124,6 +126,7 @@ var SupportedServices = map[CloudProviderType][]ServiceID{
 		GCPServiceComputeEngine,
 		GCPServiceGKE,
 		GCPServiceCloudStorage,
+		GCPServiceCloudSQLMySQL,
 	},
 }