Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

5.6 KB
Raw Blame
import { useCallback, useEffect, useMemo, useState } from 'react';
// eslint-disable-next-line no-restricted-imports
import { useDispatch, useSelector } from 'react-redux';
import { useAppLocation } from 'lib/router/useAppLocation';
import { Check, ChevronDown } from '@signozhq/icons';
import { Button, Popover } from 'antd';
import { Checkbox } from '@signozhq/ui/checkbox';
import { Typography } from '@signozhq/ui/typography';
import get from 'api/browser/localstorage/get';
import set from 'api/browser/localstorage/set';
import { DASHBOARD_TIME_IN_DURATION } from 'constants/app';
import useUrlQuery from 'hooks/useUrlQuery';
import _omit from 'lodash-es/omit';
// eslint-disable-next-line no-restricted-imports
import { Dispatch } from 'redux';
import { AppState } from 'store/reducers';
import AppActions from 'types/actions';
import { UPDATE_AUTO_REFRESH_INTERVAL } from 'types/actions/globalTime';
import { GlobalReducer } from 'types/reducer/globalTime';
import { popupContainer } from 'utils/selectPopupContainer';

import { refreshIntervalOptions } from './constants';
import { ButtonContainer } from './styles';
import { useAutoRefreshTick } from './useAutoRefreshTick';

import './AutoRefreshV2.styles.scss';

const DEFAULT_REFRESH_INTERVAL = '30s';

function AutoRefresh({
	disabled = false,
	showAutoRefreshBtnPrimary = true,
}: AutoRefreshProps): JSX.Element {
	const globalTime = useSelector<AppState, GlobalReducer>(
		(state) => state.globalTime,
	);
	const { pathname } = useAppLocation();

	const isDisabled = useMemo(
		() =>
			disabled ||
			globalTime.isAutoRefreshDisabled ||
			globalTime.selectedTime === 'custom',
		[globalTime.isAutoRefreshDisabled, disabled, globalTime.selectedTime],
	);

	const localStorageData = JSON.parse(get(DASHBOARD_TIME_IN_DURATION) || '{}');

	const localStorageValue = useMemo(
		() => localStorageData[pathname],
		[pathname, localStorageData],
	);

	const [isAutoRefreshEnabled, setIsAutoRefreshfreshEnabled] = useState<boolean>(
		Boolean(localStorageValue),
	);

	const dispatch = useDispatch<Dispatch<AppActions>>();

	useEffect(() => {
		const isAutoRefreshEnabled = Boolean(localStorageValue);
		dispatch({
			type: UPDATE_AUTO_REFRESH_INTERVAL,
			payload: localStorageValue,
		});
		setIsAutoRefreshfreshEnabled(isAutoRefreshEnabled);
	}, [localStorageValue, dispatch]);

	const params = useUrlQuery();

	const defaultOption = useMemo(
		() =>
			refreshIntervalOptions.find(
				(option) => option.key === DEFAULT_REFRESH_INTERVAL,
			),
		[],
	);

	const [selectedOption, setSelectedOption] = useState<string>(
		localStorageValue || refreshIntervalOptions[0].key,
	);

	useEffect(() => {
		setSelectedOption(localStorageValue || refreshIntervalOptions[0].key);
	}, [localStorageValue, params, defaultOption]);

	const getOption = useMemo(
		() => refreshIntervalOptions.find((option) => option.key === selectedOption),
		[selectedOption],
	);

	useAutoRefreshTick(
		!isDisabled && isAutoRefreshEnabled && selectedOption !== 'off',
		getOption?.value || 0,
	);

	const onChangeHandler = useCallback(
		(selectedValue: string) => {
			setSelectedOption(selectedValue);
			params.set(DASHBOARD_TIME_IN_DURATION, selectedValue);
			set(
				DASHBOARD_TIME_IN_DURATION,
				JSON.stringify({ ...localStorageData, [pathname]: selectedValue }),
			);
			setIsAutoRefreshfreshEnabled(true);
		},
		[params, pathname, localStorageData],
	);

	const onChangeAutoRefreshHandler = useCallback(
		(value: boolean | 'indeterminate') => {
			const checked = value === true;
			if (!checked) {
				// remove the path from localstorage
				set(
					DASHBOARD_TIME_IN_DURATION,
					JSON.stringify(_omit(localStorageData, pathname)),
				);
			} else {
				// When enabling auto-refresh, set to DEFAULT_REFRESH_INTERVAL if no previous preference
				const refreshInterval = localStorageValue || defaultOption?.key;
				set(
					DASHBOARD_TIME_IN_DURATION,
					JSON.stringify({ ...localStorageData, [pathname]: refreshInterval }),
				);
				setSelectedOption(refreshInterval);
			}
			setIsAutoRefreshfreshEnabled(checked);
		},
		[localStorageData, pathname, localStorageValue, defaultOption],
	);

	if (globalTime.selectedTime === 'custom') {
		return <></>;
	}

	return (
		<Popover
			getPopupContainer={popupContainer}
			placement="bottomRight"
			rootClassName="auto-refresh-root"
			trigger={['click']}
			content={
				<div className="auto-refresh-menu">
					<div className="auto-refresh-checkbox">
						<Checkbox
							color="primary"
							onChange={onChangeAutoRefreshHandler}
							value={isAutoRefreshEnabled}
							disabled={isDisabled}
							disabledTooltip="Auto refresh is not available for a custom time range"
						>
							Auto Refresh
						</Checkbox>
					</div>
					<Typography.Text disabled={isDisabled} className="refresh-interval-text">
						Refresh Interval
					</Typography.Text>
					{refreshIntervalOptions
						.filter((e) => e.label !== 'off')
						.map((option) => (
							<Button
								type="text"
								className="refresh-interval-btns"
								key={option.label + option.value}
								onClick={(): void => {
									onChangeHandler(option.key);
								}}
							>
								{option.label}
								{option.key === selectedOption && <Check size={14} />}
							</Button>
						))}
				</div>
			}
		>
			<ButtonContainer
				title="Set auto refresh"
				type={showAutoRefreshBtnPrimary ? 'primary' : 'default'}
			>
				<ChevronDown size={14} />
			</ButtonContainer>
		</Popover>
	);
}

interface AutoRefreshProps {
	disabled?: boolean;
	showAutoRefreshBtnPrimary?: boolean;
}

AutoRefresh.defaultProps = {
	disabled: false,
	showAutoRefreshBtnPrimary: true,
};

export default AutoRefresh;