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.5 KB
Raw Blame
import { ChangeEvent, useCallback, useMemo, useState } from 'react';
import { Col, Input, Row, Select } from 'antd';
import InputWithLabel from 'components/InputWithLabel/InputWithLabel';
import BucketOptions from 'components/QueryBuilderV2/QueryV2/QueryAddOns/BucketOptions/BucketOptions';
import { parseLimit, sanitizeLimit } from 'components/QueryBuilderV2/utils';
import { LEGEND } from 'constants/global';
import { PANEL_TYPES } from 'constants/queryBuilder';
// ** Hooks
import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
import {
	IBuilderFormula,
	OrderByPayload,
} from 'types/api/queryBuilder/queryBuilderData';
import { getFormatedLegend } from 'utils/getFormatedLegend';
import { popupContainer } from 'utils/selectPopupContainer';

import QBEntityOptions from '../QBEntityOptions/QBEntityOptions';
// ** Types
import { FormulaProps } from './Formula.interfaces';

import './Formula.styles.scss';

export function Formula({
	index,
	formula,
	query,
	isQBV2,
}: FormulaProps): JSX.Element {
	const {
		removeQueryBuilderEntityByIndex,
		handleSetFormulaData,
		panelType,
		currentQuery,
	} = useQueryBuilder();

	const { handleChangeFormulaData } = useQueryOperations({
		index,
		query,
		formula,
		entityVersion: '',
	});

	const [isCollapse, setIsCollapsed] = useState(false);

	const handleDelete = useCallback(() => {
		removeQueryBuilderEntityByIndex('queryFormulas', index);
	}, [index, removeQueryBuilderEntityByIndex]);

	const handleToggleDisableFormula = useCallback((): void => {
		const newFormula: IBuilderFormula = {
			...formula,
			disabled: !formula.disabled,
		};

		handleSetFormulaData(index, newFormula);
	}, [index, formula, handleSetFormulaData]);

	const handleToggleCollapseFormula = (): void => {
		setIsCollapsed(!isCollapse);
	};

	const handleChange = useCallback(
		(e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
			const { name, value } = e.target;
			const newFormula: IBuilderFormula = {
				...formula,
				[name]: name === LEGEND ? getFormatedLegend(value) : value,
			};

			handleSetFormulaData(index, newFormula);
		},
		[index, formula, handleSetFormulaData],
	);

	const handleChangeLimit = useCallback(
		(value: IBuilderFormula['limit']) => {
			handleChangeFormulaData('limit', value);
		},
		[handleChangeFormulaData],
	);

	const handleChangeBucketOptions = useCallback(
		(value: IBuilderFormula['bucketOptions']) => {
			handleChangeFormulaData('bucketOptions', value);
		},
		[handleChangeFormulaData],
	);

	const handleQBV2OrderByChange = useCallback(
		(value: string) => {
			const [columnName, order] = value.split(' ');
			const newOrderBy: OrderByPayload[] = [{ columnName, order }];
			handleChangeFormulaData('orderBy', newOrderBy);
		},
		[handleChangeFormulaData],
	);

	const qbV2OrderByOptions = useMemo(
		() => [
			{ label: `${formula.queryName} asc`, value: `${formula.queryName} asc` },
			{ label: `${formula.queryName} desc`, value: `${formula.queryName} desc` },
		],
		[formula.queryName],
	);

	const qbV2OrderByValue = useMemo(
		() =>
			formula.orderBy?.length
				? `${formula.orderBy[0].columnName} ${formula.orderBy[0].order}`
				: undefined,
		[formula.orderBy],
	);

	return (
		<Row gutter={[0, 15]} data-testid={`formula-${formula.queryName}`}>
			<QBEntityOptions
				isCollapsed={isCollapse}
				showFunctions={false}
				entityType="formula"
				entityData={formula}
				onToggleVisibility={handleToggleDisableFormula}
				onDelete={handleDelete}
				onCollapseEntity={handleToggleCollapseFormula}
				showDeleteButton
			/>

			{!isCollapse && (
				<Row gutter={[0, 15]} className="formula-container">
					<Col span={24}>
						<Input.TextArea
							name="expression"
							className="formula-expression"
							data-testid="formula-expression"
							onChange={handleChange}
							size="middle"
							value={formula.expression}
							placeholder="Enter formula"
							rows={2}
						/>
					</Col>
					<Col span={24}>
						<Input
							name="legend"
							className="formula-legend"
							data-testid="formula-legend"
							onChange={handleChange}
							size="middle"
							value={formula.legend}
							addonBefore="Legend Format"
						/>
					</Col>
					{isQBV2 && (
						<Col span={24}>
							<div className="formula-qbv2-container">
								<div className="periscope-input-with-label">
									<div className="label">Order By</div>
									<div className="input">
										<Select
											getPopupContainer={popupContainer}
											showSearch
											filterOption={false}
											showArrow={false}
											placeholder="Select order by"
											options={qbV2OrderByOptions}
											onChange={handleQBV2OrderByChange}
											value={qbV2OrderByValue}
											style={{ width: '100%' }}
										/>
									</div>
								</div>
								<InputWithLabel
									label="Limit"
									type="number"
									onChange={(value): void => handleChangeLimit(parseLimit(value))}
									sanitize={sanitizeLimit}
									initialValue={formula?.limit ?? undefined}
									placeholder="Enter limit"
								/>
							</div>
						</Col>
					)}
					{/* A heatmap draws its one enabled query, which is the formula when its
					    inputs are disabled — so the formula states its own bucket axis. */}
					{isQBV2 && panelType === PANEL_TYPES.HEATMAP && (
						<Col span={24}>
							<BucketOptions
								bucketOptions={formula.bucketOptions}
								unit={currentQuery.unit}
								onChange={handleChangeBucketOptions}
							/>
						</Col>
					)}
				</Row>
			)}
		</Row>
	);
}