rename buildReceiverStage -> createReceiverStage

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

docs/api/openapi.yml

@@ -4406,10 +4406,6 @@ components:
       properties:
         duration:
           type: string
-        endTime:
-          format: date-time
-          nullable: true
-          type: string
         repeatOn:
           items:
             $ref: '#/components/schemas/RuletypesRepeatOn'
@@ -4417,11 +4413,7 @@ components:
           type: array
         repeatType:
           $ref: '#/components/schemas/RuletypesRepeatType'
-        startTime:
-          format: date-time
-          type: string
       required:
-      - startTime
       - duration
       - repeatType
       type: object
@@ -4588,6 +4580,7 @@ components:
           type: string
       required:
       - timezone
+      - startTime
       type: object
     RuletypesScheduleType:
       enum:

ee/query-service/rules/manager.go

@@ -13,7 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -49,7 +48,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, tr)
 
 		// create ch rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeProm {
 
@@ -73,7 +72,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, pr)
 
 		// create promql rule task for evaluation
-		task = newTask(baserules.TaskTypeProm, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeProm, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeAnomaly {
 		// create anomaly rule
@@ -96,7 +95,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, ar)
 
 		// create anomaly rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
@@ -210,9 +209,9 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 }
 
 // newTask returns an appropriate group for the rule type
-func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) baserules.Task {
+func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc) baserules.Task {
 	if taskType == baserules.TaskTypeCh {
-		return baserules.NewRuleTask(name, "", frequency, rules, opts, notify, maintenanceStore, orgID)
+		return baserules.NewRuleTask(name, "", frequency, rules, opts, notify)
 	}
-	return baserules.NewPromRuleTask(name, "", frequency, rules, opts, notify, maintenanceStore, orgID)
+	return baserules.NewPromRuleTask(name, "", frequency, rules, opts, notify)
 }

frontend/.oxfmtrc.json

@@ -23,11 +23,6 @@
     "**/*.md",
     "**/*.json",
     "src/parser/**",
-    "src/TraceOperator/parser/**",
-    ".claude",
-    ".opencode",
-    "dist",
-    "playwright-report",
-    ".temp_cache"
+    "src/TraceOperator/parser/**"
   ]
 }

frontend/package.json

@@ -232,7 +232,6 @@
     "ts-jest": "29.4.6",
     "ts-node": "^10.2.1",
     "typescript-plugin-css-modules": "5.2.0",
-    "use-sync-external-store": "1.6.0",
     "vite-plugin-checker": "0.12.0",
     "vite-plugin-compression": "0.5.1",
     "vite-plugin-image-optimizer": "2.0.3",

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -5354,23 +5354,12 @@ export interface RuletypesRecurrenceDTO {
 	 * @type string
 	 */
 	duration: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 * @nullable true
-	 */
-	endTime?: Date | null;
 	/**
 	 * @type array
 	 * @nullable true
 	 */
 	repeatOn?: RuletypesRepeatOnDTO[] | null;
 	repeatType: RuletypesRepeatTypeDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	startTime: Date;
 }
 
 export interface RuletypesRenotifyDTO {
@@ -5555,7 +5544,7 @@ export interface RuletypesScheduleDTO {
 	 * @type string
 	 * @format date-time
 	 */
-	startTime?: Date;
+	startTime: Date;
 	/**
 	 * @type string
 	 */

frontend/src/container/InfraMonitoringK8s/Base/K8sBaseDetails.tsx

@@ -37,7 +37,10 @@ import {
 	X,
 } from 'lucide-react';
 import { isCustomTimeRange, useGlobalTimeStore } from 'store/globalTime';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime/utils';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import {
 	IBuilderQuery,
@@ -187,19 +190,16 @@ function K8sBaseDetails<T>({
 	);
 
 	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
-	const lastComputedMinMax = useGlobalTimeStore((s) => s.lastComputedMinMax);
 	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
-	const getAutoRefreshQueryKey = useGlobalTimeStore(
-		(s) => s.getAutoRefreshQueryKey,
-	);
 
-	const { startMs, endMs } = useMemo(
-		() => ({
-			startMs: Math.floor(lastComputedMinMax.minTime / NANO_SECOND_MULTIPLIER),
-			endMs: Math.floor(lastComputedMinMax.maxTime / NANO_SECOND_MULTIPLIER),
-		}),
-		[lastComputedMinMax],
-	);
+	const { startMs, endMs } = useMemo(() => {
+		const { minTime: startNs, maxTime: endNs } = getMinMaxTime(selectedTime);
+
+		return {
+			startMs: Math.floor(startNs / NANO_SECOND_MULTIPLIER),
+			endMs: Math.floor(endNs / NANO_SECOND_MULTIPLIER),
+		};
+	}, [getMinMaxTime, selectedTime]);
 
 	const [modalTimeRange, setModalTimeRange] = useState(() => ({
 		startTime: startMs,
@@ -246,7 +246,7 @@ function K8sBaseDetails<T>({
 				`${queryKeyPrefix}EntityDetails`,
 				selectedItem,
 			),
-		[getAutoRefreshQueryKey, queryKeyPrefix, selectedItem, selectedTime],
+		[queryKeyPrefix, selectedItem, selectedTime],
 	);
 
 	const {

frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.tsx

@@ -16,7 +16,10 @@ import { InfraMonitoringEvents } from 'constants/events';
 import { ChevronDown, ChevronRight } from 'lucide-react';
 import { parseAsString, useQueryState } from 'nuqs';
 import { useGlobalTimeStore } from 'store/globalTime';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime/utils';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
 import { openInNewTab } from 'utils/navigation';
@@ -111,9 +114,6 @@ export function K8sBaseList<T>({
 	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
 	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
 	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
-	const getAutoRefreshQueryKey = useGlobalTimeStore(
-		(s) => s.getAutoRefreshQueryKey,
-	);
 
 	const queryKey = useMemo(() => {
 		return getAutoRefreshQueryKey(
@@ -127,7 +127,6 @@ export function K8sBaseList<T>({
 			JSON.stringify(groupBy),
 		);
 	}, [
-		getAutoRefreshQueryKey,
 		selectedTime,
 		entity,
 		pageSize,

frontend/src/container/InfraMonitoringK8s/Base/K8sExpandedRow.tsx

@@ -11,7 +11,10 @@ import {
 } from 'antd';
 import { CornerDownRight } from 'lucide-react';
 import { useGlobalTimeStore } from 'store/globalTime';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime/utils';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
@@ -115,9 +118,6 @@ export function K8sExpandedRow<T>({
 	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
 	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
 	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
-	const getAutoRefreshQueryKey = useGlobalTimeStore(
-		(s) => s.getAutoRefreshQueryKey,
-	);
 
 	const queryKey = useMemo(() => {
 		return getAutoRefreshQueryKey(selectedTime, [
@@ -126,7 +126,7 @@ export function K8sExpandedRow<T>({
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
 		]);
-	}, [getAutoRefreshQueryKey, selectedTime, record.key, queryFilters, orderBy]);
+	}, [selectedTime, record.key, queryFilters, orderBy]);
 
 	const { data, isFetching, isLoading, isError } = useQuery({
 		queryKey,

frontend/src/container/PlannedDowntime/PlannedDowntime.tsx

@@ -17,6 +17,7 @@ import { Search } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import { USER_ROLES } from 'types/roles';
+import { DeepPartial } from 'utils/types';
 
 import 'dayjs/locale/en';
 
@@ -24,7 +25,7 @@ import { PlannedDowntimeDeleteModal } from './PlannedDowntimeDeleteModal';
 import { PlannedDowntimeForm } from './PlannedDowntimeForm';
 import { PlannedDowntimeList } from './PlannedDowntimeList';
 import {
-	defautlInitialValues,
+	defaultInitialValues,
 	deleteDowntimeHandler,
 } from './PlannedDowntimeutils';
 
@@ -48,8 +49,8 @@ export function PlannedDowntime(): JSX.Element {
 	const urlQuery = useUrlQuery();
 
 	const [initialValues, setInitialValues] =
-		useState<Partial<RuletypesPlannedMaintenanceDTO & { editMode: boolean }>>(
-			defautlInitialValues,
+		useState<DeepPartial<RuletypesPlannedMaintenanceDTO & { editMode: boolean }>>(
+			defaultInitialValues,
 		);
 
 	const downtimeSchedules = useListDowntimeSchedules();
@@ -149,7 +150,7 @@ export function PlannedDowntime(): JSX.Element {
 							icon={<PlusOutlined />}
 							type="primary"
 							onClick={(): void => {
-								setInitialValues({ ...defautlInitialValues, editMode: false });
+								setInitialValues({ ...defaultInitialValues, editMode: false });
 								setIsOpen(true);
 								setEditMode(false);
 								form.resetFields();

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -1,4 +1,10 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, {
+	ReactNode,
+	useCallback,
+	useEffect,
+	useMemo,
+	useState,
+} from 'react';
 import { CheckOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -38,6 +44,8 @@ import { defaultTo, isEmpty } from 'lodash-es';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 import { ALL_TIME_ZONES } from 'utils/timeZoneUtil';
+import { type PanelMode } from 'rc-picker/lib/interface';
+import { DeepPartial } from 'utils/types';
 
 import 'dayjs/locale/en';
 
@@ -69,14 +77,13 @@ interface PlannedDowntimeFormData {
 	endTime: dayjs.Dayjs | string;
 	recurrence?: RuletypesRecurrenceDTO | null;
 	alertRules: DefaultOptionType[];
-	recurrenceSelect?: RuletypesRecurrenceDTO;
 	timezone?: string;
 }
 
 const customFormat = DATE_TIME_FORMATS.ORDINAL_DATETIME;
 
 interface PlannedDowntimeFormProps {
-	initialValues: Partial<
+	initialValues: DeepPartial<
 		RuletypesPlannedMaintenanceDTO & {
 			editMode: boolean;
 		}
@@ -88,7 +95,7 @@ interface PlannedDowntimeFormProps {
 	setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
 	refetchAllSchedules: () => void;
 	isEditMode: boolean;
-	form: FormInstance<any>;
+	form: FormInstance;
 }
 
 export function PlannedDowntimeForm(
@@ -132,14 +139,13 @@ export function PlannedDowntimeForm(
 	const { notifications } = useNotifications();
 	const { showErrorModal } = useErrorModal();
 
-	const datePickerFooter = (mode: any): any =>
+	const datePickerFooter = (mode: PanelMode): ReactNode =>
 		mode === 'time' ? (
 			<span style={{ color: 'gray' }}>Please select the time</span>
 		) : null;
 
-	const saveHanlder = useCallback(
+	const saveHandler = useCallback(
 		async (values: PlannedDowntimeFormData) => {
-			const shouldKeepLocalTime = !isEditMode;
 			const data: RuletypesPostablePlannedMaintenanceDTO = {
 				alertIds: values.alertRules
 					.map((alert) => alert.value)
@@ -151,7 +157,6 @@ export function PlannedDowntimeForm(
 							values.startTime,
 							timezoneInitialValue,
 							values.timezone,
-							shouldKeepLocalTime,
 						),
 					),
 					timezone: values.timezone as string,
@@ -161,7 +166,6 @@ export function PlannedDowntimeForm(
 									values.endTime,
 									timezoneInitialValue,
 									values.timezone,
-									shouldKeepLocalTime,
 								),
 							)
 						: undefined,
@@ -202,38 +206,24 @@ export function PlannedDowntimeForm(
 		],
 	);
 	const onFinish = async (values: PlannedDowntimeFormData): Promise<void> => {
+		const { recurrence } = values;
 		const recurrenceData =
-			values?.recurrence?.repeatType === recurrenceOptions.doesNotRepeat.value
+			!recurrence ||
+			recurrence.repeatType === recurrenceOptions.doesNotRepeat.value
 				? undefined
 				: {
-						duration: values.recurrence?.duration
-							? `${values.recurrence?.duration}${durationUnit}`
+						duration: recurrence.duration
+							? `${recurrence.duration}${durationUnit}`
 							: undefined,
-						endTime: !isEmpty(values.endTime)
-							? handleTimeConversion(
-									values.endTime,
-									timezoneInitialValue,
-									values.timezone,
-									!isEditMode,
-								)
-							: undefined,
-						startTime: handleTimeConversion(
-							values.startTime,
-							timezoneInitialValue,
-							values.timezone,
-							!isEditMode,
-						),
-						repeatOn: !values.recurrence?.repeatOn?.length
-							? undefined
-							: values.recurrence?.repeatOn,
-						repeatType: values.recurrence?.repeatType,
+						repeatOn: recurrence.repeatOn?.length ? recurrence.repeatOn : undefined,
+						repeatType: recurrence.repeatType,
 					};
 
 		const payloadValues = {
 			...values,
 			recurrence: recurrenceData as RuletypesRecurrenceDTO | undefined,
 		};
-		await saveHanlder(payloadValues);
+		await saveHandler(payloadValues);
 	};
 
 	const formValidationRules = [
@@ -286,7 +276,7 @@ export function PlannedDowntimeForm(
 				: '',
 			recurrence: {
 				...initialValues.schedule?.recurrence,
-				repeatType: (!isScheduleRecurring(initialValues?.schedule)
+				repeatType: (!isScheduleRecurring(initialValues.schedule)
 					? recurrenceOptions.doesNotRepeat.value
 					: initialValues.schedule?.recurrence
 							?.repeatType) as RuletypesRecurrenceDTO['repeatType'],
@@ -316,7 +306,6 @@ export function PlannedDowntimeForm(
 	const getTimezoneFormattedTime = (
 		time: string | dayjs.Dayjs,
 		timeZone?: string,
-		isEditMode?: boolean,
 		format?: string,
 	): string => {
 		if (!time) {
@@ -325,20 +314,11 @@ export function PlannedDowntimeForm(
 		if (!timeZone) {
 			return dayjs(time).format(format);
 		}
-		return dayjs(time).tz(timeZone, isEditMode).format(format);
+		return dayjs(time).tz(timeZone).format(format);
 	};
 
 	const startTimeText = useMemo((): string => {
-		let startTime = formData?.startTime;
-		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			startTime =
-				(formData?.recurrence?.startTime
-					? dayjs(formData.recurrence.startTime).toISOString()
-					: '') ||
-				formData?.startTime ||
-				'';
-		}
-
+		let startTime = formData.startTime;
 		if (!startTime) {
 			return '';
 		}
@@ -348,7 +328,6 @@ export function PlannedDowntimeForm(
 				startTime,
 				timezoneInitialValue,
 				formData?.timezone,
-				!isEditMode,
 			);
 		}
 		const daysOfWeek = formData?.recurrence?.repeatOn;
@@ -356,21 +335,16 @@ export function PlannedDowntimeForm(
 		const formattedStartTime = getTimezoneFormattedTime(
 			startTime,
 			formData.timezone,
-			!isEditMode,
 			TIME_FORMAT,
 		);
-
 		const formattedStartDate = getTimezoneFormattedTime(
 			startTime,
 			formData.timezone,
-			!isEditMode,
 			DATE_FORMAT,
 		);
-
 		const ordinalFormat = getTimezoneFormattedTime(
 			startTime,
 			formData.timezone,
-			!isEditMode,
 			ORDINAL_FORMAT,
 		);
 
@@ -387,21 +361,10 @@ export function PlannedDowntimeForm(
 			default:
 				return `Scheduled for ${formattedStartDate} starting at ${formattedStartTime}.`;
 		}
-	}, [formData, recurrenceType, isEditMode, timezoneInitialValue]);
+	}, [formData, recurrenceType, timezoneInitialValue]);
 
 	const endTimeText = useMemo((): string => {
 		let endTime = formData?.endTime;
-		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			endTime =
-				(formData?.recurrence?.endTime
-					? dayjs(formData.recurrence.endTime).toISOString()
-					: '') || '';
-
-			if (!isEditMode && !endTime) {
-				endTime = formData?.endTime || '';
-			}
-		}
-
 		if (!endTime) {
 			return '';
 		}
@@ -411,25 +374,21 @@ export function PlannedDowntimeForm(
 				endTime,
 				timezoneInitialValue,
 				formData?.timezone,
-				!isEditMode,
 			);
 		}
 
 		const formattedEndTime = getTimezoneFormattedTime(
 			endTime,
 			formData.timezone,
-			!isEditMode,
 			TIME_FORMAT,
 		);
-
 		const formattedEndDate = getTimezoneFormattedTime(
 			endTime,
 			formData.timezone,
-			!isEditMode,
 			DATE_FORMAT,
 		);
 		return `Scheduled to end maintenance on ${formattedEndDate} at ${formattedEndTime}.`;
-	}, [formData, recurrenceType, isEditMode, timezoneInitialValue]);
+	}, [formData, timezoneInitialValue]);
 
 	return (
 		<Modal
@@ -464,7 +423,7 @@ export function PlannedDowntimeForm(
 					name="startTime"
 					rules={formValidationRules}
 					className={!isEmpty(startTimeText) ? 'formItemWithBullet' : ''}
-					getValueProps={(value): any => ({
+					getValueProps={(value) => ({
 						value: value ? dayjs(value).tz(timezoneInitialValue) : undefined,
 					})}
 				>
@@ -545,7 +504,7 @@ export function PlannedDowntimeForm(
 						},
 					]}
 					className={!isEmpty(endTimeText) ? 'formItemWithBullet' : ''}
-					getValueProps={(value): any => ({
+					getValueProps={(value) => ({
 						value: value ? dayjs(value).tz(timezoneInitialValue) : undefined,
 					})}
 				>

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -1,4 +1,4 @@
-import { ReactNode, useEffect } from 'react';
+import React, { ReactNode, useEffect } from 'react';
 import { UseQueryResult } from 'react-query';
 import { Color } from '@signozhq/design-tokens';
 import {
@@ -26,8 +26,9 @@ import { defaultTo } from 'lodash-es';
 import { CalendarClock, PenLine, Trash2 } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { USER_ROLES } from 'types/roles';
+import { showErrorNotification } from 'utils/error';
+import { DeepPartial } from 'utils/types';
 
-import { showErrorNotification } from '../../utils/error';
 import {
 	formatDateTime,
 	getAlertOptionsFromIds,
@@ -35,7 +36,6 @@ import {
 	getEndTime,
 	recurrenceInfo,
 } from './PlannedDowntimeutils';
-
 import './PlannedDowntime.styles.scss';
 
 const { Panel } = Collapse;
@@ -144,7 +144,7 @@ export function CollapseListContent({
 	created_at?: string;
 	created_by_name?: string;
 	created_by_email?: string;
-	timeframe: [string | undefined | null, string | undefined | null];
+	timeframe: [string | undefined, string | undefined];
 	repeats?: RuletypesRecurrenceDTO | null;
 	updated_at?: string;
 	updated_by_name?: string;
@@ -200,7 +200,12 @@ export function CollapseListContent({
 				),
 			)}
 			{renderItems('Timezone', <Typography>{timezone || '-'}</Typography>)}
-			{renderItems('Repeats', <Typography>{recurrenceInfo(repeats)}</Typography>)}
+			{renderItems(
+				'Repeats',
+				<Typography>
+					{recurrenceInfo(timeframe[0], timeframe[1], repeats)}
+				</Typography>,
+			)}
 			{renderItems(
 				'Alerts silenced',
 				alertOptions?.length ? (
@@ -220,7 +225,7 @@ export function CollapseListContent({
 export function CustomCollapseList(
 	props: DowntimeSchedulesTableData & {
 		setInitialValues: React.Dispatch<
-			React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
+			React.SetStateAction<DeepPartial<RuletypesPlannedMaintenanceDTO>>
 		>;
 		setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
 		handleDeleteDowntime: (id: string, name: string) => void;
@@ -291,9 +296,7 @@ export function CustomCollapseList(
 							schedule?.startTime?.toString(),
 							typeof endTime === 'string' ? endTime : endTime?.toString(),
 						]}
-						repeats={
-							schedule?.recurrence as RuletypesRecurrenceDTO | null | undefined
-						}
+						repeats={schedule?.recurrence}
 						updated_at={updatedAt ? dayjs(updatedAt).toISOString() : ''}
 						updated_by_name={defaultTo(updatedBy, '')}
 						alertOptions={alertOptions}
@@ -328,7 +331,7 @@ export function PlannedDowntimeList({
 	>;
 	alertOptions: DefaultOptionType[];
 	setInitialValues: React.Dispatch<
-		React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
+		React.SetStateAction<DeepPartial<RuletypesPlannedMaintenanceDTO>>
 	>;
 	setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
 	handleDeleteDowntime: (id: string, name: string) => void;

frontend/src/container/PlannedDowntime/PlannedDowntimeutils.ts

@@ -2,7 +2,7 @@ import { UseMutateAsyncFunction } from 'react-query';
 import type { NotificationInstance } from 'antd/es/notification/interface';
 import type { DefaultOptionType } from 'antd/es/select';
 import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import type {
+import {
 	DeleteDowntimeScheduleByIDPathParameters,
 	RenderErrorResponseDTO,
 	RuletypesPlannedMaintenanceDTO,
@@ -14,6 +14,7 @@ import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
 import { isEmpty, isEqual } from 'lodash-es';
 import APIError from 'types/api/error';
+import { DeepPartial } from 'utils/types';
 
 type DateTimeString = string | null | undefined;
 
@@ -60,13 +61,15 @@ export const getAlertOptionsFromIds = (
 	);
 
 export const recurrenceInfo = (
+	startTime?: string,
+	endTime?: string,
 	recurrence?: RuletypesRecurrenceDTO | null,
 ): string => {
 	if (!recurrence) {
 		return 'No';
 	}
 
-	const { startTime, duration, repeatOn, repeatType, endTime } = recurrence;
+	const { duration, repeatOn, repeatType } = recurrence;
 
 	const formattedStartTime = startTime
 		? formatDateTime(dayjs(startTime).toISOString())
@@ -80,7 +83,7 @@ export const recurrenceInfo = (
 	return `Repeats - ${repeatType} ${weeklyRepeatString} from ${formattedStartTime} ${formattedEndTime} ${durationString}`;
 };
 
-export const defautlInitialValues: Partial<
+export const defaultInitialValues: DeepPartial<
 	RuletypesPlannedMaintenanceDTO & { editMode: boolean }
 > = {
 	name: '',
@@ -210,39 +213,17 @@ export const recurrenceOptionWithSubmenu: Option[] = [
 	recurrenceOptions.monthly,
 ];
 
-export const getRecurrenceOptionFromValue = (
-	value?: string | Option | null,
-): Option | null | undefined => {
-	if (!value) {
-		return null;
-	}
-	if (typeof value === 'string') {
-		return Object.values(recurrenceOptions).find(
-			(option) => option.value === value,
-		);
-	}
-	return value;
-};
-
 export const getEndTime = ({
-	kind,
 	schedule,
-}: Partial<
+}: DeepPartial<
 	RuletypesPlannedMaintenanceDTO & {
 		editMode: boolean;
 	}
->): string | dayjs.Dayjs => {
-	if (kind === 'fixed') {
-		return schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '';
-	}
-
-	return schedule?.recurrence?.endTime
-		? dayjs(schedule.recurrence.endTime).toISOString()
-		: '';
-};
+>): string | dayjs.Dayjs =>
+	schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '';
 
 export const isScheduleRecurring = (
-	schedule?: RuletypesPlannedMaintenanceDTO['schedule'] | null,
+	schedule?: DeepPartial<RuletypesPlannedMaintenanceDTO['schedule']> | null,
 ): boolean => (schedule ? !isEmpty(schedule?.recurrence) : false);
 
 function convertUtcOffsetToTimezoneOffset(offsetMinutes: number): string {
@@ -272,7 +253,6 @@ export function handleTimeConversion(
 	dateValue: string | dayjs.Dayjs,
 	timezoneInit?: string,
 	timezone?: string,
-	shouldKeepLocalTime?: boolean,
 ): string {
 	const timezoneChanged = !isEqual(timezoneInit, timezone);
 	const initialTime = dayjs(dateValue).tz(timezoneInit);
@@ -280,5 +260,5 @@ export function handleTimeConversion(
 	const formattedTime = formatWithTimezone(initialTime, timezone);
 	return timezoneChanged
 		? formattedTime
-		: dayjs(dateValue).tz(timezone, shouldKeepLocalTime).format();
+		: dayjs(dateValue).tz(timezone).format();
 }

frontend/src/container/PlannedDowntime/__test__/testUtils.ts

@@ -8,7 +8,7 @@ import {
 } from 'api/generated/services/sigNoz.schemas';
 
 export const buildSchedule = (
-	schedule: Partial<RuletypesScheduleDTO>,
+	schedule: RuletypesScheduleDTO,
 ): RuletypesScheduleDTO => ({
 	timezone: schedule?.timezone ?? '',
 	startTime: schedule?.startTime,
@@ -17,16 +17,13 @@ export const buildSchedule = (
 });
 
 export const createMockDowntime = (
-	overrides: Partial<RuletypesPlannedMaintenanceDTO>,
+	overrides: Partial<RuletypesPlannedMaintenanceDTO> &
+		Pick<RuletypesPlannedMaintenanceDTO, 'schedule'>,
 ): RuletypesPlannedMaintenanceDTO => ({
 	id: overrides.id ?? '0',
 	name: overrides.name ?? '',
 	description: overrides.description ?? '',
-	schedule: buildSchedule({
-		timezone: 'UTC',
-		startTime: new Date('2024-01-01'),
-		...overrides.schedule,
-	}),
+	schedule: overrides.schedule,
 	alertIds: overrides.alertIds ?? [],
 	createdAt: overrides.createdAt,
 	createdBy: overrides.createdBy ?? '',

frontend/src/container/TopNav/DateTimeSelectionV2/index.tsx

@@ -17,7 +17,7 @@ import dayjs, { Dayjs } from 'dayjs';
 import {
 	useGlobalTimeQueryInvalidate,
 	useIsGlobalTimeQueryRefreshing,
-} from 'store/globalTime';
+} from 'hooks/globalTime';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
@@ -101,14 +101,14 @@ function DateTimeSelection({
 	if (modalInitialStartTime !== undefined) {
 		initialModalStartTime = modalInitialStartTime;
 	} else if (searchStartTime) {
-		initialModalStartTime = Number.parseInt(searchStartTime, 10);
+		initialModalStartTime = parseInt(searchStartTime, 10);
 	}
 
 	let initialModalEndTime = 0;
 	if (modalInitialEndTime !== undefined) {
 		initialModalEndTime = modalInitialEndTime;
 	} else if (searchEndTime) {
-		initialModalEndTime = Number.parseInt(searchEndTime, 10);
+		initialModalEndTime = parseInt(searchEndTime, 10);
 	}
 
 	const [modalStartTime, setModalStartTime] = useState<number>(
@@ -159,11 +159,9 @@ function DateTimeSelection({
 	const getTime = useCallback((): [number, number] | undefined => {
 		if (searchEndTime && searchStartTime) {
 			const startDate = dayjs(
-				new Date(Number.parseInt(getTimeString(searchStartTime), 10)),
-			);
-			const endDate = dayjs(
-				new Date(Number.parseInt(getTimeString(searchEndTime), 10)),
+				new Date(parseInt(getTimeString(searchStartTime), 10)),
 			);
+			const endDate = dayjs(new Date(parseInt(getTimeString(searchEndTime), 10)));
 
 			return [startDate.toDate().getTime() || 0, endDate.toDate().getTime() || 0];
 		}

frontend/src/hooks/globalTime/index.ts

@@ -0,0 +1,2 @@
+export { useGlobalTimeQueryInvalidate } from './useGlobalTimeQueryInvalidate';
+export { useIsGlobalTimeQueryRefreshing } from './useIsGlobalTimeQueryRefreshing';

frontend/src/hooks/globalTime/useGlobalTimeQueryInvalidate.ts

@@ -0,0 +1,16 @@
+import { useCallback } from 'react';
+import { useQueryClient } from 'react-query';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+
+/**
+ * Use when you want to invalida any query tracked by {@link REACT_QUERY_KEY.AUTO_REFRESH_QUERY}
+ */
+export function useGlobalTimeQueryInvalidate(): () => Promise<void> {
+	const queryClient = useQueryClient();
+
+	return useCallback(async () => {
+		return await queryClient.invalidateQueries({
+			queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY],
+		});
+	}, [queryClient]);
+}

frontend/src/hooks/globalTime/useIsGlobalTimeQueryRefreshing.ts

@@ -0,0 +1,13 @@
+import { useIsFetching } from 'react-query';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+
+/**
+ * Use when you want to know if any query tracked by {@link REACT_QUERY_KEY.AUTO_REFRESH_QUERY} is refreshing
+ */
+export function useIsGlobalTimeQueryRefreshing(): boolean {
+	return (
+		useIsFetching({
+			queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY],
+		}) > 0
+	);
+}

frontend/src/store/globalTime/GlobalTimeContext.tsx

@@ -1,71 +0,0 @@
-import {
-	// oxlint-disable-next-line no-restricted-imports
-	createContext,
-	ReactNode,
-	// oxlint-disable-next-line no-restricted-imports
-	useContext,
-	useState,
-} from 'react';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-
-import get from 'api/browser/localstorage/get';
-
-import {
-	createGlobalTimeStore,
-	defaultGlobalTimeStore,
-	GlobalTimeStoreApi,
-} from './globalTimeStore';
-import { GlobalTimeProviderOptions, GlobalTimeSelectedTime } from './types';
-import { usePersistence } from './usePersistence';
-import { useQueryCacheSync } from './useQueryCacheSync';
-import { useUrlSync } from './useUrlSync';
-import { useComputedMinMaxSync } from 'store/globalTime/useComputedMinMaxSync';
-
-export const GlobalTimeContext = createContext<GlobalTimeStoreApi | null>(null);
-
-export function GlobalTimeProvider({
-	children,
-	name,
-	inheritGlobalTime = false,
-	initialTime,
-	enableUrlParams = false,
-	removeQueryParamsOnUnmount = false,
-	localStoragePersistKey,
-	refreshInterval: initialRefreshInterval,
-}: GlobalTimeProviderOptions & { children: ReactNode }): JSX.Element {
-	const parentStore = useContext(GlobalTimeContext);
-	const globalStore = parentStore ?? defaultGlobalTimeStore;
-
-	const resolveInitialTime = (): GlobalTimeSelectedTime => {
-		if (inheritGlobalTime) {
-			return globalStore.getState().selectedTime;
-		}
-		if (localStoragePersistKey) {
-			const stored = get(localStoragePersistKey);
-			if (stored) {
-				return stored as GlobalTimeSelectedTime;
-			}
-		}
-		return initialTime ?? DEFAULT_TIME_RANGE;
-	};
-
-	// Create isolated store (stable reference)
-	const [store] = useState(() =>
-		createGlobalTimeStore({
-			name,
-			selectedTime: resolveInitialTime(),
-			refreshInterval: initialRefreshInterval ?? 0,
-		}),
-	);
-
-	useComputedMinMaxSync(store);
-	useQueryCacheSync(store);
-	useUrlSync(store, enableUrlParams, removeQueryParamsOnUnmount);
-	usePersistence(store, localStoragePersistKey);
-
-	return (
-		<GlobalTimeContext.Provider value={store}>
-			{children}
-		</GlobalTimeContext.Provider>
-	);
-}

frontend/src/store/globalTime/__tests__/GlobalTimeContext.test.tsx

@@ -1,693 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { ReactNode } from 'react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-
-import set from 'api/browser/localstorage/set';
-
-import { GlobalTimeProvider } from '../GlobalTimeContext';
-import { useGlobalTime } from '../hooks';
-import { GlobalTimeProviderOptions } from '../types';
-import { createCustomTimeRange, NANO_SECOND_MULTIPLIER } from '../utils';
-
-jest.mock('api/browser/localstorage/set');
-
-const createTestQueryClient = (): QueryClient =>
-	new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-			},
-		},
-	});
-
-const createWrapper = (
-	providerProps: GlobalTimeProviderOptions,
-	nuqsProps?: { searchParams?: string },
-) => {
-	const queryClient = createTestQueryClient();
-
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<NuqsTestingAdapter searchParams={nuqsProps?.searchParams}>
-					<GlobalTimeProvider {...providerProps}>{children}</GlobalTimeProvider>
-				</NuqsTestingAdapter>
-			</QueryClientProvider>
-		);
-	};
-};
-
-describe('GlobalTimeProvider', () => {
-	describe('name prop', () => {
-		it('should pass name to store when provided', () => {
-			const wrapper = createWrapper({ name: 'test-drawer' });
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.name), {
-				wrapper,
-			});
-
-			expect(result.current).toBe('test-drawer');
-		});
-
-		it('should have undefined name when not provided', () => {
-			const wrapper = createWrapper({});
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.name), {
-				wrapper,
-			});
-
-			expect(result.current).toBeUndefined();
-		});
-	});
-
-	describe('store isolation', () => {
-		it('should create isolated store for each provider', () => {
-			const wrapper1 = createWrapper({ initialTime: '1h' });
-			const wrapper2 = createWrapper({ initialTime: '15m' });
-
-			const { result: result1 } = renderHook(
-				() => useGlobalTime((s) => s.selectedTime),
-				{ wrapper: wrapper1 },
-			);
-			const { result: result2 } = renderHook(
-				() => useGlobalTime((s) => s.selectedTime),
-				{ wrapper: wrapper2 },
-			);
-
-			expect(result1.current).toBe('1h');
-			expect(result2.current).toBe('15m');
-		});
-	});
-
-	describe('inheritGlobalTime', () => {
-		it('should inherit time from parent store when inheritGlobalTime is true', () => {
-			const queryClient = createTestQueryClient();
-
-			const NestedWrapper = ({
-				children,
-			}: {
-				children: React.ReactNode;
-			}): JSX.Element => (
-				<QueryClientProvider client={queryClient}>
-					<NuqsTestingAdapter>
-						<GlobalTimeProvider initialTime="6h">
-							<GlobalTimeProvider inheritGlobalTime>{children}</GlobalTimeProvider>
-						</GlobalTimeProvider>
-					</NuqsTestingAdapter>
-				</QueryClientProvider>
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper: NestedWrapper,
-			});
-
-			// Should inherit '6h' from parent provider
-			expect(result.current).toBe('6h');
-		});
-
-		it('should use initialTime when inheritGlobalTime is false', () => {
-			const queryClient = createTestQueryClient();
-
-			const NestedWrapper = ({
-				children,
-			}: {
-				children: React.ReactNode;
-			}): JSX.Element => (
-				<QueryClientProvider client={queryClient}>
-					<NuqsTestingAdapter>
-						<GlobalTimeProvider initialTime="6h">
-							<GlobalTimeProvider inheritGlobalTime={false} initialTime="15m">
-								{children}
-							</GlobalTimeProvider>
-						</GlobalTimeProvider>
-					</NuqsTestingAdapter>
-				</QueryClientProvider>
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper: NestedWrapper,
-			});
-
-			// Should use its own initialTime, not parent's
-			expect(result.current).toBe('15m');
-		});
-
-		it('should prefer URL params over inheritGlobalTime when both are present', async () => {
-			const queryClient = createTestQueryClient();
-
-			const NestedWrapper = ({
-				children,
-			}: {
-				children: React.ReactNode;
-			}): JSX.Element => (
-				<QueryClientProvider client={queryClient}>
-					<NuqsTestingAdapter searchParams="?relativeTime=1h">
-						<GlobalTimeProvider initialTime="6h">
-							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
-								{children}
-							</GlobalTimeProvider>
-						</GlobalTimeProvider>
-					</NuqsTestingAdapter>
-				</QueryClientProvider>
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper: NestedWrapper,
-			});
-
-			// inheritGlobalTime sets initial value to '6h', but URL sync updates it to '1h'
-			await waitFor(() => {
-				expect(result.current).toBe('1h');
-			});
-		});
-
-		it('should use inherited time when URL params are empty', async () => {
-			const queryClient = createTestQueryClient();
-
-			const NestedWrapper = ({
-				children,
-			}: {
-				children: React.ReactNode;
-			}): JSX.Element => (
-				<QueryClientProvider client={queryClient}>
-					<NuqsTestingAdapter searchParams="">
-						<GlobalTimeProvider initialTime="6h">
-							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
-								{children}
-							</GlobalTimeProvider>
-						</GlobalTimeProvider>
-					</NuqsTestingAdapter>
-				</QueryClientProvider>
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper: NestedWrapper,
-			});
-
-			// No URL params, should keep inherited value
-			expect(result.current).toBe('6h');
-		});
-
-		it('should prefer custom time URL params over inheritGlobalTime', async () => {
-			const queryClient = createTestQueryClient();
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-
-			const NestedWrapper = ({
-				children,
-			}: {
-				children: React.ReactNode;
-			}): JSX.Element => (
-				<QueryClientProvider client={queryClient}>
-					<NuqsTestingAdapter
-						searchParams={`?startTime=${startTime}&endTime=${endTime}`}
-					>
-						<GlobalTimeProvider initialTime="6h">
-							<GlobalTimeProvider inheritGlobalTime enableUrlParams>
-								{children}
-							</GlobalTimeProvider>
-						</GlobalTimeProvider>
-					</NuqsTestingAdapter>
-				</QueryClientProvider>
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), {
-				wrapper: NestedWrapper,
-			});
-
-			// URL custom time params should override inherited time
-			await waitFor(() => {
-				const { minTime, maxTime } = result.current.getMinMaxTime();
-				expect(minTime).toBe(startTime * NANO_SECOND_MULTIPLIER);
-				expect(maxTime).toBe(endTime * NANO_SECOND_MULTIPLIER);
-			});
-		});
-	});
-
-	describe('URL sync', () => {
-		it('should read relativeTime from URL on mount', async () => {
-			const wrapper = createWrapper(
-				{ enableUrlParams: true },
-				{ searchParams: '?relativeTime=1h' },
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			await waitFor(() => {
-				expect(result.current).toBe('1h');
-			});
-		});
-
-		it('should read custom time from URL on mount', async () => {
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-			const wrapper = createWrapper(
-				{ enableUrlParams: true },
-				{ searchParams: `?startTime=${startTime}&endTime=${endTime}` },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				const { minTime, maxTime } = result.current.getMinMaxTime();
-				expect(minTime).toBe(startTime * NANO_SECOND_MULTIPLIER);
-				expect(maxTime).toBe(endTime * NANO_SECOND_MULTIPLIER);
-			});
-		});
-
-		it('should use custom URL keys when provided', async () => {
-			const wrapper = createWrapper(
-				{
-					enableUrlParams: {
-						relativeTimeKey: 'modalTime',
-					},
-				},
-				{ searchParams: '?modalTime=3h' },
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			await waitFor(() => {
-				expect(result.current).toBe('3h');
-			});
-		});
-
-		it('should use custom startTimeKey and endTimeKey when provided', async () => {
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-			const wrapper = createWrapper(
-				{
-					enableUrlParams: {
-						startTimeKey: 'customStart',
-						endTimeKey: 'customEnd',
-					},
-				},
-				{ searchParams: `?customStart=${startTime}&customEnd=${endTime}` },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				const { minTime, maxTime } = result.current.getMinMaxTime();
-				expect(minTime).toBe(startTime * NANO_SECOND_MULTIPLIER);
-				expect(maxTime).toBe(endTime * NANO_SECOND_MULTIPLIER);
-			});
-		});
-
-		it('should NOT read from URL when enableUrlParams is false', async () => {
-			const wrapper = createWrapper(
-				{ enableUrlParams: false, initialTime: '15m' },
-				{ searchParams: '?relativeTime=1h' },
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			// Should use initialTime, not URL value
-			expect(result.current).toBe('15m');
-		});
-
-		it('should prefer startTime/endTime over relativeTime when both present in URL', async () => {
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-			const wrapper = createWrapper(
-				{ enableUrlParams: true },
-				{
-					searchParams: `?relativeTime=15m&startTime=${startTime}&endTime=${endTime}`,
-				},
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				const { minTime, maxTime } = result.current.getMinMaxTime();
-				// Should use startTime/endTime, not relativeTime
-				expect(minTime).toBe(startTime * NANO_SECOND_MULTIPLIER);
-				expect(maxTime).toBe(endTime * NANO_SECOND_MULTIPLIER);
-			});
-		});
-
-		it('should use initialTime when URL has invalid time values', async () => {
-			const wrapper = createWrapper(
-				{ enableUrlParams: true, initialTime: '15m' },
-				{ searchParams: '?startTime=invalid&endTime=also-invalid' },
-			);
-
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			// parseAsInteger returns null for invalid values, so should fallback to initialTime
-			expect(result.current).toBe('15m');
-		});
-
-		it('should update store when custom time is set from URL with only startTime and endTime', async () => {
-			const startTime = 1700000000000;
-			const endTime = 1700003600000;
-			const wrapper = createWrapper(
-				{ enableUrlParams: true },
-				{ searchParams: `?startTime=${startTime}&endTime=${endTime}` },
-			);
-
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			await waitFor(() => {
-				// Verify selectedTime is a custom time range string
-				expect(result.current.selectedTime).toContain('||_||');
-			});
-		});
-
-		describe('removeQueryParamsOnUnmount', () => {
-			const createUnmountTestWrapper = (
-				getQueryString: () => string,
-				setQueryString: (qs: string) => void,
-			) => {
-				return function TestWrapper({
-					children,
-				}: {
-					children: React.ReactNode;
-				}): JSX.Element {
-					const queryClient = createTestQueryClient();
-					return (
-						<QueryClientProvider client={queryClient}>
-							<NuqsTestingAdapter
-								searchParams={getQueryString()}
-								onUrlUpdate={(event): void => {
-									setQueryString(event.queryString);
-								}}
-							>
-								{children}
-							</NuqsTestingAdapter>
-						</QueryClientProvider>
-					);
-				};
-			};
-
-			it('should remove URL params when provider unmounts with removeQueryParamsOnUnmount=true', async () => {
-				let currentQueryString = 'relativeTime=1h';
-				const TestWrapper = createUnmountTestWrapper(
-					() => currentQueryString,
-					(qs) => {
-						currentQueryString = qs;
-					},
-				);
-
-				const { unmount } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-					wrapper: ({ children }) => (
-						<TestWrapper>
-							<GlobalTimeProvider enableUrlParams removeQueryParamsOnUnmount>
-								{children}
-							</GlobalTimeProvider>
-						</TestWrapper>
-					),
-				});
-
-				// Verify initial URL params are present
-				expect(currentQueryString).toContain('relativeTime=1h');
-
-				// Unmount the provider
-				unmount();
-
-				// URL params should be removed
-				await waitFor(() => {
-					expect(currentQueryString).not.toContain('relativeTime');
-					expect(currentQueryString).not.toContain('startTime');
-					expect(currentQueryString).not.toContain('endTime');
-				});
-			});
-
-			it('should NOT remove URL params when provider unmounts with removeQueryParamsOnUnmount=false', async () => {
-				let currentQueryString = 'relativeTime=1h';
-				const TestWrapper = createUnmountTestWrapper(
-					() => currentQueryString,
-					(qs) => {
-						currentQueryString = qs;
-					},
-				);
-
-				const { unmount } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-					wrapper: ({ children }) => (
-						<TestWrapper>
-							<GlobalTimeProvider enableUrlParams removeQueryParamsOnUnmount={false}>
-								{children}
-							</GlobalTimeProvider>
-						</TestWrapper>
-					),
-				});
-
-				// Verify initial URL params are present
-				expect(currentQueryString).toContain('relativeTime=1h');
-
-				// Unmount the provider
-				unmount();
-
-				// Wait a tick to ensure cleanup effects would have run
-				await waitFor(() => {
-					// URL params should still be present
-					expect(currentQueryString).toContain('relativeTime=1h');
-				});
-			});
-
-			it('should remove custom time URL params on unmount', async () => {
-				const startTime = 1700000000000;
-				const endTime = 1700003600000;
-				let currentQueryString = `startTime=${startTime}&endTime=${endTime}`;
-				const TestWrapper = createUnmountTestWrapper(
-					() => currentQueryString,
-					(qs) => {
-						currentQueryString = qs;
-					},
-				);
-
-				const { unmount } = renderHook(() => useGlobalTime(), {
-					wrapper: ({ children }) => (
-						<TestWrapper>
-							<GlobalTimeProvider enableUrlParams removeQueryParamsOnUnmount>
-								{children}
-							</GlobalTimeProvider>
-						</TestWrapper>
-					),
-				});
-
-				// Verify initial URL params are present
-				expect(currentQueryString).toContain('startTime');
-				expect(currentQueryString).toContain('endTime');
-
-				// Unmount the provider
-				unmount();
-
-				// URL params should be removed
-				await waitFor(() => {
-					expect(currentQueryString).not.toContain('startTime');
-					expect(currentQueryString).not.toContain('endTime');
-				});
-			});
-
-			it('should remove custom URL key params on unmount', async () => {
-				let currentQueryString = 'modalTime=3h';
-				const TestWrapper = createUnmountTestWrapper(
-					() => currentQueryString,
-					(qs) => {
-						currentQueryString = qs;
-					},
-				);
-
-				const { unmount } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-					wrapper: ({ children }) => (
-						<TestWrapper>
-							<GlobalTimeProvider
-								enableUrlParams={{
-									relativeTimeKey: 'modalTime',
-								}}
-								removeQueryParamsOnUnmount
-							>
-								{children}
-							</GlobalTimeProvider>
-						</TestWrapper>
-					),
-				});
-
-				// Verify initial URL params are present
-				expect(currentQueryString).toContain('modalTime=3h');
-
-				// Unmount the provider
-				unmount();
-
-				// URL params should be removed
-				await waitFor(() => {
-					expect(currentQueryString).not.toContain('modalTime');
-				});
-			});
-
-			it('should NOT remove URL params when enableUrlParams is false', async () => {
-				let currentQueryString = 'relativeTime=1h';
-				const TestWrapper = createUnmountTestWrapper(
-					() => currentQueryString,
-					(qs) => {
-						currentQueryString = qs;
-					},
-				);
-
-				const { unmount } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-					wrapper: ({ children }) => (
-						<TestWrapper>
-							<GlobalTimeProvider enableUrlParams={false} removeQueryParamsOnUnmount>
-								{children}
-							</GlobalTimeProvider>
-						</TestWrapper>
-					),
-				});
-
-				// Verify initial URL params are present
-				expect(currentQueryString).toContain('relativeTime=1h');
-
-				// Unmount the provider
-				unmount();
-
-				// Wait a tick
-				await waitFor(() => {
-					// URL params should still be present (enableUrlParams is false)
-					expect(currentQueryString).toContain('relativeTime=1h');
-				});
-			});
-		});
-	});
-
-	describe('localStorage persistence', () => {
-		const mockSet = set as jest.MockedFunction<typeof set>;
-
-		beforeEach(() => {
-			localStorage.clear();
-			mockSet.mockClear();
-			mockSet.mockReturnValue(true);
-		});
-
-		it('should read from localStorage on mount', () => {
-			localStorage.setItem('test-time-key', '6h');
-
-			const wrapper = createWrapper({ localStoragePersistKey: 'test-time-key' });
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			expect(result.current).toBe('6h');
-		});
-
-		it('should write to localStorage on selectedTime change', async () => {
-			const wrapper = createWrapper({
-				localStoragePersistKey: 'test-persist-key',
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			mockSet.mockClear();
-
-			act(() => {
-				result.current.setSelectedTime('12h');
-			});
-
-			await waitFor(() => {
-				expect(mockSet).toHaveBeenCalledWith('test-persist-key', '12h');
-			});
-		});
-
-		it('should NOT write to localStorage when persistKey is undefined', async () => {
-			const wrapper = createWrapper({ initialTime: '15m' });
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			mockSet.mockClear();
-
-			act(() => {
-				result.current.setSelectedTime('1h');
-			});
-
-			// Wait a tick to ensure any async operations complete
-			await waitFor(() => {
-				expect(result.current.selectedTime).toBe('1h');
-			});
-
-			expect(mockSet).not.toHaveBeenCalled();
-		});
-
-		it('should only write to localStorage when selectedTime changes, not other state', async () => {
-			const wrapper = createWrapper({
-				localStoragePersistKey: 'test-key',
-				initialTime: '15m',
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			mockSet.mockClear();
-
-			// Change refreshInterval (not selectedTime)
-			act(() => {
-				result.current.setRefreshInterval(5000);
-			});
-
-			// Wait to ensure subscription handler had a chance to run
-			await waitFor(() => {
-				expect(result.current.refreshInterval).toBe(5000);
-			});
-
-			// Should NOT have written to localStorage for refreshInterval change
-			expect(mockSet).not.toHaveBeenCalled();
-
-			// Now change selectedTime
-			act(() => {
-				result.current.setSelectedTime('1h');
-			});
-
-			await waitFor(() => {
-				expect(mockSet).toHaveBeenCalledWith('test-key', '1h');
-			});
-		});
-
-		it('should fallback to initialTime when localStorage contains empty string', () => {
-			localStorage.setItem('test-key', '');
-
-			const wrapper = createWrapper({
-				localStoragePersistKey: 'test-key',
-				initialTime: '15m',
-			});
-			const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-				wrapper,
-			});
-
-			// Empty string is falsy, should use initialTime
-			expect(result.current).toBe('15m');
-		});
-
-		it('should write custom time range to localStorage', async () => {
-			const wrapper = createWrapper({
-				localStoragePersistKey: 'test-custom-key',
-				initialTime: '15m',
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			mockSet.mockClear();
-
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			await waitFor(() => {
-				expect(mockSet).toHaveBeenCalledWith('test-custom-key', customTime);
-			});
-		});
-	});
-
-	describe('refreshInterval', () => {
-		it('should initialize with provided refreshInterval', () => {
-			const wrapper = createWrapper({ refreshInterval: 5000 });
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			expect(result.current.refreshInterval).toBe(5000);
-			expect(result.current.isRefreshEnabled).toBe(true);
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/createGlobalTimeStore.test.ts

@@ -1,148 +0,0 @@
-import { act } from '@testing-library/react';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-
-import {
-	createGlobalTimeStore,
-	defaultGlobalTimeStore,
-} from '../globalTimeStore';
-import { createCustomTimeRange } from '../utils';
-
-describe('createGlobalTimeStore', () => {
-	describe('factory function', () => {
-		it('should create independent store instances', () => {
-			const store1 = createGlobalTimeStore();
-			const store2 = createGlobalTimeStore();
-
-			store1.getState().setSelectedTime('1h');
-
-			expect(store1.getState().selectedTime).toBe('1h');
-			expect(store2.getState().selectedTime).toBe(DEFAULT_TIME_RANGE);
-		});
-
-		it('should accept initial state', () => {
-			const store = createGlobalTimeStore({
-				selectedTime: '15m',
-				refreshInterval: 5000,
-			});
-
-			expect(store.getState().selectedTime).toBe('15m');
-			expect(store.getState().refreshInterval).toBe(5000);
-			expect(store.getState().isRefreshEnabled).toBe(true);
-		});
-
-		it('should compute isRefreshEnabled correctly for custom time', () => {
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-			const store = createGlobalTimeStore({
-				selectedTime: customTime,
-				refreshInterval: 5000,
-			});
-
-			expect(store.getState().isRefreshEnabled).toBe(false);
-		});
-	});
-
-	describe('defaultGlobalTimeStore', () => {
-		it('should be a singleton', () => {
-			expect(defaultGlobalTimeStore).toBeDefined();
-			expect(defaultGlobalTimeStore.getState().selectedTime).toBeDefined();
-		});
-	});
-
-	describe('setRefreshInterval', () => {
-		it('should update refresh interval and enable refresh', () => {
-			const store = createGlobalTimeStore();
-
-			act(() => {
-				store.getState().setRefreshInterval(10000);
-			});
-
-			expect(store.getState().refreshInterval).toBe(10000);
-			expect(store.getState().isRefreshEnabled).toBe(true);
-		});
-
-		it('should disable refresh when interval is 0', () => {
-			const store = createGlobalTimeStore({ refreshInterval: 5000 });
-
-			act(() => {
-				store.getState().setRefreshInterval(0);
-			});
-
-			expect(store.getState().refreshInterval).toBe(0);
-			expect(store.getState().isRefreshEnabled).toBe(false);
-		});
-
-		it('should not enable refresh for custom time range', () => {
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-			const store = createGlobalTimeStore({ selectedTime: customTime });
-
-			act(() => {
-				store.getState().setRefreshInterval(10000);
-			});
-
-			expect(store.getState().refreshInterval).toBe(10000);
-			expect(store.getState().isRefreshEnabled).toBe(false);
-		});
-	});
-
-	describe('store name', () => {
-		it('should store name when provided', () => {
-			const store = createGlobalTimeStore({ name: 'drawer' });
-			expect(store.getState().name).toBe('drawer');
-		});
-
-		it('should have undefined name when not provided', () => {
-			const store = createGlobalTimeStore();
-			expect(store.getState().name).toBeUndefined();
-		});
-	});
-
-	describe('getAutoRefreshQueryKey', () => {
-		it('should generate key without name for unnamed store', () => {
-			const store = createGlobalTimeStore();
-			const key = store
-				.getState()
-				.getAutoRefreshQueryKey('15m', 'MY_QUERY', 'param1');
-
-			expect(key).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'MY_QUERY',
-				'param1',
-				'15m',
-			]);
-		});
-
-		it('should generate key with name for named store', () => {
-			const store = createGlobalTimeStore({ name: 'drawer' });
-			const key = store
-				.getState()
-				.getAutoRefreshQueryKey('15m', 'MY_QUERY', 'param1');
-
-			expect(key).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'drawer',
-				'MY_QUERY',
-				'param1',
-				'15m',
-			]);
-		});
-
-		it('should handle no query parts for named store', () => {
-			const store = createGlobalTimeStore({ name: 'test' });
-			const key = store.getState().getAutoRefreshQueryKey('1h');
-
-			expect(key).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'test',
-				'1h',
-			]);
-		});
-
-		it('should handle no query parts for unnamed store', () => {
-			const store = createGlobalTimeStore();
-			const key = store.getState().getAutoRefreshQueryKey('1h');
-
-			expect(key).toStrictEqual([REACT_QUERY_KEY.AUTO_REFRESH_QUERY, '1h']);
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/globalTimeStore.test.ts

@@ -0,0 +1,202 @@
+import { act, renderHook } from '@testing-library/react';
+import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
+
+import { useGlobalTimeStore } from '../globalTimeStore';
+import { GlobalTimeSelectedTime } from '../types';
+import { createCustomTimeRange, NANO_SECOND_MULTIPLIER } from '../utils';
+
+describe('globalTimeStore', () => {
+	beforeEach(() => {
+		const { result } = renderHook(() => useGlobalTimeStore());
+		act(() => {
+			result.current.setSelectedTime(DEFAULT_TIME_RANGE, 0);
+		});
+	});
+
+	describe('initial state', () => {
+		it(`should have default selectedTime of ${DEFAULT_TIME_RANGE}`, () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			expect(result.current.selectedTime).toBe(DEFAULT_TIME_RANGE);
+		});
+
+		it('should have isRefreshEnabled as false by default', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			expect(result.current.isRefreshEnabled).toBe(false);
+		});
+
+		it('should have refreshInterval as 0 by default', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			expect(result.current.refreshInterval).toBe(0);
+		});
+	});
+
+	describe('setSelectedTime', () => {
+		it('should update selectedTime', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m');
+			});
+
+			expect(result.current.selectedTime).toBe('15m');
+		});
+
+		it('should update refreshInterval when provided', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m', 5000);
+			});
+
+			expect(result.current.refreshInterval).toBe(5000);
+		});
+
+		it('should keep existing refreshInterval when not provided', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m', 5000);
+			});
+
+			act(() => {
+				result.current.setSelectedTime('1h');
+			});
+
+			expect(result.current.refreshInterval).toBe(5000);
+		});
+
+		it('should enable refresh for relative time with refreshInterval > 0', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m', 5000);
+			});
+
+			expect(result.current.isRefreshEnabled).toBe(true);
+		});
+
+		it('should disable refresh for relative time with refreshInterval = 0', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m', 0);
+			});
+
+			expect(result.current.isRefreshEnabled).toBe(false);
+		});
+
+		it('should disable refresh for custom time range even with refreshInterval > 0', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			const customTime = createCustomTimeRange(1000000000, 2000000000);
+
+			act(() => {
+				result.current.setSelectedTime(customTime, 5000);
+			});
+
+			expect(result.current.isRefreshEnabled).toBe(false);
+			expect(result.current.refreshInterval).toBe(5000);
+		});
+
+		it('should handle various relative time formats', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			const timeFormats: GlobalTimeSelectedTime[] = [
+				'1m',
+				'5m',
+				'15m',
+				'30m',
+				'1h',
+				'3h',
+				'6h',
+				'1d',
+				'1w',
+			];
+
+			timeFormats.forEach((time) => {
+				act(() => {
+					result.current.setSelectedTime(time, 10000);
+				});
+
+				expect(result.current.selectedTime).toBe(time);
+				expect(result.current.isRefreshEnabled).toBe(true);
+			});
+		});
+	});
+
+	describe('getMinMaxTime', () => {
+		beforeEach(() => {
+			jest.useFakeTimers();
+			jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z'));
+		});
+
+		afterEach(() => {
+			jest.useRealTimers();
+		});
+
+		it('should return min/max time for custom time range', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+			const minTime = 1000000000;
+			const maxTime = 2000000000;
+			const customTime = createCustomTimeRange(minTime, maxTime);
+
+			act(() => {
+				result.current.setSelectedTime(customTime);
+			});
+
+			const { minTime: resultMin, maxTime: resultMax } =
+				result.current.getMinMaxTime();
+			expect(resultMin).toBe(minTime);
+			expect(resultMax).toBe(maxTime);
+		});
+
+		it('should compute fresh min/max time for relative time', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m');
+			});
+
+			const { minTime, maxTime } = result.current.getMinMaxTime();
+			const now = Date.now() * NANO_SECOND_MULTIPLIER;
+			const fifteenMinutesNs = 15 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
+
+			expect(maxTime).toBe(now);
+			expect(minTime).toBe(now - fifteenMinutesNs);
+		});
+
+		it('should return different values on subsequent calls for relative time', () => {
+			const { result } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result.current.setSelectedTime('15m');
+			});
+
+			const first = result.current.getMinMaxTime();
+
+			// Advance time by 1 second
+			act(() => {
+				jest.advanceTimersByTime(1000);
+			});
+
+			const second = result.current.getMinMaxTime();
+
+			// maxTime should be different (1 second later)
+			expect(second.maxTime).toBe(first.maxTime + 1000 * NANO_SECOND_MULTIPLIER);
+			expect(second.minTime).toBe(first.minTime + 1000 * NANO_SECOND_MULTIPLIER);
+		});
+	});
+
+	describe('store isolation', () => {
+		it('should share state between multiple hook instances', () => {
+			const { result: result1 } = renderHook(() => useGlobalTimeStore());
+			const { result: result2 } = renderHook(() => useGlobalTimeStore());
+
+			act(() => {
+				result1.current.setSelectedTime('1h', 10000);
+			});
+
+			expect(result2.current.selectedTime).toBe('1h');
+			expect(result2.current.refreshInterval).toBe(10000);
+			expect(result2.current.isRefreshEnabled).toBe(true);
+		});
+	});
+});

frontend/src/store/globalTime/__tests__/globalTimeStore.test.tsx

@@ -1,868 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { ReactNode } from 'react';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-
-import { createGlobalTimeStore, useGlobalTimeStore } from '../globalTimeStore';
-import { GlobalTimeContext } from '../GlobalTimeContext';
-import { useGlobalTime } from '../hooks';
-import { GlobalTimeSelectedTime, GlobalTimeState } from '../types';
-import { createCustomTimeRange, NANO_SECOND_MULTIPLIER } from '../utils';
-
-/**
- * Creates an isolated store wrapper for testing.
- * Each test gets its own store instance, avoiding test pollution.
- */
-function createIsolatedWrapper(
-	initialState?: Partial<GlobalTimeState>,
-): ({ children }: { children: ReactNode }) => JSX.Element {
-	const store = createGlobalTimeStore(initialState);
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<GlobalTimeContext.Provider value={store}>
-				{children}
-			</GlobalTimeContext.Provider>
-		);
-	};
-}
-
-describe('globalTimeStore', () => {
-	beforeEach(() => {
-		const { result } = renderHook(() => useGlobalTimeStore());
-		act(() => {
-			result.current.setSelectedTime(DEFAULT_TIME_RANGE, 0);
-		});
-	});
-
-	describe('initial state', () => {
-		it(`should have default selectedTime of ${DEFAULT_TIME_RANGE}`, () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.selectedTime).toBe(DEFAULT_TIME_RANGE);
-		});
-
-		it('should have isRefreshEnabled as false by default', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.isRefreshEnabled).toBe(false);
-		});
-
-		it('should have refreshInterval as 0 by default', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.refreshInterval).toBe(0);
-		});
-
-		it('should have lastRefreshTimestamp as 0 by default', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.lastRefreshTimestamp).toBe(0);
-		});
-
-		it('should have lastComputedMinMax with default values', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.lastComputedMinMax).toStrictEqual({
-				minTime: 0,
-				maxTime: 0,
-			});
-		});
-	});
-
-	describe('setSelectedTime', () => {
-		it('should update selectedTime', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			expect(result.current.selectedTime).toBe('15m');
-		});
-
-		it('should update refreshInterval when provided', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 5000);
-			});
-
-			expect(result.current.refreshInterval).toBe(5000);
-		});
-
-		it('should keep existing refreshInterval when not provided', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 5000);
-			});
-
-			act(() => {
-				result.current.setSelectedTime('1h');
-			});
-
-			expect(result.current.refreshInterval).toBe(5000);
-		});
-
-		it('should enable refresh for relative time with refreshInterval > 0', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 5000);
-			});
-
-			expect(result.current.isRefreshEnabled).toBe(true);
-		});
-
-		it('should disable refresh for relative time with refreshInterval = 0', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 0);
-			});
-
-			expect(result.current.isRefreshEnabled).toBe(false);
-		});
-
-		it('should disable refresh for custom time range even with refreshInterval > 0', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-
-			act(() => {
-				result.current.setSelectedTime(customTime, 5000);
-			});
-
-			expect(result.current.isRefreshEnabled).toBe(false);
-			expect(result.current.refreshInterval).toBe(5000);
-		});
-
-		it('should handle various relative time formats', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			const timeFormats: GlobalTimeSelectedTime[] = [
-				'1m',
-				'5m',
-				'15m',
-				'30m',
-				'1h',
-				'3h',
-				'6h',
-				'1d',
-				'1w',
-			];
-
-			timeFormats.forEach((time) => {
-				act(() => {
-					result.current.setSelectedTime(time, 10000);
-				});
-
-				expect(result.current.selectedTime).toBe(time);
-				expect(result.current.isRefreshEnabled).toBe(true);
-			});
-		});
-
-		it('should compute and store lastComputedMinMax when selectedTime changes', () => {
-			const wrapper = createIsolatedWrapper({
-				selectedTime: '15m',
-				refreshInterval: 5000,
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// setSelectedTime computes values on init (createIsolatedWrapper uses createGlobalTimeStore)
-			// But initial store state has minTime/maxTime as 0 until first setSelectedTime is called
-			const initialMinMax = { ...result.current.lastComputedMinMax };
-
-			// Now switch to a custom time range
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			// lastComputedMinMax should be updated to the custom range values
-			expect(result.current.lastComputedMinMax).toStrictEqual({
-				minTime: 1000000000,
-				maxTime: 2000000000,
-			});
-			expect(result.current.lastComputedMinMax).not.toStrictEqual(initialMinMax);
-		});
-
-		it('should return fresh custom time values after switching from relative time', () => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z'));
-
-			const wrapper = createIsolatedWrapper({
-				selectedTime: '15m',
-				refreshInterval: 5000,
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// Compute and cache values for relative time
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-
-			const relativeMinMax = { ...result.current.lastComputedMinMax };
-
-			// Switch to custom time range
-			const customMinTime = 5000000000;
-			const customMaxTime = 6000000000;
-			const customTime = createCustomTimeRange(customMinTime, customMaxTime);
-
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			// getMinMaxTime should return the custom time values, not cached relative values
-			const returned = result.current.getMinMaxTime();
-
-			expect(returned.minTime).toBe(customMinTime);
-			expect(returned.maxTime).toBe(customMaxTime);
-			expect(returned).not.toStrictEqual(relativeMinMax);
-
-			jest.useRealTimers();
-		});
-	});
-
-	describe('getMinMaxTime', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should return min/max time for custom time range', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			const minTime = 1000000000;
-			const maxTime = 2000000000;
-			const customTime = createCustomTimeRange(minTime, maxTime);
-
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			const { minTime: resultMin, maxTime: resultMax } =
-				result.current.getMinMaxTime();
-			expect(resultMin).toBe(minTime);
-			expect(resultMax).toBe(maxTime);
-		});
-
-		it('should NOT round custom time range values to minute boundaries', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			// Use timestamps that are NOT on minute boundaries (12:30:45.123)
-			// If rounding occurred, these would change to 12:30:00.000
-			const minTimeWithSeconds =
-				new Date('2024-01-15T12:15:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const maxTimeWithSeconds =
-				new Date('2024-01-15T12:30:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-
-			// What the values would be if rounded down to minute boundary
-			const minTimeRounded =
-				new Date('2024-01-15T12:15:00.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const maxTimeRounded =
-				new Date('2024-01-15T12:30:00.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-
-			const customTime = createCustomTimeRange(
-				minTimeWithSeconds,
-				maxTimeWithSeconds,
-			);
-
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			const { minTime, maxTime } = result.current.getMinMaxTime();
-
-			// Should return exact values, NOT rounded values
-			expect(minTime).toBe(minTimeWithSeconds);
-			expect(maxTime).toBe(maxTimeWithSeconds);
-			expect(minTime).not.toBe(minTimeRounded);
-			expect(maxTime).not.toBe(maxTimeRounded);
-		});
-
-		it('should compute fresh min/max time for relative time', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			const { minTime, maxTime } = result.current.getMinMaxTime();
-			const now = Date.now() * NANO_SECOND_MULTIPLIER;
-			const fifteenMinutesNs = 15 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
-
-			expect(maxTime).toBe(now);
-			expect(minTime).toBe(now - fifteenMinutesNs);
-		});
-
-		it('should return same values on subsequent calls when refresh disabled (under minute boundary)', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 0); // refresh disabled
-			});
-
-			const first = result.current.getMinMaxTime();
-
-			act(() => {
-				jest.advanceTimersByTime(59000);
-			});
-
-			const second = result.current.getMinMaxTime();
-
-			// With refresh disabled, should return cached lastComputedMinMax
-			expect(second.maxTime).toBe(first.maxTime);
-			expect(second.minTime).toBe(first.minTime);
-		});
-
-		it('should return different values on subsequent calls when refresh disabled after minute boundary', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m', 0); // refresh disabled
-			});
-
-			const first = result.current.getMinMaxTime();
-
-			act(() => {
-				jest.advanceTimersByTime(60000);
-			});
-
-			// Without refresh enabled, getMinMaxTime returns cached values
-			// Need to call computeAndStoreMinMax to get new values
-			const second = result.current.getMinMaxTime();
-			expect(second.maxTime).toBe(first.maxTime);
-
-			// After computing, values should update
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-
-			const third = result.current.getMinMaxTime();
-			expect(third.maxTime).toBe(first.maxTime + 60000 * NANO_SECOND_MULTIPLIER);
-			expect(third.minTime).toBe(first.minTime + 60000 * NANO_SECOND_MULTIPLIER);
-		});
-
-		it('should return stored lastComputedMinMax when available', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-				result.current.computeAndStoreMinMax();
-			});
-
-			const stored = { ...result.current.lastComputedMinMax };
-
-			// Advance time by 5 seconds
-			act(() => {
-				jest.advanceTimersByTime(5000);
-			});
-
-			// getMinMaxTime should return stored values, not fresh computation
-			const returned = result.current.getMinMaxTime();
-			expect(returned).toStrictEqual(stored);
-		});
-
-		describe('with isRefreshEnabled (isolated store)', () => {
-			it('should compute fresh values when isRefreshEnabled is true (5s rounding)', () => {
-				jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z')); // Start at 5s boundary
-
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				// getMinMaxTime computes 5s-rounded values when refresh enabled
-				const initialMinMax = result.current.getMinMaxTime();
-
-				// Advance time by 5 seconds to cross 5s boundary
-				act(() => {
-					jest.advanceTimersByTime(5000);
-				});
-
-				// getMinMaxTime should return fresh values, not cached
-				const freshValues = result.current.getMinMaxTime();
-
-				expect(freshValues.maxTime).toBe(
-					initialMinMax.maxTime + 5000 * NANO_SECOND_MULTIPLIER,
-				);
-				expect(freshValues.minTime).toBe(
-					initialMinMax.minTime + 5000 * NANO_SECOND_MULTIPLIER,
-				);
-			});
-
-			it('should update lastComputedMinMax when values change (5s rounding)', () => {
-				jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z')); // Start at 5s boundary
-
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				// Get initial values (uses 5s rounding when refresh enabled)
-				const initialMinMax = result.current.getMinMaxTime();
-
-				// Advance time by 5 seconds to cross 5s boundary
-				act(() => {
-					jest.advanceTimersByTime(5000);
-				});
-
-				// Call getMinMaxTime - should update lastComputedMinMax
-				act(() => {
-					result.current.getMinMaxTime();
-				});
-
-				expect(result.current.lastComputedMinMax.maxTime).toBe(
-					initialMinMax.maxTime + 5000 * NANO_SECOND_MULTIPLIER,
-				);
-				expect(result.current.lastComputedMinMax.minTime).toBe(
-					initialMinMax.minTime + 5000 * NANO_SECOND_MULTIPLIER,
-				);
-			});
-
-			it('should update lastRefreshTimestamp when values change', () => {
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				act(() => {
-					result.current.computeAndStoreMinMax();
-				});
-
-				const initialTimestamp = result.current.lastRefreshTimestamp;
-
-				// Advance time past minute boundary
-				act(() => {
-					jest.advanceTimersByTime(60000);
-				});
-
-				// Call getMinMaxTime - should update timestamp
-				act(() => {
-					result.current.getMinMaxTime();
-				});
-
-				expect(result.current.lastRefreshTimestamp).toBeGreaterThan(
-					initialTimestamp,
-				);
-			});
-
-			it('should NOT update lastComputedMinMax when values have not changed (same 5s window)', () => {
-				jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z')); // Start at 5s boundary
-
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				// Get initial values (triggers computation for 5s-rounded values)
-				result.current.getMinMaxTime();
-
-				const initialMinMax = { ...result.current.lastComputedMinMax };
-				const initialTimestamp = result.current.lastRefreshTimestamp;
-
-				// Advance time but stay within same 5-second window
-				act(() => {
-					jest.advanceTimersByTime(4000);
-				});
-
-				// Call getMinMaxTime - should NOT update store (same 5s boundary)
-				act(() => {
-					result.current.getMinMaxTime();
-				});
-
-				// Values should be unchanged (no unnecessary re-renders)
-				expect(result.current.lastComputedMinMax).toStrictEqual(initialMinMax);
-				expect(result.current.lastRefreshTimestamp).toBe(initialTimestamp);
-			});
-
-			it('should return cached values when isRefreshEnabled is false', () => {
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 0, // Refresh disabled
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				act(() => {
-					result.current.computeAndStoreMinMax();
-				});
-
-				const storedMinMax = { ...result.current.lastComputedMinMax };
-
-				// Advance time past minute boundary
-				act(() => {
-					jest.advanceTimersByTime(60000);
-				});
-
-				// getMinMaxTime should return cached values since refresh is disabled
-				const returned = result.current.getMinMaxTime();
-
-				expect(returned).toStrictEqual(storedMinMax);
-				expect(result.current.lastComputedMinMax).toStrictEqual(storedMinMax);
-			});
-
-			it('should return same values for custom time range regardless of time passing', () => {
-				const minTime = 1000000000;
-				const maxTime = 2000000000;
-				const customTime = createCustomTimeRange(minTime, maxTime);
-
-				const wrapper = createIsolatedWrapper({
-					selectedTime: customTime,
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				// isRefreshEnabled should be false for custom time ranges
-				expect(result.current.isRefreshEnabled).toBe(false);
-
-				// Custom time ranges always return the fixed values, not relative to "now"
-				const first = result.current.getMinMaxTime();
-				expect(first.minTime).toBe(minTime);
-				expect(first.maxTime).toBe(maxTime);
-
-				// Advance time past minute boundary
-				act(() => {
-					jest.advanceTimersByTime(60000);
-				});
-
-				// Should still return the same fixed values (custom range doesn't drift)
-				const second = result.current.getMinMaxTime();
-				expect(second.minTime).toBe(minTime);
-				expect(second.maxTime).toBe(maxTime);
-			});
-
-			it('should handle multiple consecutive refetch intervals correctly (5s rounding)', () => {
-				jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z')); // Start at 5s boundary
-
-				const wrapper = createIsolatedWrapper({
-					selectedTime: '15m',
-					refreshInterval: 5000,
-				});
-				const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-				// Get initial values
-				const initialMinMax = result.current.getMinMaxTime();
-
-				// Simulate 3 refetch intervals crossing 5-second boundaries
-				for (let i = 1; i <= 3; i++) {
-					act(() => {
-						jest.advanceTimersByTime(5000);
-					});
-
-					act(() => {
-						result.current.getMinMaxTime();
-					});
-
-					expect(result.current.lastComputedMinMax.maxTime).toBe(
-						initialMinMax.maxTime + i * 5000 * NANO_SECOND_MULTIPLIER,
-					);
-				}
-			});
-		});
-	});
-
-	describe('computeAndStoreMinMax', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should compute and store min/max values', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-
-			// maxTime should be the current time (no rounding when refresh disabled)
-			const expectedMaxTime =
-				new Date('2024-01-15T12:30:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const fifteenMinutesNs = 15 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
-
-			expect(result.current.lastComputedMinMax.maxTime).toBe(expectedMaxTime);
-			expect(result.current.lastComputedMinMax.minTime).toBe(
-				expectedMaxTime - fifteenMinutesNs,
-			);
-		});
-
-		it('should update lastRefreshTimestamp', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			const beforeTimestamp = Date.now();
-
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-
-			expect(result.current.lastRefreshTimestamp).toBeGreaterThanOrEqual(
-				beforeTimestamp,
-			);
-		});
-
-		it('should return the computed values', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			let returnedValue: { minTime: number; maxTime: number } | undefined;
-			act(() => {
-				returnedValue = result.current.computeAndStoreMinMax();
-			});
-
-			expect(returnedValue).toStrictEqual(result.current.lastComputedMinMax);
-		});
-
-		it('should NOT round custom time range values to minute boundaries', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-			// Use timestamps that are NOT on minute boundaries (12:30:45.123)
-			// If rounding occurred, these would change to 12:30:00.000
-			const minTimeWithSeconds =
-				new Date('2024-01-15T12:15:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const maxTimeWithSeconds =
-				new Date('2024-01-15T12:30:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-
-			// What the values would be if rounded down to minute boundary
-			const minTimeRounded =
-				new Date('2024-01-15T12:15:00.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const maxTimeRounded =
-				new Date('2024-01-15T12:30:00.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-
-			const customTime = createCustomTimeRange(
-				minTimeWithSeconds,
-				maxTimeWithSeconds,
-			);
-
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			let returnedValue: { minTime: number; maxTime: number } | undefined;
-			act(() => {
-				returnedValue = result.current.computeAndStoreMinMax();
-			});
-
-			// Should return exact values, NOT rounded values
-			expect(returnedValue?.minTime).toBe(minTimeWithSeconds);
-			expect(returnedValue?.maxTime).toBe(maxTimeWithSeconds);
-			expect(returnedValue?.minTime).not.toBe(minTimeRounded);
-			expect(returnedValue?.maxTime).not.toBe(maxTimeRounded);
-
-			// lastComputedMinMax should also have exact values
-			expect(result.current.lastComputedMinMax.minTime).toBe(minTimeWithSeconds);
-			expect(result.current.lastComputedMinMax.maxTime).toBe(maxTimeWithSeconds);
-		});
-	});
-
-	describe('updateRefreshTimestamp', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should update lastRefreshTimestamp to current time', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.updateRefreshTimestamp();
-			});
-
-			expect(result.current.lastRefreshTimestamp).toBe(Date.now());
-		});
-
-		it('should not modify lastComputedMinMax', () => {
-			const { result } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-
-			const beforeMinMax = { ...result.current.lastComputedMinMax };
-
-			act(() => {
-				jest.advanceTimersByTime(5000);
-				result.current.updateRefreshTimestamp();
-			});
-
-			expect(result.current.lastComputedMinMax).toStrictEqual(beforeMinMax);
-		});
-	});
-
-	describe('store isolation', () => {
-		it('should share state between multiple hook instances', () => {
-			const { result: result1 } = renderHook(() => useGlobalTimeStore());
-			const { result: result2 } = renderHook(() => useGlobalTimeStore());
-
-			act(() => {
-				result1.current.setSelectedTime('1h', 10000);
-			});
-
-			expect(result2.current.selectedTime).toBe('1h');
-			expect(result2.current.refreshInterval).toBe(10000);
-			expect(result2.current.isRefreshEnabled).toBe(true);
-		});
-	});
-
-	describe('setSelectedTime (min/max computation)', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should compute and store min/max for relative time on setSelectedTime', () => {
-			const wrapper = createIsolatedWrapper();
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// Initial state has 0 values
-			expect(result.current.lastComputedMinMax.maxTime).toBe(0);
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			// Should have computed values immediately
-			const expectedMaxTime =
-				new Date('2024-01-15T12:00:00.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const fifteenMinutesNs = 15 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
-
-			expect(result.current.lastComputedMinMax.maxTime).toBe(expectedMaxTime);
-			expect(result.current.lastComputedMinMax.minTime).toBe(
-				expectedMaxTime - fifteenMinutesNs,
-			);
-		});
-
-		it('should compute and store min/max for custom time on setSelectedTime', () => {
-			const wrapper = createIsolatedWrapper();
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			const minTime = 1000000000;
-			const maxTime = 2000000000;
-			const customTime = createCustomTimeRange(minTime, maxTime);
-
-			act(() => {
-				result.current.setSelectedTime(customTime);
-			});
-
-			expect(result.current.lastComputedMinMax.minTime).toBe(minTime);
-			expect(result.current.lastComputedMinMax.maxTime).toBe(maxTime);
-		});
-
-		it('should update lastRefreshTimestamp on setSelectedTime', () => {
-			const wrapper = createIsolatedWrapper();
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			expect(result.current.lastRefreshTimestamp).toBe(0);
-
-			act(() => {
-				result.current.setSelectedTime('15m');
-			});
-
-			expect(result.current.lastRefreshTimestamp).toBe(Date.now());
-		});
-
-		it('should skip update when same selectedTime and refreshInterval', () => {
-			const wrapper = createIsolatedWrapper({
-				selectedTime: '15m',
-				refreshInterval: 5000,
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// Set initial values
-			act(() => {
-				result.current.setSelectedTime('15m', 5000);
-			});
-
-			const initialTimestamp = result.current.lastRefreshTimestamp;
-
-			// Advance time
-			act(() => {
-				jest.advanceTimersByTime(1000);
-			});
-
-			// Try to set same values again
-			act(() => {
-				result.current.setSelectedTime('15m', 5000);
-			});
-
-			// Should not have updated timestamp (no state change)
-			expect(result.current.lastRefreshTimestamp).toBe(initialTimestamp);
-		});
-	});
-
-	describe('computeAndStoreMinMax (refresh behavior)', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:00:00.000Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should skip computation and return lastComputedMinMax when refresh is enabled', () => {
-			const wrapper = createIsolatedWrapper({
-				selectedTime: '15m',
-				refreshInterval: 5000,
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// Get initial values via getMinMaxTime (which computes for refresh enabled)
-			const initialMinMax = result.current.getMinMaxTime();
-
-			// Advance time
-			act(() => {
-				jest.advanceTimersByTime(60000);
-			});
-
-			// computeAndStoreMinMax should skip computation when refresh is enabled
-			let returnedValue: { minTime: number; maxTime: number } | undefined;
-			act(() => {
-				returnedValue = result.current.computeAndStoreMinMax();
-			});
-
-			// Should return the current lastComputedMinMax, not fresh computation
-			expect(returnedValue).toStrictEqual(initialMinMax);
-		});
-
-		it('should compute fresh values when refresh is disabled', () => {
-			const wrapper = createIsolatedWrapper({
-				selectedTime: '15m',
-				refreshInterval: 0, // Disabled
-			});
-			const { result } = renderHook(() => useGlobalTime(), { wrapper });
-
-			// Get initial values
-			act(() => {
-				result.current.computeAndStoreMinMax();
-			});
-			const initialMinMax = { ...result.current.lastComputedMinMax };
-
-			// Advance time past minute boundary
-			act(() => {
-				jest.advanceTimersByTime(60000);
-			});
-
-			// computeAndStoreMinMax should compute fresh values
-			let returnedValue: { minTime: number; maxTime: number } | undefined;
-			act(() => {
-				returnedValue = result.current.computeAndStoreMinMax();
-			});
-
-			// Should return new values
-			expect(returnedValue?.maxTime).toBe(
-				initialMinMax.maxTime + 60000 * NANO_SECOND_MULTIPLIER,
-			);
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/hooks.test.tsx

@@ -1,190 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { ReactNode } from 'react';
-
-import { createGlobalTimeStore } from '../globalTimeStore';
-import { GlobalTimeContext } from '../GlobalTimeContext';
-import {
-	useGlobalTime,
-	useGlobalTimeStoreApi,
-	useIsCustomTimeRange,
-	useLastComputedMinMax,
-} from '../hooks';
-import { useComputedMinMaxSync } from '../useComputedMinMaxSync';
-import { createCustomTimeRange } from '../utils';
-
-describe('useGlobalTime', () => {
-	it('should return full store state without selector', () => {
-		const { result } = renderHook(() => useGlobalTime());
-
-		expect(result.current.selectedTime).toBeDefined();
-		expect(result.current.setSelectedTime).toBeInstanceOf(Function);
-	});
-
-	it('should return selected value with selector', () => {
-		const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime));
-
-		expect(typeof result.current).toBe('string');
-	});
-
-	it('should use context store when provided', () => {
-		const contextStore = createGlobalTimeStore({ selectedTime: '1h' });
-
-		const wrapper = ({ children }: { children: ReactNode }): JSX.Element => (
-			<GlobalTimeContext.Provider value={contextStore}>
-				{children}
-			</GlobalTimeContext.Provider>
-		);
-
-		const { result } = renderHook(() => useGlobalTime((s) => s.selectedTime), {
-			wrapper,
-		});
-
-		expect(result.current).toBe('1h');
-	});
-});
-
-describe('useIsCustomTimeRange', () => {
-	it('should return false for relative time', () => {
-		const { result } = renderHook(() => useIsCustomTimeRange());
-
-		expect(result.current).toBe(false);
-	});
-
-	it('should return true for custom time range', () => {
-		const customTime = createCustomTimeRange(1000000000, 2000000000);
-		const contextStore = createGlobalTimeStore({ selectedTime: customTime });
-
-		const { result } = renderHook(() => useIsCustomTimeRange(), {
-			wrapper: ({ children }: { children: ReactNode }): JSX.Element => (
-				<GlobalTimeContext.Provider value={contextStore}>
-					{children}
-				</GlobalTimeContext.Provider>
-			),
-		});
-
-		expect(result.current).toBe(true);
-	});
-});
-
-describe('useGlobalTimeStoreApi', () => {
-	it('should return store API', () => {
-		const { result } = renderHook(() => useGlobalTimeStoreApi());
-
-		expect(result.current.getState).toBeInstanceOf(Function);
-		expect(result.current.subscribe).toBeInstanceOf(Function);
-	});
-});
-
-describe('useLastComputedMinMax', () => {
-	it('should return lastComputedMinMax from store', () => {
-		const contextStore = createGlobalTimeStore({ selectedTime: '15m' });
-
-		// Compute the min/max first
-		contextStore.getState().computeAndStoreMinMax();
-
-		const { result } = renderHook(() => useLastComputedMinMax(), {
-			wrapper: ({ children }: { children: ReactNode }): JSX.Element => (
-				<GlobalTimeContext.Provider value={contextStore}>
-					{children}
-				</GlobalTimeContext.Provider>
-			),
-		});
-
-		expect(result.current).toStrictEqual(
-			contextStore.getState().lastComputedMinMax,
-		);
-	});
-
-	it('should update when store changes', () => {
-		jest.useFakeTimers();
-		jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-
-		const contextStore = createGlobalTimeStore({ selectedTime: '15m' });
-		contextStore.getState().computeAndStoreMinMax();
-
-		const { result } = renderHook(() => useLastComputedMinMax(), {
-			wrapper: ({ children }: { children: ReactNode }): JSX.Element => (
-				<GlobalTimeContext.Provider value={contextStore}>
-					{children}
-				</GlobalTimeContext.Provider>
-			),
-		});
-
-		const firstValue = { ...result.current };
-
-		// Change time and recompute
-		act(() => {
-			jest.advanceTimersByTime(60000); // Advance 1 minute
-			contextStore.getState().computeAndStoreMinMax();
-		});
-
-		expect(result.current).not.toStrictEqual(firstValue);
-
-		jest.useRealTimers();
-	});
-});
-
-describe('useComputedMinMaxSync', () => {
-	beforeEach(() => {
-		jest.useFakeTimers();
-		jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-	});
-
-	afterEach(() => {
-		jest.useRealTimers();
-	});
-
-	it('should compute min/max on mount when store has zero values', () => {
-		const contextStore = createGlobalTimeStore({ selectedTime: '15m' });
-
-		expect(contextStore.getState().lastComputedMinMax).toStrictEqual({
-			minTime: 0,
-			maxTime: 0,
-		});
-
-		renderHook(() => useComputedMinMaxSync(contextStore));
-
-		// Should have computed values now
-		expect(contextStore.getState().lastComputedMinMax.maxTime).toBeGreaterThan(0);
-		expect(contextStore.getState().lastComputedMinMax.minTime).toBeGreaterThan(0);
-	});
-
-	it('should NOT recompute when store already has values', () => {
-		const contextStore = createGlobalTimeStore({ selectedTime: '15m' });
-
-		contextStore.getState().computeAndStoreMinMax();
-		const initialMinMax = { ...contextStore.getState().lastComputedMinMax };
-		const initialTimestamp = contextStore.getState().lastRefreshTimestamp;
-
-		jest.advanceTimersByTime(60000);
-
-		renderHook(() => useComputedMinMaxSync(contextStore));
-
-		// Should NOT have recomputed - values should be unchanged
-		expect(contextStore.getState().lastComputedMinMax).toStrictEqual(
-			initialMinMax,
-		);
-		expect(contextStore.getState().lastRefreshTimestamp).toBe(initialTimestamp);
-	});
-
-	it('should only compute on mount, not on re-renders', () => {
-		const contextStore = createGlobalTimeStore({ selectedTime: '15m' });
-
-		const { rerender } = renderHook(() => useComputedMinMaxSync(contextStore));
-
-		const afterMountMinMax = { ...contextStore.getState().lastComputedMinMax };
-		const afterMountTimestamp = contextStore.getState().lastRefreshTimestamp;
-
-		jest.advanceTimersByTime(60000);
-
-		rerender();
-
-		// Should NOT have recomputed on re-render
-		expect(contextStore.getState().lastComputedMinMax).toStrictEqual(
-			afterMountMinMax,
-		);
-		expect(contextStore.getState().lastRefreshTimestamp).toBe(
-			afterMountTimestamp,
-		);
-	});
-});

frontend/src/store/globalTime/__tests__/useGlobalTimeQueryInvalidate.test.tsx

@@ -1,381 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { QueryClient, QueryClientProvider, useQuery } from 'react-query';
-import { ReactNode } from 'react';
-
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
-import { GlobalTimeProvider } from '../GlobalTimeContext';
-import { useGlobalTime } from '../hooks';
-import { GlobalTimeProviderOptions } from '../types';
-import { useGlobalTimeQueryInvalidate } from '../useGlobalTimeQueryInvalidate';
-import { createCustomTimeRange, NANO_SECOND_MULTIPLIER } from '../utils';
-
-const createTestQueryClient = (): QueryClient =>
-	new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-				cacheTime: Infinity,
-			},
-		},
-	});
-
-const createWrapper = (
-	providerProps: GlobalTimeProviderOptions,
-	queryClient: QueryClient,
-) => {
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<NuqsTestingAdapter>
-					<GlobalTimeProvider {...providerProps}>{children}</GlobalTimeProvider>
-				</NuqsTestingAdapter>
-			</QueryClientProvider>
-		);
-	};
-};
-
-describe('useGlobalTimeQueryInvalidate', () => {
-	let queryClient: QueryClient;
-
-	beforeEach(() => {
-		queryClient = createTestQueryClient();
-		jest.useFakeTimers();
-		jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-	});
-
-	afterEach(() => {
-		jest.useRealTimers();
-		queryClient.clear();
-	});
-
-	it('should return a function', () => {
-		const wrapper = createWrapper({ initialTime: '15m' }, queryClient);
-		const { result } = renderHook(() => useGlobalTimeQueryInvalidate(), {
-			wrapper,
-		});
-
-		expect(typeof result.current).toBe('function');
-	});
-
-	it('should call computeAndStoreMinMax before invalidating queries (refresh disabled)', async () => {
-		const wrapper = createWrapper(
-			{ initialTime: '15m', refreshInterval: 0 }, // refresh disabled so computeAndStoreMinMax computes fresh values
-			queryClient,
-		);
-		const { result } = renderHook(
-			() => ({
-				invalidate: useGlobalTimeQueryInvalidate(),
-				globalTime: useGlobalTime(),
-			}),
-			{ wrapper },
-		);
-
-		// Initial computation - need to call computeAndStoreMinMax first
-		act(() => {
-			result.current.globalTime.computeAndStoreMinMax();
-		});
-		const initialMinMax = { ...result.current.globalTime.lastComputedMinMax };
-
-		// Advance time past minute boundary
-		act(() => {
-			jest.advanceTimersByTime(60000);
-		});
-
-		// Call invalidate - should compute fresh values when refresh is disabled
-		await act(async () => {
-			await result.current.invalidate();
-		});
-
-		// lastComputedMinMax should have been updated
-		expect(result.current.globalTime.lastComputedMinMax.maxTime).toBe(
-			initialMinMax.maxTime + 60000 * NANO_SECOND_MULTIPLIER,
-		);
-	});
-
-	it('should invalidate queries with AUTO_REFRESH_QUERY key', async () => {
-		const mockQueryFn = jest.fn().mockResolvedValue({ data: 'test' });
-
-		const wrapper = createWrapper({ initialTime: '15m' }, queryClient);
-
-		// Set up a query with AUTO_REFRESH_QUERY key
-		const { result: queryResult } = renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'test-query'],
-					queryFn: mockQueryFn,
-				}),
-			{ wrapper },
-		);
-
-		// Wait for initial query to complete
-		await waitFor(() => {
-			expect(queryResult.current.isSuccess).toBe(true);
-		});
-
-		expect(mockQueryFn).toHaveBeenCalledTimes(1);
-
-		// Now render the invalidate hook and call it
-		const { result: invalidateResult } = renderHook(
-			() => useGlobalTimeQueryInvalidate(),
-			{ wrapper },
-		);
-
-		await act(async () => {
-			await invalidateResult.current();
-		});
-
-		// Query should have been refetched
-		await waitFor(() => {
-			expect(mockQueryFn).toHaveBeenCalledTimes(2);
-		});
-	});
-
-	it('should NOT invalidate queries without AUTO_REFRESH_QUERY key', async () => {
-		const autoRefreshQueryFn = jest.fn().mockResolvedValue({ data: 'auto' });
-		const regularQueryFn = jest.fn().mockResolvedValue({ data: 'regular' });
-
-		const wrapper = createWrapper({ initialTime: '15m' }, queryClient);
-
-		// Set up both types of queries
-		const { result: autoRefreshQuery } = renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'auto-query'],
-					queryFn: autoRefreshQueryFn,
-				}),
-			{ wrapper },
-		);
-
-		const { result: regularQuery } = renderHook(
-			() =>
-				useQuery({
-					queryKey: ['regular-query'],
-					queryFn: regularQueryFn,
-				}),
-			{ wrapper },
-		);
-
-		// Wait for initial queries to complete
-		await waitFor(() => {
-			expect(autoRefreshQuery.current.isSuccess).toBe(true);
-			expect(regularQuery.current.isSuccess).toBe(true);
-		});
-
-		expect(autoRefreshQueryFn).toHaveBeenCalledTimes(1);
-		expect(regularQueryFn).toHaveBeenCalledTimes(1);
-
-		// Call invalidate
-		const { result: invalidateResult } = renderHook(
-			() => useGlobalTimeQueryInvalidate(),
-			{ wrapper },
-		);
-
-		await act(async () => {
-			await invalidateResult.current();
-		});
-
-		// Only auto-refresh query should be refetched
-		await waitFor(() => {
-			expect(autoRefreshQueryFn).toHaveBeenCalledTimes(2);
-		});
-
-		// Regular query should NOT be refetched
-		expect(regularQueryFn).toHaveBeenCalledTimes(1);
-	});
-
-	it('should use exact custom time values (not rounded) when invalidating', async () => {
-		// Use timestamps that are NOT on minute boundaries
-		const minTimeWithSeconds =
-			new Date('2024-01-15T12:15:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-		const maxTimeWithSeconds =
-			new Date('2024-01-15T12:30:45.123Z').getTime() * NANO_SECOND_MULTIPLIER;
-
-		const customTime = createCustomTimeRange(
-			minTimeWithSeconds,
-			maxTimeWithSeconds,
-		);
-
-		const wrapper = createWrapper({ initialTime: customTime }, queryClient);
-
-		const { result } = renderHook(
-			() => ({
-				invalidate: useGlobalTimeQueryInvalidate(),
-				globalTime: useGlobalTime(),
-			}),
-			{ wrapper },
-		);
-
-		// Call invalidate
-		await act(async () => {
-			await result.current.invalidate();
-		});
-
-		// Verify custom time values are NOT rounded
-		expect(result.current.globalTime.lastComputedMinMax.minTime).toBe(
-			minTimeWithSeconds,
-		);
-		expect(result.current.globalTime.lastComputedMinMax.maxTime).toBe(
-			maxTimeWithSeconds,
-		);
-	});
-
-	it('should invalidate multiple AUTO_REFRESH_QUERY queries at once', async () => {
-		const queryFn1 = jest.fn().mockResolvedValue({ data: 'query1' });
-		const queryFn2 = jest.fn().mockResolvedValue({ data: 'query2' });
-		const queryFn3 = jest.fn().mockResolvedValue({ data: 'query3' });
-
-		const wrapper = createWrapper({ initialTime: '15m' }, queryClient);
-
-		// Set up multiple auto-refresh queries
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query1'],
-					queryFn: queryFn1,
-				}),
-			{ wrapper },
-		);
-
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query2'],
-					queryFn: queryFn2,
-				}),
-			{ wrapper },
-		);
-
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query3'],
-					queryFn: queryFn3,
-				}),
-			{ wrapper },
-		);
-
-		// Wait for initial queries
-		await waitFor(() => {
-			expect(queryFn1).toHaveBeenCalledTimes(1);
-			expect(queryFn2).toHaveBeenCalledTimes(1);
-			expect(queryFn3).toHaveBeenCalledTimes(1);
-		});
-
-		// Call invalidate
-		const { result } = renderHook(() => useGlobalTimeQueryInvalidate(), {
-			wrapper,
-		});
-
-		await act(async () => {
-			await result.current();
-		});
-
-		// All queries should be refetched
-		await waitFor(() => {
-			expect(queryFn1).toHaveBeenCalledTimes(2);
-			expect(queryFn2).toHaveBeenCalledTimes(2);
-			expect(queryFn3).toHaveBeenCalledTimes(2);
-		});
-	});
-
-	describe('scoped invalidation with store name', () => {
-		it('should only invalidate queries matching store name', async () => {
-			const namedQueryFn = jest.fn().mockResolvedValue({ data: 'named' });
-			const unnamedQueryFn = jest.fn().mockResolvedValue({ data: 'unnamed' });
-
-			const wrapper = createWrapper(
-				{ name: 'drawer', initialTime: '15m' },
-				queryClient,
-			);
-
-			// Query with matching name
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'drawer', 'named-query'],
-						queryFn: namedQueryFn,
-					}),
-				{ wrapper },
-			);
-
-			// Query without name (different store)
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'unnamed-query'],
-						queryFn: unnamedQueryFn,
-					}),
-				{ wrapper },
-			);
-
-			await waitFor(() => {
-				expect(namedQueryFn).toHaveBeenCalledTimes(1);
-				expect(unnamedQueryFn).toHaveBeenCalledTimes(1);
-			});
-
-			// Call invalidate
-			const { result } = renderHook(() => useGlobalTimeQueryInvalidate(), {
-				wrapper,
-			});
-
-			await act(async () => {
-				await result.current();
-			});
-
-			// Only named query should be refetched
-			await waitFor(() => {
-				expect(namedQueryFn).toHaveBeenCalledTimes(2);
-			});
-
-			// Unnamed query should NOT be refetched
-			expect(unnamedQueryFn).toHaveBeenCalledTimes(1);
-		});
-
-		it('should invalidate all queries for unnamed store (backward compatible)', async () => {
-			const queryFn1 = jest.fn().mockResolvedValue({ data: 'query1' });
-			const queryFn2 = jest.fn().mockResolvedValue({ data: 'query2' });
-
-			// Unnamed store (no name prop)
-			const wrapper = createWrapper({ initialTime: '15m' }, queryClient);
-
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query1'],
-						queryFn: queryFn1,
-					}),
-				{ wrapper },
-			);
-
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query2'],
-						queryFn: queryFn2,
-					}),
-				{ wrapper },
-			);
-
-			await waitFor(() => {
-				expect(queryFn1).toHaveBeenCalledTimes(1);
-				expect(queryFn2).toHaveBeenCalledTimes(1);
-			});
-
-			const { result } = renderHook(() => useGlobalTimeQueryInvalidate(), {
-				wrapper,
-			});
-
-			await act(async () => {
-				await result.current();
-			});
-
-			// Both should be refetched
-			await waitFor(() => {
-				expect(queryFn1).toHaveBeenCalledTimes(2);
-				expect(queryFn2).toHaveBeenCalledTimes(2);
-			});
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/useIsGlobalTimeQueryRefreshing.test.tsx

@@ -1,323 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { QueryClient, QueryClientProvider, useQuery } from 'react-query';
-import { ReactNode } from 'react';
-
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
-import { GlobalTimeProvider } from '../GlobalTimeContext';
-import { GlobalTimeProviderOptions } from '../types';
-import { useIsGlobalTimeQueryRefreshing } from '../useIsGlobalTimeQueryRefreshing';
-
-const createTestQueryClient = (): QueryClient =>
-	new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-			},
-		},
-	});
-
-const createWrapper = (
-	queryClient: QueryClient,
-): (({ children }: { children: ReactNode }) => JSX.Element) => {
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-		);
-	};
-};
-
-const createProviderWrapper = (
-	providerProps: GlobalTimeProviderOptions,
-	queryClient: QueryClient,
-): (({ children }: { children: ReactNode }) => JSX.Element) => {
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<NuqsTestingAdapter>
-					<GlobalTimeProvider {...providerProps}>{children}</GlobalTimeProvider>
-				</NuqsTestingAdapter>
-			</QueryClientProvider>
-		);
-	};
-};
-
-describe('useIsGlobalTimeQueryRefreshing', () => {
-	let queryClient: QueryClient;
-
-	beforeEach(() => {
-		queryClient = createTestQueryClient();
-	});
-
-	afterEach(() => {
-		queryClient.clear();
-	});
-
-	it('should return false when no queries are fetching', () => {
-		const wrapper = createWrapper(queryClient);
-		const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-			wrapper,
-		});
-
-		expect(result.current).toBe(false);
-	});
-
-	it('should return true when AUTO_REFRESH_QUERY is fetching', async () => {
-		let resolveQuery: (value: unknown) => void;
-		const queryPromise = new Promise((resolve) => {
-			resolveQuery = resolve;
-		});
-
-		const wrapper = createWrapper(queryClient);
-
-		// Start the auto-refresh query
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'test'],
-					queryFn: () => queryPromise,
-				}),
-			{ wrapper },
-		);
-
-		// Check if refreshing hook detects it
-		const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-			wrapper,
-		});
-
-		// Should be true while fetching
-		expect(result.current).toBe(true);
-
-		// Resolve the query
-		act(() => {
-			resolveQuery({ data: 'done' });
-		});
-
-		// Should be false after fetching completes
-		await waitFor(() => {
-			expect(result.current).toBe(false);
-		});
-	});
-
-	it('should return false when non-AUTO_REFRESH_QUERY is fetching', async () => {
-		let resolveQuery: (value: unknown) => void;
-		const queryPromise = new Promise((resolve) => {
-			resolveQuery = resolve;
-		});
-
-		const wrapper = createWrapper(queryClient);
-
-		// Start a regular query (not auto-refresh)
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: ['regular-query'],
-					queryFn: () => queryPromise,
-				}),
-			{ wrapper },
-		);
-
-		// Check if refreshing hook detects it
-		const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-			wrapper,
-		});
-
-		// Should be false - not an auto-refresh query
-		expect(result.current).toBe(false);
-
-		// Cleanup
-		act(() => {
-			resolveQuery({ data: 'done' });
-		});
-	});
-
-	it('should return true when multiple AUTO_REFRESH_QUERY queries are fetching', async () => {
-		let resolveQuery1: (value: unknown) => void;
-		let resolveQuery2: (value: unknown) => void;
-		const queryPromise1 = new Promise((resolve) => {
-			resolveQuery1 = resolve;
-		});
-		const queryPromise2 = new Promise((resolve) => {
-			resolveQuery2 = resolve;
-		});
-
-		const wrapper = createWrapper(queryClient);
-
-		// Start multiple auto-refresh queries
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query1'],
-					queryFn: () => queryPromise1,
-				}),
-			{ wrapper },
-		);
-
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'query2'],
-					queryFn: () => queryPromise2,
-				}),
-			{ wrapper },
-		);
-
-		const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-			wrapper,
-		});
-
-		// Should be true while fetching
-		expect(result.current).toBe(true);
-
-		// Resolve first query
-		act(() => {
-			resolveQuery1({ data: 'done1' });
-		});
-
-		// Should still be true (second query still fetching)
-		await waitFor(() => {
-			expect(result.current).toBe(true);
-		});
-
-		// Resolve second query
-		act(() => {
-			resolveQuery2({ data: 'done2' });
-		});
-
-		// Should be false after all complete
-		await waitFor(() => {
-			expect(result.current).toBe(false);
-		});
-	});
-
-	it('should only track AUTO_REFRESH_QUERY, not other queries', async () => {
-		let resolveAutoRefresh: (value: unknown) => void;
-		let resolveRegular: (value: unknown) => void;
-		const autoRefreshPromise = new Promise((resolve) => {
-			resolveAutoRefresh = resolve;
-		});
-		const regularPromise = new Promise((resolve) => {
-			resolveRegular = resolve;
-		});
-
-		const wrapper = createWrapper(queryClient);
-
-		// Start both types of queries
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'auto'],
-					queryFn: () => autoRefreshPromise,
-				}),
-			{ wrapper },
-		);
-
-		renderHook(
-			() =>
-				useQuery({
-					queryKey: ['regular'],
-					queryFn: () => regularPromise,
-				}),
-			{ wrapper },
-		);
-
-		const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-			wrapper,
-		});
-
-		// Should be true (auto-refresh is fetching)
-		expect(result.current).toBe(true);
-
-		// Resolve auto-refresh query
-		act(() => {
-			resolveAutoRefresh({ data: 'done' });
-		});
-
-		// Should be false even though regular query is still fetching
-		await waitFor(() => {
-			expect(result.current).toBe(false);
-		});
-
-		// Cleanup
-		act(() => {
-			resolveRegular({ data: 'done' });
-		});
-	});
-
-	describe('scoped refreshing check with store name', () => {
-		it('should return true only for queries matching store name', async () => {
-			let resolveNamedQuery: (value: unknown) => void;
-			const namedQueryPromise = new Promise((resolve) => {
-				resolveNamedQuery = resolve;
-			});
-
-			const wrapper = createProviderWrapper(
-				{ name: 'drawer', initialTime: '15m' },
-				queryClient,
-			);
-
-			// Start query with matching name
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'drawer', 'test'],
-						queryFn: () => namedQueryPromise,
-					}),
-				{ wrapper },
-			);
-
-			// Check refreshing status
-			const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-				wrapper,
-			});
-
-			// Should be true - named query is fetching
-			expect(result.current).toBe(true);
-
-			// Resolve the query
-			act(() => {
-				resolveNamedQuery({ data: 'done' });
-			});
-
-			await waitFor(() => {
-				expect(result.current).toBe(false);
-			});
-		});
-
-		it('should return false when only different store queries are fetching', async () => {
-			let resolveOtherQuery: (value: unknown) => void;
-			const otherQueryPromise = new Promise((resolve) => {
-				resolveOtherQuery = resolve;
-			});
-
-			const wrapper = createProviderWrapper(
-				{ name: 'drawer', initialTime: '15m' },
-				queryClient,
-			);
-
-			// Start query with different name (belongs to different store)
-			renderHook(
-				() =>
-					useQuery({
-						queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'other-store', 'test'],
-						queryFn: () => otherQueryPromise,
-					}),
-				{ wrapper },
-			);
-
-			// Check refreshing status for 'drawer' store
-			const { result } = renderHook(() => useIsGlobalTimeQueryRefreshing(), {
-				wrapper,
-			});
-
-			// Should be false - the fetching query belongs to 'other-store', not 'drawer'
-			expect(result.current).toBe(false);
-
-			// Cleanup
-			act(() => {
-				resolveOtherQuery({ data: 'done' });
-			});
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/useQueryCacheSync.test.tsx

@@ -1,190 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-import { ReactNode } from 'react';
-
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
-import { createGlobalTimeStore, GlobalTimeStoreApi } from '../globalTimeStore';
-import { useQueryCacheSync } from '../useQueryCacheSync';
-
-function createTestQueryClient(): QueryClient {
-	return new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-			},
-		},
-	});
-}
-
-function createWrapper(
-	queryClient: QueryClient,
-): ({ children }: { children: ReactNode }) => JSX.Element {
-	return function Wrapper({ children }: { children: ReactNode }): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-		);
-	};
-}
-
-describe('useQueryCacheSync', () => {
-	let store: GlobalTimeStoreApi;
-	let queryClient: QueryClient;
-
-	beforeEach(() => {
-		store = createGlobalTimeStore();
-		queryClient = createTestQueryClient();
-		jest.useFakeTimers();
-		jest.setSystemTime(new Date('2024-01-15T12:30:45.123Z'));
-	});
-
-	afterEach(() => {
-		jest.useRealTimers();
-		queryClient.clear();
-	});
-
-	it('should update lastRefreshTimestamp when auto-refresh query succeeds', async () => {
-		// Initialize store
-		act(() => {
-			store.getState().computeAndStoreMinMax();
-		});
-
-		const initialTimestamp = store.getState().lastRefreshTimestamp;
-
-		// Advance time
-		act(() => {
-			jest.advanceTimersByTime(5000);
-		});
-
-		// Render the hook
-		renderHook(() => useQueryCacheSync(store), {
-			wrapper: createWrapper(queryClient),
-		});
-
-		// Simulate a successful auto-refresh query
-		await act(async () => {
-			await queryClient.fetchQuery({
-				queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'test'],
-				queryFn: () => Promise.resolve({ data: 'test' }),
-			});
-		});
-
-		await waitFor(() => {
-			expect(store.getState().lastRefreshTimestamp).toBeGreaterThan(
-				initialTimestamp,
-			);
-		});
-	});
-
-	it('should not update timestamp for non-auto-refresh queries', async () => {
-		act(() => {
-			store.getState().computeAndStoreMinMax();
-		});
-
-		const initialTimestamp = store.getState().lastRefreshTimestamp;
-
-		renderHook(() => useQueryCacheSync(store), {
-			wrapper: createWrapper(queryClient),
-		});
-
-		// Simulate a regular query (not auto-refresh)
-		await act(async () => {
-			await queryClient.fetchQuery({
-				queryKey: ['some-other-query'],
-				queryFn: () => Promise.resolve({ data: 'test' }),
-			});
-		});
-
-		expect(store.getState().lastRefreshTimestamp).toBe(initialTimestamp);
-	});
-
-	describe('store name filtering', () => {
-		it('should update timestamp for named store when matching query succeeds', async () => {
-			const store = createGlobalTimeStore({ name: 'drawer' });
-
-			act(() => {
-				store.getState().computeAndStoreMinMax();
-			});
-
-			const initialTimestamp = store.getState().lastRefreshTimestamp;
-
-			act(() => {
-				jest.advanceTimersByTime(5000);
-			});
-
-			renderHook(() => useQueryCacheSync(store), {
-				wrapper: createWrapper(queryClient),
-			});
-
-			// Query with matching name
-			await act(async () => {
-				await queryClient.fetchQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'drawer', 'test'],
-					queryFn: () => Promise.resolve({ data: 'test' }),
-				});
-			});
-
-			await waitFor(() => {
-				expect(store.getState().lastRefreshTimestamp).toBeGreaterThan(
-					initialTimestamp,
-				);
-			});
-		});
-
-		it('should NOT update timestamp for named store when different name query succeeds', async () => {
-			const store = createGlobalTimeStore({ name: 'drawer' });
-
-			act(() => {
-				store.getState().computeAndStoreMinMax();
-			});
-
-			const initialTimestamp = store.getState().lastRefreshTimestamp;
-
-			act(() => {
-				jest.advanceTimersByTime(5000);
-			});
-
-			renderHook(() => useQueryCacheSync(store), {
-				wrapper: createWrapper(queryClient),
-			});
-
-			// Query with different name
-			await act(async () => {
-				await queryClient.fetchQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'other-store', 'test'],
-					queryFn: () => Promise.resolve({ data: 'test' }),
-				});
-			});
-
-			expect(store.getState().lastRefreshTimestamp).toBe(initialTimestamp);
-		});
-
-		it('should NOT update timestamp for named store when unnamed query succeeds', async () => {
-			const store = createGlobalTimeStore({ name: 'drawer' });
-
-			act(() => {
-				store.getState().computeAndStoreMinMax();
-			});
-
-			const initialTimestamp = store.getState().lastRefreshTimestamp;
-
-			act(() => {
-				jest.advanceTimersByTime(5000);
-			});
-
-			renderHook(() => useQueryCacheSync(store), {
-				wrapper: createWrapper(queryClient),
-			});
-
-			// Query without name (unnamed store format)
-			await act(async () => {
-				await queryClient.fetchQuery({
-					queryKey: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, 'test-query'],
-					queryFn: () => Promise.resolve({ data: 'test' }),
-				});
-			});
-
-			expect(store.getState().lastRefreshTimestamp).toBe(initialTimestamp);
-		});
-	});
-});

frontend/src/store/globalTime/__tests__/utils.test.ts

@@ -1,15 +1,10 @@
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
 import {
-	computeRounded5sMinMax,
 	createCustomTimeRange,
 	CUSTOM_TIME_SEPARATOR,
-	getAutoRefreshQueryKey,
 	isCustomTimeRange,
 	NANO_SECOND_MULTIPLIER,
 	parseCustomTimeRange,
 	parseSelectedTime,
-	roundDownTo5Seconds,
 } from '../utils';
 
 describe('globalTime/utils', () => {
@@ -141,184 +136,4 @@ describe('globalTime/utils', () => {
 			expect(result.minTime).toBe(now - oneDayNs);
 		});
 	});
-
-	describe('roundDownTo5Seconds', () => {
-		it('should round down timestamp to 5-second boundary', () => {
-			// 12:30:47.123Z -> 12:30:45.000Z
-			const inputNano = 1705321847123 * NANO_SECOND_MULTIPLIER;
-			const expectedNano = 1705321845000 * NANO_SECOND_MULTIPLIER;
-
-			expect(roundDownTo5Seconds(inputNano)).toBe(expectedNano);
-		});
-
-		it('should not change timestamp already at 5-second boundary', () => {
-			const inputNano = 1705321845000 * NANO_SECOND_MULTIPLIER; // 12:30:45.000
-
-			expect(roundDownTo5Seconds(inputNano)).toBe(inputNano);
-		});
-
-		it('should round 12:30:04.999 down to 12:30:00.000', () => {
-			const inputNano = 1705321804999 * NANO_SECOND_MULTIPLIER;
-			const expectedNano = 1705321800000 * NANO_SECOND_MULTIPLIER;
-
-			expect(roundDownTo5Seconds(inputNano)).toBe(expectedNano);
-		});
-
-		it('should round 12:30:09.999 down to 12:30:05.000', () => {
-			const inputNano = 1705321809999 * NANO_SECOND_MULTIPLIER;
-			const expectedNano = 1705321805000 * NANO_SECOND_MULTIPLIER;
-
-			expect(roundDownTo5Seconds(inputNano)).toBe(expectedNano);
-		});
-
-		it('should handle timestamp at exact 5-second intervals', () => {
-			// Test 5, 10, 15, 20, 25... second marks
-			const base = 1705321800000; // 12:30:00
-			for (let sec = 0; sec < 60; sec += 5) {
-				const inputNano = (base + sec * 1000) * NANO_SECOND_MULTIPLIER;
-				expect(roundDownTo5Seconds(inputNano)).toBe(inputNano);
-			}
-		});
-	});
-
-	describe('computeRounded5sMinMax', () => {
-		beforeEach(() => {
-			jest.useFakeTimers();
-			jest.setSystemTime(new Date('2024-01-15T12:30:47.123Z'));
-		});
-
-		afterEach(() => {
-			jest.useRealTimers();
-		});
-
-		it('should return maxTime rounded to 5-second boundary for relative time', () => {
-			const result = computeRounded5sMinMax('15m');
-
-			// maxTime should be rounded down to 12:30:45.000
-			const expectedMaxTime =
-				new Date('2024-01-15T12:30:45.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-			expect(result.maxTime).toBe(expectedMaxTime);
-		});
-
-		it('should compute minTime based on 5s-rounded maxTime', () => {
-			const result = computeRounded5sMinMax('15m');
-
-			const expectedMaxTime =
-				new Date('2024-01-15T12:30:45.000Z').getTime() * NANO_SECOND_MULTIPLIER;
-			const fifteenMinutesNs = 15 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
-
-			expect(result.minTime).toBe(expectedMaxTime - fifteenMinutesNs);
-		});
-
-		it('should return unchanged values for custom time range', () => {
-			const minTime = 1000000000;
-			const maxTime = 2000000000;
-			const customTime = createCustomTimeRange(minTime, maxTime);
-
-			const result = computeRounded5sMinMax(customTime);
-
-			expect(result.minTime).toBe(minTime);
-			expect(result.maxTime).toBe(maxTime);
-		});
-
-		it('should preserve duration for 1h relative time', () => {
-			const result = computeRounded5sMinMax('1h');
-
-			const oneHourNs = 60 * 60 * 1000 * NANO_SECOND_MULTIPLIER;
-			const duration = result.maxTime - result.minTime;
-
-			expect(duration).toBe(oneHourNs);
-		});
-	});
-
-	describe('getAutoRefreshQueryKey', () => {
-		it('should prefix with AUTO_REFRESH_QUERY constant', () => {
-			const result = getAutoRefreshQueryKey('15m', 'MY_QUERY');
-
-			expect(result[0]).toBe(REACT_QUERY_KEY.AUTO_REFRESH_QUERY);
-		});
-
-		it('should append selectedTime at end', () => {
-			const result = getAutoRefreshQueryKey('15m', 'MY_QUERY', 'param1');
-
-			expect(result).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'MY_QUERY',
-				'param1',
-				'15m',
-			]);
-		});
-
-		it('should handle no additional query parts', () => {
-			const result = getAutoRefreshQueryKey('1h');
-
-			expect(result).toStrictEqual([REACT_QUERY_KEY.AUTO_REFRESH_QUERY, '1h']);
-		});
-
-		it('should handle custom time range as selectedTime', () => {
-			const customTime = createCustomTimeRange(1000000000, 2000000000);
-			const result = getAutoRefreshQueryKey(customTime, 'METRICS');
-
-			expect(result).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'METRICS',
-				customTime,
-			]);
-		});
-
-		it('should handle object query parts', () => {
-			const params = { entityId: '123', filter: 'active' };
-			const result = getAutoRefreshQueryKey('15m', 'ENTITY', params);
-
-			expect(result).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'ENTITY',
-				params,
-				'15m',
-			]);
-		});
-	});
-
-	describe('getAutoRefreshQueryKey deprecation', () => {
-		const originalEnv = process.env.NODE_ENV;
-		const originalWarn = console.warn;
-
-		beforeEach(() => {
-			console.warn = jest.fn();
-		});
-
-		afterEach(() => {
-			process.env.NODE_ENV = originalEnv;
-			console.warn = originalWarn;
-		});
-
-		it('should log deprecation warning in development', () => {
-			process.env.NODE_ENV = 'development';
-
-			getAutoRefreshQueryKey('15m', 'TEST');
-
-			expect(console.warn).toHaveBeenCalledWith(
-				expect.stringContaining('deprecated'),
-			);
-		});
-
-		it('should NOT log deprecation warning in production', () => {
-			process.env.NODE_ENV = 'production';
-
-			getAutoRefreshQueryKey('15m', 'TEST');
-
-			expect(console.warn).not.toHaveBeenCalled();
-		});
-
-		it('should still return correct query key format', () => {
-			const result = getAutoRefreshQueryKey('15m', 'MY_QUERY', 'param1');
-
-			expect(result).toStrictEqual([
-				REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-				'MY_QUERY',
-				'param1',
-				'15m',
-			]);
-		});
-	});
 });

frontend/src/store/globalTime/globalTimeStore.ts

@@ -1,144 +1,32 @@
-import { createStore, StoreApi, useStore } from 'zustand';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
+import { create } from 'zustand';
 
 import {
-	GlobalTimeSelectedTime,
-	GlobalTimeState,
-	GlobalTimeStore,
+	IGlobalTimeStoreActions,
+	IGlobalTimeStoreState,
 	ParsedTimeRange,
 } from './types';
-import {
-	computeRounded5sMinMax,
-	isCustomTimeRange,
-	parseSelectedTime,
-} from './utils';
+import { isCustomTimeRange, parseSelectedTime } from './utils';
 
-export type GlobalTimeStoreApi = StoreApi<GlobalTimeStore>;
-export type IGlobalTimeStore = GlobalTimeStore;
+export type IGlobalTimeStore = IGlobalTimeStoreState & IGlobalTimeStoreActions;
 
-function computeIsRefreshEnabled(
-	selectedTime: GlobalTimeSelectedTime,
-	refreshInterval: number,
-): boolean {
-	if (isCustomTimeRange(selectedTime)) {
-		return false;
-	}
-	return refreshInterval > 0;
-}
+export const useGlobalTimeStore = create<IGlobalTimeStore>((set, get) => ({
+	selectedTime: DEFAULT_TIME_RANGE,
+	isRefreshEnabled: false,
+	refreshInterval: 0,
+	setSelectedTime: (selectedTime, refreshInterval): void => {
+		set((state) => {
+			const newRefreshInterval = refreshInterval ?? state.refreshInterval;
+			const isCustom = isCustomTimeRange(selectedTime);
 
-export function createGlobalTimeStore(
-	initialState?: Partial<GlobalTimeState>,
-): GlobalTimeStoreApi {
-	const selectedTime = initialState?.selectedTime ?? DEFAULT_TIME_RANGE;
-	const refreshInterval = initialState?.refreshInterval ?? 0;
-	const name = initialState?.name;
-
-	return createStore<GlobalTimeStore>((set, get) => ({
-		name,
-		selectedTime,
-		refreshInterval,
-		isRefreshEnabled: computeIsRefreshEnabled(selectedTime, refreshInterval),
-		lastRefreshTimestamp: 0,
-		lastComputedMinMax: { minTime: 0, maxTime: 0 },
-
-		setSelectedTime: (
-			time: GlobalTimeSelectedTime,
-			newRefreshInterval?: number,
-		): void => {
-			const state = get();
-			const interval = newRefreshInterval ?? state.refreshInterval;
-
-			if (time === state.selectedTime && interval === state.refreshInterval) {
-				return;
-			}
-
-			const computedMinMax = parseSelectedTime(time);
-
-			set({
-				selectedTime: time,
-				refreshInterval: interval,
-				isRefreshEnabled: computeIsRefreshEnabled(time, interval),
-				lastComputedMinMax: computedMinMax,
-				lastRefreshTimestamp: Date.now(),
-			});
-		},
-
-		setRefreshInterval: (interval: number): void => {
-			set((state) => ({
-				refreshInterval: interval,
-				isRefreshEnabled: computeIsRefreshEnabled(state.selectedTime, interval),
-			}));
-		},
-
-		getMinMaxTime: (): ParsedTimeRange => {
-			const state = get();
-
-			if (isCustomTimeRange(state.selectedTime)) {
-				return parseSelectedTime(state.selectedTime);
-			}
-
-			if (state.isRefreshEnabled) {
-				const freshMinMax = computeRounded5sMinMax(state.selectedTime);
-
-				if (
-					freshMinMax.minTime !== state.lastComputedMinMax.minTime ||
-					freshMinMax.maxTime !== state.lastComputedMinMax.maxTime
-				) {
-					set({ lastComputedMinMax: freshMinMax, lastRefreshTimestamp: Date.now() });
-				}
-
-				return freshMinMax;
-			}
-
-			return state.lastComputedMinMax;
-		},
-
-		computeAndStoreMinMax: (): ParsedTimeRange => {
-			const state = get();
-
-			if (state.isRefreshEnabled) {
-				return state.lastComputedMinMax;
-			}
-
-			const computedMinMax = parseSelectedTime(state.selectedTime);
-
-			set({
-				lastComputedMinMax: computedMinMax,
-				lastRefreshTimestamp: Date.now(),
-			});
-			return computedMinMax;
-		},
-
-		updateRefreshTimestamp: (): void => {
-			set({ lastRefreshTimestamp: Date.now() });
-		},
-
-		getAutoRefreshQueryKey: (
-			selectedTime: GlobalTimeSelectedTime,
-			...queryParts: unknown[]
-		): unknown[] => {
-			const storeName = get().name;
-			if (storeName) {
-				return [
-					REACT_QUERY_KEY.AUTO_REFRESH_QUERY,
-					storeName,
-					...queryParts,
-					selectedTime,
-				];
-			}
-			return [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, ...queryParts, selectedTime];
-		},
-	}));
-}
-
-export const defaultGlobalTimeStore = createGlobalTimeStore();
-
-export const useGlobalTimeStore = <T = GlobalTimeStore>(
-	selector?: (state: GlobalTimeStore) => T,
-): T => {
-	return useStore(
-		defaultGlobalTimeStore,
-		selector ?? ((state) => state as unknown as T),
-	);
-};
+			return {
+				selectedTime,
+				refreshInterval: newRefreshInterval,
+				isRefreshEnabled: !isCustom && newRefreshInterval > 0,
+			};
+		});
+	},
+	getMinMaxTime: (selectedTime): ParsedTimeRange => {
+		return parseSelectedTime(selectedTime || get().selectedTime);
+	},
+}));

frontend/src/store/globalTime/hooks.ts

@@ -1,57 +0,0 @@
-// oxlint-disable-next-line no-restricted-imports
-import { useContext } from 'react';
-import { useStoreWithEqualityFn } from 'zustand/traditional';
-
-import { GlobalTimeContext } from './GlobalTimeContext';
-import { defaultGlobalTimeStore, GlobalTimeStoreApi } from './globalTimeStore';
-import { GlobalTimeStore, ParsedTimeRange } from './types';
-import { isCustomTimeRange } from './utils';
-
-/**
- * Access global time state with optional selector for performance.
- *
- * @example
- * // Full state (re-renders on any change)
- * const { selectedTime, setSelectedTime } = useGlobalTime();
- *
- * @example
- * // With selector (re-renders only when selectedTime changes)
- * const selectedTime = useGlobalTime(state => state.selectedTime);
- */
-export function useGlobalTime<T = GlobalTimeStore>(
-	selector?: (state: GlobalTimeStore) => T,
-	equalityFn?: (a: T, b: T) => boolean,
-): T {
-	const contextStore = useContext(GlobalTimeContext);
-	const store = contextStore ?? defaultGlobalTimeStore;
-
-	return useStoreWithEqualityFn(
-		store,
-		selector ?? ((state) => state as unknown as T),
-		equalityFn,
-	);
-}
-
-/**
- * Check if currently using a custom time range.
- */
-export function useIsCustomTimeRange(): boolean {
-	const selectedTime = useGlobalTime((state) => state.selectedTime);
-	return isCustomTimeRange(selectedTime);
-}
-
-/**
- * Get the store API directly (for subscriptions or non-React contexts).
- */
-export function useGlobalTimeStoreApi(): GlobalTimeStoreApi {
-	const contextStore = useContext(GlobalTimeContext);
-	return contextStore ?? defaultGlobalTimeStore;
-}
-
-/**
- * Get the last computed min/max time values.
- * Use this for display purposes to ensure consistency with query data.
- */
-export function useLastComputedMinMax(): ParsedTimeRange {
-	return useGlobalTime((state) => state.lastComputedMinMax);
-}

frontend/src/store/globalTime/index.ts

@@ -1,558 +1,9 @@
-/**
- * # Global Time Store
- *
- * Centralized time management for the application with auto-refresh support.
- *
- * ## Quick Start
- *
- * ```tsx
- * import { useGlobalTime, NANO_SECOND_MULTIPLIER } from 'store/globalTime';
- *
- * function MyComponent() {
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   const getMinMaxTime = useGlobalTime((s) => s.getMinMaxTime);
- *   const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *   const isRefreshEnabled = useGlobalTime((s) => s.isRefreshEnabled);
- *   const refreshInterval = useGlobalTime((s) => s.refreshInterval);
- *
- *   const { data } = useQuery({
- *     queryKey: getAutoRefreshQueryKey(selectedTime, 'MY_QUERY', params),
- *     queryFn: () => {
- *       const { minTime, maxTime } = getMinMaxTime();
- *       const start = Math.floor(minTime / NANO_SECOND_MULTIPLIER / 1000);
- *       const end = Math.floor(maxTime / NANO_SECOND_MULTIPLIER / 1000);
- *       return fetchData({ start, end });
- *     },
- *     refetchInterval: isRefreshEnabled ? refreshInterval : false,
- *   });
- * }
- * ```
- *
- * ## Core Concepts
- *
- * ### Time Formats
- *
- * | Format | Example | Description |
- * |--------|---------|-------------|
- * | Relative | `'15m'`, `'1h'`, `'1d'` | Duration from now, supports auto-refresh |
- * | Custom | `'1234567890||_||1234567899'` | Fixed range in nanoseconds, no auto-refresh |
- *
- * ### Time Units
- *
- * - Store values are in **nanoseconds**
- * - Most APIs expect **seconds**
- * - Convert to have seconds: `Math.floor(nanoTime / NANO_SECOND_MULTIPLIER / 1000)`
- * - Convert to have ms: `Math.floor(nanoTime / NANO_SECOND_MULTIPLIER)`
- *
- * ## Integration Guide
- *
- * ### Step 1: Get Store State
- *
- * Use selectors for optimal re-render performance:
- *
- * ```tsx
- * // Good - only re-renders when selectedTime changes
- * const selectedTime = useGlobalTime((s) => s.selectedTime);
- * const getMinMaxTime = useGlobalTime((s) => s.getMinMaxTime);
- *
- * // Avoid - re-renders on ANY store change
- * const store = useGlobalTime();
- * ```
- *
- * ### Step 2: Build Query Key
- *
- * Use the store's `getAutoRefreshQueryKey` to enable auto-refresh:
- *
- * ```tsx
- * const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *
- * const queryKey = useMemo(
- *   () => getAutoRefreshQueryKey(
- *     selectedTime,      // Required - triggers invalidation
- *     'UNIQUE_KEY',      // Your query identifier
- *     ...otherParams     // Additional cache-busting params
- *   ),
- *   [getAutoRefreshQueryKey, selectedTime, ...deps]
- * );
- * ```
- *
- * **Note:** For named providers (with `name` prop), query keys are automatically
- * scoped to that store, enabling isolated invalidation and refresh tracking.
- *
- * ### Step 3: Fetch Data
- *
- * **IMPORTANT**: Call `getMinMaxTime()` INSIDE `queryFn`:
- *
- * ```tsx
- * const { data } = useQuery({
- *   queryKey,
- *   queryFn: () => {
- *     // Fresh time values computed here during auto-refresh
- *     const { minTime, maxTime } = getMinMaxTime();
- *     const start = Math.floor(minTime / NANO_SECOND_MULTIPLIER / 1000);
- *     const end = Math.floor(maxTime / NANO_SECOND_MULTIPLIER / 1000);
- *     return api.fetch({ start, end });
- *   },
- *   refetchInterval: isRefreshEnabled ? refreshInterval : false,
- * });
- * ```
- *
- * ### Step 4: Add Refresh Button (Optional)
- *
- * ```tsx
- * import {
- *   useGlobalTimeQueryInvalidate,
- *   useIsGlobalTimeQueryRefreshing,
- * } from 'store/globalTime';
- *
- * function RefreshButton() {
- *   const invalidate = useGlobalTimeQueryInvalidate();
- *   const isRefreshing = useIsGlobalTimeQueryRefreshing();
- *
- *   return (
- *     <button onClick={invalidate} disabled={isRefreshing}>
- *       {isRefreshing ? 'Refreshing...' : 'Refresh'}
- *     </button>
- *   );
- * }
- * ```
- *
- * ## Avoiding Stale Data
- *
- * ### Problem: Time Drift During Refresh
- *
- * If multiple queries compute time independently, they may use different values:
- *
- * ```tsx
- * // BAD - each query gets different time
- * queryFn: () => {
- *   const now = Date.now();
- *   return fetchData({ end: now, start: now - duration });
- * }
- * ```
- *
- * ### Solution: Use getMinMaxTime()
- *
- * `getMinMaxTime()` ensures all queries use consistent timestamps:
- * - When auto-refresh is **disabled**: returns cached values from `computeAndStoreMinMax()`
- * - When auto-refresh is **enabled**: computes fresh values (rounded to 5-second boundaries)
- *
- * Since values are rounded to 5-second boundaries, all queries calling `getMinMaxTime()`
- * within the same 5-second window get identical timestamps.
- *
- * ```tsx
- * // GOOD - all queries get same time
- * queryFn: () => {
- *   const { minTime, maxTime } = getMinMaxTime();
- *   return fetchData({ start: minTime, end: maxTime });
- * }
- * ```
- *
- * ### How It Works
- *
- * **Manual refresh:**
- * 1. User clicks refresh
- * 2. `useGlobalTimeQueryInvalidate` calls `computeAndStoreMinMax()`
- * 3. Fresh min/max stored in `lastComputedMinMax`
- * 4. All queries re-run and call `getMinMaxTime()`
- * 5. All get the SAME cached values
- *
- * **Auto-refresh (when `isRefreshEnabled = true`):**
- * 1. React-query's `refetchInterval` triggers query re-execution
- * 2. `getMinMaxTime()` computes fresh values (rounded to 5 seconds)
- * 3. If values changed, updates `lastComputedMinMax` cache
- * 4. All queries within same 5-second window get consistent values
- *
- * ## Auto-Refresh Setup
- *
- * Auto-refresh is enabled when:
- * - `selectedTime` is a relative duration (e.g., `'15m'`)
- * - `refreshInterval > 0`
- *
- * ```tsx
- * // Auto-refresh configuration
- * const selectedTime = useGlobalTime((s) => s.selectedTime);
- * const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- * const isRefreshEnabled = useGlobalTime((s) => s.isRefreshEnabled);
- * const refreshInterval = useGlobalTime((s) => s.refreshInterval);
- *
- * useQuery({
- *   queryKey: getAutoRefreshQueryKey(selectedTime, 'MY_QUERY'),
- *   queryFn: () => { ... },
- *   // Enable periodic refetch
- *   refetchInterval: isRefreshEnabled ? refreshInterval : false,
- * });
- * ```
- *
- * ## API Reference
- *
- * ### Hooks
- *
- * | Hook | Returns | Description |
- * |------|---------|-------------|
- * | `useGlobalTime(selector?)` | `T` | Access store state with optional selector |
- * | `useGlobalTimeQueryInvalidate()` | `() => Promise<void>` | Invalidate all auto-refresh queries |
- * | `useIsGlobalTimeQueryRefreshing()` | `boolean` | Check if any query is refreshing |
- * | `useIsCustomTimeRange()` | `boolean` | Check if using fixed time range |
- * | `useLastComputedMinMax()` | `ParsedTimeRange` | Get cached min/max values |
- * | `useGlobalTimeStoreApi()` | `GlobalTimeStoreApi` | Get raw store API |
- *
- * ### Store Actions
- *
- * | Action | Description |
- * |--------|-------------|
- * | `setSelectedTime(time, interval?)` | Set time range and optional refresh interval (resets cache) |
- * | `setRefreshInterval(ms)` | Set auto-refresh interval |
- * | `getMinMaxTime(time?)` | Get min/max (fresh if auto-refresh enabled, cached otherwise) |
- * | `computeAndStoreMinMax()` | Compute fresh values and cache them |
- * | `getAutoRefreshQueryKey(time, ...parts)` | Build scoped query key for this store instance |
- *
- * ### Utilities
- *
- * | Function | Description |
- * |----------|-------------|
- * | `getAutoRefreshQueryKey(time, ...parts)` | **@deprecated** Use store action instead |
- * | `parseSelectedTime(time)` | Parse time string to min/max (fresh computation) |
- * | `isCustomTimeRange(time)` | Check if time is custom range format |
- * | `createCustomTimeRange(min, max)` | Create custom range string |
- *
- * ### Constants
- *
- * | Constant | Value | Description |
- * |----------|-------|-------------|
- * | `NANO_SECOND_MULTIPLIER` | `1000000` | Convert ms to ns |
- * | `CUSTOM_TIME_SEPARATOR` | `'||_||'` | Separator in custom range strings |
- *
- * ## Context & Composition
- *
- * ### Why Use Context?
- *
- * By default, `useGlobalTime()` uses a shared global store. Use `GlobalTimeProvider`
- * to create isolated time state for specific UI sections (modals, drawers, etc.).
- *
- * ### Provider Options
- *
- * | Option | Type | Description |
- * |--------|------|-------------|
- * | `name` | `string` | Scope query keys to this store (enables isolated invalidation) |
- * | `inheritGlobalTime` | `boolean` | Initialize with parent/global time value |
- * | `initialTime` | `string` | Initial time if not inheriting |
- * | `enableUrlParams` | `boolean \| object` | Sync time to URL query params |
- * | `removeQueryParamsOnUnmount` | `boolean` | Clean URL params on unmount |
- * | `localStoragePersistKey` | `string` | Persist time to localStorage |
- * | `refreshInterval` | `number` | Initial auto-refresh interval (ms) |
- *
- * ### Example 1: Isolated Time in Modal
- *
- * A modal with its own time picker that doesn't affect the main page:
- *
- * ```tsx
- * import { GlobalTimeProvider, useGlobalTime } from 'store/globalTime';
- *
- * function EntityDetailsModal({ entity, onClose }) {
- *   return (
- *     <Modal open onClose={onClose}>
- *       // Isolated time context - changes here don't affect parent
- *       <GlobalTimeProvider
- *         inheritGlobalTime  // Start with parent's current time
- *         refreshInterval={0} // No auto-refresh in modal
- *       >
- *         <ModalContent entity={entity} />
- *       </GlobalTimeProvider>
- *     </Modal>
- *   );
- * }
- *
- * function ModalContent({ entity }) {
- *   // This useGlobalTime reads from the modal's isolated store
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   const setSelectedTime = useGlobalTime((s) => s.setSelectedTime);
- *
- *   return (
- *     <>
- *       <DateTimePicker
- *         value={selectedTime}
- *         onChange={(time) => setSelectedTime(time)}
- *       />
- *       <EntityMetrics entity={entity} />
- *       <EntityLogs entity={entity} />
- *     </>
- *   );
- * }
- * ```
- *
- * ### Example 2: List Page with Detail Drawer
- *
- * Main list uses global time, drawer has independent time:
- *
- * ```tsx
- * // Main list page - uses global time (no provider needed)
- * function K8sPodsList() {
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   const [selectedPod, setSelectedPod] = useState(null);
- *
- *   return (
- *     <>
- *       <PageHeader>
- *         <DateTimeSelectionV3 /> // Controls global time
- *       </PageHeader>
- *
- *       <PodsTable
- *         timeRange={selectedTime}
- *         onRowClick={setSelectedPod}
- *       />
- *
- *       {selectedPod && (
- *         <PodDetailsDrawer
- *           pod={selectedPod}
- *           onClose={() => setSelectedPod(null)}
- *         />
- *       )}
- *     </>
- *   );
- * }
- *
- * // Drawer with its own time context
- * function PodDetailsDrawer({ pod, onClose }) {
- *   return (
- *     <Drawer open onClose={onClose}>
- *       <GlobalTimeProvider
- *         name="pod-drawer"          // Scopes queries - only this drawer's queries are invalidated
- *         inheritGlobalTime          // Start with list's time
- *         removeQueryParamsOnUnmount // Clean up URL when drawer closes
- *         enableUrlParams={{
- *           relativeTimeKey: 'drawerTime',
- *           startTimeKey: 'drawerStart',
- *           endTimeKey: 'drawerEnd',
- *         }}
- *       >
- *         <DrawerHeader>
- *           <DateTimeSelectionV3 /> // Controls drawer's time only
- *         </DrawerHeader>
- *
- *         <Tabs>
- *           <Tab label="Metrics"><PodMetrics pod={pod} /></Tab>
- *           <Tab label="Logs"><PodLogs pod={pod} /></Tab>
- *           <Tab label="Events"><PodEvents pod={pod} /></Tab>
- *         </Tabs>
- *       </GlobalTimeProvider>
- *     </Drawer>
- *   );
- * }
- * ```
- *
- * ### Example 3: Nested Contexts
- *
- * Contexts can be nested - each level creates isolation:
- *
- * ```tsx
- * // App level - global time
- * function App() {
- *   return (
- *     <QueryClientProvider>
- *       // No provider here = uses defaultGlobalTimeStore
- *       <Dashboard />
- *     </QueryClientProvider>
- *   );
- * }
- *
- * // Dashboard with comparison panel
- * function Dashboard() {
- *   return (
- *     <div className="dashboard">
- *       // Main dashboard uses global time
- *       <MainCharts />
- *
- *       // Comparison panel has its own time
- *       <GlobalTimeProvider initialTime="1h">
- *         <ComparisonPanel />
- *       </GlobalTimeProvider>
- *     </div>
- *   );
- * }
- *
- * function ComparisonPanel() {
- *   // This reads from ComparisonPanel's isolated store (1h)
- *   // Not affected by global time changes
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   return <ComparisonCharts timeRange={selectedTime} />;
- * }
- * ```
- *
- * ### Example 4: URL Sync for Shareable Links
- *
- * Persist time selection to URL for shareable links:
- *
- * ```tsx
- * function TracesExplorer() {
- *   return (
- *     <GlobalTimeProvider
- *       enableUrlParams={{
- *         relativeTimeKey: 'time',      // ?time=15m
- *         startTimeKey: 'startTime',    // ?startTime=1234567890
- *         endTimeKey: 'endTime',        // ?endTime=1234567899
- *       }}
- *       initialTime="15m"  // Fallback if URL has no time params
- *     >
- *       <TracesContent />
- *     </GlobalTimeProvider>
- *   );
- * }
- * ```
- *
- * ### Example 5: localStorage Persistence
- *
- * Remember user's last selected time across sessions:
- *
- * ```tsx
- * function MetricsExplorer() {
- *   return (
- *     <GlobalTimeProvider
- *       localStoragePersistKey="metrics-explorer-time"
- *       initialTime="1h"  // Fallback for first visit
- *     >
- *       <MetricsContent />
- *     </GlobalTimeProvider>
- *   );
- * }
- * ```
- *
- * ### Context Resolution Order
- *
- * When `useGlobalTime()` is called, it resolves the store in this order:
- *
- * 1. Nearest `GlobalTimeProvider` ancestor (if any)
- * 2. `defaultGlobalTimeStore` (global singleton)
- *
- * ```
- * App (no provider -> uses defaultGlobalTimeStore)
- * |-- Dashboard
- *     |-- MainCharts (uses defaultGlobalTimeStore)
- *     |-- GlobalTimeProvider (isolated store A)
- *         |-- ComparisonPanel (uses store A)
- *             |-- GlobalTimeProvider (isolated store B)
- *                 |-- NestedChart (uses store B)
- * ```
- *
- * ### Scoped Query Keys with `name`
- *
- * The `name` prop enables isolated query invalidation. When a provider has a name,
- * its queries are prefixed with that name, so invalidation only affects that store:
- *
- * ```tsx
- * // Main page - unnamed store
- * // Query keys: ['AUTO_REFRESH_QUERY', 'METRICS', ...]
- * function MainDashboard() {
- *   const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *   // ...
- * }
- *
- * // Drawer - named store
- * // Query keys: ['AUTO_REFRESH_QUERY', 'drawer', 'METRICS', ...]
- * function DetailDrawer() {
- *   return (
- *     <GlobalTimeProvider name="drawer" inheritGlobalTime>
- *       <DrawerContent />
- *     </GlobalTimeProvider>
- *   );
- * }
- *
- * function DrawerContent() {
- *   const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *   const invalidate = useGlobalTimeQueryInvalidate();
- *   // invalidate() only refreshes queries with 'drawer' prefix
- * }
- * ```
- *
- * ## Complete Example
- *
- * ```tsx
- * import { useMemo } from 'react';
- * import { useQuery } from 'react-query';
- * import { useGlobalTime, NANO_SECOND_MULTIPLIER } from 'store/globalTime';
- *
- * function MetricsPanel({ entityId }: { entityId: string }) {
- *   // 1. Get store state with selectors
- *   const selectedTime = useGlobalTime((s) => s.selectedTime);
- *   const getMinMaxTime = useGlobalTime((s) => s.getMinMaxTime);
- *   const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *   const isRefreshEnabled = useGlobalTime((s) => s.isRefreshEnabled);
- *   const refreshInterval = useGlobalTime((s) => s.refreshInterval);
- *
- *   // 2. Build query key (memoized) - automatically scoped if using named provider
- *   const queryKey = useMemo(
- *     () => getAutoRefreshQueryKey(selectedTime, 'METRICS', entityId),
- *     [getAutoRefreshQueryKey, selectedTime, entityId]
- *   );
- *
- *   // 3. Query with auto-refresh
- *   const { data, isLoading } = useQuery({
- *     queryKey,
- *     queryFn: () => {
- *       // Get fresh time inside queryFn
- *       const { minTime, maxTime } = getMinMaxTime();
- *       const start = Math.floor(minTime / NANO_SECOND_MULTIPLIER / 1000);
- *       const end = Math.floor(maxTime / NANO_SECOND_MULTIPLIER / 1000);
- *
- *       return fetchMetrics({ entityId, start, end });
- *     },
- *     refetchInterval: isRefreshEnabled ? refreshInterval : false,
- *   });
- *
- *   return <Chart data={data} loading={isLoading} />;
- * }
- * ```
- *
- * @module store/globalTime
- */
-
-// Store
-export {
-	createGlobalTimeStore,
-	defaultGlobalTimeStore,
-	useGlobalTimeStore,
-} from './globalTimeStore';
-export type { GlobalTimeStoreApi } from './globalTimeStore';
-
-// Context & Provider
-export { GlobalTimeContext, GlobalTimeProvider } from './GlobalTimeContext';
-
-// Hooks
-export {
-	useGlobalTime,
-	useGlobalTimeStoreApi,
-	useIsCustomTimeRange,
-	useLastComputedMinMax,
-} from './hooks';
-
-// Query hooks for auto-refresh
-export { useGlobalTimeQueryInvalidate } from './useGlobalTimeQueryInvalidate';
-export { useIsGlobalTimeQueryRefreshing } from './useIsGlobalTimeQueryRefreshing';
-
-// Types
-export type {
-	CustomTimeRange,
-	CustomTimeRangeSeparator,
-	GlobalTimeActions,
-	GlobalTimeProviderOptions,
-	GlobalTimeSelectedTime,
-	GlobalTimeState,
-	GlobalTimeStore,
-	IGlobalTimeStoreActions,
-	IGlobalTimeStoreState,
-	ParsedTimeRange,
-} from './types';
-
-// Utilities
+export { useGlobalTimeStore } from './globalTimeStore';
+export type { IGlobalTimeStoreState, ParsedTimeRange } from './types';
 export {
 	createCustomTimeRange,
 	CUSTOM_TIME_SEPARATOR,
-	getAutoRefreshQueryKey,
 	isCustomTimeRange,
-	NANO_SECOND_MULTIPLIER,
 	parseCustomTimeRange,
 	parseSelectedTime,
 } from './utils';
-
-// Internal hooks (for advanced use cases)
-export { useQueryCacheSync } from './useQueryCacheSync';

frontend/src/store/globalTime/types.ts

@@ -44,80 +44,9 @@ export interface IGlobalTimeStoreActions {
 	) => void;
 
 	/**
-	 * Get the current min/max time values.
-	 * - Custom time ranges: returns exact parsed values
-	 * - isRefreshEnabled true: computes 5s-rounded values and updates store
-	 * - isRefreshEnabled false: returns lastComputedMinMax
+	 * Get the current min/max time values parsed from selectedTime.
+	 * For durations, computes fresh values based on Date.now().
+	 * For custom ranges, extracts the stored values.
 	 */
-	getMinMaxTime: () => ParsedTimeRange;
+	getMinMaxTime: (selectedItem?: GlobalTimeSelectedTime) => ParsedTimeRange;
 }
-
-export interface GlobalTimeProviderOptions {
-	/**
-	 * Optional name for the store instance.
-	 * Used to scope query keys - only queries with this store's prefix
-	 * will be tracked/invalidated by this store's hooks.
-	 */
-	name?: string;
-	/** Initialize from parent/global time */
-	inheritGlobalTime?: boolean;
-	/** Initial time if not inheriting */
-	initialTime?: GlobalTimeSelectedTime;
-	/** URL sync configuration. When false/omitted, no URL sync. */
-	enableUrlParams?:
-		| boolean
-		| {
-				relativeTimeKey?: string;
-				startTimeKey?: string;
-				endTimeKey?: string;
-		  };
-	removeQueryParamsOnUnmount?: boolean;
-	localStoragePersistKey?: string;
-	refreshInterval?: number;
-}
-
-export interface GlobalTimeState {
-	/**
-	 * Optional name for the store instance.
-	 * Used to scope query keys for auto-refresh queries.
-	 * Unnamed stores use the default prefix without a name.
-	 */
-	name?: string;
-	selectedTime: GlobalTimeSelectedTime;
-	refreshInterval: number;
-	isRefreshEnabled: boolean;
-	lastRefreshTimestamp: number;
-	lastComputedMinMax: ParsedTimeRange;
-}
-
-export interface GlobalTimeActions {
-	setSelectedTime: (
-		time: GlobalTimeSelectedTime,
-		refreshInterval?: number,
-	) => void;
-	setRefreshInterval: (interval: number) => void;
-	getMinMaxTime: () => ParsedTimeRange;
-	/**
-	 * Compute fresh rounded min/max values, store them, and update refresh timestamp.
-	 * Call this before invalidating queries to ensure all queries use the same time values.
-	 *
-	 * @returns The newly computed ParsedTimeRange
-	 */
-	computeAndStoreMinMax: () => ParsedTimeRange;
-	/**
-	 * Update the refresh timestamp to current time.
-	 * Called by QueryCache listener when auto-refresh queries complete.
-	 */
-	updateRefreshTimestamp: () => void;
-	/**
-	 * Build query key for auto-refresh queries scoped to this store.
-	 * Named stores: ['AUTO_REFRESH_QUERY', name, ...parts, selectedTime]
-	 * Unnamed stores: ['AUTO_REFRESH_QUERY', ...parts, selectedTime]
-	 */
-	getAutoRefreshQueryKey: (
-		selectedTime: GlobalTimeSelectedTime,
-		...queryParts: unknown[]
-	) => unknown[];
-}
-
-export type GlobalTimeStore = GlobalTimeState & GlobalTimeActions;

frontend/src/store/globalTime/useComputedMinMaxSync.ts

@@ -1,18 +0,0 @@
-import { useEffect } from 'react';
-
-import { GlobalTimeStoreApi } from './globalTimeStore';
-
-/**
- * Used to initialize computed min/max on mount when store has no values yet.
- * setSelectedTime now computes min/max on change, so subscription is no longer needed.
- *
- * @internal
- */
-export function useComputedMinMaxSync(store: GlobalTimeStoreApi): void {
-	useEffect(() => {
-		const { lastComputedMinMax } = store.getState();
-		if (lastComputedMinMax.minTime === 0 && lastComputedMinMax.maxTime === 0) {
-			store.getState().computeAndStoreMinMax();
-		}
-	}, [store]);
-}

frontend/src/store/globalTime/useGlobalTimeQueryInvalidate.ts

@@ -1,36 +0,0 @@
-import { useCallback } from 'react';
-import { useQueryClient } from 'react-query';
-
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { useGlobalTime } from './hooks';
-
-/**
- * Use when you want to invalidate any query tracked by {@link REACT_QUERY_KEY.AUTO_REFRESH_QUERY}
- *
- * This hook computes fresh time values before invalidating queries,
- * ensuring all queries use the same min/max time during a refresh cycle.
- *
- * For named stores, only invalidates queries matching the store's name.
- * For unnamed stores, invalidates all AUTO_REFRESH_QUERY queries.
- *
- * @public
- */
-export function useGlobalTimeQueryInvalidate(): () => Promise<void> {
-	const queryClient = useQueryClient();
-	const computeAndStoreMinMax = useGlobalTime((s) => s.computeAndStoreMinMax);
-	const name = useGlobalTime((s) => s.name);
-
-	return useCallback(async () => {
-		// Compute fresh time values BEFORE invalidating
-		// This ensures all queries that re-run will use the same time values
-		// If refresh is enabled, this will just be skipped
-		computeAndStoreMinMax();
-
-		// Build scoped query key prefix
-		const queryKey = name
-			? [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, name]
-			: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY];
-
-		return await queryClient.invalidateQueries({ queryKey });
-	}, [queryClient, computeAndStoreMinMax, name]);
-}

frontend/src/store/globalTime/useIsGlobalTimeQueryRefreshing.ts

@@ -1,21 +0,0 @@
-import { useIsFetching } from 'react-query';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { useGlobalTime } from './hooks';
-
-/**
- * Use when you want to know if any query tracked by {@link REACT_QUERY_KEY.AUTO_REFRESH_QUERY} is refreshing
- *
- * For named stores, only checks queries matching the store's name.
- * For unnamed stores, checks all AUTO_REFRESH_QUERY queries.
- *
- * @public
- */
-export function useIsGlobalTimeQueryRefreshing(): boolean {
-	const name = useGlobalTime((s) => s.name);
-
-	const queryKey = name
-		? [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, name]
-		: [REACT_QUERY_KEY.AUTO_REFRESH_QUERY];
-
-	return useIsFetching({ queryKey }) > 0;
-}

frontend/src/store/globalTime/usePersistence.ts

@@ -1,32 +0,0 @@
-import { useEffect } from 'react';
-
-import set from 'api/browser/localstorage/set';
-
-import { GlobalTimeStoreApi } from './globalTimeStore';
-
-/**
- * Used to keep the selected time persisted on localStorage
- *
- * @internal
- */
-export function usePersistence(
-	store: GlobalTimeStoreApi,
-	persistKey: string | undefined,
-): void {
-	useEffect(() => {
-		if (!persistKey) {
-			return;
-		}
-
-		let previousSelectedTime = store.getState().selectedTime;
-
-		return store.subscribe((state) => {
-			if (state.selectedTime === previousSelectedTime) {
-				return;
-			}
-			previousSelectedTime = state.selectedTime;
-
-			set(persistKey, state.selectedTime);
-		});
-	}, [store, persistKey]);
-}

frontend/src/store/globalTime/useQueryCacheSync.ts

@@ -1,51 +0,0 @@
-import { useEffect } from 'react';
-import { useQueryClient } from 'react-query';
-
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-
-import { GlobalTimeStoreApi } from './globalTimeStore';
-
-/**
- * Used to keep lastRefreshTimestamp in sync after every react query refresh.
- * For named stores, only tracks queries with matching store name.
- * For unnamed stores, tracks all AUTO_REFRESH_QUERY queries (backward compatible).
- *
- * @internal
- */
-export function useQueryCacheSync(store: GlobalTimeStoreApi): void {
-	const queryClient = useQueryClient();
-
-	useEffect(() => {
-		const queryCache = queryClient.getQueryCache();
-		const storeName = store.getState().name;
-
-		return queryCache.subscribe((event) => {
-			if (event?.type !== 'queryUpdated') {
-				return;
-			}
-
-			const action = event.action as { type?: string };
-			if (action?.type !== 'success') {
-				return;
-			}
-
-			const queryKey = event.query.queryKey;
-			if (!Array.isArray(queryKey)) {
-				return;
-			}
-
-			// this is created by getAutoRefreshQueryKey inside the store,
-			// to track usages of global time store and autoRefresh
-			if (queryKey[0] !== REACT_QUERY_KEY.AUTO_REFRESH_QUERY) {
-				return;
-			}
-
-			// Named store: only track queries with matching name at position [1]
-			if (storeName && queryKey[1] !== storeName) {
-				return;
-			}
-			// Unnamed store: track all AUTO_REFRESH_QUERY queries (backward compatible)
-			store.getState().updateRefreshTimestamp();
-		});
-	}, [queryClient, store]);
-}

frontend/src/store/globalTime/useUrlSync.ts

@@ -1,145 +0,0 @@
-import { useEffect, useRef } from 'react';
-import { parseAsInteger, parseAsString, useQueryStates } from 'nuqs';
-import { Time } from 'container/TopNav/DateTimeSelectionV2/types';
-import { isValidShortHandDateTimeFormat } from 'lib/getMinMax';
-
-import { GlobalTimeStoreApi } from './globalTimeStore';
-import { GlobalTimeProviderOptions } from './types';
-import {
-	createCustomTimeRange,
-	isCustomTimeRange,
-	NANO_SECOND_MULTIPLIER,
-	parseCustomTimeRange,
-} from './utils';
-
-interface UrlSyncConfig {
-	relativeTimeKey: string;
-	startTimeKey: string;
-	endTimeKey: string;
-}
-
-/**
- * Used to sync internal state with URL when URL params are enabled.
- *
- * @internal
- */
-export function useUrlSync(
-	store: GlobalTimeStoreApi,
-	enableUrlParams: GlobalTimeProviderOptions['enableUrlParams'],
-	removeOnUnmount: boolean,
-): void {
-	const isInitialMount = useRef(true);
-
-	const keys: UrlSyncConfig =
-		enableUrlParams && typeof enableUrlParams === 'object'
-			? {
-					relativeTimeKey: enableUrlParams.relativeTimeKey ?? 'relativeTime',
-					startTimeKey: enableUrlParams.startTimeKey ?? 'startTime',
-					endTimeKey: enableUrlParams.endTimeKey ?? 'endTime',
-				}
-			: {
-					relativeTimeKey: 'relativeTime',
-					startTimeKey: 'startTime',
-					endTimeKey: 'endTime',
-				};
-
-	const [urlState, setUrlState] = useQueryStates(
-		{
-			[keys.relativeTimeKey]: parseAsString,
-			[keys.startTimeKey]: parseAsInteger,
-			[keys.endTimeKey]: parseAsInteger,
-		},
-		{ history: 'replace' },
-	);
-
-	useEffect(() => {
-		if (!enableUrlParams || !isInitialMount.current) {
-			return;
-		}
-		isInitialMount.current = false;
-
-		const relativeTime = urlState[keys.relativeTimeKey];
-		const startTime = urlState[keys.startTimeKey];
-		const endTime = urlState[keys.endTimeKey];
-
-		if (typeof startTime === 'number' && typeof endTime === 'number') {
-			const customTime = createCustomTimeRange(
-				startTime * NANO_SECOND_MULTIPLIER,
-				endTime * NANO_SECOND_MULTIPLIER,
-			);
-			store.getState().setSelectedTime(customTime);
-		} else if (
-			typeof relativeTime === 'string' &&
-			isValidShortHandDateTimeFormat(relativeTime)
-		) {
-			store.getState().setSelectedTime(relativeTime as Time);
-		}
-	}, [
-		urlState,
-		keys?.startTimeKey,
-		keys?.endTimeKey,
-		keys?.relativeTimeKey,
-		store,
-		enableUrlParams,
-	]);
-
-	useEffect(() => {
-		if (!enableUrlParams) {
-			return;
-		}
-
-		let previousSelectedTime = store.getState().selectedTime;
-
-		return store.subscribe((state) => {
-			if (state.selectedTime === previousSelectedTime) {
-				return;
-			}
-			previousSelectedTime = state.selectedTime;
-
-			if (isCustomTimeRange(state.selectedTime)) {
-				const parsed = parseCustomTimeRange(state.selectedTime);
-				if (parsed) {
-					void setUrlState({
-						[keys.relativeTimeKey]: null,
-						[keys.startTimeKey]: Math.floor(parsed.minTime / NANO_SECOND_MULTIPLIER),
-						[keys.endTimeKey]: Math.floor(parsed.maxTime / NANO_SECOND_MULTIPLIER),
-					});
-				}
-			} else {
-				void setUrlState({
-					[keys.relativeTimeKey]: state.selectedTime,
-					[keys.startTimeKey]: null,
-					[keys.endTimeKey]: null,
-				});
-			}
-		});
-	}, [
-		store,
-		keys?.startTimeKey,
-		keys?.endTimeKey,
-		keys?.relativeTimeKey,
-		setUrlState,
-		enableUrlParams,
-	]);
-
-	useEffect(() => {
-		if (!enableUrlParams || !removeOnUnmount) {
-			return;
-		}
-
-		return (): void => {
-			void setUrlState({
-				[keys.relativeTimeKey]: null,
-				[keys.startTimeKey]: null,
-				[keys.endTimeKey]: null,
-			});
-		};
-	}, [
-		removeOnUnmount,
-		keys?.relativeTimeKey,
-		keys?.startTimeKey,
-		keys?.endTimeKey,
-		setUrlState,
-		enableUrlParams,
-	]);
-}

frontend/src/store/globalTime/utils.ts

@@ -44,8 +44,8 @@ export function parseCustomTimeRange(
 	}
 
 	const [minStr, maxStr] = selectedTime.split(CUSTOM_TIME_SEPARATOR);
-	const minTime = Number.parseInt(minStr, 10);
-	const maxTime = Number.parseInt(maxStr, 10);
+	const minTime = parseInt(minStr, 10);
+	const maxTime = parseInt(maxStr, 10);
 
 	if (Number.isNaN(minTime) || Number.isNaN(maxTime)) {
 		return null;
@@ -79,60 +79,11 @@ export function parseSelectedTime(selectedTime: string): ParsedTimeRange {
 }
 
 /**
- * @deprecated Use store.getAutoRefreshQueryKey() instead.
- * Access via: const getAutoRefreshQueryKey = useGlobalTime((s) => s.getAutoRefreshQueryKey);
- *
- * This function only works with the default (unnamed) store prefix.
- * For named stores, use the store method to get properly scoped query keys.
+ * Use to build your react-query key for auto-refresh queries
  */
 export function getAutoRefreshQueryKey(
 	selectedTime: GlobalTimeSelectedTime,
 	...queryParts: unknown[]
 ): unknown[] {
-	if (process.env.NODE_ENV === 'development') {
-		console.warn(
-			'[globalTime] getAutoRefreshQueryKey from utils is deprecated. ' +
-				'Use useGlobalTime((s) => s.getAutoRefreshQueryKey) instead.',
-		);
-	}
 	return [REACT_QUERY_KEY.AUTO_REFRESH_QUERY, ...queryParts, selectedTime];
 }
-
-/**
- * Round timestamp down to the nearest 5-second boundary.
- * Used for tighter sync during auto-refresh scenarios.
- *
- * @param timestampNano - Timestamp in nanoseconds
- * @returns Timestamp rounded down to 5-second boundary in nanoseconds
- */
-export function roundDownTo5Seconds(timestampNano: number): number {
-	const msPerInterval = 5 * 1000;
-	const timestampMs = Math.floor(timestampNano / NANO_SECOND_MULTIPLIER);
-	const roundedMs = Math.floor(timestampMs / msPerInterval) * msPerInterval;
-	return roundedMs * NANO_SECOND_MULTIPLIER;
-}
-
-/**
- * Compute min/max time with maxTime rounded down to 5-second boundary.
- * Used when isRefreshEnabled is true for tighter time sync.
- *
- * @param selectedTime - The selected time (relative like '15m' or custom range)
- * @returns ParsedTimeRange with 5-second rounded maxTime for relative times
- */
-export function computeRounded5sMinMax(selectedTime: string): ParsedTimeRange {
-	if (isCustomTimeRange(selectedTime)) {
-		return parseSelectedTime(selectedTime);
-	}
-
-	const nowNano = Date.now() * NANO_SECOND_MULTIPLIER;
-	const roundedMaxTime = roundDownTo5Seconds(nowNano);
-
-	const { minTime: originalMin, maxTime: originalMax } =
-		getMinMaxForSelectedTime(selectedTime as Time, 0, 0);
-	const durationNano = originalMax - originalMin;
-
-	return {
-		minTime: roundedMaxTime - durationNano,
-		maxTime: roundedMaxTime,
-	};
-}

frontend/src/types/common/index.ts

@@ -19,7 +19,6 @@ export type ServerError = 500;
 export type SuccessStatusCode = Created | Success | SuccessNoContent;
 
 export type ErrorStatusCode =
-	| Forbidden
 	| Forbidden
 	| Unauthorized
 	| NotFound

frontend/src/utils/types.ts

@@ -0,0 +1,22 @@
+type Builtin =
+	| string
+	| number
+	| boolean
+	| bigint
+	| symbol
+	| null
+	| undefined
+	| Function // eslint-disable-line
+	| Date
+	| RegExp
+	| Error;
+
+export type DeepPartial<T> = T extends Builtin
+	? T
+	: T extends Array<infer U>
+		? Array<DeepPartial<U>>
+		: T extends ReadonlyArray<infer U>
+			? ReadonlyArray<DeepPartial<U>>
+			: T extends object
+				? { [K in keyof T]?: DeepPartial<T[K]> }
+				: T;

frontend/yarn.lock

@@ -19194,11 +19194,6 @@ use-sidecar@^1.1.3:
     detect-node-es "^1.1.0"
     tslib "^2.0.0"
 
-use-sync-external-store@1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz#b174bfa65cb2b526732d9f2ac0a408027876f32d"
-  integrity sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==
-
 util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
   version "1.0.2"
   resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"

pkg/alertmanager/alertmanagerserver/maintenance_muter.go

@@ -0,0 +1,94 @@
+package alertmanagerserver
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+)
+
+// MaintenanceMuter implements types.Muter for maintenance windows.
+// It suppresses alerts whose ruleId label matches an active maintenance schedule.
+// Results are cached for cacheTTL to avoid a DB query on every per-alert check.
+type MaintenanceMuter struct {
+	maintenanceStore ruletypes.MaintenanceStore
+	orgID            string
+	logger           *slog.Logger
+
+	mu          sync.RWMutex
+	cached      []*ruletypes.PlannedMaintenance
+	cacheExpiry time.Time
+}
+
+const maintenanceCacheTTL = 30 * time.Second
+
+func NewMaintenanceMuter(store ruletypes.MaintenanceStore, orgID string, logger *slog.Logger) *MaintenanceMuter {
+	return &MaintenanceMuter{
+		maintenanceStore: store,
+		orgID:            orgID,
+		logger:           logger,
+	}
+}
+
+func (m *MaintenanceMuter) Mutes(ctx context.Context, lset model.LabelSet) bool {
+	ruleID := string(lset[ruletypes.AlertRuleIDLabel])
+	if ruleID == "" {
+		return false
+	}
+	now := time.Now()
+	for _, mw := range m.getMaintenances(ctx) {
+		if mw.ShouldSkip(ruleID, now) {
+			return true
+		}
+	}
+	return false
+}
+
+func (m *MaintenanceMuter) getMaintenances(ctx context.Context) []*ruletypes.PlannedMaintenance {
+	m.mu.RLock()
+	if time.Now().Before(m.cacheExpiry) {
+		cached := m.cached
+		m.mu.RUnlock()
+		return cached
+	}
+	m.mu.RUnlock()
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Double-check after acquiring write lock.
+	if time.Now().Before(m.cacheExpiry) {
+		return m.cached
+	}
+
+	mws, err := m.maintenanceStore.ListPlannedMaintenance(ctx, m.orgID)
+	if err != nil {
+		m.logger.ErrorContext(ctx, "failed to list planned maintenance windows; alerts will not be suppressed", slog.String("org_id", m.orgID))
+		return m.cached // return stale (potentially empty) cache on error
+	}
+	m.cached = mws
+	m.cacheExpiry = time.Now().Add(maintenanceCacheTTL)
+	return m.cached
+}
+
+// maintenanceMuteStage wraps MaintenanceMuter as a notify.Stage.
+// We implement the stage directly rather than using notify.NewMuteStage to avoid
+// a dependency on the unexported *notify.Metrics field of PipelineBuilder.
+type maintenanceMuteStage struct {
+	muter *MaintenanceMuter
+}
+
+func (s *maintenanceMuteStage) Exec(ctx context.Context, _ *slog.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) {
+	filtered := make([]*types.Alert, 0, len(alerts))
+	for _, a := range alerts {
+		if !s.muter.Mutes(ctx, a.Labels) {
+			filtered = append(filtered, a)
+		}
+	}
+	return ctx, filtered, nil
+}

pkg/alertmanager/alertmanagerserver/pipeline_builder.go

@@ -0,0 +1,120 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// Copyright 2015 Prometheus Team
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package alertmanagerserver
+
+// pipelineBuilder is a local copy of notify.PipelineBuilder that injects
+// the maintenance mute stage immediately before the receiver stage.
+//
+// We maintain our own copy so we can control exactly where in the pipeline
+// the maintenance stage runs (between the silence stage and the receiver),
+// which is not possible by wrapping the output of the upstream builder.
+//
+// Upstream pipeline order (notify.PipelineBuilder.New, notify.go:444):
+//
+//	GossipSettle → Inhibit → TimeActive → TimeMute → Silence → [mms] → Receiver
+
+import (
+	"time"
+
+	"github.com/prometheus/alertmanager/featurecontrol"
+	"github.com/prometheus/alertmanager/inhibit"
+	"github.com/prometheus/alertmanager/nflog/nflogpb"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/silence"
+	"github.com/prometheus/alertmanager/timeinterval"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type pipelineBuilder struct {
+	metrics *notify.Metrics
+	ff      featurecontrol.Flagger
+	muter   *MaintenanceMuter
+}
+
+func newPipelineBuilder(
+	r prometheus.Registerer,
+	ff featurecontrol.Flagger,
+	muter *MaintenanceMuter,
+) *pipelineBuilder {
+	return &pipelineBuilder{
+		metrics: notify.NewMetrics(r, ff),
+		ff:      ff,
+		muter:   muter,
+	}
+}
+
+// New returns a map of receivers to Stages, mirroring notify.PipelineBuilder.New
+// but inserting a maintenanceMuteStage between the silence stage and the receiver.
+func (pb *pipelineBuilder) New(
+	receivers map[string][]notify.Integration,
+	wait func() time.Duration,
+	inhibitor *inhibit.Inhibitor,
+	silencer *silence.Silencer,
+	intervener *timeinterval.Intervener,
+	marker types.GroupMarker,
+	notificationLog notify.NotificationLog,
+	peer notify.Peer,
+) notify.RoutingStage {
+	rs := make(notify.RoutingStage, len(receivers))
+
+	ms := notify.NewGossipSettleStage(peer)
+	is := notify.NewMuteStage(inhibitor, pb.metrics)
+	tas := notify.NewTimeActiveStage(intervener, marker, pb.metrics)
+	tms := notify.NewTimeMuteStage(intervener, marker, pb.metrics)
+	ss := notify.NewMuteStage(silencer, pb.metrics)
+
+	var mms *maintenanceMuteStage
+	if pb.muter != nil {
+		mms = &maintenanceMuteStage{muter: pb.muter}
+	}
+
+	for name := range receivers {
+		stages := notify.MultiStage{ms, is, tas, tms, ss}
+		if mms != nil {
+			stages = append(stages, mms)
+		}
+		stages = append(stages, createReceiverStage(name, receivers[name], wait, notificationLog, pb.metrics))
+		rs[name] = stages
+	}
+
+	pb.metrics.InitializeFor(receivers)
+	return rs
+}
+
+// createReceiverStage is a copy of notify.createReceiverStage (unexported upstream).
+func createReceiverStage(
+	name string,
+	integrations []notify.Integration,
+	wait func() time.Duration,
+	notificationLog notify.NotificationLog,
+	metrics *notify.Metrics,
+) notify.Stage {
+	var fs notify.FanoutStage
+	for i := range integrations {
+		recv := &nflogpb.Receiver{
+			GroupName:   name,
+			Integration: integrations[i].Name(),
+			Idx:         uint32(integrations[i].Index()),
+		}
+		var s notify.MultiStage
+		s = append(s, notify.NewWaitStage(wait))
+		s = append(s, notify.NewDedupStage(&integrations[i], notificationLog, recv))
+		s = append(s, notify.NewRetryStage(integrations[i], name, metrics))
+		s = append(s, notify.NewSetNotifiesStage(notificationLog, recv))
+		fs = append(fs, s)
+	}
+	return fs
+}

pkg/alertmanager/alertmanagerserver/server.go

@@ -26,14 +26,13 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 )
 
-var (
-	// This is not a real file and will never be used. We need this placeholder to ensure maintenance runs on shutdown. See
-	// https://github.com/prometheus/server/blob/3ee2cd0f1271e277295c02b6160507b4d193dde2/silence/silence.go#L435-L438
-	// and https://github.com/prometheus/server/blob/3b06b97af4d146e141af92885a185891eb79a5b0/nflog/nflog.go#L362.
-	snapfnoop string = "snapfnoop"
-)
+// This is not a real snapshot file and will never be used. We need this placeholder to ensure maintenance runs on shutdown.
+// See https://github.com/prometheus/alertmanager/blob/3ee2cd0f1271e277295c02b6160507b4d193dde2/silence/silence.go#L435-L438
+// and https://github.com/prometheus/alertmanager/blob/3b06b97af4d146e141af92885a185891eb79a5b0/nflog/nflog.go#L362.
+var snapfnoop string = "snapfnoop"
 
 type Server struct {
 	// logger is the logger for the alertmanager
@@ -63,7 +62,7 @@ type Server struct {
 	silencer            *silence.Silencer
 	silences            *silence.Silences
 	timeIntervals       map[string][]timeinterval.TimeInterval
-	pipelineBuilder     *notify.PipelineBuilder
+	pipelineBuilder     *pipelineBuilder
 	marker              *alertmanagertypes.MemMarker
 	tmpl                *template.Template
 	wg                  sync.WaitGroup
@@ -71,7 +70,16 @@ type Server struct {
 	notificationManager nfmanager.NotificationManager
 }
 
-func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registerer, srvConfig Config, orgID string, stateStore alertmanagertypes.StateStore, nfManager nfmanager.NotificationManager) (*Server, error) {
+func New(
+	ctx context.Context,
+	logger *slog.Logger,
+	registry prometheus.Registerer,
+	srvConfig Config,
+	orgID string,
+	stateStore alertmanagertypes.StateStore,
+	nfManager nfmanager.NotificationManager,
+	maintenanceStore ruletypes.MaintenanceStore,
+) (*Server, error) {
 	server := &Server{
 		logger:              logger.With(slog.String("pkg", "go.signoz.io/pkg/alertmanager/alertmanagerserver")),
 		registry:            registry,
@@ -160,7 +168,6 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 
 			return c, server.stateStore.Set(ctx, storableSilences)
 		})
-
 	}()
 
 	// Start maintenance for notification logs
@@ -196,7 +203,11 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 		return nil, err
 	}
 
-	server.pipelineBuilder = notify.NewPipelineBuilder(signozRegisterer, featurecontrol.NoopFlags{})
+	var muter *MaintenanceMuter
+	if maintenanceStore != nil {
+		muter = NewMaintenanceMuter(maintenanceStore, orgID, server.logger)
+	}
+	server.pipelineBuilder = newPipelineBuilder(signozRegisterer, featurecontrol.NoopFlags{}, muter)
 	server.dispatcherMetrics = NewDispatcherMetrics(false, signozRegisterer)
 
 	return server, nil

pkg/alertmanager/alertmanagerserver/server_e2e_test.go

@@ -90,7 +90,7 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 	stateStore := alertmanagertypestest.NewStateStore()
 	registry := prometheus.NewRegistry()
 	logger := slog.New(slog.DiscardHandler)
-	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager)
+	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager, nil)
 	require.NoError(t, err)
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
 	require.NoError(t, err)

pkg/alertmanager/alertmanagerserver/server_test.go

@@ -25,7 +25,7 @@ import (
 
 func TestServerSetConfigAndStop(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, nil)
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -37,7 +37,7 @@ func TestServerSetConfigAndStop(t *testing.T) {
 
 func TestServerTestReceiverTypeWebhook(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, nil)
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -85,7 +85,7 @@ func TestServerPutAlerts(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -133,7 +133,7 @@ func TestServerTestAlert(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -238,7 +238,7 @@ func TestServerTestAlertContinuesOnFailure(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)
 
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")

pkg/alertmanager/service.go

@@ -14,6 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 )
 
 type Service struct {
@@ -39,16 +40,18 @@ type Service struct {
 	serversMtx sync.RWMutex
 
 	notificationManager nfmanager.NotificationManager
+
+	maintenanceStore ruletypes.MaintenanceStore
 }
 
 func New(
-	ctx context.Context,
 	settings factory.ScopedProviderSettings,
 	config alertmanagerserver.Config,
 	stateStore alertmanagertypes.StateStore,
 	configStore alertmanagertypes.ConfigStore,
 	orgGetter organization.Getter,
 	nfManager nfmanager.NotificationManager,
+	maintenanceStore ruletypes.MaintenanceStore,
 ) *Service {
 	service := &Service{
 		config:              config,
@@ -59,6 +62,7 @@ func New(
 		servers:             make(map[string]*alertmanagerserver.Server),
 		serversMtx:          sync.RWMutex{},
 		notificationManager: nfManager,
+		maintenanceStore:    maintenanceStore,
 	}
 
 	return service
@@ -177,7 +181,10 @@ func (service *Service) newServer(ctx context.Context, orgID string) (*alertmana
 		return nil, err
 	}
 
-	server, err := alertmanagerserver.New(ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID, service.stateStore, service.notificationManager)
+	server, err := alertmanagerserver.New(
+		ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID,
+		service.stateStore, service.notificationManager, service.maintenanceStore,
+	)
 	if err != nil {
 		return nil, err
 	}

pkg/alertmanager/signozalertmanager/provider.go

@@ -20,6 +20,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -30,35 +31,49 @@ type provider struct {
 	configStore         alertmanagertypes.ConfigStore
 	stateStore          alertmanagertypes.StateStore
 	notificationManager nfmanager.NotificationManager
+	maintenanceStore    ruletypes.MaintenanceStore
 	stopC               chan struct{}
 }
 
-func NewFactory(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
+func NewFactory(
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	notificationManager nfmanager.NotificationManager,
+	maintenanceStore ruletypes.MaintenanceStore,
+) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, settings factory.ProviderSettings, config alertmanager.Config) (alertmanager.Alertmanager, error) {
-		return New(ctx, settings, config, sqlstore, orgGetter, notificationManager)
+		return New(settings, config, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	})
 }
 
-func New(ctx context.Context, providerSettings factory.ProviderSettings, config alertmanager.Config, sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) (*provider, error) {
+func New(
+	providerSettings factory.ProviderSettings,
+	config alertmanager.Config,
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	notificationManager nfmanager.NotificationManager,
+	maintenanceStore ruletypes.MaintenanceStore,
+) (*provider, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager")
 	configStore := sqlalertmanagerstore.NewConfigStore(sqlstore)
 	stateStore := sqlalertmanagerstore.NewStateStore(sqlstore)
 
 	p := &provider{
 		service: alertmanager.New(
-			ctx,
 			settings,
 			config.Signoz.Config,
 			stateStore,
 			configStore,
 			orgGetter,
 			notificationManager,
+			maintenanceStore,
 		),
 		settings:            settings,
 		config:              config,
 		configStore:         configStore,
 		stateStore:          stateStore,
 		notificationManager: notificationManager,
+		maintenanceStore:    maintenanceStore,
 		stopC:               make(chan struct{}),
 	}
 

pkg/query-service/rules/manager.go

@@ -32,30 +32,28 @@ import (
 )
 
 type PrepareTaskOptions struct {
-	Rule             *ruletypes.PostableRule
-	TaskName         string
-	RuleStore        ruletypes.RuleStore
-	MaintenanceStore ruletypes.MaintenanceStore
-	Querier          querier.Querier
-	Logger           *slog.Logger
-	Cache            cache.Cache
-	ManagerOpts      *ManagerOptions
-	NotifyFunc       NotifyFunc
-	SQLStore         sqlstore.SQLStore
-	OrgID            valuer.UUID
+	Rule        *ruletypes.PostableRule
+	TaskName    string
+	RuleStore   ruletypes.RuleStore
+	Querier     querier.Querier
+	Logger      *slog.Logger
+	Cache       cache.Cache
+	ManagerOpts *ManagerOptions
+	NotifyFunc  NotifyFunc
+	SQLStore    sqlstore.SQLStore
+	OrgID       valuer.UUID
 }
 
 type PrepareTestRuleOptions struct {
-	Rule             *ruletypes.PostableRule
-	RuleStore        ruletypes.RuleStore
-	MaintenanceStore ruletypes.MaintenanceStore
-	Querier          querier.Querier
-	Logger           *slog.Logger
-	Cache            cache.Cache
-	ManagerOpts      *ManagerOptions
-	NotifyFunc       NotifyFunc
-	SQLStore         sqlstore.SQLStore
-	OrgID            valuer.UUID
+	Rule        *ruletypes.PostableRule
+	RuleStore   ruletypes.RuleStore
+	Querier     querier.Querier
+	Logger      *slog.Logger
+	Cache       cache.Cache
+	ManagerOpts *ManagerOptions
+	NotifyFunc  NotifyFunc
+	SQLStore    sqlstore.SQLStore
+	OrgID       valuer.UUID
 }
 
 const taskNameSuffix = "webAppEditor"
@@ -134,7 +132,6 @@ func defaultOptions(o *ManagerOptions) *ManagerOptions {
 }
 
 func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
-
 	rules := make([]Rule, 0)
 	var task Task
 
@@ -159,7 +156,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
-
 		if err != nil {
 			return task, err
 		}
@@ -167,7 +163,7 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 		rules = append(rules, tr)
 
 		// create ch rule task for evaluation
-		task = newTask(TaskTypeCh, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(TaskTypeCh, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeProm {
 
@@ -183,7 +179,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
-
 		if err != nil {
 			return task, err
 		}
@@ -191,7 +186,7 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 		rules = append(rules, pr)
 
 		// create promql rule task for evaluation
-		task = newTask(TaskTypeProm, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(TaskTypeProm, opts.TaskName, taskNameSuffix, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc)
 
 	} else {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
@@ -241,6 +236,7 @@ func (m *Manager) MaintenanceStore() ruletypes.MaintenanceStore {
 	return m.maintenanceStore
 }
 
+// TODO: remove (unused)?
 func (m *Manager) Pause(b bool) {
 	m.mtx.Lock()
 	defer m.mtx.Unlock()
@@ -430,19 +426,17 @@ func (m *Manager) editTask(_ context.Context, orgID valuer.UUID, rule *ruletypes
 	m.logger.Debug("editing a rule task", "name", taskName)
 
 	newTask, err := m.prepareTaskFunc(PrepareTaskOptions{
-		Rule:             rule,
-		TaskName:         taskName,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.notifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        rule,
+		TaskName:    taskName,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.notifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
-
 	if err != nil {
 		m.logger.Error("loading tasks failed", errors.Attr(err))
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error preparing rule with given parameters, previous rule set restored")
@@ -643,19 +637,17 @@ func (m *Manager) addTask(_ context.Context, orgID valuer.UUID, rule *ruletypes.
 
 	m.logger.Debug("adding a new rule task", "name", taskName)
 	newTask, err := m.prepareTaskFunc(PrepareTaskOptions{
-		Rule:             rule,
-		TaskName:         taskName,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.notifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        rule,
+		TaskName:    taskName,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.notifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
-
 	if err != nil {
 		m.logger.Error("creating rule task failed", "name", taskName, errors.Attr(err))
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "error loading rules, previous rule set restored")
@@ -703,7 +695,6 @@ func (m *Manager) RuleTasks() []Task {
 // RuleTasksWithoutLock returns the list of manager's rule tasks without
 // acquiring a lock on the manager.
 func (m *Manager) RuleTasksWithoutLock() []Task {
-
 	rgs := make([]Task, 0, len(m.tasks))
 	for _, g := range m.tasks {
 		rgs = append(rgs, g)
@@ -897,7 +888,6 @@ func (m *Manager) GetRule(ctx context.Context, id valuer.UUID) (*ruletypes.Getta
 // the task state. For example - if a stored rule is disabled, then
 // there is no task running against it.
 func (m *Manager) syncRuleStateWithTask(ctx context.Context, orgID valuer.UUID, taskName string, rule *ruletypes.PostableRule) error {
-
 	if rule.Disabled {
 		// check if rule has any task running
 		if _, ok := m.tasks[taskName]; ok {
@@ -1029,16 +1019,15 @@ func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleS
 	}
 
 	alertCount, err := m.prepareTestRuleFunc(PrepareTestRuleOptions{
-		Rule:             &parsedRule,
-		RuleStore:        m.ruleStore,
-		MaintenanceStore: m.maintenanceStore,
-		Querier:          m.opts.Querier,
-		Logger:           m.opts.Logger,
-		Cache:            m.cache,
-		ManagerOpts:      m.opts,
-		NotifyFunc:       m.testNotifyFunc,
-		SQLStore:         m.sqlstore,
-		OrgID:            orgID,
+		Rule:        &parsedRule,
+		RuleStore:   m.ruleStore,
+		Querier:     m.opts.Querier,
+		Logger:      m.opts.Logger,
+		Cache:       m.cache,
+		ManagerOpts: m.opts,
+		NotifyFunc:  m.testNotifyFunc,
+		SQLStore:    m.sqlstore,
+		OrgID:       orgID,
 	})
 
 	return alertCount, err

pkg/query-service/rules/prom_rule_task.go

@@ -15,7 +15,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // PromRuleTask is a promql rule executor
@@ -39,14 +38,11 @@ type PromRuleTask struct {
 	pause  bool
 	logger *slog.Logger
 	notify NotifyFunc
-
-	maintenanceStore ruletypes.MaintenanceStore
-	orgID            valuer.UUID
 }
 
 // NewPromRuleTask holds rules that have promql condition
 // and evaluates the rule at a given frequency
-func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) *PromRuleTask {
+func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) *PromRuleTask {
 	opts.Logger.Info("initiating a new rule group", "name", name, "frequency", frequency)
 
 	if frequency == 0 {
@@ -63,10 +59,8 @@ func NewPromRuleTask(name, file string, frequency time.Duration, rules []Rule, o
 		seriesInPreviousEval: make([]map[string]plabels.Labels, len(rules)),
 		done:                 make(chan struct{}),
 		terminated:           make(chan struct{}),
-		notify:               notify,
-		maintenanceStore:     maintenanceStore,
-		logger:               opts.Logger,
-		orgID:                orgID,
+		notify: notify,
+		logger: opts.Logger,
 	}
 }
 
@@ -330,30 +324,12 @@ func (g *PromRuleTask) Eval(ctx context.Context, ts time.Time) {
 	}()
 
 	g.logger.InfoContext(ctx, "promql rule task", "name", g.name, "eval_started_at", ts)
-	maintenance, err := g.maintenanceStore.ListPlannedMaintenance(ctx, g.orgID.StringValue())
-	if err != nil {
-		g.logger.ErrorContext(ctx, "error in processing sql query", errors.Attr(err))
-	}
 
 	for i, rule := range g.rules {
 		if rule == nil {
 			continue
 		}
 
-		shouldSkip := false
-		for _, m := range maintenance {
-			g.logger.InfoContext(ctx, "checking if rule should be skipped", slog.String("rule.id", rule.ID()), slog.Any("maintenance", m))
-			if m.ShouldSkip(rule.ID(), ts) {
-				shouldSkip = true
-				break
-			}
-		}
-
-		if shouldSkip {
-			g.logger.InfoContext(ctx, "rule should be skipped", slog.String("rule.id", rule.ID()))
-			continue
-		}
-
 		select {
 		case <-g.done:
 			return

pkg/query-service/rules/rule_task.go

@@ -2,20 +2,18 @@ package rules
 
 import (
 	"context"
+	"log/slog"
 	"runtime/debug"
 	"sort"
 	"sync"
 	"time"
 
-	"log/slog"
-
 	opentracing "github.com/opentracing/opentracing-go"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // RuleTask holds a rule (with composite queries)
@@ -37,34 +35,28 @@ type RuleTask struct {
 
 	pause  bool
 	notify NotifyFunc
-
-	maintenanceStore ruletypes.MaintenanceStore
-	orgID            valuer.UUID
 }
 
 const DefaultFrequency = 1 * time.Minute
 
 // NewRuleTask makes a new RuleTask with the given name, options, and rules.
-func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) *RuleTask {
-
+func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) *RuleTask {
 	if frequency == 0 {
 		frequency = DefaultFrequency
 	}
 	opts.Logger.Info("initiating a new rule task", "name", name, "frequency", frequency)
 
 	return &RuleTask{
-		name:             name,
-		file:             file,
-		pause:            false,
-		frequency:        frequency,
-		rules:            rules,
-		opts:             opts,
-		logger:           opts.Logger,
-		done:             make(chan struct{}),
-		terminated:       make(chan struct{}),
-		notify:           notify,
-		maintenanceStore: maintenanceStore,
-		orgID:            orgID,
+		name:       name,
+		file:       file,
+		pause:      false,
+		frequency:  frequency,
+		rules:      rules,
+		opts:       opts,
+		logger:     opts.Logger,
+		done:       make(chan struct{}),
+		terminated: make(chan struct{}),
+		notify:     notify,
 	}
 }
 
@@ -72,6 +64,7 @@ func NewRuleTask(name, file string, frequency time.Duration, rules []Rule, opts
 func (g *RuleTask) Name() string { return g.name }
 
 // Key returns the group key
+// TODO: remove (unused)?
 func (g *RuleTask) Key() string {
 	return g.name + ";" + g.file
 }
@@ -261,7 +254,6 @@ func nameAndLabels(rule Rule) string {
 // Rules are matched based on their name and labels. If there are duplicates, the
 // first is matched with the first, second with the second etc.
 func (g *RuleTask) CopyState(fromTask Task) error {
-
 	from, ok := fromTask.(*RuleTask)
 	if !ok {
 		return errors.NewInternalf(errors.CodeInternal, "invalid from task for copy")
@@ -306,7 +298,6 @@ func (g *RuleTask) CopyState(fromTask Task) error {
 
 // Eval runs a single evaluation cycle in which all rules are evaluated sequentially.
 func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
-
 	defer func() {
 		if r := recover(); r != nil {
 			g.logger.ErrorContext(
@@ -318,31 +309,11 @@ func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
 
 	g.logger.DebugContext(ctx, "rule task eval started", "name", g.name, "start_time", ts)
 
-	maintenance, err := g.maintenanceStore.ListPlannedMaintenance(ctx, g.orgID.StringValue())
-
-	if err != nil {
-		g.logger.ErrorContext(ctx, "error in processing sql query", errors.Attr(err))
-	}
-
 	for i, rule := range g.rules {
 		if rule == nil {
 			continue
 		}
 
-		shouldSkip := false
-		for _, m := range maintenance {
-			g.logger.InfoContext(ctx, "checking if rule should be skipped", slog.String("rule.id", rule.ID()), slog.Any("maintenance", m))
-			if m.ShouldSkip(rule.ID(), ts) {
-				shouldSkip = true
-				break
-			}
-		}
-
-		if shouldSkip {
-			g.logger.InfoContext(ctx, "rule should be skipped", slog.String("rule.id", rule.ID()))
-			continue
-		}
-
 		select {
 		case <-g.done:
 			return
@@ -382,7 +353,6 @@ func (g *RuleTask) Eval(ctx context.Context, ts time.Time) {
 			}
 
 			rule.SendAlerts(ctx, ts, g.opts.ResendDelay, g.frequency, g.notify)
-
 		}(i, rule)
 	}
 }

pkg/query-service/rules/task.go

@@ -3,9 +3,6 @@ package rules
 import (
 	"context"
 	"time"
-
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 type TaskType string
@@ -32,9 +29,9 @@ type Task interface {
 
 // newTask returns an appropriate group for
 // rule type
-func newTask(taskType TaskType, name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) Task {
+func newTask(taskType TaskType, name, file string, frequency time.Duration, rules []Rule, opts *ManagerOptions, notify NotifyFunc) Task {
 	if taskType == TaskTypeCh {
-		return NewRuleTask(name, file, frequency, rules, opts, notify, maintenanceStore, orgID)
+		return NewRuleTask(name, file, frequency, rules, opts, notify)
 	}
-	return NewPromRuleTask(name, file, frequency, rules, opts, notify, maintenanceStore, orgID)
+	return NewPromRuleTask(name, file, frequency, rules, opts, notify)
 }

pkg/signoz/handler_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/sharder/noopsharder"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -38,7 +39,8 @@ func TestNewHandlers(t *testing.T) {
 	orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstore), sharder)
 	notificationManager := nfmanagertest.NewMock()
 	require.NoError(t, err)
-	alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager)
+	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
+	alertmanager, err := signozalertmanager.New(providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	require.NoError(t, err)
 	tokenizer := tokenizertest.NewMockTokenizer(t)
 	emailing := emailingtest.New()

pkg/signoz/module_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/sharder/noopsharder"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -39,7 +40,8 @@ func TestNewModules(t *testing.T) {
 	orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstore), sharder)
 	notificationManager := nfmanagertest.NewMock()
 	require.NoError(t, err)
-	alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager)
+	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
+	alertmanager, err := signozalertmanager.New(providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager, maintenanceStore)
 	require.NoError(t, err)
 	tokenizer := tokenizertest.NewMockTokenizer(t)
 	emailing := emailingtest.New()

pkg/signoz/provider.go

@@ -65,6 +65,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/tokenizer/tokenizerstore/sqltokenizerstore"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/SigNoz/signoz/pkg/web/noopweb"
@@ -221,9 +222,14 @@ func NewNotificationManagerProviderFactories(routeStore alertmanagertypes.RouteS
 	)
 }
 
-func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, nfManager nfmanager.NotificationManager) factory.NamedMap[factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config]] {
+func NewAlertmanagerProviderFactories(
+	sqlstore sqlstore.SQLStore,
+	orgGetter organization.Getter,
+	nfManager nfmanager.NotificationManager,
+	maintenanceStore ruletypes.MaintenanceStore,
+) factory.NamedMap[factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config]] {
 	return factory.MustNewNamedMap(
-		signozalertmanager.NewFactory(sqlstore, orgGetter, nfManager),
+		signozalertmanager.NewFactory(sqlstore, orgGetter, nfManager, maintenanceStore),
 	)
 }
 

pkg/signoz/provider_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlschema/sqlschematest"
+	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
@@ -59,9 +60,11 @@ func TestNewProviderFactories(t *testing.T) {
 	})
 
 	assert.NotPanics(t, func() {
-		orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)), nil)
+		store := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)
+		orgGetter := implorganization.NewGetter(implorganization.NewStore(store), nil)
 		notificationManager := nfmanagertest.NewMock()
-		NewAlertmanagerProviderFactories(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), orgGetter, notificationManager)
+		maintenanceStore := sqlrulestore.NewMaintenanceStore(store)
+		NewAlertmanagerProviderFactories(store, orgGetter, notificationManager, maintenanceStore)
 	})
 
 	assert.NotPanics(t, func() {

pkg/signoz/signoz.go

@@ -34,6 +34,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/ruler"
+	sqlrulestore "github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/sqlmigration"
 	"github.com/SigNoz/signoz/pkg/sqlmigrator"
@@ -362,12 +363,14 @@ func New(
 		return nil, err
 	}
 
+	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
+
 	// Initialize alertmanager from the available alertmanager provider factories
 	alertmanager, err := factory.NewProviderFromNamedMap(
 		ctx,
 		providerSettings,
 		config.Alertmanager,
-		NewAlertmanagerProviderFactories(sqlstore, orgGetter, nfManager),
+		NewAlertmanagerProviderFactories(sqlstore, orgGetter, nfManager, maintenanceStore),
 		config.Alertmanager.Provider,
 	)
 	if err != nil {

pkg/types/ruletypes/maintenance.go

@@ -11,9 +11,7 @@ import (
 	"github.com/uptrace/bun"
 )
 
-var (
-	ErrCodeInvalidPlannedMaintenancePayload = errors.MustNewCode("invalid_planned_maintenance_payload")
-)
+var ErrCodeInvalidPlannedMaintenancePayload = errors.MustNewCode("invalid_planned_maintenance_payload")
 
 type MaintenanceStatus struct {
 	valuer.String
@@ -63,15 +61,15 @@ type StorablePlannedMaintenance struct {
 }
 
 type PlannedMaintenance struct {
-	ID          valuer.UUID `json:"id" required:"true"`
-	Name        string      `json:"name" required:"true"`
-	Description string      `json:"description"`
-	Schedule    *Schedule   `json:"schedule" required:"true"`
-	RuleIDs     []string    `json:"alertIds"`
-	CreatedAt   time.Time   `json:"createdAt"`
-	CreatedBy   string      `json:"createdBy"`
-	UpdatedAt   time.Time   `json:"updatedAt"`
-	UpdatedBy   string      `json:"updatedBy"`
+	ID          valuer.UUID       `json:"id" required:"true"`
+	Name        string            `json:"name" required:"true"`
+	Description string            `json:"description"`
+	Schedule    *Schedule         `json:"schedule" required:"true"`
+	RuleIDs     []string          `json:"alertIds"`
+	CreatedAt   time.Time         `json:"createdAt"`
+	CreatedBy   string            `json:"createdBy"`
+	UpdatedAt   time.Time         `json:"updatedAt"`
+	UpdatedBy   string            `json:"updatedBy"`
 	Status      MaintenanceStatus `json:"status" required:"true"`
 	Kind        MaintenanceKind   `json:"kind" required:"true"`
 }
@@ -100,11 +98,11 @@ func (p *PostablePlannedMaintenance) Validate() error {
 	if _, err := time.LoadLocation(p.Schedule.Timezone); err != nil {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "invalid timezone in the payload")
 	}
-
-	if !p.Schedule.StartTime.IsZero() && !p.Schedule.EndTime.IsZero() {
-		if p.Schedule.StartTime.After(p.Schedule.EndTime) {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "start time cannot be after end time")
-		}
+	if p.Schedule.StartTime.IsZero() {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "missing start time in the payload")
+	}
+	if !p.Schedule.EndTime.IsZero() && p.Schedule.StartTime.After(p.Schedule.EndTime) {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "start time cannot be after end time")
 	}
 
 	if p.Schedule.Recurrence != nil {
@@ -114,9 +112,6 @@ func (p *PostablePlannedMaintenance) Validate() error {
 		if p.Schedule.Recurrence.Duration.IsZero() {
 			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "missing duration in the payload")
 		}
-		if p.Schedule.Recurrence.EndTime != nil && p.Schedule.Recurrence.EndTime.Before(p.Schedule.Recurrence.StartTime) {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "end time cannot be before start time")
-		}
 	}
 	return nil
 }
@@ -159,43 +154,34 @@ func (m *PlannedMaintenance) ShouldSkip(ruleID string, now time.Time) bool {
 		return false
 	}
 
+	// TODO(jatinderjit): `In(loc)` conversions seem redundant
 	currentTime := now.In(loc)
+	startTime := m.Schedule.StartTime.In(loc)
+	endTime := m.Schedule.EndTime.In(loc)
 
-	// fixed schedule
-	if !m.Schedule.StartTime.IsZero() && !m.Schedule.EndTime.IsZero() {
-		startTime := m.Schedule.StartTime.In(loc)
-		endTime := m.Schedule.EndTime.In(loc)
-		if currentTime.Equal(startTime) || currentTime.Equal(endTime) ||
-			(currentTime.After(startTime) && currentTime.Before(endTime)) {
-			return true
-		}
+	// Maintenance window hasn't yet started
+	if currentTime.Before(startTime) {
+		return false
+	}
+
+	// Maintenance window has ended
+	if !endTime.IsZero() && currentTime.After(endTime) {
+		return false
+	}
+
+	// Fixed schedule (startTime <= currentTime <= endTime)
+	if m.Schedule.Recurrence == nil {
+		return true
 	}
 
 	// recurring schedule
-	if m.Schedule.Recurrence != nil {
-		start := m.Schedule.Recurrence.StartTime
-
-		// Make sure the recurrence has started
-		if currentTime.Before(start.In(loc)) {
-			return false
-		}
-
-		// Check if recurrence has expired
-		if m.Schedule.Recurrence.EndTime != nil {
-			endTime := *m.Schedule.Recurrence.EndTime
-			if !endTime.IsZero() && currentTime.After(endTime.In(loc)) {
-				return false
-			}
-		}
-
-		switch m.Schedule.Recurrence.RepeatType {
-		case RepeatTypeDaily:
-			return m.checkDaily(currentTime, m.Schedule.Recurrence, loc)
-		case RepeatTypeWeekly:
-			return m.checkWeekly(currentTime, m.Schedule.Recurrence, loc)
-		case RepeatTypeMonthly:
-			return m.checkMonthly(currentTime, m.Schedule.Recurrence, loc)
-		}
+	switch m.Schedule.Recurrence.RepeatType {
+	case RepeatTypeDaily:
+		return m.checkDaily(currentTime, m.Schedule.Recurrence, loc)
+	case RepeatTypeWeekly:
+		return m.checkWeekly(currentTime, m.Schedule.Recurrence, loc)
+	case RepeatTypeMonthly:
+		return m.checkMonthly(currentTime, m.Schedule.Recurrence, loc)
 	}
 
 	return false
@@ -206,7 +192,7 @@ func (m *PlannedMaintenance) ShouldSkip(ruleID string, now time.Time) bool {
 func (m *PlannedMaintenance) checkDaily(currentTime time.Time, rec *Recurrence, loc *time.Location) bool {
 	candidate := time.Date(
 		currentTime.Year(), currentTime.Month(), currentTime.Day(),
-		rec.StartTime.Hour(), rec.StartTime.Minute(), 0, 0,
+		m.Schedule.StartTime.Hour(), m.Schedule.StartTime.Minute(), 0, 0,
 		loc,
 	)
 	if candidate.After(currentTime) {
@@ -234,7 +220,7 @@ func (m *PlannedMaintenance) checkWeekly(currentTime time.Time, rec *Recurrence,
 		// Build a candidate occurrence by rebasing today's date to the allowed weekday.
 		candidate := time.Date(
 			currentTime.Year(), currentTime.Month(), currentTime.Day(),
-			rec.StartTime.Hour(), rec.StartTime.Minute(), 0, 0,
+			m.Schedule.StartTime.Hour(), m.Schedule.StartTime.Minute(), 0, 0,
 			loc,
 		).AddDate(0, 0, delta)
 		// If the candidate is in the future, subtract 7 days.
@@ -251,7 +237,8 @@ func (m *PlannedMaintenance) checkWeekly(currentTime time.Time, rec *Recurrence,
 // checkMonthly rebases the candidate occurrence using the recurrence's day-of-month.
 // If the candidate for the current month is in the future, it uses the previous month.
 func (m *PlannedMaintenance) checkMonthly(currentTime time.Time, rec *Recurrence, loc *time.Location) bool {
-	refDay := rec.StartTime.Day()
+	startTime := m.Schedule.StartTime
+	refDay := startTime.Day()
 	year, month, _ := currentTime.Date()
 	lastDay := time.Date(year, month+1, 0, 0, 0, 0, 0, loc).Day()
 	day := refDay
@@ -259,7 +246,7 @@ func (m *PlannedMaintenance) checkMonthly(currentTime time.Time, rec *Recurrence
 		day = lastDay
 	}
 	candidate := time.Date(year, month, day,
-		rec.StartTime.Hour(), rec.StartTime.Minute(), rec.StartTime.Second(), rec.StartTime.Nanosecond(),
+		startTime.Hour(), startTime.Minute(), startTime.Second(), startTime.Nanosecond(),
 		loc,
 	)
 	if candidate.After(currentTime) {
@@ -269,12 +256,12 @@ func (m *PlannedMaintenance) checkMonthly(currentTime time.Time, rec *Recurrence
 		lastDayPrev := time.Date(y, m+1, 0, 0, 0, 0, 0, loc).Day()
 		if refDay > lastDayPrev {
 			candidate = time.Date(y, m, lastDayPrev,
-				rec.StartTime.Hour(), rec.StartTime.Minute(), rec.StartTime.Second(), rec.StartTime.Nanosecond(),
+				startTime.Hour(), startTime.Minute(), startTime.Second(), startTime.Nanosecond(),
 				loc,
 			)
 		} else {
 			candidate = time.Date(y, m, refDay,
-				rec.StartTime.Hour(), rec.StartTime.Minute(), rec.StartTime.Second(), rec.StartTime.Nanosecond(),
+				startTime.Hour(), startTime.Minute(), startTime.Second(), startTime.Nanosecond(),
 				loc,
 			)
 		}
@@ -296,14 +283,7 @@ func (m *PlannedMaintenance) IsUpcoming() bool {
 		return false
 	}
 	now := time.Now().In(loc)
-
-	if !m.Schedule.StartTime.IsZero() && !m.Schedule.EndTime.IsZero() {
-		return now.Before(m.Schedule.StartTime)
-	}
-	if m.Schedule.Recurrence != nil {
-		return now.Before(m.Schedule.Recurrence.StartTime)
-	}
-	return false
+	return now.Before(m.Schedule.StartTime)
 }
 
 func (m *PlannedMaintenance) IsRecurring() bool {
@@ -320,16 +300,16 @@ func (m *PlannedMaintenance) Validate() error {
 	if m.Schedule.Timezone == "" {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "missing timezone in the payload")
 	}
-
 	_, err := time.LoadLocation(m.Schedule.Timezone)
 	if err != nil {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "invalid timezone in the payload")
 	}
+	if m.Schedule.StartTime.IsZero() {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "missing start time in the payload")
+	}
 
-	if !m.Schedule.StartTime.IsZero() && !m.Schedule.EndTime.IsZero() {
-		if m.Schedule.StartTime.After(m.Schedule.EndTime) {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "start time cannot be after end time")
-		}
+	if !m.Schedule.EndTime.IsZero() && m.Schedule.StartTime.After(m.Schedule.EndTime) {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "start time cannot be after end time")
 	}
 
 	if m.Schedule.Recurrence != nil {
@@ -339,9 +319,6 @@ func (m *PlannedMaintenance) Validate() error {
 		if m.Schedule.Recurrence.Duration.IsZero() {
 			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "missing duration in the payload")
 		}
-		if m.Schedule.Recurrence.EndTime != nil && m.Schedule.Recurrence.EndTime.Before(m.Schedule.Recurrence.StartTime) {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidPlannedMaintenancePayload, "end time cannot be before start time")
-		}
 	}
 	return nil
 }

pkg/types/ruletypes/maintenance_test.go

@@ -7,13 +7,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-// Helper function to create a time pointer.
-func timePtr(t time.Time) *time.Time {
-	return &t
-}
-
 func TestShouldSkipMaintenance(t *testing.T) {
-
 	cases := []struct {
 		name        string
 		maintenance *PlannedMaintenance
@@ -24,9 +18,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "only-on-saturday",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "Europe/London",
+					Timezone:  "Europe/London",
+					StartTime: time.Date(2025, 3, 1, 0, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2025, 3, 1, 0, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("24h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday, RepeatOnTuesday, RepeatOnWednesday, RepeatOnThursday, RepeatOnFriday, RepeatOnSunday},
@@ -41,10 +35,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
-						Duration:   valuer.MustParseTextDuration("4h"),           // Until Tuesday 02:00
+						Duration:   valuer.MustParseTextDuration("4h"), // Until Tuesday 02:00
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday}, // Only Monday
 					},
@@ -58,10 +52,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
-						Duration:   valuer.MustParseTextDuration("4h"),           // Until Tuesday 02:00
+						Duration:   valuer.MustParseTextDuration("4h"), // Until Tuesday 02:00
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday}, // Only Monday
 					},
@@ -75,10 +69,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 1, 22, 0, 0, 0, time.UTC), // Monday 22:00
-						Duration:   valuer.MustParseTextDuration("52h"),          // Until Thursday 02:00
+						Duration:   valuer.MustParseTextDuration("52h"), // Until Thursday 02:00
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday}, // Only Monday
 					},
@@ -92,10 +86,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-across-midnight-previous-day-not-in-repeaton",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 2, 22, 0, 0, 0, time.UTC), // Tuesday 22:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 2, 22, 0, 0, 0, time.UTC), // Tuesday 22:00
-						Duration:   valuer.MustParseTextDuration("4h"),           // Until Wednesday 02:00
+						Duration:   valuer.MustParseTextDuration("4h"), // Until Wednesday 02:00
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnTuesday}, // Only Tuesday
 					},
@@ -109,10 +103,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "daily-maintenance-across-midnight",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 23, 0, 0, 0, time.UTC), // 23:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 23, 0, 0, 0, time.UTC), // 23:00
-						Duration:   valuer.MustParseTextDuration("2h"),           // Until 01:00 next day
+						Duration:   valuer.MustParseTextDuration("2h"), // Until 01:00 next day
 						RepeatType: RepeatTypeDaily,
 					},
 				},
@@ -125,9 +119,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "at-start-time-boundary",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -141,9 +135,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "at-end-time-boundary",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -157,9 +151,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-multi-day-duration",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 28, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 28, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("72h"), // 3 days
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -173,9 +167,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-multi-day-duration",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 28, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 28, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("72h"), // 3 days
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnSunday},
@@ -190,9 +184,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-crosses-to-next-month",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 30, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 30, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("48h"), // 2 days, crosses to Feb 1
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -206,9 +200,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "timezone-offset-test",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "America/New_York", // UTC-5 or UTC-4 depending on DST
+					Timezone:  "America/New_York", // UTC-5 or UTC-4 depending on DST
+					StartTime: time.Date(2024, 1, 1, 22, 0, 0, 0, time.FixedZone("America/New_York", -5*3600)),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 22, 0, 0, 0, time.FixedZone("America/New_York", -5*3600)),
 						Duration:   valuer.MustParseTextDuration("4h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -222,9 +216,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "daily-maintenance-time-outside-window",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -238,10 +232,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "recurring-maintenance-with-past-end-date",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+					EndTime:   time.Date(2024, 1, 10, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
-						EndTime:    timePtr(time.Date(2024, 1, 10, 12, 0, 0, 0, time.UTC)),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -255,10 +249,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-spans-month-end",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 3, 31, 22, 0, 0, 0, time.UTC), // March 31, 22:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 3, 31, 22, 0, 0, 0, time.UTC), // March 31, 22:00
-						Duration:   valuer.MustParseTextDuration("6h"),            // Until April 1, 04:00
+						Duration:   valuer.MustParseTextDuration("6h"), // Until April 1, 04:00
 						RepeatType: RepeatTypeMonthly,
 					},
 				},
@@ -271,9 +265,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-empty-repeaton",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{}, // Empty - should apply to all days
@@ -288,9 +282,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-february-fewer-days",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -303,9 +297,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "daily-maintenance-crosses-midnight",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 23, 30, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 23, 30, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("1h"), // Crosses to 00:30 next day
 						RepeatType: RepeatTypeDaily,
 					},
@@ -318,9 +312,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-crosses-month-end",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -333,9 +327,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-days",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 30, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 30, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("48h"), // 2 days duration
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -348,10 +342,10 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "weekly-maintenance-crosses-midnight",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 23, 0, 0, 0, time.UTC), // Monday 23:00
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 4, 1, 23, 0, 0, 0, time.UTC), // Monday 23:00
-						Duration:   valuer.MustParseTextDuration("2h"),           // Until Tuesday 01:00
+						Duration:   valuer.MustParseTextDuration("2h"), // Until Tuesday 01:00
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday}, // Only Monday
 					},
@@ -364,9 +358,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-days",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), // January 31st
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -379,9 +373,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "daily-maintenance-crosses-midnight",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 22, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 22, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("4h"), // Until 02:00 next day
 						RepeatType: RepeatTypeDaily,
 					},
@@ -394,9 +388,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-hours",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
@@ -445,9 +439,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "recurring maintenance, repeat sunday, saturday, weekly for 24 hours, in Us/Eastern timezone",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "US/Eastern",
+					Timezone:  "US/Eastern",
+					StartTime: time.Date(2025, 3, 29, 20, 0, 0, 0, time.FixedZone("US/Eastern", -4*3600)),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2025, 3, 29, 20, 0, 0, 0, time.FixedZone("US/Eastern", -4*3600)),
 						Duration:   valuer.MustParseTextDuration("24h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnSunday, RepeatOnSaturday},
@@ -461,9 +455,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -476,9 +470,9 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
@@ -491,140 +485,176 @@ func TestShouldSkipMaintenance(t *testing.T) {
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeDaily,
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 1, 12, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 4, 1, 12, 10, 0, 0, time.UTC),
 			skip: true,
 		},
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 01, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday},
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 15, 12, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 4, 15, 12, 10, 0, 0, time.UTC),
 			skip: true,
 		},
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 01, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday},
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 14, 12, 10, 0, 0, time.UTC), // 14th 04 is sunday
+			ts:   time.Date(2024, 4, 14, 12, 10, 0, 0, time.UTC), // 14th 04 is sunday
 			skip: false,
 		},
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 01, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday},
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 16, 12, 10, 0, 0, time.UTC), // 16th 04 is tuesday
+			ts:   time.Date(2024, 4, 16, 12, 10, 0, 0, time.UTC), // 16th 04 is tuesday
 			skip: false,
 		},
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 01, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday},
 					},
 				},
 			},
-			ts:   time.Date(2024, 05, 06, 12, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 5, 6, 12, 10, 0, 0, time.UTC),
 			skip: true,
 		},
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 1, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 01, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeWeekly,
 						RepeatOn:   []RepeatOn{RepeatOnMonday},
 					},
 				},
 			},
-			ts:   time.Date(2024, 05, 06, 14, 00, 0, 0, time.UTC),
+			ts:   time.Date(2024, 5, 6, 14, 0, 0, 0, time.UTC),
 			skip: true,
 		},
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 4, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 04, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 04, 12, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 4, 4, 12, 10, 0, 0, time.UTC),
 			skip: true,
 		},
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 4, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 04, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
 				},
 			},
-			ts:   time.Date(2024, 04, 04, 14, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 4, 4, 14, 10, 0, 0, time.UTC),
 			skip: false,
 		},
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &PlannedMaintenance{
 				Schedule: &Schedule{
-					Timezone: "UTC",
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 4, 4, 12, 0, 0, 0, time.UTC),
 					Recurrence: &Recurrence{
-						StartTime:  time.Date(2024, 04, 04, 12, 0, 0, 0, time.UTC),
 						Duration:   valuer.MustParseTextDuration("2h"),
 						RepeatType: RepeatTypeMonthly,
 					},
 				},
 			},
-			ts:   time.Date(2024, 05, 04, 12, 10, 0, 0, time.UTC),
+			ts:   time.Date(2024, 5, 4, 12, 10, 0, 0, time.UTC),
+			skip: true,
+		},
+		// The recurrence should govern, when set. Not the fixed range.
+		{
+			name: "recurring-daily-with-fixed-times-outside-daily-window",
+			maintenance: &PlannedMaintenance{
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					// These fixed fields should be ignored when Recurrence is set.
+					StartTime: time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC), // daily at 14:00
+					EndTime:   time.Date(2026, 4, 30, 18, 0, 0, 0, time.UTC),
+					Recurrence: &Recurrence{
+						Duration:   valuer.MustParseTextDuration("2h"), // until 16:00
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			// 2026-04-15 11:00 is inside the fixed range but outside the daily 14:00-16:00 window.
+			ts:   time.Date(2026, 4, 15, 11, 0, 0, 0, time.UTC),
+			skip: false,
+		},
+		{
+			name: "recurring-daily-with-fixed-times-inside-daily-window",
+			maintenance: &PlannedMaintenance{
+				Schedule: &Schedule{
+					Timezone:  "UTC",
+					StartTime: time.Date(2026, 4, 1, 14, 0, 0, 0, time.UTC),
+					EndTime:   time.Date(2026, 4, 30, 18, 0, 0, 0, time.UTC),
+					Recurrence: &Recurrence{
+						Duration:   valuer.MustParseTextDuration("2h"),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			// 15:00 is inside the daily 14:00-16:00 window. Should skip.
+			ts:   time.Date(2026, 4, 15, 15, 0, 0, 0, time.UTC),
 			skip: true,
 		},
 	}

pkg/types/ruletypes/recurrence.go

@@ -65,8 +65,6 @@ var RepeatOnAllMap = map[RepeatOn]time.Weekday{
 }
 
 type Recurrence struct {
-	StartTime  time.Time           `json:"startTime" required:"true"`
-	EndTime    *time.Time          `json:"endTime,omitempty"`
 	Duration   valuer.TextDuration `json:"duration" required:"true"`
 	RepeatType RepeatType          `json:"repeatType" required:"true"`
 	RepeatOn   []RepeatOn          `json:"repeatOn"`
@@ -97,33 +95,16 @@ func (s Schedule) MarshalJSON() ([]byte, error) {
 		endTime = time.Date(s.EndTime.Year(), s.EndTime.Month(), s.EndTime.Day(), s.EndTime.Hour(), s.EndTime.Minute(), s.EndTime.Second(), s.EndTime.Nanosecond(), loc)
 	}
 
-	var recurrence *Recurrence
-	if s.Recurrence != nil {
-		recStartTime := time.Date(s.Recurrence.StartTime.Year(), s.Recurrence.StartTime.Month(), s.Recurrence.StartTime.Day(), s.Recurrence.StartTime.Hour(), s.Recurrence.StartTime.Minute(), s.Recurrence.StartTime.Second(), s.Recurrence.StartTime.Nanosecond(), loc)
-		var recEndTime *time.Time
-		if s.Recurrence.EndTime != nil {
-			end := time.Date(s.Recurrence.EndTime.Year(), s.Recurrence.EndTime.Month(), s.Recurrence.EndTime.Day(), s.Recurrence.EndTime.Hour(), s.Recurrence.EndTime.Minute(), s.Recurrence.EndTime.Second(), s.Recurrence.EndTime.Nanosecond(), loc)
-			recEndTime = &end
-		}
-		recurrence = &Recurrence{
-			StartTime:  recStartTime,
-			EndTime:    recEndTime,
-			Duration:   s.Recurrence.Duration,
-			RepeatType: s.Recurrence.RepeatType,
-			RepeatOn:   s.Recurrence.RepeatOn,
-		}
-	}
-
 	return json.Marshal(&struct {
 		Timezone   string      `json:"timezone"`
-		StartTime  string      `json:"startTime"`
-		EndTime    string      `json:"endTime"`
+		StartTime  time.Time   `json:"startTime"`
+		EndTime    time.Time   `json:"endTime,omitzero"`
 		Recurrence *Recurrence `json:"recurrence,omitempty"`
 	}{
 		Timezone:   s.Timezone,
-		StartTime:  startTime.Format(time.RFC3339),
-		EndTime:    endTime.Format(time.RFC3339),
-		Recurrence: recurrence,
+		StartTime:  startTime,
+		EndTime:    endTime,
+		Recurrence: s.Recurrence,
 	})
 }
 
@@ -158,34 +139,11 @@ func (s *Schedule) UnmarshalJSON(data []byte) error {
 		if err != nil {
 			return err
 		}
+		// TODO(jatinderjit): if endTime.IsZero() then we should not set the endTime
 		s.EndTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), endTime.Hour(), endTime.Minute(), endTime.Second(), endTime.Nanosecond(), loc)
 	}
 
 	s.Timezone = aux.Timezone
-
-	if aux.Recurrence != nil {
-		recStartTime, err := time.Parse(time.RFC3339, aux.Recurrence.StartTime.Format(time.RFC3339))
-		if err != nil {
-			return err
-		}
-
-		var recEndTime *time.Time
-		if aux.Recurrence.EndTime != nil {
-			end, err := time.Parse(time.RFC3339, aux.Recurrence.EndTime.Format(time.RFC3339))
-			if err != nil {
-				return err
-			}
-			endConverted := time.Date(end.Year(), end.Month(), end.Day(), end.Hour(), end.Minute(), end.Second(), end.Nanosecond(), loc)
-			recEndTime = &endConverted
-		}
-
-		s.Recurrence = &Recurrence{
-			StartTime:  time.Date(recStartTime.Year(), recStartTime.Month(), recStartTime.Day(), recStartTime.Hour(), recStartTime.Minute(), recStartTime.Second(), recStartTime.Nanosecond(), loc),
-			EndTime:    recEndTime,
-			Duration:   aux.Recurrence.Duration,
-			RepeatType: aux.Recurrence.RepeatType,
-			RepeatOn:   aux.Recurrence.RepeatOn,
-		}
-	}
+	s.Recurrence = aux.Recurrence
 	return nil
 }

pkg/types/ruletypes/schedule.go

@@ -8,8 +8,8 @@ import (
 
 type Schedule struct {
 	Timezone   string      `json:"timezone" required:"true"`
-	StartTime  time.Time   `json:"startTime,omitempty"`
-	EndTime    time.Time   `json:"endTime,omitempty"`
+	StartTime  time.Time   `json:"startTime" required:"true"`
+	EndTime    time.Time   `json:"endTime,omitzero"`
 	Recurrence *Recurrence `json:"recurrence"`
 }