fix: handle url.full and http.url in third-party API endpoint count

Use two queries combined via formula to count distinct endpoints
across both semconv versions (url.full and http.url).
This avoids missing count for endpoint if only url.full is used.

Alternative a simple coalesce in count_distinct would have fixed
this but it would require substantial query builder refactoring
since it's not supported currently.

frontend/.eslintrc.js

@@ -64,7 +64,14 @@ module.exports = {
 
 		// TypeScript rules
 		'@typescript-eslint/explicit-function-return-type': 'error', // Requires explicit return types on functions
-		'@typescript-eslint/no-unused-vars': 'off',
+		'@typescript-eslint/no-unused-vars': [
+			// Disallows unused variables/args
+			'error',
+			{
+				argsIgnorePattern: '^_', // Allows unused args prefixed with _ (e.g., _unusedParam)
+				varsIgnorePattern: '^_', // Allows unused vars prefixed with _ (e.g., _unusedVar)
+			},
+		],
 		'@typescript-eslint/no-explicit-any': 'warn', // Warns when using 'any' type (consider upgrading to error)
 		// TODO: Change to 'error' after fixing ~80 empty function placeholders in providers/contexts
 		'@typescript-eslint/no-empty-function': 'off', // Disallows empty function bodies

frontend/src/api/messagingQueues/getConsumerLagDetails.ts

@@ -41,7 +41,7 @@ export const getConsumerLagDetails = async (
 > => {
 	const { detailType, ...restProps } = props;
 	const response = await axios.post(
-		`/messaging-queues/kafka/consumer-lag/${props.detailType}`,
+		`/messaging-queues/kafka/consumer-lag/${detailType}`,
 		{
 			...restProps,
 		},

frontend/src/components/ExplorerCard/utils.ts

@@ -43,16 +43,17 @@ export const omitIdFromQuery = (query: Query | null): any => ({
 	builder: {
 		...query?.builder,
 		queryData: query?.builder.queryData.map((queryData) => {
-			const { id, ...rest } = queryData.aggregateAttribute || {};
+			const { id: _aggregateAttributeId, ...rest } =
+				queryData.aggregateAttribute || {};
 			const newAggregateAttribute = rest;
 			const newGroupByAttributes = queryData.groupBy.map((groupByAttribute) => {
-				const { id, ...rest } = groupByAttribute;
+				const { id: _groupByAttributeId, ...rest } = groupByAttribute;
 				return rest;
 			});
 			const newItems = queryData.filters?.items?.map((item) => {
-				const { id, ...newItem } = item;
+				const { id: _itemId, ...newItem } = item;
 				if (item.key) {
-					const { id, ...rest } = item.key;
+					const { id: _keyId, ...rest } = item.key;
 					return {
 						...newItem,
 						key: rest,

frontend/src/components/MarkdownRenderer/MarkdownRenderer.tsx

@@ -45,7 +45,6 @@ function Pre({
 }
 
 function Code({
-	node,
 	inline,
 	className = 'blog-code',
 	children,

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch.tsx

@@ -29,7 +29,6 @@ import {
 	QUERY_BUILDER_OPERATORS_BY_KEY_TYPE,
 	queryOperatorSuggestions,
 } from 'constants/antlrQueryConstants';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import useDebounce from 'hooks/useDebounce';
 import { debounce, isNull } from 'lodash-es';
@@ -208,8 +207,6 @@ function QuerySearch({
 	const lastValueRef = useRef<string>('');
 	const isMountedRef = useRef<boolean>(true);
 
-	const { handleRunQuery } = useQueryBuilder();
-
 	const { selectedDashboard } = useDashboard();
 
 	const dynamicVariables = useMemo(

frontend/src/components/QueryBuilderV2/QueryV2/TraceOperator/TraceOperatorEditor.tsx

@@ -87,7 +87,7 @@ function TraceOperatorEditor({
 	// Track if the query was changed externally (from props) vs internally (user input)
 	const [isExternalQueryChange, setIsExternalQueryChange] = useState(false);
 	const [lastExternalValue, setLastExternalValue] = useState<string>('');
-	const { currentQuery, handleRunQuery } = useQueryBuilder();
+	const { currentQuery } = useQueryBuilder();
 
 	const queryOptions = useMemo(
 		() =>

frontend/src/components/QueryBuilderV2/QueryV2/__tests__/QuerySearch.test.tsx

@@ -5,7 +5,6 @@ import { EditorView } from '@uiw/react-codemirror';
 import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
 import { getValueSuggestions } from 'api/querySuggestions/getValueSuggestion';
 import { initialQueriesMap } from 'constants/queryBuilder';
-import * as UseQBModule from 'hooks/queryBuilder/useQueryBuilder';
 import { fireEvent, render, userEvent, waitFor } from 'tests/test-utils';
 import type { QueryKeyDataSuggestionsProps } from 'types/api/querySuggestions/types';
 import { DataSource } from 'types/common/queryBuilder';
@@ -121,13 +120,8 @@ jest.mock('api/querySuggestions/getValueSuggestion', () => ({
 // Note: We're NOT mocking CodeMirror here - using the real component
 // This provides integration testing with the actual CodeMirror editor
 
-const handleRunQueryMock = ((UseQBModule as unknown) as {
-	handleRunQuery: jest.MockedFunction<() => void>;
-}).handleRunQuery;
-
 const SAMPLE_KEY_TYPING = 'http.';
 const SAMPLE_VALUE_TYPING_INCOMPLETE = "service.name = '";
-const SAMPLE_VALUE_TYPING_COMPLETE = "service.name = 'frontend'";
 const SAMPLE_STATUS_QUERY = "http.status_code = '200'";
 
 describe('QuerySearch (Integration with Real CodeMirror)', () => {

frontend/src/components/QueryBuilderV2/utils.ts

@@ -796,12 +796,12 @@ export const adjustQueryForV5 = (currentQuery: Query): Query => {
 			});
 
 			const {
-				aggregateAttribute,
-				aggregateOperator,
-				timeAggregation,
-				spaceAggregation,
-				reduceTo,
-				filters,
+				aggregateAttribute: _aggregateAttribute,
+				aggregateOperator: _aggregateOperator,
+				timeAggregation: _timeAggregation,
+				spaceAggregation: _spaceAggregation,
+				reduceTo: _reduceTo,
+				filters: _filters,
 				...retainedQuery
 			} = query;
 

frontend/src/components/QuickFilters/QuickFilters.tsx

@@ -303,13 +303,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 								/>
 							);
 						case FiltersType.DURATION:
-							return (
-								<Duration
-									filter={filter}
-									onFilterChange={onFilterChange}
-									source={source}
-								/>
-							);
+							return <Duration filter={filter} onFilterChange={onFilterChange} />;
 						case FiltersType.SLIDER:
 							return <Slider />;
 						// eslint-disable-next-line sonarjs/no-duplicated-branches

frontend/src/container/CreateAlertV2/CreateAlertHeader/__tests__/CreateAlertHeader.test.tsx

@@ -1,7 +1,6 @@
 /* eslint-disable react/jsx-props-no-spreading */
 import { fireEvent, render, screen } from '@testing-library/react';
 import { QueryParams } from 'constants/query';
-import { initialQueriesMap } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { defaultPostableAlertRuleV2 } from 'container/CreateAlertV2/constants';
 import { getCreateAlertLocalStateFromAlertDef } from 'container/CreateAlertV2/utils';

frontend/src/container/DashboardContainer/DashboardDescription/index.tsx

@@ -73,7 +73,7 @@ export function sanitizeDashboardData(
 
 	const updatedVariables = Object.entries(selectedData.variables).reduce(
 		(acc, [key, value]) => {
-			const { selectedValue, ...rest } = value;
+			const { selectedValue: _selectedValue, ...rest } = value;
 			acc[key] = rest;
 			return acc;
 		},

frontend/src/container/FormAlertRules/QuerySection.tsx

@@ -9,10 +9,11 @@ import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
 import { ENTITY_VERSION_V4 } from 'constants/app';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { QBShortcuts } from 'constants/shortcuts/QBShortcuts';
+import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { isEmpty } from 'lodash-es';
-import { Atom, Play, Terminal } from 'lucide-react';
+import { Atom, Terminal } from 'lucide-react';
 import { useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
@@ -165,9 +166,8 @@ function QuerySection({
 							onChange={handleQueryCategoryChange}
 							tabBarExtraContent={
 								<span style={{ display: 'flex', gap: '1rem', alignItems: 'center' }}>
-									<Button
-										type="primary"
-										onClick={(): void => {
+									<RunQueryBtn
+										onStageRunQuery={(): void => {
 											runQuery();
 											logEvent('Alert: Stage and run query', {
 												dataSource: ALERTS_DATA_SOURCE_MAP[alertType],
@@ -176,11 +176,7 @@ function QuerySection({
 												queryType: queryCategory,
 											});
 										}}
-										className="stage-run-query"
-										icon={<Play size={14} />}
-									>
-										Stage & Run Query
-									</Button>
+									/>
 								</span>
 							}
 							items={tabs}
@@ -199,14 +195,7 @@ function QuerySection({
 							onChange={handleQueryCategoryChange}
 							tabBarExtraContent={
 								<span style={{ display: 'flex', gap: '1rem', alignItems: 'center' }}>
-									<Button
-										type="primary"
-										onClick={runQuery}
-										className="stage-run-query"
-										icon={<Play size={14} />}
-									>
-										Stage & Run Query
-									</Button>
+									<RunQueryBtn onStageRunQuery={runQuery} />
 								</span>
 							}
 							items={items}

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -1,14 +1,6 @@
 /* eslint-disable react/display-name */
 import { PlusOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Dropdown,
-	Flex,
-	Input,
-	MenuProps,
-	Tag,
-	Typography,
-} from 'antd';
+import { Button, Flex, Input, Typography } from 'antd';
 import type { ColumnsType } from 'antd/es/table/interface';
 import saveAlertApi from 'api/alerts/save';
 import logEvent from 'api/common/logEvent';

frontend/src/container/MetricsExplorer/Summary/Summary.tsx

@@ -91,7 +91,7 @@ function Summary(): JSX.Element {
 	const queryFiltersWithoutId = useMemo(() => {
 		const filtersWithoutId = {
 			...queryFilters,
-			items: queryFilters.items.map(({ id, ...rest }) => rest),
+			items: queryFilters.items.map(({ id: _id, ...rest }) => rest),
 		};
 		return JSON.stringify(filtersWithoutId);
 	}, [queryFilters]);

frontend/src/container/NewWidget/LeftContainer/QuerySection/index.tsx

@@ -12,6 +12,7 @@ import {
 	getDefaultWidgetData,
 	PANEL_TYPE_TO_QUERY_TYPES,
 } from 'container/NewWidget/utils';
+import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
 // import { QueryBuilder } from 'container/QueryBuilder';
 import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
@@ -20,7 +21,7 @@ import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { defaultTo, isUndefined } from 'lodash-es';
-import { Atom, Play, Terminal } from 'lucide-react';
+import { Atom, Terminal } from 'lucide-react';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import {
 	getNextWidgets,
@@ -28,20 +29,14 @@ import {
 	getSelectedWidgetIndex,
 } from 'providers/Dashboard/util';
 import { useCallback, useEffect, useMemo } from 'react';
-import { UseQueryResult } from 'react-query';
-import { SuccessResponse } from 'types/api';
 import { Widgets } from 'types/api/dashboard/getAll';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 
 import ClickHouseQueryContainer from './QueryBuilder/clickHouse';
 import PromQLQueryContainer from './QueryBuilder/promQL';
 
-function QuerySection({
-	selectedGraph,
-	queryResponse,
-}: QueryProps): JSX.Element {
+function QuerySection({ selectedGraph }: QueryProps): JSX.Element {
 	const {
 		currentQuery,
 		handleRunQuery: handleRunQueryFromQueryBuilder,
@@ -242,15 +237,7 @@ function QuerySection({
 				tabBarExtraContent={
 					<span style={{ display: 'flex', gap: '1rem', alignItems: 'center' }}>
 						<TextToolTip text="This will temporarily save the current query and graph state. This will persist across tab change" />
-						<Button
-							loading={queryResponse.isFetching}
-							type="primary"
-							onClick={handleRunQuery}
-							className="stage-run-query"
-							icon={<Play size={14} />}
-						>
-							Stage & Run Query
-						</Button>
+						<RunQueryBtn label="Stage & Run Query" onStageRunQuery={handleRunQuery} />
 					</span>
 				}
 				items={items}
@@ -261,10 +248,6 @@ function QuerySection({
 
 interface QueryProps {
 	selectedGraph: PANEL_TYPES;
-	queryResponse: UseQueryResult<
-		SuccessResponse<MetricRangePayloadProps, unknown>,
-		Error
-	>;
 }
 
 export default QuerySection;

frontend/src/container/NewWidget/LeftContainer/index.tsx

@@ -64,7 +64,7 @@ function LeftContainer({
 				enableDrillDown={enableDrillDown}
 			/>
 			<QueryContainer className="query-section-left-container">
-				<QuerySection selectedGraph={selectedGraph} queryResponse={queryResponse} />
+				<QuerySection selectedGraph={selectedGraph} />
 				{selectedGraph === PANEL_TYPES.LIST && (
 					<ExplorerColumnsRenderer
 						selectedLogFields={selectedLogFields}

frontend/src/container/QueryBuilder/components/RunQueryBtn/RunQueryBtn.scss

@@ -0,0 +1,37 @@
+.run-query-btn {
+	display: flex;
+	min-width: 132px;
+	align-items: center;
+	gap: 6px;
+
+	.ant-btn-icon {
+		margin: 0 !important;
+	}
+}
+
+.cancel-query-btn {
+	display: flex;
+	min-width: 132px;
+	align-items: center;
+	gap: 6px;
+}
+
+.cmd-hint {
+	display: inline-flex;
+	align-items: center;
+	gap: 2px;
+	padding: 2px 4px;
+	border-radius: 4px;
+	//not using var here to support opacity 60%. To be handled at design system level.
+	background: rgba(35, 38, 46, 0.6);
+	line-height: 1;
+	font-size: 10px;
+}
+
+.lightMode {
+	.cmd-hint {
+		color: var(--bg-ink-200);
+		//not using var here to support opacity 60%. To be handled at design system level.
+		background: rgba(231, 232, 236, 0.8);
+	}
+}

frontend/src/container/QueryBuilder/components/RunQueryBtn/RunQueryBtn.tsx

@@ -0,0 +1,53 @@
+import './RunQueryBtn.scss';
+
+import { Button } from 'antd';
+import {
+	ChevronUp,
+	Command,
+	CornerDownLeft,
+	Loader2,
+	Play,
+} from 'lucide-react';
+import { getUserOperatingSystem, UserOperatingSystem } from 'utils/getUserOS';
+
+interface RunQueryBtnProps {
+	label?: string;
+	isLoadingQueries?: boolean;
+	handleCancelQuery?: () => void;
+	onStageRunQuery?: () => void;
+}
+
+function RunQueryBtn({
+	label,
+	isLoadingQueries,
+	handleCancelQuery,
+	onStageRunQuery,
+}: RunQueryBtnProps): JSX.Element {
+	const isMac = getUserOperatingSystem() === UserOperatingSystem.MACOS;
+	return isLoadingQueries ? (
+		<Button
+			type="default"
+			icon={<Loader2 size={14} className="loading-icon animate-spin" />}
+			className="cancel-query-btn periscope-btn danger"
+			onClick={handleCancelQuery}
+		>
+			Cancel
+		</Button>
+	) : (
+		<Button
+			type="primary"
+			className="run-query-btn periscope-btn primary"
+			disabled={isLoadingQueries || !onStageRunQuery}
+			onClick={onStageRunQuery}
+			icon={<Play size={14} />}
+		>
+			{label || 'Run Query'}
+			<div className="cmd-hint">
+				{isMac ? <Command size={12} /> : <ChevronUp size={12} />}
+				<CornerDownLeft size={12} />
+			</div>
+		</Button>
+	);
+}
+
+export default RunQueryBtn;

frontend/src/container/QueryBuilder/components/RunQueryBtn/__test__/RunQueryBtn.test.tsx

@@ -0,0 +1,82 @@
+// frontend/src/container/QueryBuilder/components/RunQueryBtn/__tests__/RunQueryBtn.test.tsx
+import { fireEvent, render, screen } from '@testing-library/react';
+
+import RunQueryBtn from '../RunQueryBtn';
+
+// Mock OS util
+jest.mock('utils/getUserOS', () => ({
+	getUserOperatingSystem: jest.fn(),
+	UserOperatingSystem: { MACOS: 'mac', WINDOWS: 'win', LINUX: 'linux' },
+}));
+import { getUserOperatingSystem, UserOperatingSystem } from 'utils/getUserOS';
+
+describe('RunQueryBtn', () => {
+	test('renders run state and triggers on click', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.MACOS,
+		);
+		const onRun = jest.fn();
+		render(<RunQueryBtn onStageRunQuery={onRun} />);
+		const btn = screen.getByRole('button', { name: /run query/i });
+		expect(btn).toBeEnabled();
+		fireEvent.click(btn);
+		expect(onRun).toHaveBeenCalledTimes(1);
+	});
+
+	test('disabled when onStageRunQuery is undefined', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.MACOS,
+		);
+		render(<RunQueryBtn />);
+		expect(screen.getByRole('button', { name: /run query/i })).toBeDisabled();
+	});
+
+	test('shows cancel state and calls handleCancelQuery', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.MACOS,
+		);
+		const onCancel = jest.fn();
+		render(<RunQueryBtn isLoadingQueries handleCancelQuery={onCancel} />);
+		const cancel = screen.getByRole('button', { name: /cancel/i });
+		fireEvent.click(cancel);
+		expect(onCancel).toHaveBeenCalledTimes(1);
+	});
+
+	test('shows Command + CornerDownLeft on mac', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.MACOS,
+		);
+		const { container } = render(
+			<RunQueryBtn onStageRunQuery={(): void => {}} />,
+		);
+		expect(container.querySelector('.lucide-command')).toBeInTheDocument();
+		expect(
+			container.querySelector('.lucide-corner-down-left'),
+		).toBeInTheDocument();
+	});
+
+	test('shows ChevronUp + CornerDownLeft on non-mac', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.WINDOWS,
+		);
+		const { container } = render(
+			<RunQueryBtn onStageRunQuery={(): void => {}} />,
+		);
+		expect(container.querySelector('.lucide-chevron-up')).toBeInTheDocument();
+		expect(container.querySelector('.lucide-command')).not.toBeInTheDocument();
+		expect(
+			container.querySelector('.lucide-corner-down-left'),
+		).toBeInTheDocument();
+	});
+
+	test('renders custom label when provided', () => {
+		(getUserOperatingSystem as jest.Mock).mockReturnValue(
+			UserOperatingSystem.MACOS,
+		);
+		const onRun = jest.fn();
+		render(<RunQueryBtn onStageRunQuery={onRun} label="Stage & Run Query" />);
+		expect(
+			screen.getByRole('button', { name: /stage & run query/i }),
+		).toBeInTheDocument();
+	});
+});

frontend/src/container/QueryBuilder/components/ToolbarActions/RightToolbarActions.tsx

@@ -1,12 +1,12 @@
 import './ToolbarActions.styles.scss';
 
-import { Button } from 'antd';
 import { LogsExplorerShortcuts } from 'constants/shortcuts/logsExplorerShortcuts';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
-import { Loader2, Play } from 'lucide-react';
 import { MutableRefObject, useEffect } from 'react';
 import { useQueryClient } from 'react-query';
 
+import RunQueryBtn from '../RunQueryBtn/RunQueryBtn';
+
 interface RightToolbarActionsProps {
 	onStageRunQuery: () => void;
 	isLoadingQueries?: boolean;
@@ -42,14 +42,7 @@ export default function RightToolbarActions({
 	if (showLiveLogs) {
 		return (
 			<div className="right-toolbar-actions-container">
-				<Button
-					type="primary"
-					className="run-query-btn periscope-btn primary"
-					disabled
-					icon={<Play size={14} />}
-				>
-					Run Query
-				</Button>
+				<RunQueryBtn />
 			</div>
 		);
 	}
@@ -65,26 +58,11 @@ export default function RightToolbarActions({
 
 	return (
 		<div className="right-toolbar-actions-container">
-			{isLoadingQueries ? (
-				<Button
-					type="default"
-					icon={<Loader2 size={14} className="loading-icon animate-spin" />}
-					className="cancel-query-btn periscope-btn danger"
-					onClick={handleCancelQuery}
-				>
-					Cancel
-				</Button>
-			) : (
-				<Button
-					type="primary"
-					className="run-query-btn periscope-btn primary"
-					disabled={isLoadingQueries}
-					onClick={onStageRunQuery}
-					icon={<Play size={14} />}
-				>
-					Run Query
-				</Button>
-			)}
+			<RunQueryBtn
+				isLoadingQueries={isLoadingQueries}
+				handleCancelQuery={handleCancelQuery}
+				onStageRunQuery={onStageRunQuery}
+			/>
 		</div>
 	);
 }

frontend/src/container/QueryTable/Drilldown/useAggregateDrilldown.tsx

@@ -136,7 +136,6 @@ const useAggregateDrilldown = ({
 		query,
 		// panelType,
 		aggregateData: aggregateDataWithTimeRange,
-		widgetId,
 		onClose,
 	});
 

frontend/src/container/QueryTable/Drilldown/useDashboardVarConfig.tsx

@@ -17,7 +17,6 @@ interface UseBaseAggregateOptionsProps {
 	query?: Query;
 	// panelType?: PANEL_TYPES;
 	aggregateData?: AggregateData | null;
-	widgetId?: string;
 	onClose: () => void;
 }
 
@@ -27,7 +26,6 @@ const useDashboardVarConfig = ({
 	query,
 	// panelType,
 	aggregateData,
-	widgetId,
 	onClose,
 }: UseBaseAggregateOptionsProps): {
 	dashbaordVariablesConfig: {

frontend/src/container/Toolbar/Toolbar.styles.scss

@@ -19,20 +19,6 @@
 			display: flex;
 			align-items: center;
 			gap: 8px;
-
-			.cancel-query-btn {
-				min-width: 96px;
-				display: flex;
-				align-items: center;
-				gap: 2px;
-			}
-
-			.run-query-btn {
-				min-width: 96px;
-				display: flex;
-				align-items: center;
-				gap: 2px;
-			}
 		}
 	}
 

frontend/src/hooks/TracesFunnels/useFunnelConfiguration.tsx

@@ -31,8 +31,8 @@ export const normalizeSteps = (steps: FunnelStepData[]): FunnelStepData[] => {
 			...step.filters,
 			items: step.filters.items.map((item) => {
 				const {
-					id: unusedId,
-					isIndexed,
+					id: _unusedId,
+					isIndexed: _isIndexed,
 					...keyObj
 				} = item.key as BaseAutocompleteData;
 				return {

frontend/src/hooks/TracesFunnels/useFunnels.tsx

@@ -143,7 +143,7 @@ export const useValidateFunnelSteps = ({
 			selectedTime,
 			steps.map((step) => {
 				// eslint-disable-next-line @typescript-eslint/naming-convention
-				const { latency_type, ...rest } = step;
+				const { latency_type: _latency_type, ...rest } = step;
 				return rest;
 			}),
 		],

frontend/src/pages/MessagingQueues/MQDetails/MQTables/MQTables.tsx

@@ -9,7 +9,6 @@ import {
 	MessagingQueuesPayloadProps,
 } from 'api/messagingQueues/getConsumerLagDetails';
 import axios from 'axios';
-import { isNumber } from 'chart.js/helpers';
 import cx from 'classnames';
 import { ColumnTypeRender } from 'components/Logs/TableView/types';
 import { SOMETHING_WENT_WRONG } from 'constants/api';

frontend/src/pages/MessagingQueues/MessagingQueuesUtils.ts

@@ -275,7 +275,7 @@ export function setConfigDetail(
 	},
 ): void {
 	// remove "key" and its value from the paramsToSet object
-	const { key, ...restParamsToSet } = paramsToSet || {};
+	const { key: _key, ...restParamsToSet } = paramsToSet || {};
 
 	if (!isEmpty(restParamsToSet)) {
 		const configDetail = {

frontend/src/pages/TracesExplorer/Filter/filterUtils.ts

@@ -145,7 +145,7 @@ export const removeFilter = (
 		const updatedValues = prevValue.filter((item: any) => item !== value);
 
 		if (updatedValues.length === 0) {
-			const { [filterType]: item, ...remainingFilters } = prevFilters;
+			const { [filterType]: _item, ...remainingFilters } = prevFilters;
 			return Object.keys(remainingFilters).length > 0
 				? (remainingFilters as FilterType)
 				: undefined;
@@ -175,7 +175,7 @@ export const removeAllFilters = (
 			return prevFilters;
 		}
 
-		const { [filterType]: item, ...remainingFilters } = prevFilters;
+		const { [filterType]: _item, ...remainingFilters } = prevFilters;
 
 		return Object.keys(remainingFilters).length > 0
 			? (remainingFilters as Record<

pkg/modules/thirdpartyapi/translator.go

@@ -81,8 +81,10 @@ func FilterIntermediateColumns(result *qbtypes.QueryRangeResponse) *qbtypes.Quer
 		// Filter out columns for intermediate queries used only in formulas
 		filteredColumns := make([]*qbtypes.ColumnDescriptor, 0)
 		intermediateQueryNames := map[string]bool{
-			"error":      true,
-			"total_span": true,
+			"error":             true,
+			"total_span":        true,
+			"endpoints_current": true,
+			"endpoints_legacy":  true,
 		}
 
 		columnIndices := make([]int, 0)
@@ -296,15 +298,15 @@ func BuildDomainList(req *thirdpartyapitypes.ThirdPartyApiRequest) (*qbtypes.Que
 		return nil, err
 	}
 
-	queries := []qbtypes.QueryEnvelope{
-		buildEndpointsQuery(req),
+	queries := buildEndpointsQueries(req)
+	queries = append(queries,
 		buildLastSeenQuery(req),
 		buildRpsQuery(req),
 		buildErrorQuery(req),
 		buildTotalSpanQuery(req),
 		buildP99Query(req),
 		buildErrorRateFormula(),
-	}
+	)
 
 	return &qbtypes.QueryRangeRequest{
 		SchemaVersion: "v5",
@@ -346,20 +348,58 @@ func BuildDomainInfo(req *thirdpartyapitypes.ThirdPartyApiRequest) (*qbtypes.Que
 	}, nil
 }
 
-func buildEndpointsQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.QueryEnvelope {
-	return qbtypes.QueryEnvelope{
+// buildEndpointsQueries returns queries for counting distinct URLs with semconv fallback.
+// It uses two queries with mutually exclusive filters:
+// - endpoints_current: count_distinct(url.full) WHERE url.full EXISTS
+// - endpoints_legacy: count_distinct(http.url) WHERE url.full NOT EXISTS
+// And a formula to combine them: endpoints_current + endpoints_legacy
+func buildEndpointsQueries(req *thirdpartyapitypes.ThirdPartyApiRequest) []qbtypes.QueryEnvelope {
+	// Query for current semconv (url.full)
+	currentFilter := buildBaseFilter(req.Filter)
+	currentFilter.Expression = fmt.Sprintf("(%s) AND %s EXISTS", currentFilter.Expression, urlPathKey)
+
+	endpointsCurrent := qbtypes.QueryEnvelope{
 		Type: qbtypes.QueryTypeBuilder,
 		Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
-			Name:         "endpoints",
+			Name:         "endpoints_current",
 			Signal:       telemetrytypes.SignalTraces,
 			StepInterval: qbtypes.Step{Duration: defaultStepInterval},
 			Aggregations: []qbtypes.TraceAggregation{
-				{Expression: "count_distinct(http.url)"},
+				{Expression: fmt.Sprintf("count_distinct(%s)", urlPathKey)},
 			},
-			Filter:  buildBaseFilter(req.Filter),
+			Filter:  currentFilter,
 			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
+
+	// Query for legacy semconv (http.url) - only when url.full doesn't exist
+	legacyFilter := buildBaseFilter(req.Filter)
+	legacyFilter.Expression = fmt.Sprintf("(%s) AND %s NOT EXISTS", legacyFilter.Expression, urlPathKey)
+
+	endpointsLegacy := qbtypes.QueryEnvelope{
+		Type: qbtypes.QueryTypeBuilder,
+		Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
+			Name:         "endpoints_legacy",
+			Signal:       telemetrytypes.SignalTraces,
+			StepInterval: qbtypes.Step{Duration: defaultStepInterval},
+			Aggregations: []qbtypes.TraceAggregation{
+				{Expression: fmt.Sprintf("count_distinct(%s)", urlPathKeyLegacy)},
+			},
+			Filter:  legacyFilter,
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
+		},
+	}
+
+	// Formula to combine both counts
+	endpointsFormula := qbtypes.QueryEnvelope{
+		Type: qbtypes.QueryTypeFormula,
+		Spec: qbtypes.QueryBuilderFormula{
+			Name:       "endpoints",
+			Expression: "endpoints_current + endpoints_legacy",
+		},
+	}
+
+	return []qbtypes.QueryEnvelope{endpointsCurrent, endpointsLegacy, endpointsFormula}
 }
 
 func buildLastSeenQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.QueryEnvelope {