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.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
import {
// eslint-disable-next-line no-restricted-imports
createContext,
PropsWithChildren,
useCallback,
useEffect,
useMemo,
useRef,
useState,
} from 'react';
import { useAppLocation } from 'lib/router/useAppLocation';
import { QueryParams } from 'constants/query';
import {
alphabet,
baseAutoCompleteIdKeysOrder,
formulasNames,
initialClickHouseData,
initialFormulaBuilderFormValues,
initialQueriesMap,
initialQueryBuilderFormTraceOperatorValues,
initialQueryBuilderFormValuesMap,
initialQueryPromQLData,
initialQueryState,
initialSingleQueryMap,
MAX_FORMULAS,
MAX_QUERIES,
PANEL_TYPES,
TRACE_OPERATOR_QUERY_NAME,
} from 'constants/queryBuilder';
import ROUTES from 'constants/routes';
import {
panelTypeDataSourceFormValuesMap,
PartialPanelTypes,
} from 'lib/query/panelTypeDataSourceFormValuesMap';
import { useNormalizedCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
import { updateStepInterval } from 'hooks/queryBuilder/useStepInterval';
import { useSafeNavigate } from 'hooks/useSafeNavigate';
import { createIdFromObjectFields } from 'lib/createIdFromObjectFields';
import { createNewBuilderItemName } from 'lib/newQueryBuilder/createNewBuilderItemName';
import { getOperatorsBySourceAndPanelType } from 'lib/newQueryBuilder/getOperatorsBySourceAndPanelType';
import { saveRecentQuery } from 'lib/recentQueries/saveRecentQuery';
import { cloneDeep, get, isEqual, set } from 'lodash-es';
import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
// ** Types
import {
IBuilderFormula,
IBuilderQuery,
IBuilderTraceOperator,
IClickHouseQuery,
IPromQLQuery,
Query,
QueryState,
} from 'types/api/queryBuilder/queryBuilderData';
import { EQueryType } from 'types/common/dashboard';
import {
DataSource,
IsDefaultQueryProps,
QueryBuilderContextType,
QueryBuilderData,
ReduceOperators,
} from 'types/common/queryBuilder';
import { sanitizeOrderByForExplorer } from 'utils/sanitizeOrderBy';
import { v4 as uuid } from 'uuid';
import { getUnstableCurrentSearchParams } from 'utils/getUnstableCurrentSearchParams';
import { readPanelTypeFromUrl } from 'utils/readPanelTypeFromUrl';
export const QueryBuilderContext = createContext<QueryBuilderContextType>({
currentQuery: initialQueriesMap.metrics,
supersetQuery: initialQueriesMap.metrics,
lastUsedQuery: null,
setLastUsedQuery: () => {},
setSupersetQuery: () => {},
stagedQuery: initialQueriesMap.metrics,
initialDataSource: null,
panelType: PANEL_TYPES.TIME_SERIES,
isEnabledQuery: false,
handleSetQueryData: () => {},
handleSetTraceOperatorData: () => {},
handleSetFormulaData: () => {},
handleSetQueryItemData: () => {},
handleSetConfig: () => {},
removeQueryBuilderEntityByIndex: () => {},
removeAllQueryBuilderEntities: () => {},
removeQueryTypeItemByIndex: () => {},
addNewBuilderQuery: () => {},
cloneQuery: () => {},
addNewFormula: () => {},
addTraceOperator: () => {},
removeTraceOperator: () => {},
addNewQueryItem: () => {},
redirectWithQueryBuilderData: () => {},
handleRunQuery: () => {},
resetQuery: () => {},
updateAllQueriesOperators: () => initialQueriesMap.metrics,
updateQueriesData: () => initialQueriesMap.metrics,
initQueryBuilderData: () => {},
handleOnUnitsChange: () => {},
isDefaultQuery: () => false,
});
export function QueryBuilderProvider({
children,
}: PropsWithChildren): JSX.Element {
const location = useAppLocation();
const currentPathnameRef = useRef<string | null>(location.pathname);
// This is used to determine if the query was called from the handleRunQuery function - which means manual trigger from Stage and Run button
const [calledFromHandleRunQuery, setCalledFromHandleRunQuery] =
useState<boolean>(false);
const normalizedCompositeQuery = useNormalizedCompositeQueryParam();
const compositeQueryParam = normalizedCompositeQuery?.query ?? null;
const { queryType: queryTypeParam, ...queryState } =
compositeQueryParam || initialQueriesMap.metrics;
const [initialDataSource, setInitialDataSource] = useState<DataSource | null>(
null,
);
const panelTypeQueryParams = getUnstableCurrentSearchParams().get(
QueryParams.panelTypes,
) as PANEL_TYPES | null;
const [panelType, setPanelType] = useState<PANEL_TYPES | null>(
panelTypeQueryParams,
);
const [currentQuery, setCurrentQuery] = useState<QueryState>(queryState);
const [supersetQuery, setSupersetQuery] = useState<QueryState>(queryState);
const [lastUsedQuery, setLastUsedQuery] = useState<number | null>(0);
const [stagedQuery, setStagedQuery] = useState<Query | null>(null);
const [queryType, setQueryType] = useState<EQueryType>(queryTypeParam);
const getElementWithActualOperator = useCallback(
(
queryData: IBuilderQuery,
dataSource: DataSource,
currentPanelType: PANEL_TYPES,
): IBuilderQuery => {
const initialOperators = getOperatorsBySourceAndPanelType({
dataSource,
panelType: currentPanelType,
});
const isCurrentOperatorAvailableInList = initialOperators
.map((operator) => operator.value)
.includes(queryData.aggregateOperator || '');
if (!isCurrentOperatorAvailableInList) {
return { ...queryData, aggregateOperator: initialOperators[0]?.value };
}
return queryData;
},
[],
);
const prepareQueryBuilderData = useCallback(
(query: Query): Query => {
const builder: QueryBuilderData = {
queryData:
query.builder.queryData?.map((item) => ({
...initialQueryBuilderFormValuesMap[
initialDataSource || DataSource.METRICS
],
...item,
})) ?? [],
queryFormulas:
query.builder.queryFormulas?.map((item) => ({
...initialFormulaBuilderFormValues,
...item,
})) ?? [],
queryTraceOperator:
query.builder.queryTraceOperator?.map((item) => ({
...initialQueryBuilderFormTraceOperatorValues,
...item,
})) ?? [],
};
const urlPanelType = readPanelTypeFromUrl(PANEL_TYPES.LIST);
const isRawPanel =
urlPanelType === PANEL_TYPES.LIST || urlPanelType === PANEL_TYPES.TRACE;
const setupedQueryData = builder.queryData.map((item) => {
const currentElement: IBuilderQuery = {
...item,
groupBy: item.groupBy.map(({ id: _, ...item }) => ({
...item,
id: createIdFromObjectFields(item, baseAutoCompleteIdKeysOrder),
})),
aggregateAttribute: {
...item.aggregateAttribute,
id: createIdFromObjectFields(
item.aggregateAttribute as BaseAutocompleteData,
baseAutoCompleteIdKeysOrder,
),
} as BaseAutocompleteData,
};
// Explorer pages: sanitize stale orderBy before first query
const isExplorer =
(location.pathname === ROUTES.LOGS_EXPLORER ||
location.pathname === ROUTES.TRACES_EXPLORER ||
location.pathname === ROUTES.AI_OBSERVABILITY_EXPLORER) &&
!isRawPanel;
if (isExplorer) {
const sanitizedOrderBy = sanitizeOrderByForExplorer(currentElement);
return calledFromHandleRunQuery
? currentElement
: { ...currentElement, orderBy: sanitizedOrderBy };
}
return currentElement;
});
const promql: IPromQLQuery[] =
query.promql?.map((item) => ({
...initialQueryPromQLData,
...item,
})) ?? [];
const clickHouse: IClickHouseQuery[] =
query.clickhouse_sql?.map((item) => ({
...initialClickHouseData,
...item,
})) ?? [];
const newQueryState: QueryState = {
clickhouse_sql: clickHouse,
promql,
builder: {
...builder,
queryData: setupedQueryData,
},
id: query.id,
unit: query.unit,
};
const nextQuery: Query = {
...newQueryState,
queryType: query.queryType,
};
return nextQuery;
},
[initialDataSource, location.pathname, calledFromHandleRunQuery],
);
const initQueryBuilderData = useCallback(
(query: Query): void => {
const { queryType: newQueryType, ...queryState } =
prepareQueryBuilderData(query);
const type = newQueryType || EQueryType.QUERY_BUILDER;
const newQueryState: QueryState = {
...queryState,
id: queryState.id,
};
const nextQuery: Query = { ...newQueryState, queryType: type };
setStagedQuery(nextQuery);
setCurrentQuery(newQueryState);
setQueryType(type);
setCalledFromHandleRunQuery(false);
},
[prepareQueryBuilderData],
);
const updateAllQueriesOperators = useCallback(
(
query: Query,
panelType: PANEL_TYPES,
dataSource: DataSource,
signalSource?: 'meter' | '',
): Query => {
const queryData = query.builder.queryData?.map((item) =>
getElementWithActualOperator(item, dataSource, panelType),
);
return {
...query,
builder: {
...query.builder,
queryData: queryData.map((item) => ({
...item,
source: signalSource,
})),
},
};
},
[getElementWithActualOperator],
);
const extractRelevantKeys = useCallback(
(queryData: IBuilderQuery): IBuilderQuery => {
const {
dataSource,
queryName,
aggregateOperator,
aggregateAttribute,
timeAggregation,
spaceAggregation,
functions,
filters,
expression,
disabled,
stepInterval,
having,
groupBy,
legend,
} = queryData;
return {
dataSource,
queryName,
aggregateOperator,
// remove id from aggregateAttribute
aggregateAttribute: {
...aggregateAttribute,
id: '',
} as BaseAutocompleteData,
timeAggregation,
spaceAggregation,
functions,
filters,
expression,
disabled,
stepInterval,
having,
groupBy,
legend,
// set to default values
orderBy: [],
limit: null,
reduceTo: ReduceOperators.AVG,
};
},
[],
);
const isDefaultQuery = useCallback(
({ currentQuery, sourcePage }: IsDefaultQueryProps): boolean => {
// Get default query with updated operators
const defaultQuery = updateAllQueriesOperators(
initialQueriesMap[sourcePage],
PANEL_TYPES.LIST,
sourcePage,
);
// Early return if query types don't match
if (currentQuery.queryType !== defaultQuery.queryType) {
return false;
}
// Only compare builder queries
if (currentQuery.queryType !== EQueryType.QUERY_BUILDER) {
return false;
}
// If there is more than one query, then it is not a default query
if (currentQuery.builder.queryData.length > 1) {
return false;
}
const currentBuilderData = extractRelevantKeys(
currentQuery.builder.queryData[0],
);
const defaultBuilderData = extractRelevantKeys(
defaultQuery.builder.queryData[0],
);
return isEqual(currentBuilderData, defaultBuilderData);
},
[updateAllQueriesOperators, extractRelevantKeys],
);
const updateQueriesData = useCallback(
<T extends keyof QueryBuilderData>(
query: Query,
type: T,
updateCallback: (
item: QueryBuilderData[T][number],
index: number,
) => QueryBuilderData[T][number],
): Query => {
const result = query.builder[type].map(updateCallback);
return { ...query, builder: { ...query.builder, [type]: result } };
},
[],
);
const removeQueryBuilderEntityByIndex = useCallback(
(type: keyof QueryBuilderData, index: number) => {
setCurrentQuery((prevState) => {
const currentArray: (
| IBuilderQuery
| IBuilderFormula
| IBuilderTraceOperator
)[] = prevState.builder[type];
const filteredArray = currentArray.filter((_, i) => index !== i);
return {
...prevState,
builder: {
...prevState.builder,
[type]: filteredArray,
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const currentArray: (
| IBuilderQuery
| IBuilderFormula
| IBuilderTraceOperator
)[] = prevState.builder[type];
const filteredArray = currentArray.filter((_, i) => index !== i);
return {
...prevState,
builder: {
...prevState.builder,
[type]: filteredArray,
},
};
});
},
[],
);
const removeAllQueryBuilderEntities = useCallback(
(type: keyof QueryBuilderData) => {
setCurrentQuery((prevState) => ({
...prevState,
builder: { ...prevState.builder, [type]: [] },
}));
setSupersetQuery((prevState) => ({
...prevState,
builder: { ...prevState.builder, [type]: [] },
}));
},
[setCurrentQuery, setSupersetQuery],
);
const removeQueryTypeItemByIndex = useCallback(
(type: EQueryType.PROM | EQueryType.CLICKHOUSE, index: number) => {
setCurrentQuery((prevState) => {
const targetArray: (IPromQLQuery | IClickHouseQuery)[] = prevState[type];
return {
...prevState,
[type]: targetArray.filter((_, i) => index !== i),
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const targetArray: (IPromQLQuery | IClickHouseQuery)[] = prevState[type];
return {
...prevState,
[type]: targetArray.filter((_, i) => index !== i),
};
});
},
[],
);
const createNewBuilderQuery = useCallback(
(queries: IBuilderQuery[]): IBuilderQuery => {
const existNames = queries.map((item) => item.queryName);
// Hosts without a fixed data source (the panel editor) continue the
// previous query's signal rather than resetting to metrics.
const previous = queries[queries.length - 1];
const initialBuilderQuery =
initialQueryBuilderFormValuesMap[
initialDataSource || previous?.dataSource || DataSource.METRICS
];
const newQuery: IBuilderQuery = {
...initialBuilderQuery,
source: previous?.source || '',
builderQueryType: queries?.[0]?.builderQueryType,
queryName: createNewBuilderItemName({ existNames, sourceNames: alphabet }),
expression: createNewBuilderItemName({
existNames,
sourceNames: alphabet,
}),
};
return newQuery;
},
[initialDataSource],
);
const cloneNewBuilderQuery = useCallback(
(queries: IBuilderQuery[], query: IBuilderQuery): IBuilderQuery => {
const existNames = queries.map((item) => item.queryName);
const clonedQuery: IBuilderQuery = {
...query,
queryName: createNewBuilderItemName({ existNames, sourceNames: alphabet }),
expression: createNewBuilderItemName({
existNames,
sourceNames: alphabet,
}),
};
return clonedQuery;
},
[],
);
const createNewBuilderFormula = useCallback((formulas: IBuilderFormula[]) => {
const existNames = formulas.map((item) => item.queryName);
const newFormula: IBuilderFormula = {
...initialFormulaBuilderFormValues,
queryName: createNewBuilderItemName({
existNames,
sourceNames: formulasNames,
}),
};
return newFormula;
}, []);
const createNewQueryTypeItem = useCallback(
(
itemArray: QueryState['clickhouse_sql'] | QueryState['promql'],
type: EQueryType.CLICKHOUSE | EQueryType.PROM,
): IPromQLQuery | IClickHouseQuery => {
const existNames = itemArray.map((item) => item.name);
const newItem: IPromQLQuery | IClickHouseQuery = {
...initialSingleQueryMap[type],
name: createNewBuilderItemName({
existNames,
sourceNames: alphabet,
}),
};
return newItem;
},
[],
);
const addNewQueryItem = useCallback(
(type: EQueryType.CLICKHOUSE | EQueryType.PROM) => {
setCurrentQuery((prevState) => {
if (prevState[type].length >= MAX_QUERIES) {
return prevState;
}
const newQuery = createNewQueryTypeItem(prevState[type], type);
return {
...prevState,
[type]: [...prevState[type], newQuery],
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
if (prevState[type].length >= MAX_QUERIES) {
return prevState;
}
const newQuery = createNewQueryTypeItem(prevState[type], type);
return {
...prevState,
[type]: [...prevState[type], newQuery],
};
});
},
[createNewQueryTypeItem],
);
const addNewBuilderQuery = useCallback(() => {
setCurrentQuery((prevState) => {
if (prevState.builder.queryData.length >= MAX_QUERIES) {
return prevState;
}
const newQuery = createNewBuilderQuery(prevState.builder.queryData);
return {
...prevState,
builder: {
...prevState.builder,
queryData: [...prevState.builder.queryData, newQuery],
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
if (prevState.builder.queryData.length >= MAX_QUERIES) {
return prevState;
}
const newQuery = createNewBuilderQuery(prevState.builder.queryData);
return {
...prevState,
builder: {
...prevState.builder,
queryData: [...prevState.builder.queryData, newQuery],
},
};
});
}, [createNewBuilderQuery]);
const cloneQuery = useCallback(
(type: string, query: IBuilderQuery): void => {
setCurrentQuery((prevState) => {
if (prevState.builder.queryData.length >= MAX_QUERIES) {
return prevState;
}
const clonedQuery = cloneNewBuilderQuery(
prevState.builder.queryData,
query,
);
return {
...prevState,
builder: {
...prevState.builder,
queryData: [...prevState.builder.queryData, clonedQuery],
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
if (prevState.builder.queryData.length >= MAX_QUERIES) {
return prevState;
}
const clonedQuery = cloneNewBuilderQuery(
prevState.builder.queryData,
query,
);
return {
...prevState,
builder: {
...prevState.builder,
queryData: [...prevState.builder.queryData, clonedQuery],
},
};
});
},
[cloneNewBuilderQuery],
);
const addNewFormula = useCallback(() => {
setCurrentQuery((prevState) => {
if (prevState.builder.queryFormulas.length >= MAX_FORMULAS) {
return prevState;
}
const newFormula = createNewBuilderFormula(prevState.builder.queryFormulas);
return {
...prevState,
builder: {
...prevState.builder,
queryFormulas: [...prevState.builder.queryFormulas, newFormula],
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
if (prevState.builder.queryFormulas.length >= MAX_FORMULAS) {
return prevState;
}
const newFormula = createNewBuilderFormula(prevState.builder.queryFormulas);
return {
...prevState,
builder: {
...prevState.builder,
queryFormulas: [...prevState.builder.queryFormulas, newFormula],
},
};
});
}, [createNewBuilderFormula]);
const addTraceOperator = useCallback((expression = '') => {
const trimmed = (expression || '').trim();
setCurrentQuery((prevState) => {
const existing = prevState.builder.queryTraceOperator?.[0] || null;
const updated: IBuilderTraceOperator = existing
? { ...existing, expression: trimmed }
: {
...initialQueryBuilderFormTraceOperatorValues,
queryName: TRACE_OPERATOR_QUERY_NAME,
expression: trimmed,
};
return {
...prevState,
builder: {
...prevState.builder,
// enforce single trace operator and replace only expression
queryTraceOperator: [updated],
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const existing = prevState.builder.queryTraceOperator?.[0] || null;
const updated: IBuilderTraceOperator = existing
? { ...existing, expression: trimmed }
: {
...initialQueryBuilderFormTraceOperatorValues,
queryName: TRACE_OPERATOR_QUERY_NAME,
expression: trimmed,
};
return {
...prevState,
builder: {
...prevState.builder,
// enforce single trace operator and replace only expression
queryTraceOperator: [updated],
},
};
});
}, []);
const removeTraceOperator = useCallback(() => {
setCurrentQuery((prevState) => ({
...prevState,
builder: {
...prevState.builder,
queryTraceOperator: [],
},
}));
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => ({
...prevState,
builder: {
...prevState.builder,
queryTraceOperator: [],
},
}));
}, []);
const updateQueryBuilderData: <T>(
arr: T[],
index: number,
newQueryItem: T,
) => T[] = useCallback(
(arr, index, newQueryItem) =>
arr.map((item, idx) => (index === idx ? newQueryItem : item)),
[],
);
const updateSuperSetQueryBuilderData = useCallback(
(arr: IBuilderQuery[], index: number, newQueryItem: IBuilderQuery) =>
arr.map((item, idx) => {
if (index === idx) {
if (!panelType) {
return newQueryItem;
}
const queryItem = cloneDeep(item) as IBuilderQuery;
const propsRequired =
panelTypeDataSourceFormValuesMap[panelType as keyof PartialPanelTypes]?.[
queryItem.dataSource
].builder.queryData;
// `dataSource` travels with the panel type's fields, but on a copy:
// `propsRequired` is the list the map holds, and pushing onto it grew
// that array by one entry on every call.
if (propsRequired) {
[...propsRequired, 'dataSource'].forEach((p) => {
set(queryItem, p, get(newQueryItem, p));
});
}
return queryItem;
}
return item;
}),
[panelType],
);
const handleSetQueryItemData = useCallback(
(
index: number,
type: EQueryType.PROM | EQueryType.CLICKHOUSE,
newQueryData: IPromQLQuery | IClickHouseQuery,
) => {
setCurrentQuery((prevState) => {
const updatedQueryBuilderData = updateQueryBuilderData(
prevState[type],
index,
newQueryData,
);
return {
...prevState,
[type]: updatedQueryBuilderData,
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const updatedQueryBuilderData = updateQueryBuilderData(
prevState[type],
index,
newQueryData,
);
return {
...prevState,
[type]: updatedQueryBuilderData,
};
});
},
[updateQueryBuilderData],
);
const handleSetQueryData = useCallback(
(index: number, newQueryData: IBuilderQuery): void => {
setCurrentQuery((prevState) => {
const updatedQueryBuilderData = updateQueryBuilderData(
prevState.builder.queryData,
index,
newQueryData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryData: updatedQueryBuilderData,
},
};
});
setSupersetQuery((prevState) => {
const updatedQueryBuilderData = updateSuperSetQueryBuilderData(
prevState.builder.queryData,
index,
newQueryData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryData: updatedQueryBuilderData,
},
};
});
},
[updateQueryBuilderData, updateSuperSetQueryBuilderData],
);
const handleSetTraceOperatorData = useCallback(
(index: number, traceOperatorData: IBuilderTraceOperator): void => {
setCurrentQuery((prevState) => {
const updatedTraceOperatorBuilderData = updateQueryBuilderData(
prevState.builder.queryTraceOperator,
index,
traceOperatorData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryTraceOperator: updatedTraceOperatorBuilderData,
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const updatedTraceOperatorBuilderData = updateQueryBuilderData(
prevState.builder.queryTraceOperator,
index,
traceOperatorData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryTraceOperator: updatedTraceOperatorBuilderData,
},
};
});
},
[updateQueryBuilderData],
);
const handleSetFormulaData = useCallback(
(index: number, formulaData: IBuilderFormula): void => {
setCurrentQuery((prevState) => {
const updatedFormulasBuilderData = updateQueryBuilderData(
prevState.builder.queryFormulas,
index,
formulaData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryFormulas: updatedFormulasBuilderData,
},
};
});
// eslint-disable-next-line sonarjs/no-identical-functions
setSupersetQuery((prevState) => {
const updatedFormulasBuilderData = updateQueryBuilderData(
prevState.builder.queryFormulas,
index,
formulaData,
);
return {
...prevState,
builder: {
...prevState.builder,
queryFormulas: updatedFormulasBuilderData,
},
};
});
},
[updateQueryBuilderData],
);
const { safeNavigate } = useSafeNavigate({
preventSameUrlNavigation: false,
});
const redirectWithQueryBuilderData = useCallback(
(
query: Partial<Query>,
searchParams?: Record<string, unknown>,
redirectingUrl?: (typeof ROUTES)[keyof typeof ROUTES],
shouldNotStringify?: boolean,
newTab?: boolean,
) => {
const queryType =
!query.queryType || !Object.values(EQueryType).includes(query.queryType)
? EQueryType.QUERY_BUILDER
: query.queryType;
const builder =
!query.builder || query.builder.queryData?.length === 0
? initialQueryState.builder
: query.builder;
const promql =
!query.promql || query.promql.length === 0
? initialQueryState.promql
: query.promql;
const clickhouseSql =
!query.clickhouse_sql || query.clickhouse_sql.length === 0
? initialQueryState.clickhouse_sql
: query.clickhouse_sql;
const currentGeneratedQuery: Query = {
queryType,
builder,
promql,
clickhouse_sql: clickhouseSql,
id: uuid(),
unit: query.unit || initialQueryState.unit,
};
const urlQuery = getUnstableCurrentSearchParams();
const pagination = urlQuery.get(QueryParams.pagination);
if (pagination) {
const parsedPagination = JSON.parse(pagination);
urlQuery.set(
QueryParams.pagination,
JSON.stringify({
limit: parsedPagination.limit,
offset: 0,
}),
);
}
urlQuery.set(
QueryParams.compositeQuery,
encodeURIComponent(JSON.stringify(currentGeneratedQuery)),
);
if (searchParams) {
Object.keys(searchParams).forEach((param) =>
urlQuery.set(
param,
shouldNotStringify
? (searchParams[param] as string)
: JSON.stringify(searchParams[param]),
),
);
}
// Remove Hidden Filters from URL query parameters on query change
urlQuery.delete(QueryParams.activeLogId);
const generatedUrl = redirectingUrl
? `${redirectingUrl}?${urlQuery}`
: `${location.pathname}?${urlQuery}`;
safeNavigate(generatedUrl, { newTab });
},
[location.pathname, safeNavigate],
);
const handleSetConfig = useCallback(
(newPanelType: PANEL_TYPES, dataSource: DataSource | null) => {
setPanelType(newPanelType);
setInitialDataSource(dataSource);
},
[],
);
const handleRunQuery = useCallback(() => {
const isExplorer =
location.pathname === ROUTES.LOGS_EXPLORER ||
location.pathname === ROUTES.TRACES_EXPLORER ||
location.pathname === ROUTES.AI_OBSERVABILITY_EXPLORER;
if (isExplorer) {
setCalledFromHandleRunQuery(true);
}
saveRecentQuery(currentQuery);
const currentQueryData = {
...currentQuery,
builder: {
...currentQuery.builder,
queryData: currentQuery.builder.queryData.map((item) => ({
...item,
filter: {
...item.filter,
expression:
item.filter?.expression.trim() === ''
? ''
: (item.filter?.expression ?? ''),
},
filters: {
items: [],
op: 'AND',
},
})),
},
};
redirectWithQueryBuilderData({
...{
...currentQueryData,
...updateStepInterval({
builder: currentQueryData.builder,
clickhouse_sql: currentQueryData.clickhouse_sql,
promql: currentQueryData.promql,
id: currentQueryData.id,
queryType,
unit: currentQueryData.unit,
}),
},
queryType,
});
}, [currentQuery, location.pathname, queryType, redirectWithQueryBuilderData]);
useEffect(() => {
if (location.pathname !== currentPathnameRef.current) {
currentPathnameRef.current = location.pathname;
setStagedQuery(null);
// reset the last used query to 0 when navigating away from the page
setLastUsedQuery(0);
setCalledFromHandleRunQuery(false);
}
}, [location.pathname]);
// Separate useEffect to handle initQueryBuilderData after pathname changes
useEffect(() => {
if (!compositeQueryParam) {
return;
}
// Only run initQueryBuilderData if we're not in the middle of a pathname change
if (location.pathname === currentPathnameRef.current) {
if (stagedQuery && stagedQuery.id === compositeQueryParam.id) {
return;
}
if (normalizedCompositeQuery?.changed) {
const urlQuery = getUnstableCurrentSearchParams();
urlQuery.set(
QueryParams.compositeQuery,
encodeURIComponent(JSON.stringify(compositeQueryParam)),
);
safeNavigate(`${location.pathname}?${urlQuery}`, { replace: true });
return;
}
initQueryBuilderData(compositeQueryParam);
}
}, [
initQueryBuilderData,
safeNavigate,
normalizedCompositeQuery,
compositeQueryParam,
stagedQuery,
location.pathname,
]);
const resetQuery = (newCurrentQuery?: QueryState): void => {
setStagedQuery(null);
if (newCurrentQuery) {
setCurrentQuery(newCurrentQuery);
setSupersetQuery(newCurrentQuery);
}
};
const handleOnUnitsChange = useCallback(
(unit: string) => {
setCurrentQuery((prevState) => ({
...prevState,
unit,
}));
setSupersetQuery((prevState) => ({
...prevState,
unit,
}));
},
[setCurrentQuery, setSupersetQuery],
);
const query: Query = useMemo(
() => ({
...currentQuery,
queryType,
}),
[currentQuery, queryType],
);
const superQuery: Query = useMemo(
() => ({
...supersetQuery,
queryType,
}),
[supersetQuery, queryType],
);
const isEnabledQuery = useMemo(
() => !!stagedQuery && !!panelType,
[stagedQuery, panelType],
);
const contextValues: QueryBuilderContextType = useMemo(
() => ({
currentQuery: query,
supersetQuery: superQuery,
lastUsedQuery,
setLastUsedQuery,
setSupersetQuery,
stagedQuery,
initialDataSource,
panelType,
isEnabledQuery,
handleSetQueryData,
handleSetTraceOperatorData,
handleSetFormulaData,
handleSetQueryItemData,
handleSetConfig,
removeQueryBuilderEntityByIndex,
removeQueryTypeItemByIndex,
removeAllQueryBuilderEntities,
cloneQuery,
addNewBuilderQuery,
addNewFormula,
addTraceOperator,
removeTraceOperator,
addNewQueryItem,
redirectWithQueryBuilderData,
handleRunQuery,
resetQuery,
updateAllQueriesOperators,
isDefaultQuery,
updateQueriesData,
initQueryBuilderData,
handleOnUnitsChange,
}),
[
query,
superQuery,
lastUsedQuery,
stagedQuery,
initialDataSource,
panelType,
isEnabledQuery,
handleSetQueryData,
handleSetTraceOperatorData,
handleSetFormulaData,
handleSetQueryItemData,
handleSetConfig,
removeQueryBuilderEntityByIndex,
removeQueryTypeItemByIndex,
removeAllQueryBuilderEntities,
cloneQuery,
addNewBuilderQuery,
addNewFormula,
addTraceOperator,
removeTraceOperator,
addNewQueryItem,
redirectWithQueryBuilderData,
handleRunQuery,
updateAllQueriesOperators,
isDefaultQuery,
updateQueriesData,
initQueryBuilderData,
handleOnUnitsChange,
],
);
return (
<QueryBuilderContext.Provider value={contextValues}>
{children}
</QueryBuilderContext.Provider>
);
}