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.

12.0 KB
Raw Blame
import { useCallback, useEffect, useMemo, useState } from 'react';
import { useQueryClient } from 'react-query';
import { useAppSearchParams } from 'lib/router/useAppSearchParams';
import * as Sentry from '@sentry/react';
import { Filter } from '@signozhq/icons';
import { Button } from '@signozhq/ui/button';
import { Switch } from '@signozhq/ui/switch';
import { Tooltip } from '@signozhq/ui/tooltip';
import logEvent from 'api/common/logEvent';
import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
import WarningPopover from 'components/WarningPopover/WarningPopover';
import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
import { usePageActions } from 'container/AIAssistant/pageActions/usePageActions';
import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
import QuickFiltersLayout from 'components/QuickFilters/QuickFiltersLayout/QuickFiltersLayout';
import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
import DateTimeSelector from 'container/TopNav/DateTimeSelectionV2';
import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
import { isEmpty } from 'lodash-es';
import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
import {
	metricsAddFilterAction,
	metricsRunQueryAction,
	metricsSaveViewAction,
} from 'pages/MetricsExplorer/aiActions';
import { Warning } from 'types/api';
import { MetricAggregation } from 'types/api/v5/queryRange';
import { DataSource } from 'types/common/queryBuilder';

import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
import MetricDetails from '../MetricDetails/MetricDetails';
import TimeSeries from './TimeSeries';
import {
	getMetricUnits,
	splitQueryIntoOneChartPerQuery,
	useGetMetrics,
} from './utils';

import './Explorer.styles.scss';

const ONE_CHART_PER_QUERY_ENABLED_KEY = 'isOneChartPerQueryEnabled';

function Explorer(): JSX.Element {
	const {
		handleRunQuery,
		stagedQuery,
		updateAllQueriesOperators,
		currentQuery,
		handleSetQueryData,
		redirectWithQueryBuilderData,
	} = useQueryBuilder();
	const isAIAssistantEnabled = useIsAIAssistantEnabled();
	const [isMetricDetailsOpen, setIsMetricDetailsOpen] = useState(false);
	const [showSidebar, setShowSidebar] = useState(true);

	const queryClient = useQueryClient();
	const [isLoadingQueries, setIsLoadingQueries] = useState(false);
	const [isCancelled, setIsCancelled] = useState(false);

	useEffect(() => {
		if (isLoadingQueries) {
			setIsCancelled(false);
		}
	}, [isLoadingQueries]);

	const handleCancelQuery = useCallback(() => {
		queryClient.cancelQueries([REACT_QUERY_KEY.GET_QUERY_RANGE]);
		setIsCancelled(true);
	}, [queryClient]);

	const metricNames = useMemo(() => {
		const currentMetricNames: string[] = [];
		stagedQuery?.builder.queryData.forEach((query) => {
			const metricName =
				query.aggregateAttribute?.key ||
				(query.aggregations?.[0] as MetricAggregation | undefined)?.metricName;
			if (metricName) {
				currentMetricNames.push(metricName);
			}
		});
		return currentMetricNames;
	}, [stagedQuery]);

	const {
		metrics,
		isLoading: isMetricUnitsLoading,
		isError: isMetricUnitsError,
	} = useGetMetrics(metricNames);

	const units = useMemo(() => getMetricUnits(metrics), [metrics]);

	const areAllMetricUnitsSame = useMemo(
		() =>
			!isMetricUnitsLoading &&
			!isMetricUnitsError &&
			units.length > 0 &&
			units.every((unit) => unit === units[0]),
		[units, isMetricUnitsLoading, isMetricUnitsError],
	);

	const [searchParams, setSearchParams] = useAppSearchParams();
	const isOneChartPerQueryEnabled =
		searchParams.get(ONE_CHART_PER_QUERY_ENABLED_KEY) === 'true';

	const [showOneChartPerQuery, toggleShowOneChartPerQuery] = useState(
		isOneChartPerQueryEnabled,
	);
	const [disableOneChartPerQuery, toggleDisableOneChartPerQuery] =
		useState(false);
	const [yAxisUnit, setYAxisUnit] = useState<string | undefined>();

	const unitsLength = useMemo(() => units.length, [units]);
	const firstUnit = useMemo(() => units[0], [units]);

	useEffect(() => {
		// Set the y axis unit to the first metric unit if
		// 1. There is one metric unit and it is not empty
		// 2. All metric units are the same and not empty
		// Else, set the y axis unit to empty if
		// 1. There are more than one metric units and they are not the same
		// 2. There are no metric units
		// 3. There is exactly one metric unit but it is empty/undefined
		if (unitsLength === 0) {
			setYAxisUnit(undefined);
		} else if (unitsLength === 1 && firstUnit) {
			setYAxisUnit(firstUnit);
		} else if (unitsLength === 1 && !firstUnit) {
			setYAxisUnit(undefined);
		} else if (areAllMetricUnitsSame) {
			if (firstUnit) {
				setYAxisUnit(firstUnit);
			} else {
				setYAxisUnit(undefined);
			}
		} else if (unitsLength > 1 && !areAllMetricUnitsSame) {
			setYAxisUnit(undefined);
		}
	}, [unitsLength, firstUnit, areAllMetricUnitsSame]);

	useEffect(() => {
		// Don't apply logic during loading to avoid overwriting user preferences
		if (isMetricUnitsLoading) {
			return;
		}

		// Disable one chart per query if -
		// 1. There are more than one metric
		// 2. The metric units are not the same
		if (units.length > 1 && !areAllMetricUnitsSame) {
			toggleShowOneChartPerQuery(true);
			toggleDisableOneChartPerQuery(true);
		} else if (units.length <= 1) {
			toggleShowOneChartPerQuery(false);
			toggleDisableOneChartPerQuery(true);
		} else {
			// When units are the same and loading is complete, restore URL-based preference
			toggleShowOneChartPerQuery(isOneChartPerQueryEnabled);
			toggleDisableOneChartPerQuery(false);
		}
	}, [
		units,
		areAllMetricUnitsSame,
		isMetricUnitsLoading,
		isOneChartPerQueryEnabled,
	]);

	const handleToggleShowOneChartPerQuery = (): void => {
		toggleShowOneChartPerQuery(!showOneChartPerQuery);
		setSearchParams({
			...Object.fromEntries(searchParams),
			[ONE_CHART_PER_QUERY_ENABLED_KEY]: (!showOneChartPerQuery).toString(),
		});
	};

	const defaultQuery = useMemo(
		() =>
			updateAllQueriesOperators(
				initialQueriesMap[DataSource.METRICS],
				PANEL_TYPES.TIME_SERIES,
				DataSource.METRICS,
			),
		[updateAllQueriesOperators],
	);

	const exportDefaultQuery = useMemo(() => {
		const query = updateAllQueriesOperators(
			currentQuery || initialQueriesMap[DataSource.METRICS],
			PANEL_TYPES.TIME_SERIES,
			DataSource.METRICS,
		);
		if (yAxisUnit && !query.unit) {
			return {
				...query,
				unit: yAxisUnit,
			};
		}
		return query;
	}, [currentQuery, updateAllQueriesOperators, yAxisUnit]);

	useShareBuilderUrl({ defaultValue: defaultQuery });

	// ─── AI Assistant page actions (only when license feature is on) ───────────
	const aiActions = useMemo(
		() =>
			isAIAssistantEnabled
				? [
						metricsRunQueryAction({
							currentQuery,
							handleSetQueryData,
							redirectWithQueryBuilderData,
						}),
						metricsAddFilterAction({
							currentQuery,
							handleSetQueryData,
							redirectWithQueryBuilderData,
						}),
						metricsSaveViewAction({
							// POC stub — logs a save request; wire to real API when available
							onSaveView: async (name) => {
								// eslint-disable-next-line no-console
								console.info('[AI Assistant] Save view requested:', name);
							},
						}),
					]
				: [],
		// eslint-disable-next-line react-hooks/exhaustive-deps
		[
			isAIAssistantEnabled,
			currentQuery,
			handleSetQueryData,
			redirectWithQueryBuilderData,
		],
	);
	usePageActions('metrics-explorer', aiActions);
	// ───────────────────────────────────────────────────────────────────────────

	const splitedQueries = useMemo(
		() =>
			splitQueryIntoOneChartPerQuery(
				stagedQuery || initialQueriesMap[DataSource.METRICS],
				metricNames,
				units,
			),
		[stagedQuery, metricNames, units],
	);

	const [selectedMetricName, setSelectedMetricName] = useState<string | null>(
		null,
	);

	const handleOpenMetricDetails = (metricName: string): void => {
		setIsMetricDetailsOpen(true);
		setSelectedMetricName(metricName);
	};

	const handleCloseMetricDetails = (): void => {
		setIsMetricDetailsOpen(false);
		setSelectedMetricName(null);
	};

	useEffect(() => {
		logEvent(MetricsExplorerEvents.TabChanged, {
			[MetricsExplorerEventKeys.Tab]: 'explorer',
		});
	}, []);

	const [warning, setWarning] = useState<Warning | undefined>();

	const oneChartPerQueryDisabledTooltip = useMemo(() => {
		if (splitedQueries.length <= 1) {
			return 'One chart per query cannot be toggled for a single query.';
		}
		if (units.length <= 1) {
			return 'One chart per query cannot be toggled when there is only one metric.';
		}
		if (disableOneChartPerQuery) {
			return 'One chart per query cannot be disabled for multiple queries with different units.';
		}
		return;
	}, [disableOneChartPerQuery, splitedQueries.length, units.length]);

	// Show the y axis unit selector if -
	// 1. There is only one metric
	// 2. The metric has no saved unit
	const showYAxisUnitSelector = useMemo(
		() => !isMetricUnitsLoading && units.length === 1 && !units[0],
		[units, isMetricUnitsLoading],
	);

	return (
		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
			<QuickFiltersLayout
				showFilters={showSidebar}
				onToggleFilters={(): void => setShowSidebar(!showSidebar)}
				savedViewProps={{ source: SavedviewtypesSourceDTO.metrics }}
			>
				<div className="metrics-explorer-explore-container">
					<div className="explore-header">
						<div className="explore-header-left-actions">
							{!showSidebar && (
								<Tooltip title="Show Views">
									<Button
										variant="outlined"
										color="secondary"
										size="sm"
										icon
										aria-label="Show Views"
										onClick={(): void => setShowSidebar(true)}
										testId="metrics-explorer-show-sidebar"
									>
										<Filter size={16} />
									</Button>
								</Tooltip>
							)}
							<span>1 chart/query</span>
							<Switch
								testId="metrics-explorer-one-chart-per-query"
								color="primary"
								textPlacement="right"
								value={showOneChartPerQuery}
								onChange={handleToggleShowOneChartPerQuery}
								disabled={disableOneChartPerQuery || splitedQueries.length <= 1}
								disabledTooltip={oneChartPerQueryDisabledTooltip}
							/>
						</div>
						<div className="explore-header-right-actions">
							{!isEmpty(warning) && <WarningPopover warningData={warning} />}
							<DateTimeSelector showAutoRefresh />
							<RightToolbarActions
								onStageRunQuery={(): void => handleRunQuery()}
								isLoadingQueries={isLoadingQueries}
								handleCancelQuery={handleCancelQuery}
							/>
						</div>
					</div>
					<QueryBuilderV2
						config={{ initialDataSource: DataSource.METRICS, queryVariant: 'static' }}
						panelType={PANEL_TYPES.TIME_SERIES}
						showFunctions={false}
						version="v3"
					/>
					<div className="explore-content">
						<TimeSeries
							onFetchingStateChange={setIsLoadingQueries}
							showOneChartPerQuery={showOneChartPerQuery}
							setWarning={setWarning}
							areAllMetricUnitsSame={areAllMetricUnitsSame}
							isMetricUnitsLoading={isMetricUnitsLoading}
							isMetricUnitsError={isMetricUnitsError}
							metricUnits={units}
							metricNames={metricNames}
							metrics={metrics}
							handleOpenMetricDetails={handleOpenMetricDetails}
							yAxisUnit={yAxisUnit}
							setYAxisUnit={setYAxisUnit}
							showYAxisUnitSelector={showYAxisUnitSelector}
							isCancelled={isCancelled}
							exportDefaultQuery={exportDefaultQuery}
						/>
					</div>
				</div>
			</QuickFiltersLayout>
			{isMetricDetailsOpen && selectedMetricName && (
				<MetricDetails
					metricName={selectedMetricName}
					isOpen={isMetricDetailsOpen}
					onClose={handleCloseMetricDetails}
					isModalTimeSelection={false}
				/>
			)}
		</Sentry.ErrorBoundary>
	);
}

export default Explorer;