chore: address review comments

frontend/public/locales/en-GB/titles.json

@@ -46,5 +46,8 @@
 	"ALERT_HISTORY": "SigNoz | Alert Rule History",
 	"ALERT_OVERVIEW": "SigNoz | Alert Rule Overview",
 	"INFRASTRUCTURE_MONITORING_HOSTS": "SigNoz | Infra Monitoring",
-	"INFRASTRUCTURE_MONITORING_KUBERNETES": "SigNoz | Infra Monitoring"
+	"INFRASTRUCTURE_MONITORING_KUBERNETES": "SigNoz | Infra Monitoring",
+	"METER_EXPLORER": "SigNoz | Meter Explorer",
+	"METER_EXPLORER_VIEWS": "SigNoz | Meter Explorer",
+	"METER_EXPLORER_BASE": "SigNoz | Meter Explorer"
 }

frontend/public/locales/en/titles.json

@@ -69,5 +69,8 @@
 	"METRICS_EXPLORER": "SigNoz | Metrics Explorer",
 	"METRICS_EXPLORER_EXPLORER": "SigNoz | Metrics Explorer",
 	"METRICS_EXPLORER_VIEWS": "SigNoz | Metrics Explorer",
-	"API_MONITORING": "SigNoz | External APIs"
+	"API_MONITORING": "SigNoz | External APIs",
+	"METER_EXPLORER": "SigNoz | Meter Explorer",
+	"METER_EXPLORER_VIEWS": "SigNoz | Meter Explorer",
+	"METER_EXPLORER_BASE": "SigNoz | Meter Explorer"
 }

frontend/src/AppRoutes/routes.ts

@@ -1,5 +1,6 @@
 import ROUTES from 'constants/routes';
 import MessagingQueues from 'pages/MessagingQueues';
+import MeterExplorer from 'pages/MeterExplorer';
 import { RouteProps } from 'react-router-dom';
 
 import {
@@ -434,6 +435,28 @@ const routes: AppRoutes[] = [
 		key: 'METRICS_EXPLORER_VIEWS',
 		isPrivate: true,
 	},
+
+	{
+		path: ROUTES.METER_EXPLORER_BASE,
+		exact: true,
+		component: MeterExplorer,
+		key: 'METER_EXPLORER_BASE',
+		isPrivate: true,
+	},
+	{
+		path: ROUTES.METER_EXPLORER,
+		exact: true,
+		component: MeterExplorer,
+		key: 'METER_EXPLORER',
+		isPrivate: true,
+	},
+	{
+		path: ROUTES.METER_EXPLORER_VIEWS,
+		exact: true,
+		component: MeterExplorer,
+		key: 'METER_EXPLORER_VIEWS',
+		isPrivate: true,
+	},
 	{
 		path: ROUTES.API_MONITORING,
 		exact: true,

frontend/src/api/queryBuilder/getAggregateAttribute.ts

@@ -17,6 +17,7 @@ export const getAggregateAttribute = async ({
 	aggregateOperator,
 	searchText,
 	dataSource,
+	source,
 }: IGetAggregateAttributePayload): Promise<
 	SuccessResponse<IQueryAutocompleteResponse> | ErrorResponse
 > => {
@@ -27,7 +28,7 @@ export const getAggregateAttribute = async ({
 			`/autocomplete/aggregate_attributes?${createQueryParams({
 				aggregateOperator,
 				searchText,
-				dataSource,
+				dataSource: source === 'meter' ? 'meter' : dataSource,
 			})}`,
 		);
 

frontend/src/api/querySuggestions/getKeySuggestions.ts

@@ -14,6 +14,7 @@ export const getKeySuggestions = (
 		metricName = '',
 		fieldContext = '',
 		fieldDataType = '',
+		signalSource = '',
 	} = props;
 
 	const encodedSignal = encodeURIComponent(signal);
@@ -21,8 +22,9 @@ export const getKeySuggestions = (
 	const encodedMetricName = encodeURIComponent(metricName);
 	const encodedFieldContext = encodeURIComponent(fieldContext);
 	const encodedFieldDataType = encodeURIComponent(fieldDataType);
+	const encodedSource = encodeURIComponent(signalSource);
 
 	return axios.get(
-		`/fields/keys?signal=${encodedSignal}&searchText=${encodedSearchText}&metricName=${encodedMetricName}&fieldContext=${encodedFieldContext}&fieldDataType=${encodedFieldDataType}`,
+		`/fields/keys?signal=${encodedSignal}&searchText=${encodedSearchText}&metricName=${encodedMetricName}&fieldContext=${encodedFieldContext}&fieldDataType=${encodedFieldDataType}&source=${encodedSource}`,
 	);
 };

frontend/src/api/querySuggestions/getValueSuggestion.ts

@@ -8,13 +8,14 @@ import {
 export const getValueSuggestions = (
 	props: QueryKeyValueRequestProps,
 ): Promise<AxiosResponse<QueryKeyValueSuggestionsResponseProps>> => {
-	const { signal, key, searchText } = props;
+	const { signal, key, searchText, signalSource } = props;
 
 	const encodedSignal = encodeURIComponent(signal);
 	const encodedKey = encodeURIComponent(key);
 	const encodedSearchText = encodeURIComponent(searchText);
+	const encodedSource = encodeURIComponent(signalSource || '');
 
 	return axios.get(
-		`/fields/values?signal=${encodedSignal}&name=${encodedKey}&searchText=${encodedSearchText}`,
+		`/fields/values?signal=${encodedSignal}&name=${encodedKey}&searchText=${encodedSearchText}&source=${encodedSource}`,
 	);
 };

frontend/src/api/saveView/getAllViews.ts

@@ -4,6 +4,6 @@ import { AllViewsProps } from 'types/api/saveViews/types';
 import { DataSource } from 'types/common/queryBuilder';
 
 export const getAllViews = (
-	sourcepage: DataSource,
+	sourcepage: DataSource | 'meter',
 ): Promise<AxiosResponse<AllViewsProps>> =>
 	axios.get(`/explorer/views?sourcePage=${sourcepage}`);

frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.ts

@@ -260,6 +260,7 @@ export function convertBuilderQueriesToV5(
 					spec = {
 						name: queryName,
 						signal: 'metrics' as const,
+						source: queryData.source || '',
 						...baseSpec,
 						aggregations: aggregations as MetricAggregation[],
 						// reduceTo: queryData.reduceTo,

frontend/src/components/PanelDataLoading/PanelDataLoading.styles.scss

@@ -0,0 +1,19 @@
+.loading-panel-data {
+	padding: 24px 0;
+	height: 240px;
+
+	display: flex;
+	justify-content: center;
+	align-items: flex-start;
+
+	.loading-panel-data-content {
+		display: flex;
+		align-items: flex-start;
+		flex-direction: column;
+
+		.loading-gif {
+			height: 72px;
+			margin-left: -24px;
+		}
+	}
+}

frontend/src/components/PanelDataLoading/PanelDataLoading.tsx

@@ -0,0 +1,19 @@
+import './PanelDataLoading.styles.scss';
+
+import { Typography } from 'antd';
+
+export function PanelDataLoading(): JSX.Element {
+	return (
+		<div className="loading-panel-data">
+			<div className="loading-panel-data-content">
+				<img
+					className="loading-gif"
+					src="/Icons/loading-plane.gif"
+					alt="wait-icon"
+				/>
+
+				<Typography.Text>Fetching data...</Typography.Text>
+			</div>
+		</div>
+	);
+}

frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx

@@ -131,6 +131,7 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 								queryVariant={config?.queryVariant || 'dropdown'}
 								showOnlyWhereClause={showOnlyWhereClause}
 								isListViewPanel={isListViewPanel}
+								signalSource={config?.signalSource || ''}
 							/>
 						))}
 

frontend/src/components/QueryBuilderV2/QueryV2/MerticsAggregateSection/MetricsAggregateSection.tsx

@@ -18,11 +18,13 @@ const MetricsAggregateSection = memo(function MetricsAggregateSection({
 	index,
 	version,
 	panelType,
+	signalSource = '',
 }: {
 	query: IBuilderQuery;
 	index: number;
 	version: string;
 	panelType: PANEL_TYPES | null;
+	signalSource: string;
 }): JSX.Element {
 	const { setAggregationOptions } = useQueryBuilderV2Context();
 	const {
@@ -208,6 +210,7 @@ const MetricsAggregateSection = memo(function MetricsAggregateSection({
 										disabled={!queryAggregation.metricName}
 										query={query}
 										onChange={handleChangeGroupByKeys}
+										signalSource={signalSource}
 									/>
 								</div>
 							</div>
@@ -244,6 +247,7 @@ const MetricsAggregateSection = memo(function MetricsAggregateSection({
 									disabled={!queryAggregation.metricName}
 									query={query}
 									onChange={handleChangeGroupByKeys}
+									signalSource={signalSource}
 								/>
 							</div>
 						</div>

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

@@ -9,10 +9,12 @@ export const MetricsSelect = memo(function MetricsSelect({
 	query,
 	index,
 	version,
+	signalSource,
 }: {
 	query: IBuilderQuery;
 	index: number;
 	version: string;
+	signalSource: 'meter' | '';
 }): JSX.Element {
 	const { handleChangeAggregatorAttribute } = useQueryOperations({
 		index,
@@ -26,6 +28,7 @@ export const MetricsSelect = memo(function MetricsSelect({
 				onChange={handleChangeAggregatorAttribute}
 				query={query}
 				index={index}
+				signalSource={signalSource || ''}
 			/>
 		</div>
 	);

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

@@ -81,10 +81,12 @@ function QuerySearch({
 	queryData,
 	dataSource,
 	onRun,
+	signalSource,
 }: {
 	onChange: (value: string) => void;
 	queryData: IBuilderQuery;
 	dataSource: DataSource;
+	signalSource?: string;
 	onRun?: (query: string) => void;
 }): JSX.Element {
 	const isDarkMode = useIsDarkMode();
@@ -214,6 +216,7 @@ function QuerySearch({
 				signal: dataSource,
 				searchText: searchText || '',
 				metricName: debouncedMetricName ?? undefined,
+				signalSource: signalSource as 'meter' | '',
 			});
 
 			if (response.data.data) {
@@ -241,6 +244,7 @@ function QuerySearch({
 			keySuggestions,
 			toggleSuggestions,
 			queryData.aggregateAttribute?.key,
+			signalSource,
 		],
 	);
 
@@ -374,6 +378,7 @@ function QuerySearch({
 					key,
 					searchText: sanitizedSearchText,
 					signal: dataSource,
+					signalSource: signalSource as 'meter' | '',
 				});
 
 				// Skip updates if component unmounted or key changed
@@ -461,8 +466,13 @@ function QuerySearch({
 				setIsFetchingCompleteValuesList(false);
 			}
 		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[activeKey, dataSource, isFocused],
+		[
+			activeKey,
+			dataSource,
+			isLoadingSuggestions,
+			signalSource,
+			toggleSuggestions,
+		],
 	);
 
 	const debouncedFetchValueSuggestions = useMemo(
@@ -1436,6 +1446,7 @@ function QuerySearch({
 
 QuerySearch.defaultProps = {
 	onRun: undefined,
+	signalSource: '',
 };
 
 export default QuerySearch;

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

@@ -28,6 +28,7 @@ export const QueryV2 = memo(function QueryV2({
 	isListViewPanel = false,
 	version,
 	showOnlyWhereClause = false,
+	signalSource = '',
 }: QueryProps & { ref: React.RefObject<HTMLDivElement> }): JSX.Element {
 	const { cloneQuery, panelType } = useQueryBuilder();
 
@@ -175,6 +176,7 @@ export const QueryV2 = memo(function QueryV2({
 										query={query}
 										index={index}
 										version={ENTITY_VERSION_V5}
+										signalSource={signalSource as 'meter' | ''}
 									/>
 								</div>
 							)}
@@ -186,6 +188,7 @@ export const QueryV2 = memo(function QueryV2({
 										onChange={handleSearchChange}
 										queryData={query}
 										dataSource={dataSource}
+										signalSource={signalSource}
 									/>
 								</div>
 
@@ -218,6 +221,7 @@ export const QueryV2 = memo(function QueryV2({
 								index={index}
 								key={`metrics-aggregate-section-${query.queryName}-${query.dataSource}`}
 								version="v4"
+								signalSource={signalSource as 'meter' | ''}
 							/>
 						)}
 

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.tsx

@@ -17,6 +17,7 @@ import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
 import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
 import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useGetQueryKeyValueSuggestions } from 'hooks/querySuggestions/useGetQueryKeyValueSuggestions';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { cloneDeep, isArray, isEqual, isFunction } from 'lodash-es';
 import { ChevronDown, ChevronRight } from 'lucide-react';
@@ -73,18 +74,59 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 			searchText: searchText ?? '',
 		},
 		{
-			enabled: isOpen,
+			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
 			keepPreviousData: true,
 		},
 	);
 
+	const {
+		data: keyValueSuggestions,
+		isLoading: isLoadingKeyValueSuggestions,
+	} = useGetQueryKeyValueSuggestions({
+		key: filter.attributeKey.key,
+		signal: filter.dataSource || DataSource.LOGS,
+		signalSource: 'meter',
+		options: {
+			enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
+			keepPreviousData: true,
+		},
+	});
+
 	const attributeValues: string[] = useMemo(() => {
 		const dataType = filter.attributeKey.dataType || DataTypes.String;
+
+		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
+			// Process the response data
+			const responseData = keyValueSuggestions?.data as any;
+			const values = responseData.data?.values || {};
+			const stringValues = values.stringValues || [];
+			const numberValues = values.numberValues || [];
+
+			// Generate options from string values - explicitly handle empty strings
+			const stringOptions = stringValues
+				// Strict filtering for empty string - we'll handle it as a special case if needed
+				.filter(
+					(value: string | null | undefined): value is string =>
+						value !== null && value !== undefined && value !== '',
+				);
+
+			// Generate options from number values
+			const numberOptions = numberValues
+				.filter(
+					(value: number | null | undefined): value is number =>
+						value !== null && value !== undefined,
+				)
+				.map((value: number) => value.toString());
+
+			// Combine all options and make sure we don't have duplicate labels
+			return [...stringOptions, ...numberOptions];
+		}
+
 		const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
 		return (data?.payload?.[key] || []).filter(
 			(val) => val !== undefined && val !== null,
 		);
-	}, [data?.payload, filter.attributeKey.dataType]);
+	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
 
 	const currentAttributeKeys = attributeValues.slice(0, visibleItemsCount);
 
@@ -478,12 +520,14 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 					)}
 				</section>
 			</section>
-			{isOpen && isLoading && !attributeValues.length && (
-				<section className="loading">
-					<Skeleton paragraph={{ rows: 4 }} />
-				</section>
-			)}
-			{isOpen && !isLoading && (
+			{isOpen &&
+				(isLoading || isLoadingKeyValueSuggestions) &&
+				!attributeValues.length && (
+					<section className="loading">
+						<Skeleton paragraph={{ rows: 4 }} />
+					</section>
+				)}
+			{isOpen && !isLoading && !isLoadingKeyValueSuggestions && (
 				<>
 					{!isEmptyStateWithDocsEnabled && (
 						<section className="search">

frontend/src/components/QuickFilters/QuickFilters.styles.scss

@@ -1,6 +1,8 @@
 .quick-filters-container {
 	display: flex;
 	height: 100%;
+	position: relative;
+
 	.quick-filters-settings-container {
 		position: relative;
 	}
@@ -102,6 +104,37 @@
 			margin: 8px 12px;
 		}
 	}
+
+	.no-filters-container {
+		display: flex;
+		height: 100%;
+		gap: 8px;
+		align-items: center;
+		padding: 8px;
+	}
+}
+
+.perilin-bg {
+	position: absolute;
+	top: 0;
+	left: 0;
+	width: 100%;
+	height: 100%;
+
+	background: radial-gradient(circle, #fff 10%, transparent 0);
+	background-size: 12px 12px;
+	opacity: 1;
+
+	mask-image: radial-gradient(
+		circle at 50% 0,
+		rgba(11, 12, 14, 0.1) 0,
+		rgba(11, 12, 14, 0) 100%
+	);
+	-webkit-mask-image: radial-gradient(
+		circle at 50% 0,
+		rgba(11, 12, 14, 0.1) 0,
+		rgba(11, 12, 14, 0) 100%
+	);
 }
 
 .lightMode {

frontend/src/components/QuickFilters/QuickFilters.tsx

@@ -15,7 +15,7 @@ import { LOCALSTORAGE } from 'constants/localStorage';
 import { useApiMonitoringParams } from 'container/ApiMonitoring/queryParams';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { cloneDeep, isFunction, isNull } from 'lodash-es';
-import { Settings2 as SettingsIcon } from 'lucide-react';
+import { Frown, Settings2 as SettingsIcon } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { useMemo, useState } from 'react';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
@@ -236,6 +236,13 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 											);
 									}
 								})}
+
+								{filterConfig.length === 0 && (
+									<div className="no-filters-container">
+										<Frown size={16} />
+										<Typography.Text>No filters found</Typography.Text>
+									</div>
+								)}
 							</section>
 						</>
 					</OverlayScrollbar>

frontend/src/components/QuickFilters/QuickFiltersSettings/constants.ts

@@ -6,4 +6,5 @@ export const SIGNAL_DATA_SOURCE_MAP = {
 	[SignalType.TRACES]: DataSource.TRACES,
 	[SignalType.EXCEPTIONS]: DataSource.TRACES,
 	[SignalType.API_MONITORING]: DataSource.TRACES,
+	[SignalType.METER_EXPLORER]: DataSource.METRICS,
 };

frontend/src/components/QuickFilters/types.ts

@@ -23,6 +23,7 @@ export enum SignalType {
 	LOGS = 'logs',
 	API_MONITORING = 'api_monitoring',
 	EXCEPTIONS = 'exceptions',
+	METER_EXPLORER = 'meter_explorer',
 }
 
 export interface IQuickFiltersConfig {
@@ -53,4 +54,5 @@ export enum QuickFiltersSource {
 	TRACES_EXPLORER = 'traces-explorer',
 	API_MONITORING = 'api-monitoring',
 	EXCEPTIONS = 'exceptions',
+	METER_EXPLORER = 'meter-explorer',
 }

frontend/src/constants/queryBuilder.ts

@@ -23,6 +23,7 @@ import {
 	BoolOperators,
 	DataSource,
 	LogsAggregatorOperator,
+	MeterAggregateOperator,
 	MetricAggregateOperator,
 	NumberOperators,
 	QueryAdditionalFilter,
@@ -36,6 +37,7 @@ import { v4 as uuid } from 'uuid';
 
 import {
 	logsAggregateOperatorOptions,
+	meterAggregateOperatorOptions,
 	metricAggregateOperatorOptions,
 	metricsGaugeAggregateOperatorOptions,
 	metricsGaugeSpaceAggregateOperatorOptions,
@@ -79,6 +81,7 @@ export const mapOfOperators = {
 	metrics: metricAggregateOperatorOptions,
 	logs: logsAggregateOperatorOptions,
 	traces: tracesAggregateOperatorOptions,
+	meter: meterAggregateOperatorOptions,
 };
 
 export const metricsOperatorsByType = {
@@ -193,6 +196,7 @@ export const initialQueryBuilderFormValues: IBuilderQuery = {
 	groupBy: [],
 	legend: '',
 	reduceTo: 'avg',
+	source: '',
 };
 
 const initialQueryBuilderFormLogsValues: IBuilderQuery = {
@@ -209,6 +213,39 @@ const initialQueryBuilderFormTracesValues: IBuilderQuery = {
 	dataSource: DataSource.TRACES,
 };
 
+export const initialQueryBuilderFormMeterValues: IBuilderQuery = {
+	dataSource: DataSource.METRICS,
+	queryName: createNewBuilderItemName({ existNames: [], sourceNames: alphabet }),
+	aggregateOperator: MeterAggregateOperator.COUNT,
+	aggregateAttribute: initialAutocompleteData,
+	timeAggregation: MeterAggregateOperator.RATE,
+	spaceAggregation: MeterAggregateOperator.SUM,
+	filter: { expression: '' },
+	aggregations: [
+		{
+			metricName: '',
+			temporality: '',
+			timeAggregation: MeterAggregateOperator.COUNT,
+			spaceAggregation: MeterAggregateOperator.SUM,
+			reduceTo: 'avg',
+		},
+	],
+	functions: [],
+	filters: { items: [], op: 'AND' },
+	expression: createNewBuilderItemName({
+		existNames: [],
+		sourceNames: alphabet,
+	}),
+	disabled: false,
+	stepInterval: undefined,
+	having: [],
+	limit: null,
+	orderBy: [],
+	groupBy: [],
+	legend: '',
+	reduceTo: 'avg',
+};
+
 export const initialQueryBuilderFormValuesMap: Record<
 	DataSource,
 	IBuilderQuery
@@ -285,6 +322,19 @@ export const initialQueriesMap: Record<DataSource, Query> = {
 	traces: initialQueryTracesWithType,
 };
 
+export const initialQueryMeterWithType: Query = {
+	...initialQueryWithType,
+	builder: {
+		...initialQueryWithType.builder,
+		queryData: [
+			{
+				...initialQueryBuilderFormValuesMap.metrics,
+				source: 'meter',
+			},
+		],
+	},
+};
+
 export const operatorsByTypes: Record<LocalDataType, string[]> = {
 	string: Object.values(StringOperators),
 	number: Object.values(NumberOperators),

frontend/src/constants/queryBuilderOperators.ts

@@ -125,6 +125,126 @@ export const metricAggregateOperatorOptions: SelectOption<string, string>[] = [
 	},
 ];
 
+export const meterAggregateOperatorOptions: SelectOption<string, string>[] = [
+	{
+		value: MetricAggregateOperator.COUNT,
+		label: 'Count',
+	},
+	{
+		value: MetricAggregateOperator.COUNT_DISTINCT,
+		// eslint-disable-next-line sonarjs/no-duplicate-string
+		label: 'Count Distinct',
+	},
+	{
+		value: MetricAggregateOperator.SUM,
+		label: 'Sum',
+	},
+	{
+		value: MetricAggregateOperator.AVG,
+		label: 'Avg',
+	},
+	{
+		value: MetricAggregateOperator.MAX,
+		label: 'Max',
+	},
+	{
+		value: MetricAggregateOperator.MIN,
+		label: 'Min',
+	},
+	{
+		value: MetricAggregateOperator.P05,
+		label: 'P05',
+	},
+	{
+		value: MetricAggregateOperator.P10,
+		label: 'P10',
+	},
+	{
+		value: MetricAggregateOperator.P20,
+		label: 'P20',
+	},
+	{
+		value: MetricAggregateOperator.P25,
+		label: 'P25',
+	},
+	{
+		value: MetricAggregateOperator.P50,
+		label: 'P50',
+	},
+	{
+		value: MetricAggregateOperator.P75,
+		label: 'P75',
+	},
+	{
+		value: MetricAggregateOperator.P90,
+		label: 'P90',
+	},
+	{
+		value: MetricAggregateOperator.P95,
+		label: 'P95',
+	},
+	{
+		value: MetricAggregateOperator.P99,
+		label: 'P99',
+	},
+	{
+		value: MetricAggregateOperator.RATE,
+		label: 'Rate',
+	},
+	{
+		value: MetricAggregateOperator.SUM_RATE,
+		label: 'Sum_rate',
+	},
+	{
+		value: MetricAggregateOperator.AVG_RATE,
+		label: 'Avg_rate',
+	},
+	{
+		value: MetricAggregateOperator.MAX_RATE,
+		label: 'Max_rate',
+	},
+	{
+		value: MetricAggregateOperator.MIN_RATE,
+		label: 'Min_rate',
+	},
+	{
+		value: MetricAggregateOperator.RATE_SUM,
+		label: 'Rate_sum',
+	},
+	{
+		value: MetricAggregateOperator.RATE_AVG,
+		label: 'Rate_avg',
+	},
+	{
+		value: MetricAggregateOperator.RATE_MIN,
+		label: 'Rate_min',
+	},
+	{
+		value: MetricAggregateOperator.RATE_MAX,
+		label: 'Rate_max',
+	},
+	{
+		value: MetricAggregateOperator.HIST_QUANTILE_50,
+		label: 'Hist_quantile_50',
+	},
+	{
+		value: MetricAggregateOperator.HIST_QUANTILE_75,
+		label: 'Hist_quantile_75',
+	},
+	{
+		value: MetricAggregateOperator.HIST_QUANTILE_90,
+		label: 'Hist_quantile_90',
+	},
+	{
+		value: MetricAggregateOperator.HIST_QUANTILE_95,
+		label: 'Hist_quantile_95',
+	},
+	{
+		value: MetricAggregateOperator.HIST_QUANTILE_99,
+		label: 'Hist_quantile_99',
+	},
+];
+
 export const tracesAggregateOperatorOptions: SelectOption<string, string>[] = [
 	{
 		value: TracesAggregatorOperator.COUNT,

frontend/src/constants/routes.ts

@@ -77,6 +77,9 @@ const ROUTES = {
 	API_MONITORING: '/api-monitoring/explorer',
 	METRICS_EXPLORER_BASE: '/metrics-explorer',
 	WORKSPACE_ACCESS_RESTRICTED: '/workspace-access-restricted',
+	METER_EXPLORER_BASE: '/meter-explorer',
+	METER_EXPLORER: '/meter-explorer',
+	METER_EXPLORER_VIEWS: '/meter-explorer/views',
 	HOME_PAGE: '/',
 } as const;
 

frontend/src/container/ExplorerOptions/ExplorerOptionWrapper.tsx

@@ -16,6 +16,7 @@ function ExplorerOptionWrapper({
 	sourcepage,
 	isOneChartPerQuery,
 	splitedQueries,
+	signalSource,
 }: ExplorerOptionsWrapperProps): JSX.Element {
 	const [isExplorerOptionHidden, setIsExplorerOptionHidden] = useState(false);
 
@@ -32,6 +33,7 @@ function ExplorerOptionWrapper({
 			isLoading={isLoading}
 			onExport={onExport}
 			sourcepage={sourcepage}
+			signalSource={signalSource}
 			isExplorerOptionHidden={isExplorerOptionHidden}
 			setIsExplorerOptionHidden={setIsExplorerOptionHidden}
 			isOneChartPerQuery={isOneChartPerQuery}

frontend/src/container/ExplorerOptions/ExplorerOptions.styles.scss

@@ -1,12 +1,12 @@
 .explorer-options-container {
 	position: fixed;
-	bottom: 24px;
+	bottom: 8px;
 	left: calc(50% + 240px);
 	transform: translate(calc(-50% - 120px), 0);
 	transition: left 0.2s linear;
 
 	display: flex;
-	gap: 16px;
+	gap: 8px;
 	background-color: transparent;
 
 	.multi-alert-button,
@@ -33,11 +33,12 @@
 	display: inline-flex;
 	align-items: center;
 	gap: 12px;
-	padding: 10px 10px;
-	border-radius: 50px;
-	border: 1px solid var(--bg-slate-400);
+	padding: 10px 12px;
 	background: rgba(22, 24, 29, 0.6);
+	border: 1px solid var(--bg-slate-500);
+	border-radius: 4px;
 	backdrop-filter: blur(20px);
+	box-sizing: border-box;
 
 	.action-icon {
 		display: flex;
@@ -64,9 +65,9 @@
 
 .explorer-options {
 	padding: 10px 12px;
-	border: 1px solid var(--bg-slate-400);
-	border-radius: 50px;
-	background: rgba(22, 24, 29, 0.6);
+	border-radius: 4px;
+	border: 1px solid var(--bg-slate-500);
+	background: var(--bg-ink-400);
 	backdrop-filter: blur(20px);
 
 	cursor: default;

frontend/src/container/ExplorerOptions/ExplorerOptions.tsx

@@ -93,6 +93,7 @@ function ExplorerOptions({
 	onExport,
 	query,
 	sourcepage,
+	signalSource,
 	isExplorerOptionHidden = false,
 	setIsExplorerOptionHidden,
 	isOneChartPerQuery = false,
@@ -110,6 +111,7 @@ function ExplorerOptions({
 
 	const isLogsExplorer = sourcepage === DataSource.LOGS;
 	const isMetricsExplorer = sourcepage === DataSource.METRICS;
+	const isMeterExplorer = signalSource === 'meter';
 
 	const PRESERVED_VIEW_LOCAL_STORAGE_KEY = LOCALSTORAGE.LAST_USED_SAVED_VIEWS;
 
@@ -120,8 +122,11 @@ function ExplorerOptions({
 		if (isMetricsExplorer) {
 			return PreservedViewsTypes.METRICS;
 		}
+		if (isMeterExplorer) {
+			return PreservedViewsTypes.METER;
+		}
 		return PreservedViewsTypes.TRACES;
-	}, [isLogsExplorer, isMetricsExplorer]);
+	}, [isLogsExplorer, isMetricsExplorer, isMeterExplorer]);
 
 	const onModalToggle = useCallback((value: boolean) => {
 		setIsExport(value);
@@ -150,6 +155,10 @@ function ExplorerOptions({
 				[MetricsExplorerEventKeys.OneChartPerQueryEnabled]: isOneChartPerQuery,
 				panelType,
 			});
+		} else if (isMeterExplorer) {
+			logEvent('Meter Explorer: Save view clicked', {
+				panelType,
+			});
 		}
 		setIsSaveModalOpen(!isSaveModalOpen);
 	};
@@ -243,7 +252,7 @@ function ExplorerOptions({
 		error,
 		isRefetching,
 		refetch: refetchAllView,
-	} = useGetAllViews(sourcepage);
+	} = useGetAllViews(isMeterExplorer ? 'meter' : sourcepage);
 
 	const compositeQuery = mapCompositeQueryFromQuery(currentQuery, panelType);
 
@@ -316,7 +325,7 @@ function ExplorerOptions({
 		compositeQuery,
 		viewKey,
 		extraData: updatedExtraData,
-		sourcePage: sourcepage,
+		sourcePage: isMeterExplorer ? 'meter' : sourcepage,
 		viewName,
 	});
 
@@ -332,7 +341,7 @@ function ExplorerOptions({
 				compositeQuery: mapCompositeQueryFromQuery(currentQuery, panelType),
 				viewKey,
 				extraData: updatedExtraData,
-				sourcePage: sourcepage,
+				sourcePage: isMeterExplorer ? 'meter' : sourcepage,
 				viewName,
 			},
 			{
@@ -459,6 +468,11 @@ function ExplorerOptions({
 				panelType,
 				viewName: option?.value,
 			});
+		} else if (isMeterExplorer) {
+			logEvent('Meter Explorer: Select view', {
+				panelType,
+				viewName: option?.value,
+			});
 		}
 
 		updatePreservedViewInLocalStorage(option);
@@ -505,6 +519,11 @@ function ExplorerOptions({
 					: defaultLogsSelectedColumns,
 		});
 
+		if (signalSource === 'meter') {
+			history.replace(ROUTES.METER_EXPLORER);
+			return;
+		}
+
 		history.replace(DATASOURCE_VS_ROUTES[sourcepage]);
 	};
 
@@ -549,7 +568,7 @@ function ExplorerOptions({
 			redirectWithQueryBuilderData,
 			refetchAllView,
 			saveViewAsync,
-			sourcePage: sourcepage,
+			sourcePage: isMeterExplorer ? 'meter' : sourcepage,
 			viewName: newViewName,
 			setNewViewName,
 		});
@@ -668,7 +687,7 @@ function ExplorerOptions({
 		return `Query ${query.builder.queryData[0].queryName}`;
 	};
 
-	const alertButton = useMemo(() => {
+	const CreateAlertButton = useMemo(() => {
 		if (isOneChartPerQuery) {
 			const selectLabel = (
 				<Button
@@ -721,7 +740,7 @@ function ExplorerOptions({
 		splitedQueries,
 	]);
 
-	const dashboardButton = useMemo(() => {
+	const AddToDashboardButton = useMemo(() => {
 		if (isOneChartPerQuery) {
 			const selectLabel = (
 				<Button
@@ -829,7 +848,7 @@ function ExplorerOptions({
 					style={{
 						background: extraData
 							? `linear-gradient(90deg, rgba(0,0,0,0) -5%, ${rgbaColor} 9%, rgba(0,0,0,0) 30%)`
-							: 'transparent',
+							: 'initial',
 					}}
 				>
 					<div className="view-options">
@@ -884,10 +903,13 @@ function ExplorerOptions({
 
 					<hr className={isEditDeleteSupported ? '' : 'hidden'} />
 
-					<div className={cx('actions', isEditDeleteSupported ? '' : 'hidden')}>
-						{alertButton}
-						{dashboardButton}
-					</div>
+					{signalSource !== 'meter' && (
+						<div className={cx('actions', isEditDeleteSupported ? '' : 'hidden')}>
+							{CreateAlertButton}
+							{AddToDashboardButton}
+						</div>
+					)}
+
 					<div className="actions">
 						{/* Hide the info icon for metrics explorer until we get the docs link */}
 						{!isMetricsExplorer && (
@@ -993,6 +1015,7 @@ export interface ExplorerOptionsProps {
 	query: Query | null;
 	disabled: boolean;
 	sourcepage: DataSource;
+	signalSource?: string;
 	isExplorerOptionHidden?: boolean;
 	setIsExplorerOptionHidden?: Dispatch<SetStateAction<boolean>>;
 	isOneChartPerQuery?: boolean;
@@ -1005,6 +1028,7 @@ ExplorerOptions.defaultProps = {
 	setIsExplorerOptionHidden: undefined,
 	isOneChartPerQuery: false,
 	splitedQueries: [],
+	signalSource: '',
 };
 
 export default ExplorerOptions;

frontend/src/container/ExplorerOptions/constants.ts

@@ -2,4 +2,5 @@ export enum PreservedViewsTypes {
 	LOGS = 'logs',
 	TRACES = 'traces',
 	METRICS = 'metrics',
+	METER = 'meter',
 }

frontend/src/container/ExplorerOptions/types.ts

@@ -13,7 +13,7 @@ import { PreservedViewsTypes } from './constants';
 export interface SaveNewViewHandlerProps {
 	viewName: string;
 	compositeQuery: ICompositeMetricQuery;
-	sourcePage: DataSource;
+	sourcePage: DataSource | 'meter';
 	extraData: SaveViewProps['extraData'];
 	panelType: PANEL_TYPES | null;
 	notifications: NotificationInstance;
@@ -32,7 +32,8 @@ export interface SaveNewViewHandlerProps {
 export type PreservedViewType =
 	| PreservedViewsTypes.LOGS
 	| PreservedViewsTypes.TRACES
-	| PreservedViewsTypes.METRICS;
+	| PreservedViewsTypes.METRICS
+	| PreservedViewsTypes.METER;
 
 export type PreservedViewsInLocalStorage = Partial<
 	Record<PreservedViewType, { key: string; value: string }>

frontend/src/container/ExplorerOptions/utils.ts

@@ -37,7 +37,7 @@ export const saveNewViewHandler = ({
 		{
 			viewName,
 			compositeQuery,
-			sourcePage,
+			sourcePage: sourcePage as DataSource,
 			extraData,
 		},
 		{

frontend/src/container/MeterExplorer/Explorer/Explorer.styles.scss

@@ -0,0 +1,195 @@
+.meter-explorer-container {
+	display: flex;
+	flex-direction: row;
+
+	.meter-explorer-quick-filters-section {
+		width: 280px;
+		border-right: 1px solid var(--bg-slate-500);
+
+		&.hidden {
+			display: none;
+		}
+	}
+
+	.meter-explorer-content-section {
+		width: 100%;
+
+		.explore-header {
+			display: flex;
+			align-items: center;
+			justify-content: space-between;
+			margin: 4px 0;
+			padding: 0 8px;
+
+			.explore-header-left-actions {
+				display: flex;
+				align-items: flex-start;
+				gap: 10px;
+			}
+
+			.explore-header-right-actions {
+				display: flex;
+				align-items: flex-end;
+				gap: 10px;
+			}
+		}
+
+		.query-section {
+			max-height: 450px;
+			overflow-y: auto;
+
+			.rc-virtual-list-holder {
+				height: 150px;
+			}
+		}
+
+		.explore-tabs {
+			margin: 15px 0;
+			.tab {
+				background-color: var(--bg-slate-500);
+				border-color: var(--bg-ink-200);
+				width: 180px;
+				padding: 16px 0;
+				display: flex;
+				justify-content: center;
+				align-items: center;
+			}
+
+			.tab:first-of-type {
+				border-top-left-radius: 2px;
+			}
+
+			.tab:last-of-type {
+				border-top-right-radius: 2px;
+			}
+
+			.selected-view {
+				background: var(--bg-ink-500);
+			}
+		}
+
+		.explore-content {
+			.ant-space {
+				margin-top: 10px;
+				margin-bottom: 20px;
+			}
+
+			.empty-meter-search {
+				display: flex;
+				flex-direction: column;
+				justify-content: center;
+				align-items: center;
+				width: 100%;
+				height: 100%;
+			}
+
+			.time-series-view-panel {
+				border-radius: 4px;
+				border: 1px solid var(--bg-slate-500);
+				background: var(--bg-ink-400);
+				padding: 8px !important;
+				margin: 8px;
+			}
+
+			.time-series-container {
+				display: grid;
+				grid-template-columns: repeat(
+					auto-fit,
+					minmax(min(100%, calc(50% - 8px)), 1fr)
+				);
+				gap: 16px;
+				width: 100%;
+				height: fit-content;
+			}
+		}
+	}
+
+	&.quick-filters-open {
+		.meter-explorer-content-section {
+			width: calc(100% - 280px);
+		}
+	}
+
+	padding-bottom: 80px;
+}
+
+.meter-time-series-container {
+	display: flex;
+	flex-direction: column;
+	gap: 10px;
+
+	.builder-units-filter {
+		padding: 0 8px;
+		margin-bottom: 0px !important;
+
+		.builder-units-filter-label {
+			margin-bottom: 0px !important;
+			font-size: 13px;
+		}
+	}
+}
+
+.lightMode {
+	.meter-explorer-container {
+		.explore-tabs {
+			.tab {
+				background-color: var(--bg-vanilla-100);
+				border-color: var(--bg-vanilla-400);
+			}
+
+			.selected-view {
+				background: var(--bg-vanilla-500);
+			}
+		}
+	}
+}
+
+.dashboards-and-alerts-popover-container {
+	display: flex;
+	gap: 16px;
+
+	.dashboards-and-alerts-popover {
+		border-radius: 20px;
+		padding: 4px 8px;
+		cursor: pointer;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		gap: 4px;
+
+		&:hover {
+			opacity: 0.8;
+		}
+	}
+
+	.dashboards-popover {
+		border: 1px solid var(--bg-sienna-500);
+		.ant-typography {
+			color: var(--bg-sienna-500);
+		}
+	}
+
+	.alerts-popover {
+		border: 1px solid var(--bg-sakura-500);
+		.ant-typography {
+			color: var(--bg-sakura-500);
+		}
+	}
+}
+
+.no-data-container {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	align-items: center;
+	width: 100%;
+	height: 100%;
+	gap: 16px;
+
+	.no-data-text {
+		color: var(--text-vanilla-500);
+		font-size: 14px;
+		line-height: 20px;
+		text-align: center;
+	}
+}

frontend/src/container/MeterExplorer/Explorer/Explorer.tsx

@@ -0,0 +1,182 @@
+import './Explorer.styles.scss';
+
+import * as Sentry from '@sentry/react';
+import { Button, Tooltip } from 'antd';
+import logEvent from 'api/common/logEvent';
+import cx from 'classnames';
+import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
+import QuickFilters from 'components/QuickFilters/QuickFilters';
+import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
+import { initialQueryMeterWithType, PANEL_TYPES } from 'constants/queryBuilder';
+import ExplorerOptionWrapper from 'container/ExplorerOptions/ExplorerOptionWrapper';
+import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
+import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
+import DateTimeSelector from 'container/TopNav/DateTimeSelectionV2';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import { Filter } from 'lucide-react';
+import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Dashboard } from 'types/api/dashboard/getAll';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+import { generateExportToDashboardLink } from 'utils/dashboard/generateExportToDashboardLink';
+import { v4 as uuid } from 'uuid';
+
+import { MeterExplorerEventKeys, MeterExplorerEvents } from '../events';
+import TimeSeries from './TimeSeries';
+import { splitQueryIntoOneChartPerQuery } from './utils';
+
+function Explorer(): JSX.Element {
+	const {
+		handleRunQuery,
+		stagedQuery,
+		updateAllQueriesOperators,
+		currentQuery,
+	} = useQueryBuilder();
+	const { safeNavigate } = useSafeNavigate();
+
+	const [showQuickFilters, setShowQuickFilters] = useState(true);
+
+	const defaultQuery = useMemo(
+		() =>
+			updateAllQueriesOperators(
+				initialQueryMeterWithType,
+				PANEL_TYPES.TIME_SERIES,
+				DataSource.METRICS,
+				'meter' as 'meter' | '',
+			),
+		[updateAllQueriesOperators],
+	);
+
+	const exportDefaultQuery = useMemo(
+		() =>
+			updateAllQueriesOperators(
+				currentQuery || initialQueryMeterWithType,
+				PANEL_TYPES.TIME_SERIES,
+				DataSource.METRICS,
+				'meter' as 'meter' | '',
+			),
+		[currentQuery, updateAllQueriesOperators],
+	);
+
+	useShareBuilderUrl({ defaultValue: defaultQuery });
+
+	const handleExport = useCallback(
+		(
+			dashboard: Dashboard | null,
+			_isNewDashboard?: boolean,
+			queryToExport?: Query,
+		): void => {
+			if (!dashboard) return;
+
+			const widgetId = uuid();
+
+			const dashboardEditView = generateExportToDashboardLink({
+				query: queryToExport || exportDefaultQuery,
+				panelType: PANEL_TYPES.TIME_SERIES,
+				dashboardId: dashboard.id,
+				widgetId,
+			});
+
+			safeNavigate(dashboardEditView);
+		},
+		[exportDefaultQuery, safeNavigate],
+	);
+
+	const splitedQueries = useMemo(
+		() =>
+			splitQueryIntoOneChartPerQuery(stagedQuery || initialQueryMeterWithType),
+		[stagedQuery],
+	);
+
+	useEffect(() => {
+		logEvent(MeterExplorerEvents.TabChanged, {
+			[MeterExplorerEventKeys.Tab]: 'explorer',
+		});
+	}, []);
+
+	const queryComponents = useMemo(
+		(): QueryBuilderProps['queryComponents'] => ({}),
+		[],
+	);
+
+	return (
+		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
+			<div
+				className={cx('meter-explorer-container', {
+					'quick-filters-open': showQuickFilters,
+				})}
+			>
+				<div
+					className={cx('meter-explorer-quick-filters-section', {
+						hidden: !showQuickFilters,
+					})}
+				>
+					<QuickFilters
+						className="qf-meter-explorer"
+						source={QuickFiltersSource.METER_EXPLORER}
+						signal={SignalType.METER_EXPLORER}
+						showFilterCollapse
+						showQueryName={false}
+						handleFilterVisibilityChange={(): void => {
+							setShowQuickFilters(!showQuickFilters);
+						}}
+					/>
+				</div>
+
+				<div className="meter-explorer-content-section">
+					<div className="meter-explorer-explore-content">
+						<div className="explore-header">
+							<div className="explore-header-left-actions">
+								{!showQuickFilters && (
+									<Tooltip title="Show Quick Filters" placement="right" arrow={false}>
+										<Button
+											className="periscope-btn outline"
+											icon={<Filter size={16} />}
+											onClick={(): void => setShowQuickFilters(!showQuickFilters)}
+										/>
+									</Tooltip>
+								)}
+							</div>
+
+							<div className="explore-header-right-actions">
+								<DateTimeSelector showAutoRefresh />
+								<RightToolbarActions
+									onStageRunQuery={(): void => handleRunQuery(true, true)}
+								/>
+							</div>
+						</div>
+						<QueryBuilderV2
+							config={{
+								initialDataSource: DataSource.METRICS,
+								queryVariant: 'static',
+								signalSource: 'meter',
+							}}
+							panelType={PANEL_TYPES.TIME_SERIES}
+							queryComponents={queryComponents}
+							showFunctions={false}
+							version="v3"
+						/>
+
+						<div className="explore-content">
+							<TimeSeries />
+						</div>
+					</div>
+					<ExplorerOptionWrapper
+						disabled={!stagedQuery}
+						query={exportDefaultQuery}
+						sourcepage={DataSource.METRICS}
+						signalSource="meter"
+						onExport={handleExport}
+						isOneChartPerQuery={false}
+						splitedQueries={splitedQueries}
+					/>
+				</div>
+			</div>
+		</Sentry.ErrorBoundary>
+	);
+}
+
+export default Explorer;

frontend/src/container/MeterExplorer/Explorer/NoData.tsx

@@ -0,0 +1,13 @@
+import { Typography } from 'antd';
+import { ChartLine } from 'lucide-react';
+
+export default function NoData(): JSX.Element {
+	return (
+		<div className="no-data-container">
+			<ChartLine size={48} />
+			<Typography.Text className="no-data-text">
+				No data found for the selected query
+			</Typography.Text>
+		</div>
+	);
+}

frontend/src/container/MeterExplorer/Explorer/QuerySection.tsx

@@ -0,0 +1,43 @@
+import { Button } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { QueryBuilder } from 'container/QueryBuilder';
+import { ButtonWrapper } from 'container/TracesExplorer/QuerySection/styles';
+import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { MeterExplorerEventKeys, MeterExplorerEvents } from '../events';
+
+function QuerySection(): JSX.Element {
+	const { handleRunQuery } = useQueryBuilder();
+
+	const panelTypes = useGetPanelTypesQueryParam(PANEL_TYPES.TIME_SERIES);
+
+	return (
+		<div className="query-section">
+			<QueryBuilder
+				panelType={panelTypes}
+				config={{ initialDataSource: DataSource.METRICS, queryVariant: 'static' }}
+				version="v4"
+				actions={
+					<ButtonWrapper>
+						<Button
+							onClick={(): void => {
+								handleRunQuery();
+								logEvent(MeterExplorerEvents.QueryBuilderQueryChanged, {
+									[MeterExplorerEventKeys.Tab]: 'explorer',
+								});
+							}}
+							type="primary"
+						>
+							Run Query
+						</Button>
+					</ButtonWrapper>
+				}
+			/>
+		</div>
+	);
+}
+
+export default QuerySection;

frontend/src/container/MeterExplorer/Explorer/TimeSeries.tsx

@@ -0,0 +1,142 @@
+import { isAxiosError } from 'axios';
+import { ENTITY_VERSION_V5 } from 'constants/app';
+import { initialQueryMeterWithType, PANEL_TYPES } from 'constants/queryBuilder';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { BuilderUnitsFilter } from 'container/QueryBuilder/filters/BuilderUnitsFilter';
+import TimeSeriesView from 'container/TimeSeriesView/TimeSeriesView';
+import { convertDataValueToMs } from 'container/TimeSeriesView/utils';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { useMemo, useState } from 'react';
+import { useQueries } from 'react-query';
+import { useSelector } from 'react-redux';
+import { AppState } from 'store/reducers';
+import { SuccessResponse } from 'types/api';
+import APIError from 'types/api/error';
+import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+import { DataSource } from 'types/common/queryBuilder';
+import { GlobalReducer } from 'types/reducer/globalTime';
+
+function TimeSeries(): JSX.Element {
+	const { stagedQuery, currentQuery } = useQueryBuilder();
+
+	const { selectedTime: globalSelectedTime, maxTime, minTime } = useSelector<
+		AppState,
+		GlobalReducer
+	>((state) => state.globalTime);
+
+	const [yAxisUnit, setYAxisUnit] = useState<string>('');
+
+	const isValidToConvertToMs = useMemo(() => {
+		const isValid: boolean[] = [];
+
+		currentQuery.builder.queryData.forEach(
+			({ aggregateAttribute, aggregateOperator }) => {
+				const isExistDurationNanoAttribute =
+					aggregateAttribute?.key === 'durationNano' ||
+					aggregateAttribute?.key === 'duration_nano';
+
+				const isCountOperator =
+					aggregateOperator === 'count' || aggregateOperator === 'count_distinct';
+
+				isValid.push(!isCountOperator && isExistDurationNanoAttribute);
+			},
+		);
+
+		return isValid.every(Boolean);
+	}, [currentQuery]);
+
+	const queryPayloads = useMemo(
+		() => [stagedQuery || initialQueryMeterWithType],
+		[stagedQuery],
+	);
+
+	const { showErrorModal } = useErrorModal();
+
+	const queries = useQueries(
+		queryPayloads.map((payload, index) => ({
+			queryKey: [
+				REACT_QUERY_KEY.GET_QUERY_RANGE,
+				payload,
+				ENTITY_VERSION_V5,
+				globalSelectedTime,
+				maxTime,
+				minTime,
+				index,
+			],
+			queryFn: (): Promise<SuccessResponse<MetricRangePayloadProps>> =>
+				GetMetricQueryRange(
+					{
+						query: payload,
+						graphType: PANEL_TYPES.TIME_SERIES,
+						selectedTime: 'GLOBAL_TIME',
+						globalSelectedInterval: globalSelectedTime,
+						params: {
+							dataSource: DataSource.METRICS,
+						},
+					},
+					ENTITY_VERSION_V5,
+				),
+			enabled: !!payload,
+			retry: (failureCount: number, error: Error): boolean => {
+				let status: number | undefined;
+
+				if (error instanceof APIError) {
+					status = error.getHttpStatusCode();
+				} else if (isAxiosError(error)) {
+					status = error.response?.status;
+				}
+
+				if (status && status >= 400 && status < 500) {
+					return false;
+				}
+
+				return failureCount < 3;
+			},
+			onError: (error: APIError): void => {
+				showErrorModal(error);
+			},
+		})),
+	);
+
+	const data = useMemo(() => queries.map(({ data }) => data) ?? [], [queries]);
+
+	const responseData = useMemo(
+		() =>
+			data.map((datapoint) =>
+				isValidToConvertToMs ? convertDataValueToMs(datapoint) : datapoint,
+			),
+		[data, isValidToConvertToMs],
+	);
+
+	const onUnitChangeHandler = (value: string): void => {
+		setYAxisUnit(value);
+	};
+
+	return (
+		<div className="meter-time-series-container">
+			<BuilderUnitsFilter onChange={onUnitChangeHandler} yAxisUnit={yAxisUnit} />
+			<div className="time-series-container">
+				{responseData.map((datapoint, index) => (
+					<div
+						className="time-series-view-panel"
+						// eslint-disable-next-line react/no-array-index-key
+						key={index}
+					>
+						<TimeSeriesView
+							isFilterApplied={false}
+							isError={queries[index].isError}
+							isLoading={queries[index].isLoading}
+							data={datapoint}
+							dataSource={DataSource.METRICS}
+							yAxisUnit={yAxisUnit}
+						/>
+					</div>
+				))}
+			</div>
+		</div>
+	);
+}
+
+export default TimeSeries;

frontend/src/container/MeterExplorer/Explorer/__tests__/Explorer.test.tsx

@@ -0,0 +1,220 @@
+import { render, screen } from '@testing-library/react';
+import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
+import * as useOptionsMenuHooks from 'container/OptionsMenu';
+import * as useUpdateDashboardHooks from 'hooks/dashboard/useUpdateDashboard';
+import * as useQueryBuilderHooks from 'hooks/queryBuilder/useQueryBuilder';
+import * as appContextHooks from 'providers/App/App';
+import { ErrorModalProvider } from 'providers/ErrorModalProvider';
+import * as timezoneHooks from 'providers/Timezone';
+import { QueryClient, QueryClientProvider } from 'react-query';
+import { Provider } from 'react-redux';
+import { MemoryRouter } from 'react-router-dom';
+import { useSearchParams } from 'react-router-dom-v5-compat';
+import store from 'store';
+import { LicenseEvent } from 'types/api/licensesV3/getActive';
+import { DataSource } from 'types/common/queryBuilder';
+
+import Explorer from '../Explorer';
+
+const mockSetSearchParams = jest.fn();
+const queryClient = new QueryClient();
+const mockUpdateAllQueriesOperators = jest.fn();
+const mockUseQueryBuilderData = {
+	handleRunQuery: jest.fn(),
+	stagedQuery: initialQueriesMap[DataSource.METRICS],
+	updateAllQueriesOperators: mockUpdateAllQueriesOperators,
+	currentQuery: initialQueriesMap[DataSource.METRICS],
+	resetQuery: jest.fn(),
+	redirectWithQueryBuilderData: jest.fn(),
+	isStagedQueryUpdated: jest.fn(),
+	handleSetQueryData: jest.fn(),
+	handleSetFormulaData: jest.fn(),
+	handleSetQueryItemData: jest.fn(),
+	handleSetConfig: jest.fn(),
+	removeQueryBuilderEntityByIndex: jest.fn(),
+	removeQueryTypeItemByIndex: jest.fn(),
+	isDefaultQuery: jest.fn(),
+};
+
+jest.mock('react-router-dom-v5-compat', () => {
+	const actual = jest.requireActual('react-router-dom-v5-compat');
+	return {
+		...actual,
+		useSearchParams: jest.fn(),
+		useNavigationType: (): any => 'PUSH',
+	};
+});
+jest.mock('hooks/useDimensions', () => ({
+	useResizeObserver: (): { width: number; height: number } => ({
+		width: 800,
+		height: 400,
+	}),
+}));
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
+	useQueryClient: jest.fn().mockReturnValue({
+		getQueriesData: jest.fn(),
+	}),
+}));
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): any => ({
+		safeNavigate: jest.fn(),
+	}),
+}));
+jest.mock('hooks/useNotifications', () => ({
+	useNotifications: (): any => ({
+		notifications: {
+			error: jest.fn(),
+		},
+	}),
+}));
+jest.mock('uplot', () => {
+	const paths = {
+		spline: jest.fn(),
+		bars: jest.fn(),
+	};
+	const uplotMock = jest.fn(() => ({
+		paths,
+	}));
+	return {
+		paths,
+		default: uplotMock,
+	};
+});
+jest.mock('react-redux', () => ({
+	...jest.requireActual('react-redux'),
+	useSelector: (): any => ({
+		globalTime: {
+			selectedTime: {
+				startTime: 1713734400000,
+				endTime: 1713738000000,
+			},
+			maxTime: 1713738000000,
+			minTime: 1713734400000,
+		},
+	}),
+}));
+
+jest.spyOn(useUpdateDashboardHooks, 'useUpdateDashboard').mockReturnValue({
+	mutate: jest.fn(),
+	isLoading: false,
+} as any);
+jest.spyOn(useOptionsMenuHooks, 'useOptionsMenu').mockReturnValue({
+	options: {
+		selectColumns: [],
+	},
+} as any);
+jest.spyOn(timezoneHooks, 'useTimezone').mockReturnValue({
+	timezone: {
+		offset: 0,
+	},
+	browserTimezone: {
+		offset: 0,
+	},
+} as any);
+jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
+	user: {
+		role: 'admin',
+	},
+	activeLicenseV3: {
+		event_queue: {
+			created_at: '0',
+			event: LicenseEvent.NO_EVENT,
+			scheduled_at: '0',
+			status: '',
+			updated_at: '0',
+		},
+		license: {
+			license_key: 'test-license-key',
+			license_type: 'trial',
+			org_id: 'test-org-id',
+			plan_id: 'test-plan-id',
+			plan_name: 'test-plan-name',
+			plan_type: 'trial',
+			plan_version: 'test-plan-version',
+		},
+	},
+} as any);
+jest.spyOn(useQueryBuilderHooks, 'useQueryBuilder').mockReturnValue({
+	...mockUseQueryBuilderData,
+} as any);
+
+describe('Explorer', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should render Explorer query builder with metrics datasource selected', () => {
+		jest.spyOn(useQueryBuilderHooks, 'useQueryBuilder').mockReturnValue({
+			...mockUseQueryBuilderData,
+			stagedQuery: initialQueriesMap[DataSource.TRACES],
+		} as any);
+
+		(useSearchParams as jest.Mock).mockReturnValue([
+			new URLSearchParams({ isOneChartPerQueryEnabled: 'false' }),
+			mockSetSearchParams,
+		]);
+
+		render(
+			<QueryClientProvider client={queryClient}>
+				<MemoryRouter>
+					<Provider store={store}>
+						<ErrorModalProvider>
+							<Explorer />
+						</ErrorModalProvider>
+					</Provider>
+				</MemoryRouter>
+			</QueryClientProvider>,
+		);
+
+		expect(mockUpdateAllQueriesOperators).toHaveBeenCalledWith(
+			initialQueriesMap[DataSource.METRICS],
+			PANEL_TYPES.TIME_SERIES,
+			DataSource.METRICS,
+		);
+	});
+
+	it('should enable one chart per query toggle when oneChartPerQuery=true in URL', () => {
+		(useSearchParams as jest.Mock).mockReturnValue([
+			new URLSearchParams({ isOneChartPerQueryEnabled: 'true' }),
+			mockSetSearchParams,
+		]);
+
+		render(
+			<QueryClientProvider client={queryClient}>
+				<MemoryRouter>
+					<Provider store={store}>
+						<ErrorModalProvider>
+							<Explorer />
+						</ErrorModalProvider>
+					</Provider>
+				</MemoryRouter>
+			</QueryClientProvider>,
+		);
+
+		const toggle = screen.getByRole('switch');
+		expect(toggle).toBeChecked();
+	});
+
+	it('should disable one chart per query toggle when oneChartPerQuery=false in URL', () => {
+		(useSearchParams as jest.Mock).mockReturnValue([
+			new URLSearchParams({ isOneChartPerQueryEnabled: 'false' }),
+			mockSetSearchParams,
+		]);
+
+		render(
+			<QueryClientProvider client={queryClient}>
+				<MemoryRouter>
+					<Provider store={store}>
+						<ErrorModalProvider>
+							<Explorer />
+						</ErrorModalProvider>
+					</Provider>
+				</MemoryRouter>
+			</QueryClientProvider>,
+		);
+
+		const toggle = screen.getByRole('switch');
+		expect(toggle).not.toBeChecked();
+	});
+});

frontend/src/container/MeterExplorer/Explorer/index.ts

@@ -0,0 +1,3 @@
+import Explorer from './Explorer';
+
+export default Explorer;

frontend/src/container/MeterExplorer/Explorer/types.ts

@@ -0,0 +1,37 @@
+import { RelatedMetric } from 'api/metricsExplorer/getRelatedMetrics';
+import { UseQueryResult } from 'react-query';
+import { SuccessResponse } from 'types/api';
+import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+
+export enum ExplorerTabs {
+	TIME_SERIES = 'time-series',
+	RELATED_METRICS = 'related-metrics',
+}
+
+export interface TimeSeriesProps {
+	showOneChartPerQuery: boolean;
+}
+
+export interface RelatedMetricsProps {
+	metricNames: string[];
+}
+
+export interface RelatedMetricsCardProps {
+	metric: RelatedMetricWithQueryResult;
+}
+
+export interface UseGetRelatedMetricsGraphsProps {
+	selectedMetricName: string | null;
+	startMs: number;
+	endMs: number;
+}
+
+export interface UseGetRelatedMetricsGraphsReturn {
+	relatedMetrics: RelatedMetricWithQueryResult[];
+	isRelatedMetricsLoading: boolean;
+	isRelatedMetricsError: boolean;
+}
+
+export interface RelatedMetricWithQueryResult extends RelatedMetric {
+	queryResult: UseQueryResult<SuccessResponse<MetricRangePayloadProps>, unknown>;
+}

frontend/src/container/MeterExplorer/Explorer/utils.tsx

@@ -0,0 +1,37 @@
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { v4 as uuid } from 'uuid';
+
+export const splitQueryIntoOneChartPerQuery = (query: Query): Query[] => {
+	const queries: Query[] = [];
+
+	query.builder.queryData.forEach((currentQuery) => {
+		const newQuery = {
+			...query,
+			id: uuid(),
+			builder: {
+				...query.builder,
+				queryData: [currentQuery],
+				queryFormulas: [],
+			},
+		};
+		queries.push(newQuery);
+	});
+
+	query.builder.queryFormulas.forEach((currentFormula) => {
+		const newQuery = {
+			...query,
+			id: uuid(),
+			builder: {
+				...query.builder,
+				queryFormulas: [currentFormula],
+				queryData: query.builder.queryData.map((currentQuery) => ({
+					...currentQuery,
+					disabled: true,
+				})),
+			},
+		};
+		queries.push(newQuery);
+	});
+
+	return queries;
+};

frontend/src/container/MeterExplorer/events.ts

@@ -0,0 +1,51 @@
+/**
+ * This file contains all analytics events for the Meter Explorer.
+ */
+export enum MeterExplorerEvents {
+	TabChanged = 'Meter Explorer: Tab visited',
+	ModalOpened = 'Meter Explorer: Modal opened',
+	MeterClicked = 'Meter Explorer: Meter clicked',
+	FilterApplied = 'Meter Explorer: Filter applied',
+	TreemapViewChanged = 'Meter Explorer: Treemap view changed',
+	PageNumberChanged = 'Meter Explorer: Page number changed',
+	PageSizeChanged = 'Meter Explorer: Page size changed',
+	OrderByApplied = 'Meter Explorer: Order by applied',
+	MetricMetadataUpdated = 'Meter Explorer: Metric metadata updated',
+	OpenInExplorerClicked = 'Meter Explorer: Open in explorer clicked',
+	InspectViewChanged = 'Meter Explorer: Inspect view changed',
+	InspectQueryChanged = 'Meter Explorer: Inspect query changed',
+	InspectPointClicked = 'Meter Explorer: Inspect point clicked',
+	QueryBuilderQueryChanged = 'Meter Explorer: QueryBuilder query changed',
+	YAxisUnitApplied = 'Meter Explorer: Y axis unit applied',
+	AddToAlertClicked = 'Meter Explorer: Add to alert clicked',
+	AddToDashboardClicked = 'Meter Explorer: Add to dashboard clicked',
+	SaveViewClicked = 'Meter Explorer: Save view clicked',
+	SearchApplied = 'Meter Explorer: Search applied',
+	ViewEdited = 'Meter Explorer: View edited',
+	ViewDeleted = 'Meter Explorer: View deleted',
+}
+
+export enum MeterExplorerEventKeys {
+	Tab = 'tab',
+	Modal = 'modal',
+	View = 'view',
+	Interval = 'interval',
+	ViewType = 'viewType',
+	PageNumber = 'pageNumber',
+	PageSize = 'pageSize',
+	ColumnName = 'columnName',
+	Order = 'order',
+	AttributeKey = 'attributeKey',
+	AttributeValue = 'attributeValue',
+	MetricName = 'metricName',
+	InspectView = 'inspectView',
+	TimeAggregationOption = 'timeAggregationOption',
+	TimeAggregationInterval = 'timeAggregationInterval',
+	SpaceAggregationOption = 'spaceAggregationOption',
+	SpaceAggregationLabels = 'spaceAggregationLabels',
+	OneChartPerQueryEnabled = 'oneChartPerQueryEnabled',
+	YAxisUnit = 'yAxisUnit',
+	ViewName = 'viewName',
+	Filters = 'filters',
+	TimeRange = 'timeRange',
+}

frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx

@@ -188,7 +188,7 @@ function Explorer(): JSX.Element {
 				query={exportDefaultQuery}
 				sourcepage={DataSource.METRICS}
 				onExport={handleExport}
-				isOneChartPerQuery={showOneChartPerQuery}
+				isOneChartPerQuery={false}
 				splitedQueries={splitedQueries}
 			/>
 		</Sentry.ErrorBoundary>

frontend/src/container/QueryBuilder/QueryBuilder.interfaces.ts

@@ -17,8 +17,9 @@ export type QueryBuilderConfig =
 	| {
 			queryVariant: 'static';
 			initialDataSource: DataSource;
+			signalSource?: string;
 	  }
-	| { queryVariant: 'dropdown' };
+	| { queryVariant: 'dropdown'; signalSource?: string };
 
 export type QueryBuilderProps = {
 	config?: QueryBuilderConfig;

frontend/src/container/QueryBuilder/components/Query/Query.interfaces.ts

@@ -11,4 +11,5 @@ export type QueryProps = {
 	version: string;
 	showSpanScopeSelector?: boolean;
 	showOnlyWhereClause?: boolean;
+	signalSource?: string;
 } & Pick<QueryBuilderProps, 'filterConfigs' | 'queryComponents'>;

frontend/src/container/QueryBuilder/filters/AggregatorFilter/AggregatorFilter.intefaces.ts

@@ -8,4 +8,5 @@ export type AgregatorFilterProps = Pick<AutoCompleteProps, 'disabled'> & {
 	defaultValue?: string;
 	onSelect?: (value: BaseAutocompleteData) => void;
 	index?: number;
+	signalSource?: 'meter' | '';
 };

frontend/src/container/QueryBuilder/filters/AggregatorFilter/AggregatorFilter.tsx

@@ -38,6 +38,7 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 	defaultValue,
 	onSelect,
 	index,
+	signalSource,
 }: AgregatorFilterProps): JSX.Element {
 	const queryClient = useQueryClient();
 	const [optionsData, setOptionsData] = useState<ExtendedSelectOption[]>([]);
@@ -73,6 +74,7 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 				searchText: debouncedValue,
 				aggregateOperator: queryAggregation.timeAggregation,
 				dataSource: query.dataSource,
+				source: signalSource || '',
 			}),
 		{
 			enabled:
@@ -152,10 +154,17 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 		setSearchText(text);
 	}, []);
 
-	const placeholder: string =
-		query.dataSource === DataSource.METRICS
-			? `Search metric name`
-			: 'Aggregate attribute';
+	const getPlaceholder = useCallback(() => {
+		if (signalSource === 'meter') {
+			return 'Meter name';
+		}
+
+		if (query.dataSource === DataSource.METRICS) {
+			return 'Metric name';
+		}
+
+		return 'Aggregate attribute';
+	}, [signalSource, query.dataSource]);
 
 	const getAttributesData = useCallback(
 		(): BaseAutocompleteData[] =>
@@ -284,7 +293,7 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 	return (
 		<AutoComplete
 			getPopupContainer={popupContainer}
-			placeholder={placeholder}
+			placeholder={getPlaceholder()}
 			style={selectStyle}
 			filterOption={false}
 			onSearch={handleSearchText}

frontend/src/container/QueryBuilder/filters/BuilderUnitsFilter/BuilderUnits.tsx

@@ -30,8 +30,10 @@ function BuilderUnitsFilter({
 	};
 
 	return (
-		<Space>
-			<DefaultLabel>Y-axis unit</DefaultLabel>
+		<Space className="builder-units-filter">
+			<DefaultLabel className="builder-units-filter-label">
+				Y-axis unit
+			</DefaultLabel>
 			<Select
 				getPopupContainer={popupContainer}
 				style={selectStyles}

frontend/src/container/QueryBuilder/filters/GroupByFilter/GroupByFilter.interfaces.ts

@@ -5,4 +5,5 @@ export type GroupByFilterProps = {
 	query: IBuilderQuery;
 	onChange: (values: BaseAutocompleteData[]) => void;
 	disabled: boolean;
+	signalSource?: string;
 };

frontend/src/container/QueryBuilder/filters/GroupByFilter/GroupByFilter.tsx

@@ -10,9 +10,17 @@ import { chooseAutocompleteFromCustomValue } from 'lib/newQueryBuilder/chooseAut
 // ** Helpers
 import { transformStringWithPrefix } from 'lib/query/transformStringWithPrefix';
 import { isEqual, uniqWith } from 'lodash-es';
-import { memo, ReactNode, useCallback, useEffect, useState } from 'react';
+import {
+	memo,
+	ReactNode,
+	useCallback,
+	useEffect,
+	useMemo,
+	useState,
+} from 'react';
 import { useQueryClient } from 'react-query';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { DataSource } from 'types/common/queryBuilder';
 import { SelectOption } from 'types/common/select';
 import { popupContainer } from 'utils/selectPopupContainer';
 
@@ -25,6 +33,7 @@ export const GroupByFilter = memo(function GroupByFilter({
 	query,
 	onChange,
 	disabled,
+	signalSource,
 }: GroupByFilterProps): JSX.Element {
 	const queryClient = useQueryClient();
 	const [searchText, setSearchText] = useState<string>('');
@@ -38,10 +47,17 @@ export const GroupByFilter = memo(function GroupByFilter({
 
 	const debouncedValue = useDebounce(searchText, DEBOUNCE_DELAY);
 
+	const dataSource = useMemo(() => {
+		if (signalSource === 'meter') {
+			return 'meter' as DataSource;
+		}
+		return query.dataSource;
+	}, [signalSource, query.dataSource]);
+
 	const { isFetching } = useGetAggregateKeys(
 		{
 			aggregateAttribute: query.aggregateAttribute?.key || '',
-			dataSource: query.dataSource,
+			dataSource,
 			aggregateOperator: query.aggregateOperator || '',
 			searchText: debouncedValue,
 		},

frontend/src/container/SideNav/menuItems.tsx

@@ -8,6 +8,7 @@ import {
 	Book,
 	Boxes,
 	BugIcon,
+	ChartArea,
 	Cloudy,
 	DraftingCompass,
 	FileKey2,
@@ -113,7 +114,7 @@ const menuItems: SidebarItem[] = [
 		key: ROUTES.METRICS_EXPLORER,
 		label: 'Metrics',
 		icon: <BarChart2 size={16} />,
-		isNew: true,
+		isNew: false,
 		itemKey: 'metrics',
 	},
 	{
@@ -230,7 +231,7 @@ export const defaultMoreMenuItems: SidebarItem[] = [
 		key: ROUTES.METRICS_EXPLORER,
 		label: 'Metrics',
 		icon: <BarChart2 size={16} />,
-		isNew: true,
+		isNew: false,
 		isEnabled: true,
 		itemKey: 'metrics',
 	},
@@ -264,6 +265,15 @@ export const defaultMoreMenuItems: SidebarItem[] = [
 		isEnabled: true,
 		itemKey: 'external-apis',
 	},
+	{
+		key: ROUTES.METER_EXPLORER,
+		label: 'Meter Explorer',
+		icon: <ChartArea size={16} />,
+		isNew: false,
+		isEnabled: false,
+		isBeta: true,
+		itemKey: 'meter-explorer',
+	},
 	{
 		key: ROUTES.MESSAGING_QUEUES_OVERVIEW,
 		label: 'Messaging Queues',

frontend/src/container/TimeSeriesView/TimeSeriesView.tsx

@@ -205,6 +205,7 @@ function TimeSeriesView({
 	return (
 		<div className="time-series-view">
 			{isError && error && <ErrorInPlace error={error as APIError} />}
+
 			<div
 				className="graph-container"
 				style={{ height: '100%', width: '100%' }}

frontend/src/container/TimeSeriesView/index.tsx

@@ -47,7 +47,7 @@ function TimeSeriesViewContainer({
 		return isValid.every(Boolean);
 	}, [currentQuery]);
 
-	const { data, isLoading, isError, error } = useGetQueryRange(
+	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
 		{
 			query: stagedQuery || initialQueriesMap[dataSource],
 			graphType: panelType || PANEL_TYPES.TIME_SERIES,
@@ -88,7 +88,7 @@ function TimeSeriesViewContainer({
 			isFilterApplied={isFilterApplied}
 			isError={isError}
 			error={error as APIError}
-			isLoading={isLoading}
+			isLoading={isLoading || isFetching}
 			data={responseData}
 			yAxisUnit={isValidToConvertToMs ? 'ms' : 'short'}
 			dataSource={dataSource}

frontend/src/container/TopNav/DateTimeSelectionV2/config.ts

@@ -233,6 +233,9 @@ export const routesToSkip = [
 	ROUTES.ALL_ERROR,
 	ROUTES.UN_AUTHORIZED,
 	ROUTES.NOT_FOUND,
+	ROUTES.METER_EXPLORER,
+	ROUTES.METER_EXPLORER_BASE,
+	ROUTES.METER_EXPLORER_VIEWS,
 	ROUTES.SOMETHING_WENT_WRONG,
 ];
 

frontend/src/hooks/querySuggestions/useGetQueryKeyValueSuggestions.ts

@@ -1,22 +1,34 @@
 import { getValueSuggestions } from 'api/querySuggestions/getValueSuggestion';
 import { AxiosError, AxiosResponse } from 'axios';
-import { useQuery, UseQueryResult } from 'react-query';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { ErrorResponse } from 'react-router-dom-v5-compat';
+import { SuccessResponse } from 'types/api';
 import { QueryKeyValueSuggestionsResponseProps } from 'types/api/querySuggestions/types';
 
 export const useGetQueryKeyValueSuggestions = ({
 	key,
 	signal,
 	searchText,
+	signalSource,
 }: {
 	key: string;
 	signal: 'traces' | 'logs' | 'metrics';
 	searchText?: string;
+	signalSource?: 'meter' | '';
+	options?: UseQueryOptions<
+		SuccessResponse<QueryKeyValueSuggestionsResponseProps> | ErrorResponse
+	>;
 }): UseQueryResult<
 	AxiosResponse<QueryKeyValueSuggestionsResponseProps>,
 	AxiosError
 > =>
 	useQuery<AxiosResponse<QueryKeyValueSuggestionsResponseProps>, AxiosError>({
-		queryKey: ['queryKeyValueSuggestions', key, signal, searchText],
+		queryKey: ['queryKeyValueSuggestions', key, signal, searchText, signalSource],
 		queryFn: () =>
-			getValueSuggestions({ signal, key, searchText: searchText || '' }),
+			getValueSuggestions({
+				signal,
+				key,
+				searchText: searchText || '',
+				signalSource: signalSource as 'meter' | '',
+			}),
 	});

frontend/src/hooks/saveViews/useGetAllViews.ts

@@ -5,9 +5,9 @@ import { AllViewsProps } from 'types/api/saveViews/types';
 import { DataSource } from 'types/common/queryBuilder';
 
 export const useGetAllViews = (
-	sourcepage: DataSource,
+	sourcepage: DataSource | 'meter',
 ): UseQueryResult<AxiosResponse<AllViewsProps>, AxiosError> =>
 	useQuery<AxiosResponse<AllViewsProps>, AxiosError>({
 		queryKey: [{ sourcepage }],
-		queryFn: () => getAllViews(sourcepage),
+		queryFn: () => getAllViews(sourcepage as DataSource),
 	});

frontend/src/lib/dashboard/getQueryResults.ts

@@ -40,7 +40,9 @@ function validateMetricNameForMetricsDataSource(query: Query): boolean {
 
 	// Check if any METRICS data source queries exist
 	const metricsQueries = queryData.filter(
-		(queryItem) => queryItem.dataSource === DataSource.METRICS,
+		(queryItem) =>
+			queryItem.dataSource === DataSource.METRICS ||
+			queryItem.dataSource === DataSource.METER,
 	);
 
 	// If no METRICS queries, validation passes

frontend/src/pages/MeterExplorer/MeterExplorer.styles.scss

@@ -0,0 +1,16 @@
+.meter-explorer-page {
+	.ant-tabs-nav {
+		margin-bottom: 0;
+	}
+
+	.ant-tabs-tab {
+		padding: 8px 16px;
+		margin: 0 8px 0 0 !important;
+
+		.tab-item {
+			display: flex;
+			gap: 8px;
+			align-items: center;
+		}
+	}
+}

frontend/src/pages/MeterExplorer/MeterExplorerPage.tsx

@@ -0,0 +1,22 @@
+import './MeterExplorer.styles.scss';
+
+import RouteTab from 'components/RouteTab';
+import { TabRoutes } from 'components/RouteTab/types';
+import history from 'lib/history';
+import { useLocation } from 'react-use';
+
+import { Explorer, Views } from './constants';
+
+function MeterExplorerPage(): JSX.Element {
+	const { pathname } = useLocation();
+
+	const routes: TabRoutes[] = [Explorer, Views];
+
+	return (
+		<div className="meter-explorer-page">
+			<RouteTab routes={routes} activeKey={pathname} history={history} />
+		</div>
+	);
+}
+
+export default MeterExplorerPage;

frontend/src/pages/MeterExplorer/constants.tsx

@@ -0,0 +1,32 @@
+import { TabRoutes } from 'components/RouteTab/types';
+import ROUTES from 'constants/routes';
+import ExplorerPage from 'container/MeterExplorer/Explorer';
+import { Compass, TowerControl } from 'lucide-react';
+import SaveView from 'pages/SaveView';
+import { PreferenceContextProvider } from 'providers/preferences/context/PreferenceContextProvider';
+
+export const Explorer: TabRoutes = {
+	Component: (): JSX.Element => (
+		<PreferenceContextProvider>
+			<ExplorerPage />
+		</PreferenceContextProvider>
+	),
+	name: (
+		<div className="tab-item">
+			<Compass size={16} /> Explorer
+		</div>
+	),
+	route: ROUTES.METER_EXPLORER,
+	key: ROUTES.METER_EXPLORER,
+};
+
+export const Views: TabRoutes = {
+	Component: SaveView,
+	name: (
+		<div className="tab-item">
+			<TowerControl size={16} /> Views
+		</div>
+	),
+	route: ROUTES.METER_EXPLORER_VIEWS,
+	key: ROUTES.METER_EXPLORER_VIEWS,
+};

frontend/src/pages/MeterExplorer/index.tsx

@@ -0,0 +1,3 @@
+import MeterExplorerPage from './MeterExplorerPage';
+
+export default MeterExplorerPage;

frontend/src/pages/SaveView/constants.ts

@@ -6,6 +6,7 @@ export const SOURCEPAGE_VS_ROUTES: {
 	logs: ROUTES.LOGS_EXPLORER,
 	traces: ROUTES.TRACES_EXPLORER,
 	metrics: ROUTES.METRICS_EXPLORER_EXPLORER,
+	meter: ROUTES.METER_EXPLORER,
 } as const;
 
 export const ROUTES_VS_SOURCEPAGE: {
@@ -14,4 +15,5 @@ export const ROUTES_VS_SOURCEPAGE: {
 	[ROUTES.LOGS_SAVE_VIEWS]: 'logs',
 	[ROUTES.TRACES_SAVE_VIEWS]: 'traces',
 	[ROUTES.METRICS_EXPLORER_VIEWS]: 'metrics',
+	[ROUTES.METER_EXPLORER_VIEWS]: 'meter',
 } as const;

frontend/src/pages/SaveView/index.tsx

@@ -17,6 +17,10 @@ import {
 } from 'components/ExplorerCard/utils';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { getRandomColor } from 'container/ExplorerOptions/utils';
+import {
+	MeterExplorerEventKeys,
+	MeterExplorerEvents,
+} from 'container/MeterExplorer/events';
 import {
 	MetricsExplorerEventKeys,
 	MetricsExplorerEvents,
@@ -163,6 +167,10 @@ function SaveView(): JSX.Element {
 				logEvent(MetricsExplorerEvents.TabChanged, {
 					[MetricsExplorerEventKeys.Tab]: 'views',
 				});
+			} else if (sourcepage === 'meter') {
+				logEvent(MeterExplorerEvents.TabChanged, {
+					[MeterExplorerEventKeys.Tab]: 'views',
+				});
 			}
 			logEventCalledRef.current = true;
 		}

frontend/src/providers/QueryBuilder.tsx

@@ -241,12 +241,26 @@ export function QueryBuilderProvider({
 	);
 
 	const updateAllQueriesOperators = useCallback(
-		(query: Query, panelType: PANEL_TYPES, dataSource: DataSource): Query => {
+		(
+			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 } };
+			return {
+				...query,
+				builder: {
+					...query.builder,
+					queryData: queryData.map((item) => ({
+						...item,
+						source: signalSource,
+					})),
+				},
+			};
 		},
 
 		[getElementWithActualOperator],
@@ -854,6 +868,7 @@ export function QueryBuilderProvider({
 	const handleRunQuery = useCallback(
 		(shallUpdateStepInterval?: boolean, newQBQuery?: boolean) => {
 			let currentQueryData = currentQuery;
+
 			if (newQBQuery) {
 				currentQueryData = {
 					...currentQueryData,

frontend/src/types/api/queryBuilder/getAggregatorAttribute.ts

@@ -4,4 +4,5 @@ export interface IGetAggregateAttributePayload {
 	aggregateOperator: string;
 	dataSource: DataSource;
 	searchText: string;
+	source?: 'meter' | '';
 }

frontend/src/types/api/queryBuilder/queryBuilderData.ts

@@ -87,6 +87,7 @@ export type IBuilderQuery = {
 	pageSize?: number;
 	offset?: number;
 	selectColumns?: BaseAutocompleteData[] | TelemetryFieldKey[];
+	source?: 'meter' | '';
 };
 
 export interface IClickHouseQuery {

frontend/src/types/api/querySuggestions/types.ts

@@ -28,6 +28,7 @@ export interface QueryKeyRequestProps {
 	fieldContext?: 'resource' | 'scope' | 'attribute' | 'span';
 	fieldDataType?: QUERY_BUILDER_KEY_TYPES;
 	metricName?: string;
+	signalSource?: 'meter' | '';
 }
 
 export interface QueryKeyValueSuggestionsProps {
@@ -44,4 +45,7 @@ export interface QueryKeyValueRequestProps {
 	signal: 'traces' | 'logs' | 'metrics';
 	key: string;
 	searchText: string;
+	signalSource?: 'meter' | '';
 }
+
+export type SignalType = 'traces' | 'logs' | 'metrics';

frontend/src/types/api/v5/queryRange.ts

@@ -239,10 +239,17 @@ export interface MetricBuilderQuery extends BaseBuilderQuery {
 	aggregations?: MetricAggregation[];
 }
 
+export interface MeterBuilderQuery extends BaseBuilderQuery {
+	signal: 'metrics';
+	source: 'meter';
+	aggregations?: MetricAggregation[];
+}
+
 export type BuilderQuery =
 	| TraceBuilderQuery
 	| LogBuilderQuery
-	| MetricBuilderQuery;
+	| MetricBuilderQuery
+	| MeterBuilderQuery;
 
 export interface QueryBuilderFormula {
 	name: string;

frontend/src/types/common/queryBuilder.ts

@@ -105,6 +105,42 @@ export enum MetricAggregateOperator {
 	LATEST = 'latest',
 }
 
+export enum MeterAggregateOperator {
+	EMPTY = '', // used as time aggregator for histograms
+	NOOP = 'noop',
+	COUNT = 'count',
+	COUNT_DISTINCT = 'count_distinct',
+	SUM = 'sum',
+	AVG = 'avg',
+	MAX = 'max',
+	MIN = 'min',
+	P05 = 'p05',
+	P10 = 'p10',
+	P20 = 'p20',
+	P25 = 'p25',
+	P50 = 'p50',
+	P75 = 'p75',
+	P90 = 'p90',
+	P95 = 'p95',
+	P99 = 'p99',
+	RATE = 'rate',
+	SUM_RATE = 'sum_rate',
+	AVG_RATE = 'avg_rate',
+	MAX_RATE = 'max_rate',
+	MIN_RATE = 'min_rate',
+	RATE_SUM = 'rate_sum',
+	RATE_AVG = 'rate_avg',
+	RATE_MIN = 'rate_min',
+	RATE_MAX = 'rate_max',
+	HIST_QUANTILE_50 = 'hist_quantile_50',
+	HIST_QUANTILE_75 = 'hist_quantile_75',
+	HIST_QUANTILE_90 = 'hist_quantile_90',
+	HIST_QUANTILE_95 = 'hist_quantile_95',
+	HIST_QUANTILE_99 = 'hist_quantile_99',
+	INCREASE = 'increase',
+	LATEST = 'latest',
+}
+
 export enum TracesAggregatorOperator {
 	NOOP = 'noop',
 	COUNT = 'count',
@@ -237,6 +273,7 @@ export type QueryBuilderContextType = {
 		queryData: Query,
 		panelType: PANEL_TYPES,
 		dataSource: DataSource,
+		signalSource?: 'meter' | '',
 	) => Query;
 	updateQueriesData: <T extends keyof QueryBuilderData>(
 		query: Query,

frontend/src/utils/permission/index.ts

@@ -123,4 +123,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	INFRASTRUCTURE_MONITORING_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
 	API_MONITORING_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
 	MESSAGING_QUEUES_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
+	METER_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
+	METER_EXPLORER_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
+	METER_EXPLORER_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],
 };

pkg/apis/fields/api.go

@@ -9,6 +9,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
+	"github.com/SigNoz/signoz/pkg/telemetrymeter"
 	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
@@ -33,6 +34,8 @@ func NewAPI(
 		telemetrytraces.SpanIndexV3TableName,
 		telemetrymetrics.DBName,
 		telemetrymetrics.AttributesMetadataTableName,
+		telemetrymeter.DBName,
+		telemetrymeter.SamplesAgg1dTableName,
 		telemetrylogs.DBName,
 		telemetrylogs.LogsV2TableName,
 		telemetrylogs.TagAttributesV2TableName,

pkg/apis/fields/parse.go

@@ -12,6 +12,7 @@ import (
 func parseFieldKeyRequest(r *http.Request) (*telemetrytypes.FieldKeySelector, error) {
 	var req telemetrytypes.FieldKeySelector
 	var signal telemetrytypes.Signal
+	var source telemetrytypes.Source
 	var err error
 
 	signalStr := r.URL.Query().Get("signal")
@@ -21,6 +22,13 @@ func parseFieldKeyRequest(r *http.Request) (*telemetrytypes.FieldKeySelector, er
 		signal = telemetrytypes.SignalUnspecified
 	}
 
+	sourceStr := r.URL.Query().Get("source")
+	if sourceStr != "" {
+		source = telemetrytypes.Source{String: valuer.NewString(sourceStr)}
+	} else {
+		source = telemetrytypes.SourceUnspecified
+	}
+
 	if r.URL.Query().Get("limit") != "" {
 		limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
 		if err != nil {
@@ -76,6 +84,7 @@ func parseFieldKeyRequest(r *http.Request) (*telemetrytypes.FieldKeySelector, er
 		StartUnixMilli:    startUnixMilli,
 		EndUnixMilli:      endUnixMilli,
 		Signal:            signal,
+		Source:            source,
 		Name:              name,
 		FieldContext:      fieldContext,
 		FieldDataType:     fieldDataType,

pkg/querier/builder_query.go

@@ -62,6 +62,9 @@ func (q *builderQuery[T]) Fingerprint() string {
 	// Add signal type
 	parts = append(parts, fmt.Sprintf("signal=%s", q.spec.Signal.StringValue()))
 
+	// Add source type
+	parts = append(parts, fmt.Sprintf("source=%s", q.spec.Source.StringValue()))
+
 	// Add step interval if present
 	parts = append(parts, fmt.Sprintf("step=%s", q.spec.StepInterval.String()))
 

pkg/querier/querier.go

@@ -31,6 +31,7 @@ type querier struct {
 	traceStmtBuilder  qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	logStmtBuilder    qbtypes.StatementBuilder[qbtypes.LogAggregation]
 	metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation]
+	meterStmtBuilder  qbtypes.StatementBuilder[qbtypes.MetricAggregation]
 	bucketCache       BucketCache
 }
 
@@ -44,6 +45,7 @@ func New(
 	traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
 	logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
 	metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation],
+	meterStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation],
 	bucketCache BucketCache,
 ) *querier {
 	querierSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/querier")
@@ -55,6 +57,7 @@ func New(
 		traceStmtBuilder:  traceStmtBuilder,
 		logStmtBuilder:    logStmtBuilder,
 		metricStmtBuilder: metricStmtBuilder,
+		meterStmtBuilder:  meterStmtBuilder,
 		bucketCache:       bucketCache,
 	}
 }
@@ -168,17 +171,21 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 				event.MetricsUsed = true
 				event.FilterApplied = spec.Filter != nil && spec.Filter.Expression != ""
 				event.GroupByApplied = len(spec.GroupBy) > 0
-				if spec.StepInterval.Seconds() == 0 {
-					spec.StepInterval = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMetric(req.Start, req.End)),
-					}
-				}
-				if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)) {
-					spec.StepInterval = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)),
-					}
-				}
 
+				if spec.Source == telemetrytypes.SourceMeter {
+					spec.StepInterval = qbtypes.Step{Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMeter(req.Start, req.End))}
+				} else {
+					if spec.StepInterval.Seconds() == 0 {
+						spec.StepInterval = qbtypes.Step{
+							Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMetric(req.Start, req.End)),
+						}
+					}
+					if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)) {
+						spec.StepInterval = qbtypes.Step{
+							Duration: time.Second * time.Duration(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)),
+						}
+					}
+				}
 				req.CompositeQuery.Queries[idx].Spec = spec
 			}
 		} else if query.Type == qbtypes.QueryTypePromQL {
@@ -265,7 +272,14 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 				}
 				spec.ShiftBy = extractShiftFromBuilderQuery(spec)
 				timeRange := adjustTimeRangeForShift(spec, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType)
-				bq := newBuilderQuery(q.telemetryStore, q.metricStmtBuilder, spec, timeRange, req.RequestType, tmplVars)
+				var bq *builderQuery[qbtypes.MetricAggregation]
+
+				if spec.Source == telemetrytypes.SourceMeter {
+					bq = newBuilderQuery(q.telemetryStore, q.meterStmtBuilder, spec, timeRange, req.RequestType, tmplVars)
+				} else {
+					bq = newBuilderQuery(q.telemetryStore, q.metricStmtBuilder, spec, timeRange, req.RequestType, tmplVars)
+				}
+
 				queries[spec.Name] = bq
 				steps[spec.Name] = spec.StepInterval
 			default:
@@ -517,6 +531,9 @@ func (q *querier) createRangedQuery(originalQuery qbtypes.Query, timeRange qbtyp
 	case *builderQuery[qbtypes.MetricAggregation]:
 		qt.spec.ShiftBy = extractShiftFromBuilderQuery(qt.spec)
 		adjustedTimeRange := adjustTimeRangeForShift(qt.spec, timeRange, qt.kind)
+		if qt.spec.Source == telemetrytypes.SourceMeter {
+			return newBuilderQuery(q.telemetryStore, q.meterStmtBuilder, qt.spec, adjustedTimeRange, qt.kind, qt.variables)
+		}
 		return newBuilderQuery(q.telemetryStore, q.metricStmtBuilder, qt.spec, adjustedTimeRange, qt.kind, qt.variables)
 	default:
 		return nil

pkg/querier/signozquerier/provider.go

@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/querybuilder/resourcefilter"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
+	"github.com/SigNoz/signoz/pkg/telemetrymeter"
 	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
@@ -52,6 +53,8 @@ func newProvider(
 		telemetrytraces.SpanIndexV3TableName,
 		telemetrymetrics.DBName,
 		telemetrymetrics.AttributesMetadataTableName,
+		telemetrymeter.DBName,
+		telemetrymeter.SamplesAgg1dTableName,
 		telemetrylogs.DBName,
 		telemetrylogs.LogsV2TableName,
 		telemetrylogs.TagAttributesV2TableName,
@@ -122,6 +125,14 @@ func newProvider(
 		metricConditionBuilder,
 	)
 
+	// Create meter statement builder
+	meterStmtBuilder := telemetrymeter.NewMeterQueryStatementBuilder(
+		settings,
+		telemetryMetadataStore,
+		metricFieldMapper,
+		metricConditionBuilder,
+	)
+
 	// Create bucket cache
 	bucketCache := querier.NewBucketCache(
 		settings,
@@ -139,6 +150,7 @@ func newProvider(
 		traceStmtBuilder,
 		logStmtBuilder,
 		metricStmtBuilder,
+		meterStmtBuilder,
 		bucketCache,
 	), nil
 }

pkg/query-service/app/clickhouseReader/reader.go

@@ -64,6 +64,8 @@ const (
 	signozTraceLocalTableName = "signoz_index_v2"
 	signozMetricDBName        = "signoz_metrics"
 	signozMetadataDbName      = "signoz_metadata"
+	signozMeterDBName         = "signoz_meter"
+	signozMeterSamplesName    = "samples_agg_1d"
 
 	signozSampleLocalTableName = "samples_v4"
 	signozSampleTableName      = "distributed_samples_v4"
@@ -2741,8 +2743,55 @@ func (r *ClickHouseReader) GetMetricAggregateAttributes(ctx context.Context, org
 	return &response, nil
 }
 
-func (r *ClickHouseReader) GetMetricAttributeKeys(ctx context.Context, req *v3.FilterAttributeKeyRequest) (*v3.FilterAttributeKeyResponse, error) {
+func (r *ClickHouseReader) GetMeterAggregateAttributes(ctx context.Context, orgID valuer.UUID, req *v3.AggregateAttributeRequest) (*v3.AggregateAttributeResponse, error) {
+	var response v3.AggregateAttributeResponse
+	// Query all relevant metric names from time_series_v4, but leave metadata retrieval to cache/db
+	query := fmt.Sprintf(
+		`SELECT metric_name,type,temporality,is_monotonic 
+		 FROM %s.%s 
+		 WHERE metric_name ILIKE $1
+		 GROUP BY metric_name,type,temporality,is_monotonic`,
+		signozMeterDBName, signozMeterSamplesName)
 
+	if req.Limit != 0 {
+		query = query + fmt.Sprintf(" LIMIT %d;", req.Limit)
+	}
+
+	rows, err := r.db.Query(ctx, query, fmt.Sprintf("%%%s%%", req.SearchText))
+	if err != nil {
+		zap.L().Error("Error while querying meter names", zap.Error(err))
+		return nil, fmt.Errorf("error while executing meter name query: %s", err.Error())
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var name string
+		var typ string
+		var temporality string
+		var isMonotonic bool
+		if err := rows.Scan(&name, &typ, &temporality, &isMonotonic); err != nil {
+			return nil, fmt.Errorf("error while scanning meter name: %s", err.Error())
+		}
+
+		// Non-monotonic cumulative sums are treated as gauges
+		if typ == "Sum" && !isMonotonic && temporality == string(v3.Cumulative) {
+			typ = "Gauge"
+		}
+
+		// unlike traces/logs `tag`/`resource` type, the `Type` will be metric type
+		key := v3.AttributeKey{
+			Key:      name,
+			DataType: v3.AttributeKeyDataTypeFloat64,
+			Type:     v3.AttributeKeyType(typ),
+			IsColumn: true,
+		}
+		response.AttributeKeys = append(response.AttributeKeys, key)
+	}
+
+	return &response, nil
+}
+
+func (r *ClickHouseReader) GetMetricAttributeKeys(ctx context.Context, req *v3.FilterAttributeKeyRequest) (*v3.FilterAttributeKeyResponse, error) {
 	var query string
 	var err error
 	var rows driver.Rows
@@ -2782,6 +2831,41 @@ func (r *ClickHouseReader) GetMetricAttributeKeys(ctx context.Context, req *v3.F
 	return &response, nil
 }
 
+func (r *ClickHouseReader) GetMeterAttributeKeys(ctx context.Context, req *v3.FilterAttributeKeyRequest) (*v3.FilterAttributeKeyResponse, error) {
+	var query string
+	var err error
+	var rows driver.Rows
+	var response v3.FilterAttributeKeyResponse
+
+	// skips the internal attributes i.e attributes starting with __
+	query = fmt.Sprintf("SELECT DISTINCT arrayJoin(JSONExtractKeys(labels)) as attr_name FROM %s.%s WHERE metric_name=$1 AND attr_name ILIKE $2 AND attr_name NOT LIKE '\\_\\_%%'", signozMeterDBName, signozMeterSamplesName)
+	if req.Limit != 0 {
+		query = query + fmt.Sprintf(" LIMIT %d;", req.Limit)
+	}
+	rows, err = r.db.Query(ctx, query, req.AggregateAttribute, fmt.Sprintf("%%%s%%", req.SearchText))
+	if err != nil {
+		zap.L().Error("Error while executing query", zap.Error(err))
+		return nil, fmt.Errorf("error while executing query: %s", err.Error())
+	}
+	defer rows.Close()
+
+	var attributeKey string
+	for rows.Next() {
+		if err := rows.Scan(&attributeKey); err != nil {
+			return nil, fmt.Errorf("error while scanning rows: %s", err.Error())
+		}
+		key := v3.AttributeKey{
+			Key:      attributeKey,
+			DataType: v3.AttributeKeyDataTypeString, // https://github.com/OpenObservability/OpenMetrics/blob/main/proto/openmetrics_data_model.proto#L64-L72.
+			Type:     v3.AttributeKeyTypeTag,
+			IsColumn: false,
+		}
+		response.AttributeKeys = append(response.AttributeKeys, key)
+	}
+
+	return &response, nil
+}
+
 func (r *ClickHouseReader) GetMetricAttributeValues(ctx context.Context, req *v3.FilterAttributeValueRequest) (*v3.FilterAttributeValueResponse, error) {
 
 	var query string

pkg/query-service/app/http_handler.go

@@ -4218,6 +4218,8 @@ func (aH *APIHandler) autocompleteAggregateAttributes(w http.ResponseWriter, r *
 		response, err = aH.reader.GetLogAggregateAttributes(r.Context(), req)
 	case v3.DataSourceTraces:
 		response, err = aH.reader.GetTraceAggregateAttributes(r.Context(), req)
+	case v3.DataSourceMeter:
+		response, err = aH.reader.GetMeterAggregateAttributes(r.Context(), orgID, req)
 	default:
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("invalid data source")}, nil)
 		return
@@ -4267,6 +4269,8 @@ func (aH *APIHandler) autoCompleteAttributeKeys(w http.ResponseWriter, r *http.R
 	switch req.DataSource {
 	case v3.DataSourceMetrics:
 		response, err = aH.reader.GetMetricAttributeKeys(r.Context(), req)
+	case v3.DataSourceMeter:
+		response, err = aH.reader.GetMeterAttributeKeys(r.Context(), req)
 	case v3.DataSourceLogs:
 		response, err = aH.reader.GetLogAttributeKeys(r.Context(), req)
 	case v3.DataSourceTraces:

pkg/query-service/interfaces/interface.go

@@ -50,7 +50,9 @@ type Reader interface {
 
 	FetchTemporality(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string]map[v3.Temporality]bool, error)
 	GetMetricAggregateAttributes(ctx context.Context, orgID valuer.UUID, req *v3.AggregateAttributeRequest, skipSignozMetrics bool) (*v3.AggregateAttributeResponse, error)
+	GetMeterAggregateAttributes(ctx context.Context, orgID valuer.UUID, req *v3.AggregateAttributeRequest) (*v3.AggregateAttributeResponse, error)
 	GetMetricAttributeKeys(ctx context.Context, req *v3.FilterAttributeKeyRequest) (*v3.FilterAttributeKeyResponse, error)
+	GetMeterAttributeKeys(ctx context.Context, req *v3.FilterAttributeKeyRequest) (*v3.FilterAttributeKeyResponse, error)
 	GetMetricAttributeValues(ctx context.Context, req *v3.FilterAttributeValueRequest) (*v3.FilterAttributeValueResponse, error)
 
 	// Returns `MetricStatus` for latest received metric among `metricNames`. Useful for status calculations

pkg/query-service/model/v3/v3.go

@@ -22,11 +22,12 @@ const (
 	DataSourceTraces  DataSource = "traces"
 	DataSourceLogs    DataSource = "logs"
 	DataSourceMetrics DataSource = "metrics"
+	DataSourceMeter   DataSource = "meter"
 )
 
 func (d DataSource) Validate() error {
 	switch d {
-	case DataSourceTraces, DataSourceLogs, DataSourceMetrics:
+	case DataSourceTraces, DataSourceLogs, DataSourceMetrics, DataSourceMeter:
 		return nil
 	default:
 		return fmt.Errorf("invalid data source: %s", d)

pkg/querybuilder/time.go

@@ -61,6 +61,32 @@ func MinAllowedStepInterval(start, end uint64) uint64 {
 	return step - step%5
 }
 
+func RecommendedStepIntervalForMeter(start, end uint64) uint64 {
+	start = ToNanoSecs(start)
+	end = ToNanoSecs(end)
+
+	step := (end - start) / RecommendedNumberOfPoints / 1e9
+
+	// for meter queries the minimum step interval allowed is 1 hour as this is our granularity
+	if step < 3600 {
+		return 3600
+	}
+
+	// return the nearest lower multiple of 3600 ( 1 hour )
+	recommended := step - step%3600
+
+	// if the time range is greater than 1 month set the step interval to be multiple of 1 day
+	if end-start >= uint64(30*24*time.Hour.Nanoseconds()) {
+		if recommended < 86400 {
+			recommended = 86400
+		} else {
+			recommended = uint64(math.Round(float64(recommended)/86400)) * 86400
+		}
+	}
+
+	return recommended
+}
+
 func RecommendedStepIntervalForMetric(start, end uint64) uint64 {
 	start = ToNanoSecs(start)
 	end = ToNanoSecs(end)

pkg/signoz/provider.go

@@ -124,6 +124,7 @@ func NewSQLMigrationProviderFactories(sqlstore sqlstore.SQLStore, sqlschema sqls
 		sqlmigration.NewUpdateUserInviteFactory(sqlstore, sqlschema),
 		sqlmigration.NewUpdateOrgDomainFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddFactorIndexesFactory(sqlstore, sqlschema),
+		sqlmigration.NewAddMeterQuickFiltersFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/sqlmigration/046_add_meter_quickfilters.go

@@ -0,0 +1,135 @@
+package sqlmigration
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlschema"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+type addMeterQuickFilters struct {
+	sqlstore  sqlstore.SQLStore
+	sqlschema sqlschema.SQLSchema
+}
+
+func NewAddMeterQuickFiltersFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_meter_quick_filters"), func(ctx context.Context, providerSettings factory.ProviderSettings, config Config) (SQLMigration, error) {
+		return newAddMeterQuickFilters(ctx, providerSettings, config, sqlstore, sqlschema)
+	})
+}
+
+func newAddMeterQuickFilters(_ context.Context, _ factory.ProviderSettings, _ Config, sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) (SQLMigration, error) {
+	return &addMeterQuickFilters{
+		sqlstore:  sqlstore,
+		sqlschema: sqlschema,
+	}, nil
+}
+
+func (migration *addMeterQuickFilters) Register(migrations *migrate.Migrations) error {
+	if err := migrations.Register(migration.Up, migration.Down); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addMeterQuickFilters) Up(ctx context.Context, db *bun.DB) error {
+	meterFilters := []map[string]interface{}{
+		{"key": "deployment.environment", "dataType": "float64", "type": "Sum"},
+		{"key": "service.name", "dataType": "float64", "type": "Sum"},
+		{"key": "host.name", "dataType": "float64", "type": "Sum"},
+	}
+
+	meterJSON, err := json.Marshal(meterFilters)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal meter filters")
+	}
+
+	type signal struct {
+		valuer.String
+	}
+
+	type identifiable struct {
+		ID valuer.UUID `json:"id" bun:"id,pk,type:text"`
+	}
+
+	type timeAuditable struct {
+		CreatedAt time.Time `bun:"created_at" json:"createdAt"`
+		UpdatedAt time.Time `bun:"updated_at" json:"updatedAt"`
+	}
+
+	type quickFilterType struct {
+		bun.BaseModel `bun:"table:quick_filter"`
+		identifiable
+		OrgID  valuer.UUID `bun:"org_id,type:text,notnull"`
+		Filter string      `bun:"filter,type:text,notnull"`
+		Signal signal      `bun:"signal,type:text,notnull"`
+		timeAuditable
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	var orgIDs []string
+	err = tx.NewSelect().
+		Table("organizations").
+		Column("id").
+		Scan(ctx, &orgIDs)
+	if err != nil && err != sql.ErrNoRows {
+		return err
+	}
+
+	var meterFiltersToInsert []quickFilterType
+	for _, orgIDStr := range orgIDs {
+		orgID, err := valuer.NewUUID(orgIDStr)
+		if err != nil {
+			return err
+		}
+
+		meterFiltersToInsert = append(meterFiltersToInsert, quickFilterType{
+			identifiable: identifiable{
+				ID: valuer.GenerateUUID(),
+			},
+			OrgID:  orgID,
+			Filter: string(meterJSON),
+			Signal: signal{valuer.NewString("meter_explorer")},
+			timeAuditable: timeAuditable{
+				CreatedAt: time.Now(),
+				UpdatedAt: time.Now(),
+			},
+		})
+	}
+
+	_, err = tx.NewInsert().
+		Model(&meterFiltersToInsert).
+		On("CONFLICT (org_id, signal) DO UPDATE").
+		Set("filter = EXCLUDED.filter, updated_at = EXCLUDED.updated_at").
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addMeterQuickFilters) Down(ctx context.Context, db *bun.DB) error {
+	return nil
+}

pkg/telemetrymetadata/metadata.go

@@ -25,6 +25,8 @@ var (
 	ErrFailedToGetLogsKeys      = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get logs keys")
 	ErrFailedToGetTblStatement  = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get tbl statement")
 	ErrFailedToGetMetricsKeys   = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get metrics keys")
+	ErrFailedToGetMeterKeys     = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get meter keys")
+	ErrFailedToGetMeterValues   = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get meter values")
 	ErrFailedToGetRelatedValues = errors.Newf(errors.TypeInternal, errors.CodeInternal, "failed to get related values")
 )
 
@@ -36,6 +38,8 @@ type telemetryMetaStore struct {
 	indexV3TblName         string
 	metricsDBName          string
 	metricsFieldsTblName   string
+	meterDBName            string
+	meterFieldsTblName     string
 	logsDBName             string
 	logsFieldsTblName      string
 	logsV2TblName          string
@@ -54,6 +58,8 @@ func NewTelemetryMetaStore(
 	indexV3TblName string,
 	metricsDBName string,
 	metricsFieldsTblName string,
+	meterDBName string,
+	meterFieldsTblName string,
 	logsDBName string,
 	logsV2TblName string,
 	logsFieldsTblName string,
@@ -70,6 +76,8 @@ func NewTelemetryMetaStore(
 		indexV3TblName:         indexV3TblName,
 		metricsDBName:          metricsDBName,
 		metricsFieldsTblName:   metricsFieldsTblName,
+		meterDBName:            meterDBName,
+		meterFieldsTblName:     meterFieldsTblName,
 		logsDBName:             logsDBName,
 		logsV2TblName:          logsV2TblName,
 		logsFieldsTblName:      logsFieldsTblName,
@@ -550,6 +558,66 @@ func (t *telemetryMetaStore) getMetricsKeys(ctx context.Context, fieldKeySelecto
 	return keys, nil
 }
 
+// getMeterKeys returns the keys from the meter metrics that match the field selection criteria
+func (t *telemetryMetaStore) getMeterSourceMetricKeys(ctx context.Context, fieldKeySelectors []*telemetrytypes.FieldKeySelector) ([]*telemetrytypes.TelemetryFieldKey, error) {
+	if len(fieldKeySelectors) == 0 {
+		return nil, nil
+	}
+
+	sb := sqlbuilder.Select("DISTINCT arrayJoin(JSONExtractKeys(labels)) as attr_name").From(t.meterDBName + "." + t.meterFieldsTblName)
+	conds := []string{}
+	var limit int
+	for _, fieldKeySelector := range fieldKeySelectors {
+		fieldConds := []string{}
+		if fieldKeySelector.SelectorMatchType == telemetrytypes.FieldSelectorMatchTypeExact {
+			fieldConds = append(fieldConds, sb.E("attr_name", fieldKeySelector.Name))
+		} else {
+			fieldConds = append(fieldConds, sb.Like("attr_name", "%"+fieldKeySelector.Name+"%"))
+		}
+		fieldConds = append(fieldConds, sb.NotLike("attr_name", "\\_\\_%"))
+
+		if fieldKeySelector.MetricContext != nil {
+			fieldConds = append(fieldConds, sb.E("metric_name", fieldKeySelector.MetricContext.MetricName))
+		}
+
+		conds = append(conds, sb.And(fieldConds...))
+		limit += fieldKeySelector.Limit
+	}
+	sb.Where(sb.Or(conds...))
+	if limit == 0 {
+		limit = 1000
+	}
+
+	sb.Limit(limit)
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterKeys.Error())
+	}
+	defer rows.Close()
+
+	keys := []*telemetrytypes.TelemetryFieldKey{}
+	for rows.Next() {
+		var name string
+		err = rows.Scan(&name)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterKeys.Error())
+		}
+		keys = append(keys, &telemetrytypes.TelemetryFieldKey{
+			Name:   name,
+			Signal: telemetrytypes.SignalMetrics,
+		})
+	}
+
+	if rows.Err() != nil {
+		return nil, errors.Wrapf(rows.Err(), errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterKeys.Error())
+	}
+
+	return keys, nil
+
+}
+
 func (t *telemetryMetaStore) GetKeys(ctx context.Context, fieldKeySelector *telemetrytypes.FieldKeySelector) (map[string][]*telemetrytypes.TelemetryFieldKey, error) {
 	var keys []*telemetrytypes.TelemetryFieldKey
 	var err error
@@ -565,7 +633,11 @@ func (t *telemetryMetaStore) GetKeys(ctx context.Context, fieldKeySelector *tele
 	case telemetrytypes.SignalLogs:
 		keys, err = t.getLogsKeys(ctx, selectors)
 	case telemetrytypes.SignalMetrics:
-		keys, err = t.getMetricsKeys(ctx, selectors)
+		if fieldKeySelector.Source == telemetrytypes.SourceMeter {
+			keys, err = t.getMeterSourceMetricKeys(ctx, selectors)
+		} else {
+			keys, err = t.getMetricsKeys(ctx, selectors)
+		}
 	case telemetrytypes.SignalUnspecified:
 		// get traces keys
 		tracesKeys, err := t.getTracesKeys(ctx, selectors)
@@ -587,6 +659,14 @@ func (t *telemetryMetaStore) GetKeys(ctx context.Context, fieldKeySelector *tele
 			return nil, err
 		}
 		keys = append(keys, metricsKeys...)
+
+		// get meter metrics keys
+		meterSourceMetricsKeys, err := t.getMeterSourceMetricKeys(ctx, selectors)
+		if err != nil {
+			return nil, err
+		}
+
+		keys = append(keys, meterSourceMetricsKeys...)
 	}
 	if err != nil {
 		return nil, err
@@ -605,6 +685,7 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, fieldKeySelectors
 	logsSelectors := []*telemetrytypes.FieldKeySelector{}
 	tracesSelectors := []*telemetrytypes.FieldKeySelector{}
 	metricsSelectors := []*telemetrytypes.FieldKeySelector{}
+	meterSourceMetricsSelectors := []*telemetrytypes.FieldKeySelector{}
 
 	for _, fieldKeySelector := range fieldKeySelectors {
 		switch fieldKeySelector.Signal {
@@ -613,11 +694,16 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, fieldKeySelectors
 		case telemetrytypes.SignalTraces:
 			tracesSelectors = append(tracesSelectors, fieldKeySelector)
 		case telemetrytypes.SignalMetrics:
-			metricsSelectors = append(metricsSelectors, fieldKeySelector)
+			if fieldKeySelector.Source == telemetrytypes.SourceMeter {
+				meterSourceMetricsSelectors = append(meterSourceMetricsSelectors, fieldKeySelector)
+			} else {
+				metricsSelectors = append(metricsSelectors, fieldKeySelector)
+			}
 		case telemetrytypes.SignalUnspecified:
 			logsSelectors = append(logsSelectors, fieldKeySelector)
 			tracesSelectors = append(tracesSelectors, fieldKeySelector)
 			metricsSelectors = append(metricsSelectors, fieldKeySelector)
+			meterSourceMetricsSelectors = append(meterSourceMetricsSelectors, fieldKeySelector)
 		}
 	}
 
@@ -634,6 +720,11 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, fieldKeySelectors
 		return nil, err
 	}
 
+	meterSourceMetricsKeys, err := t.getMeterSourceMetricKeys(ctx, meterSourceMetricsSelectors)
+	if err != nil {
+		return nil, err
+	}
+
 	mapOfKeys := make(map[string][]*telemetrytypes.TelemetryFieldKey)
 	for _, key := range logsKeys {
 		mapOfKeys[key.Name] = append(mapOfKeys[key.Name], key)
@@ -644,6 +735,9 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, fieldKeySelectors
 	for _, key := range metricsKeys {
 		mapOfKeys[key.Name] = append(mapOfKeys[key.Name], key)
 	}
+	for _, key := range meterSourceMetricsKeys {
+		mapOfKeys[key.Name] = append(mapOfKeys[key.Name], key)
+	}
 
 	return mapOfKeys, nil
 }
@@ -949,6 +1043,51 @@ func (t *telemetryMetaStore) getMetricFieldValues(ctx context.Context, fieldValu
 		}
 		values.StringValues = append(values.StringValues, stringValue)
 	}
+
+	return values, nil
+}
+
+func (t *telemetryMetaStore) getMeterSourceMetricFieldValues(ctx context.Context, fieldValueSelector *telemetrytypes.FieldValueSelector) (*telemetrytypes.TelemetryFieldValues, error) {
+	sb := sqlbuilder.Select("DISTINCT arrayJoin(JSONExtractKeysAndValues(labels, 'String')) AS attr").
+		From(t.meterDBName + "." + t.meterFieldsTblName)
+
+	if fieldValueSelector.Name != "" {
+		sb.Where(sb.E("attr.1", fieldValueSelector.Name))
+	}
+	sb.Where(sb.NotLike("attr.1", "\\_\\_%"))
+
+	if fieldValueSelector.Value != "" {
+		if fieldValueSelector.SelectorMatchType == telemetrytypes.FieldSelectorMatchTypeExact {
+			sb.Where(sb.E("attr.2", fieldValueSelector.Value))
+		} else {
+			sb.Where(sb.Like("attr.2", "%"+fieldValueSelector.Value+"%"))
+		}
+	}
+	sb.Where(sb.NE("attr.2", ""))
+
+	if fieldValueSelector.Limit > 0 {
+		sb.Limit(fieldValueSelector.Limit)
+	} else {
+		sb.Limit(50)
+	}
+
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterValues.Error())
+	}
+	defer rows.Close()
+
+	values := &telemetrytypes.TelemetryFieldValues{}
+	for rows.Next() {
+		var attribute []string
+		if err := rows.Scan(&attribute); err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterValues.Error())
+		}
+		if len(attribute) > 1 {
+			values.StringValues = append(values.StringValues, attribute[1])
+		}
+	}
 	return values, nil
 }
 
@@ -983,7 +1122,11 @@ func (t *telemetryMetaStore) GetAllValues(ctx context.Context, fieldValueSelecto
 	case telemetrytypes.SignalLogs:
 		values, err = t.getLogFieldValues(ctx, fieldValueSelector)
 	case telemetrytypes.SignalMetrics:
-		values, err = t.getMetricFieldValues(ctx, fieldValueSelector)
+		if fieldValueSelector.Source == telemetrytypes.SourceMeter {
+			values, err = t.getMeterSourceMetricFieldValues(ctx, fieldValueSelector)
+		} else {
+			values, err = t.getMetricFieldValues(ctx, fieldValueSelector)
+		}
 	case telemetrytypes.SignalUnspecified:
 		mapOfValues := make(map[any]bool)
 		mapOfRelatedValues := make(map[any]bool)
@@ -1000,6 +1143,10 @@ func (t *telemetryMetaStore) GetAllValues(ctx context.Context, fieldValueSelecto
 		if err == nil {
 			populateAllUnspecifiedValues(allUnspecifiedValues, mapOfValues, mapOfRelatedValues, metricsValues)
 		}
+		meterSourceMetricsValues, err := t.getMeterSourceMetricFieldValues(ctx, fieldValueSelector)
+		if err == nil {
+			populateAllUnspecifiedValues(allUnspecifiedValues, mapOfValues, mapOfRelatedValues, meterSourceMetricsValues)
+		}
 		values = allUnspecifiedValues
 	}
 	if err != nil {
@@ -1031,6 +1178,33 @@ func (t *telemetryMetaStore) FetchTemporalityMulti(ctx context.Context, metricNa
 		return make(map[string]metrictypes.Temporality), nil
 	}
 
+	result := make(map[string]metrictypes.Temporality)
+	metricsTemporality, err := t.fetchMetricsTemporality(ctx, metricNames...)
+	if err != nil {
+		return nil, err
+	}
+	meterMetricsTemporality, err := t.fetchMeterSourceMetricsTemporality(ctx, metricNames...)
+	if err != nil {
+		return nil, err
+	}
+
+	// For metrics not found in the database, set to Unknown
+	for _, metricName := range metricNames {
+		if temporality, exists := metricsTemporality[metricName]; exists {
+			result[metricName] = temporality
+			continue
+		}
+		if temporality, exists := meterMetricsTemporality[metricName]; exists {
+			result[metricName] = temporality
+			continue
+		}
+		result[metricName] = metrictypes.Unknown
+	}
+
+	return result, nil
+}
+
+func (t *telemetryMetaStore) fetchMetricsTemporality(ctx context.Context, metricNames ...string) (map[string]metrictypes.Temporality, error) {
 	result := make(map[string]metrictypes.Temporality)
 
 	// Build query to fetch temporality for all metrics
@@ -1082,11 +1256,55 @@ func (t *telemetryMetaStore) FetchTemporalityMulti(ctx context.Context, metricNa
 		result[metricName] = temporality
 	}
 
-	// For metrics not found in the database, set to Unknown
-	for _, metricName := range metricNames {
-		if _, exists := result[metricName]; !exists {
-			result[metricName] = metrictypes.Unknown
+	return result, nil
+}
+
+func (t *telemetryMetaStore) fetchMeterSourceMetricsTemporality(ctx context.Context, metricNames ...string) (map[string]metrictypes.Temporality, error) {
+	result := make(map[string]metrictypes.Temporality)
+
+	sb := sqlbuilder.Select(
+		"metric_name",
+		"argMax(temporality, unix_milli) as temporality",
+	).From(t.meterDBName + "." + t.meterFieldsTblName)
+
+	// Filter by metric names (in the temporality column due to data mix-up)
+	sb.Where(sb.In("metric_name", metricNames))
+
+	// Group by metric name to get one temporality per metric
+	sb.GroupBy("metric_name")
+
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	t.logger.DebugContext(ctx, "fetching meter metrics temporality", "query", query, "args", args)
+
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to fetch meter metric temporality")
+	}
+	defer rows.Close()
+
+	// Process results
+	for rows.Next() {
+		var metricName, temporalityStr string
+		if err := rows.Scan(&metricName, &temporalityStr); err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to scan temporality result")
 		}
+
+		// Convert string to Temporality type
+		var temporality metrictypes.Temporality
+		switch temporalityStr {
+		case "Delta":
+			temporality = metrictypes.Delta
+		case "Cumulative":
+			temporality = metrictypes.Cumulative
+		case "Unspecified":
+			temporality = metrictypes.Unspecified
+		default:
+			// Unknown or empty temporality
+			temporality = metrictypes.Unknown
+		}
+
+		result[metricName] = temporality
 	}
 
 	return result, nil

pkg/telemetrymetadata/metadata_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetrymeter"
 	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
@@ -42,6 +43,8 @@ func TestGetKeys(t *testing.T) {
 		telemetrytraces.SpanIndexV3TableName,
 		telemetrymetrics.DBName,
 		telemetrymetrics.AttributesMetadataTableName,
+		telemetrymeter.DBName,
+		telemetrymeter.SamplesAgg1dTableName,
 		telemetrylogs.DBName,
 		telemetrylogs.LogsV2TableName,
 		telemetrylogs.TagAttributesV2TableName,

pkg/telemetrymeter/statement_builder.go

@@ -0,0 +1,365 @@
+package telemetrymeter
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+type meterQueryStatementBuilder struct {
+	logger                  *slog.Logger
+	metadataStore           telemetrytypes.MetadataStore
+	fm                      qbtypes.FieldMapper
+	cb                      qbtypes.ConditionBuilder
+	metricsStatementBuilder *telemetrymetrics.MetricQueryStatementBuilder
+}
+
+var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*meterQueryStatementBuilder)(nil)
+
+func NewMeterQueryStatementBuilder(
+	settings factory.ProviderSettings,
+	metadataStore telemetrytypes.MetadataStore,
+	fieldMapper qbtypes.FieldMapper,
+	conditionBuilder qbtypes.ConditionBuilder,
+) *meterQueryStatementBuilder {
+	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetrymeter")
+	metricsStatementBuilder := telemetrymetrics.NewMetricQueryStatementBuilder(settings, metadataStore, fieldMapper, conditionBuilder)
+
+	return &meterQueryStatementBuilder{
+		logger:                  metricsSettings.Logger(),
+		metadataStore:           metadataStore,
+		fm:                      fieldMapper,
+		cb:                      conditionBuilder,
+		metricsStatementBuilder: metricsStatementBuilder,
+	}
+}
+
+func (b *meterQueryStatementBuilder) Build(
+	ctx context.Context,
+	start uint64,
+	end uint64,
+	_ qbtypes.RequestType,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	variables map[string]qbtypes.VariableItem,
+) (*qbtypes.Statement, error) {
+	keySelectors := telemetrymetrics.GetKeySelectors(query)
+	keys, err := b.metadataStore.GetKeysMulti(ctx, keySelectors)
+	if err != nil {
+		return nil, err
+	}
+
+	start, end = querybuilder.AdjustedMetricTimeRange(start, end, uint64(query.StepInterval.Seconds()), query)
+
+	return b.buildPipelineStatement(ctx, start, end, query, keys, variables)
+}
+
+func (b *meterQueryStatementBuilder) buildPipelineStatement(
+	ctx context.Context,
+	start, end uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	keys map[string][]*telemetrytypes.TelemetryFieldKey,
+	variables map[string]qbtypes.VariableItem,
+) (*qbtypes.Statement, error) {
+	var (
+		cteFragments []string
+		cteArgs      [][]any
+	)
+
+	if b.metricsStatementBuilder.CanShortCircuitDelta(query) {
+		// spatial_aggregation_cte directly for certain delta queries
+		frag, args := b.buildTemporalAggDeltaFastPath(ctx, start, end, query, keys, variables)
+		if frag != "" {
+			cteFragments = append(cteFragments, frag)
+			cteArgs = append(cteArgs, args)
+		}
+	} else {
+		// temporal_aggregation_cte
+		if frag, args, err := b.buildTemporalAggregationCTE(ctx, start, end, query, keys, variables); err != nil {
+			return nil, err
+		} else if frag != "" {
+			cteFragments = append(cteFragments, frag)
+			cteArgs = append(cteArgs, args)
+		}
+
+		// spatial_aggregation_cte
+		frag, args := b.buildSpatialAggregationCTE(ctx, start, end, query, keys)
+		if frag != "" {
+			cteFragments = append(cteFragments, frag)
+			cteArgs = append(cteArgs, args)
+		}
+	}
+
+	// final SELECT
+	return b.metricsStatementBuilder.BuildFinalSelect(cteFragments, cteArgs, query)
+}
+
+func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(
+	ctx context.Context,
+	start, end uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	keys map[string][]*telemetrytypes.TelemetryFieldKey,
+	variables map[string]qbtypes.VariableItem,
+) (string, []any) {
+	var filterWhere *querybuilder.PreparedWhereClause
+	var err error
+	stepSec := int64(query.StepInterval.Seconds())
+
+	sb := sqlbuilder.NewSelectBuilder()
+
+	sb.SelectMore(fmt.Sprintf(
+		"toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(%d)) AS ts",
+		stepSec,
+	))
+	for _, g := range query.GroupBy {
+		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		if err != nil {
+			return "", []any{}
+		}
+		sb.SelectMore(col)
+	}
+
+	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	if query.Aggregations[0].TimeAggregation == metrictypes.TimeAggregationRate {
+		aggCol = fmt.Sprintf("%s/%d", aggCol, stepSec)
+	}
+
+	sb.SelectMore(fmt.Sprintf("%s AS value", aggCol))
+	sb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	sb.Where(
+		sb.In("metric_name", query.Aggregations[0].MetricName),
+		sb.GTE("unix_milli", start),
+		sb.LT("unix_milli", end),
+	)
+	if query.Filter != nil && query.Filter.Expression != "" {
+		filterWhere, err = querybuilder.PrepareWhereClause(query.Filter.Expression, querybuilder.FilterExprVisitorOpts{
+			FieldMapper:      b.fm,
+			ConditionBuilder: b.cb,
+			FieldKeys:        keys,
+			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
+			Variables:        variables,
+		})
+		if err != nil {
+			return "", []any{}
+		}
+	}
+	if filterWhere != nil {
+		sb.AddWhereClause(filterWhere.WhereClause)
+	}
+
+	if query.Aggregations[0].Temporality != metrictypes.Unknown {
+		sb.Where(sb.ILike("temporality", query.Aggregations[0].Temporality.StringValue()))
+	}
+	sb.GroupBy("ts")
+	sb.GroupBy(querybuilder.GroupByKeys(query.GroupBy)...)
+
+	q, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
+}
+
+func (b *meterQueryStatementBuilder) buildTemporalAggregationCTE(
+	ctx context.Context,
+	start, end uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	keys map[string][]*telemetrytypes.TelemetryFieldKey,
+	variables map[string]qbtypes.VariableItem,
+) (string, []any, error) {
+	if query.Aggregations[0].Temporality == metrictypes.Delta {
+		return b.buildTemporalAggDelta(ctx, start, end, query, keys, variables)
+	}
+	return b.buildTemporalAggCumulativeOrUnspecified(ctx, start, end, query, keys, variables)
+}
+
+func (b *meterQueryStatementBuilder) buildTemporalAggDelta(
+	ctx context.Context,
+	start, end uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	keys map[string][]*telemetrytypes.TelemetryFieldKey,
+	variables map[string]qbtypes.VariableItem,
+) (string, []any, error) {
+	var filterWhere *querybuilder.PreparedWhereClause
+	var err error
+
+	stepSec := int64(query.StepInterval.Seconds())
+	sb := sqlbuilder.NewSelectBuilder()
+
+	sb.Select("fingerprint")
+	sb.SelectMore(fmt.Sprintf(
+		"toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(%d)) AS ts",
+		stepSec,
+	))
+
+	for _, g := range query.GroupBy {
+		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		if err != nil {
+			return "", nil, err
+		}
+		sb.SelectMore(col)
+	}
+
+	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality,
+		query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	if query.Aggregations[0].TimeAggregation == metrictypes.TimeAggregationRate {
+		aggCol = fmt.Sprintf("%s/%d", aggCol, stepSec)
+	}
+
+	sb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
+
+	sb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	sb.Where(
+		sb.In("metric_name", query.Aggregations[0].MetricName),
+		sb.GTE("unix_milli", start),
+		sb.LT("unix_milli", end),
+	)
+
+	if query.Filter != nil && query.Filter.Expression != "" {
+		filterWhere, err = querybuilder.PrepareWhereClause(query.Filter.Expression, querybuilder.FilterExprVisitorOpts{
+			FieldMapper:      b.fm,
+			ConditionBuilder: b.cb,
+			FieldKeys:        keys,
+			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
+			Variables:        variables,
+		})
+		if err != nil {
+			return "", nil, err
+		}
+	}
+	if filterWhere != nil {
+		sb.AddWhereClause(filterWhere.WhereClause)
+	}
+
+	if query.Aggregations[0].Temporality != metrictypes.Unknown {
+		sb.Where(sb.ILike("temporality", query.Aggregations[0].Temporality.StringValue()))
+	}
+
+	sb.GroupBy("fingerprint", "ts")
+	sb.GroupBy(querybuilder.GroupByKeys(query.GroupBy)...)
+	sb.OrderBy("fingerprint", "ts")
+
+	q, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
+}
+
+func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
+	ctx context.Context,
+	start, end uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	keys map[string][]*telemetrytypes.TelemetryFieldKey,
+	variables map[string]qbtypes.VariableItem,
+) (string, []any, error) {
+	var filterWhere *querybuilder.PreparedWhereClause
+	var err error
+	stepSec := int64(query.StepInterval.Seconds())
+
+	baseSb := sqlbuilder.NewSelectBuilder()
+	baseSb.Select("fingerprint")
+	baseSb.SelectMore(fmt.Sprintf(
+		"toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(%d)) AS ts",
+		stepSec,
+	))
+	for _, g := range query.GroupBy {
+		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		if err != nil {
+			return "", nil, err
+		}
+		baseSb.SelectMore(col)
+	}
+
+	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	baseSb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
+
+	baseSb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	baseSb.Where(
+		baseSb.In("metric_name", query.Aggregations[0].MetricName),
+		baseSb.GTE("unix_milli", start),
+		baseSb.LT("unix_milli", end),
+	)
+	if query.Filter != nil && query.Filter.Expression != "" {
+		filterWhere, err = querybuilder.PrepareWhereClause(query.Filter.Expression, querybuilder.FilterExprVisitorOpts{
+			FieldMapper:      b.fm,
+			ConditionBuilder: b.cb,
+			FieldKeys:        keys,
+			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
+			Variables:        variables,
+		})
+		if err != nil {
+			return "", nil, err
+		}
+	}
+	if filterWhere != nil {
+		baseSb.AddWhereClause(filterWhere.WhereClause)
+	}
+
+	if query.Aggregations[0].Temporality != metrictypes.Unknown {
+		baseSb.Where(baseSb.ILike("temporality", query.Aggregations[0].Temporality.StringValue()))
+	}
+	baseSb.GroupBy("fingerprint", "ts")
+	baseSb.GroupBy(querybuilder.GroupByKeys(query.GroupBy)...)
+	baseSb.OrderBy("fingerprint", "ts")
+
+	innerQuery, innerArgs := baseSb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	switch query.Aggregations[0].TimeAggregation {
+	case metrictypes.TimeAggregationRate:
+		rateExpr := fmt.Sprintf(telemetrymetrics.RateWithoutNegative, start, start)
+		wrapped := sqlbuilder.NewSelectBuilder()
+		wrapped.Select("ts")
+		for _, g := range query.GroupBy {
+			wrapped.SelectMore(fmt.Sprintf("`%s`", g.TelemetryFieldKey.Name))
+		}
+		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", rateExpr))
+		wrapped.From(fmt.Sprintf("(%s) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)", innerQuery))
+		q, args := wrapped.BuildWithFlavor(sqlbuilder.ClickHouse, innerArgs...)
+		return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
+
+	case metrictypes.TimeAggregationIncrease:
+		incExpr := fmt.Sprintf(telemetrymetrics.IncreaseWithoutNegative, start, start)
+		wrapped := sqlbuilder.NewSelectBuilder()
+		wrapped.Select("ts")
+		for _, g := range query.GroupBy {
+			wrapped.SelectMore(fmt.Sprintf("`%s`", g.TelemetryFieldKey.Name))
+		}
+		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", incExpr))
+		wrapped.From(fmt.Sprintf("(%s) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)", innerQuery))
+		q, args := wrapped.BuildWithFlavor(sqlbuilder.ClickHouse, innerArgs...)
+		return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
+	default:
+		return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", innerQuery), innerArgs, nil
+	}
+}
+
+func (b *meterQueryStatementBuilder) buildSpatialAggregationCTE(
+	_ context.Context,
+	_ uint64,
+	_ uint64,
+	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
+	_ map[string][]*telemetrytypes.TelemetryFieldKey,
+) (string, []any) {
+	sb := sqlbuilder.NewSelectBuilder()
+
+	sb.Select("ts")
+	for _, g := range query.GroupBy {
+		sb.SelectMore(fmt.Sprintf("`%s`", g.TelemetryFieldKey.Name))
+	}
+	sb.SelectMore(fmt.Sprintf("%s(per_series_value) AS value", query.Aggregations[0].SpaceAggregation.StringValue()))
+	sb.From("__temporal_aggregation_cte")
+	sb.Where(sb.EQ("isNaN(per_series_value)", 0))
+	if query.Aggregations[0].ValueFilter != nil {
+		sb.Where(sb.EQ("per_series_value", query.Aggregations[0].ValueFilter.Value))
+	}
+	sb.GroupBy("ts")
+	sb.GroupBy(querybuilder.GroupByKeys(query.GroupBy)...)
+
+	q, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
+}

pkg/telemetrymeter/stmt_builder_test.go

@@ -0,0 +1,191 @@
+package telemetrymeter
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStatementBuilder(t *testing.T) {
+	cases := []struct {
+		name        string
+		requestType qbtypes.RequestType
+		query       qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]
+		expected    qbtypes.Statement
+		expectedErr error
+	}{
+		{
+			name:        "test_cumulative_rate_sum",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Signal:       telemetrytypes.SignalMetrics,
+				StepInterval: qbtypes.Step{Duration: 24 * time.Hour},
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "signoz_calls_total",
+						Type:             metrictypes.SumType,
+						Temporality:      metrictypes.Cumulative,
+						TimeAggregation:  metrictypes.TimeAggregationRate,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "service.name = 'cartservice'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "service.name",
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __temporal_aggregation_cte AS (SELECT ts, `service.name`, If((per_series_value - lagInFrame(per_series_value, 1, 0) OVER rate_window) < 0, per_series_value / (ts - lagInFrame(ts, 1, toDateTime(fromUnixTimestamp64Milli(1747785600000))) OVER rate_window), (per_series_value - lagInFrame(per_series_value, 1, 0) OVER rate_window) / (ts - lagInFrame(ts, 1, toDateTime(fromUnixTimestamp64Milli(1747785600000))) OVER rate_window)) AS per_series_value FROM (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(86400)) AS ts, JSONExtractString(labels, 'service.name') AS `service.name`, max(value) AS per_series_value FROM signoz_meter.distributed_samples AS points WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? AND JSONExtractString(labels, 'service.name') = ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, ts, `service.name` ORDER BY fingerprint, ts) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)), __spatial_aggregation_cte AS (SELECT ts, `service.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `service.name`) SELECT * FROM __spatial_aggregation_cte",
+				Args:  []any{"signoz_calls_total", uint64(1747785600000), uint64(1747983420000), "cartservice", "cumulative", 0},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:        "test_delta_rate_sum",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Signal:       telemetrytypes.SignalMetrics,
+				StepInterval: qbtypes.Step{Duration: 24 * time.Hour},
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "signoz_calls_total",
+						Type:             metrictypes.SumType,
+						Temporality:      metrictypes.Delta,
+						TimeAggregation:  metrictypes.TimeAggregationRate,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "service.name = 'cartservice'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "service.name",
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __spatial_aggregation_cte AS (SELECT toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(86400)) AS ts, JSONExtractString(labels, 'service.name') AS `service.name`, sum(value)/86400 AS value FROM signoz_meter.distributed_samples AS points WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? AND JSONExtractString(labels, 'service.name') = ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY ts, `service.name`) SELECT * FROM __spatial_aggregation_cte",
+				Args:  []any{"signoz_calls_total", uint64(1747872000000), uint64(1747983420000), "cartservice", "delta"},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:        "test_delta_rate_avg",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Signal:       telemetrytypes.SignalMetrics,
+				StepInterval: qbtypes.Step{Duration: 24 * time.Hour},
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "signoz_calls_total",
+						Type:             metrictypes.SumType,
+						Temporality:      metrictypes.Delta,
+						TimeAggregation:  metrictypes.TimeAggregationRate,
+						SpaceAggregation: metrictypes.SpaceAggregationAvg,
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "service.name = 'cartservice'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "service.name",
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __temporal_aggregation_cte AS (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(86400)) AS ts, JSONExtractString(labels, 'service.name') AS `service.name`, sum(value)/86400 AS per_series_value FROM signoz_meter.distributed_samples AS points WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? AND JSONExtractString(labels, 'service.name') = ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, ts, `service.name` ORDER BY fingerprint, ts), __spatial_aggregation_cte AS (SELECT ts, `service.name`, avg(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `service.name`) SELECT * FROM __spatial_aggregation_cte",
+				Args:  []any{"signoz_calls_total", uint64(1747872000000), uint64(1747983420000), "cartservice", "delta", 0},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:        "test_gauge_avg_sum",
+			requestType: qbtypes.RequestTypeTimeSeries,
+			query: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
+				Signal:       telemetrytypes.SignalMetrics,
+				StepInterval: qbtypes.Step{Duration: 24 * time.Hour},
+				Aggregations: []qbtypes.MetricAggregation{
+					{
+						MetricName:       "system.memory.usage",
+						Type:             metrictypes.GaugeType,
+						Temporality:      metrictypes.Unspecified,
+						TimeAggregation:  metrictypes.TimeAggregationAvg,
+						SpaceAggregation: metrictypes.SpaceAggregationSum,
+					},
+				},
+				Filter: &qbtypes.Filter{
+					Expression: "host.name = 'big-data-node-1'",
+				},
+				Limit: 10,
+				GroupBy: []qbtypes.GroupByKey{
+					{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name: "host.name",
+						},
+					},
+				},
+			},
+			expected: qbtypes.Statement{
+				Query: "WITH __temporal_aggregation_cte AS (SELECT fingerprint, toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), toIntervalSecond(86400)) AS ts, JSONExtractString(labels, 'host.name') AS `host.name`, avg(value) AS per_series_value FROM signoz_meter.distributed_samples AS points WHERE metric_name IN (?) AND unix_milli >= ? AND unix_milli < ? AND JSONExtractString(labels, 'host.name') = ? AND LOWER(temporality) LIKE LOWER(?) GROUP BY fingerprint, ts, `host.name` ORDER BY fingerprint, ts), __spatial_aggregation_cte AS (SELECT ts, `host.name`, sum(per_series_value) AS value FROM __temporal_aggregation_cte WHERE isNaN(per_series_value) = ? GROUP BY ts, `host.name`) SELECT * FROM __spatial_aggregation_cte",
+				Args:  []any{"system.memory.usage", uint64(1747872000000), uint64(1747983420000), "big-data-node-1", "unspecified", 0},
+			},
+			expectedErr: nil,
+		},
+	}
+
+	fm := telemetrymetrics.NewFieldMapper()
+	cb := telemetrymetrics.NewConditionBuilder(fm)
+	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
+	keys, err := telemetrytypestest.LoadFieldKeysFromJSON("testdata/keys_map.json")
+	if err != nil {
+		t.Fatalf("failed to load field keys: %v", err)
+	}
+	mockMetadataStore.KeysMap = keys
+
+	statementBuilder := NewMeterQueryStatementBuilder(
+		instrumentationtest.New().ToProviderSettings(),
+		mockMetadataStore,
+		fm,
+		cb,
+	)
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+
+			q, err := statementBuilder.Build(context.Background(), 1747947419000, 1747983448000, c.requestType, c.query, nil)
+
+			if c.expectedErr != nil {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), c.expectedErr.Error())
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, c.expected.Query, q.Query)
+				require.Equal(t, c.expected.Args, q.Args)
+				require.Equal(t, c.expected.Warnings, q.Warnings)
+			}
+		})
+	}
+}

pkg/telemetrymeter/tables.go

@@ -0,0 +1,194 @@
+package telemetrymeter
+
+import (
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
+)
+
+const (
+	DBName                     = "signoz_meter"
+	SamplesTableName           = "distributed_samples"
+	SamplesLocalTableName      = "samples"
+	SamplesAgg1dTableName      = "distributed_samples_agg_1d"
+	SamplesAgg1dLocalTableName = "samples_agg_1d"
+)
+
+var (
+	oneMonthInMilliseconds = uint64(time.Hour.Milliseconds() * 24 * 30)
+
+	// when the query requests for almost 1 day, but not exactly 1 day, we need to add an offset to the end time
+	// to make sure that we are using the correct table
+	// this is because the start gets adjusted to the nearest step interval and uses the 5m table for 4m step interval
+	// leading to time series that doesn't best represent the rate of change
+	offsetBucket = uint64(1 * time.Hour.Milliseconds())
+)
+
+// start and end are in milliseconds
+// we have two tables for samples
+// 1. distributed_samples
+// 2. distributed_samples_agg_1d - for queries with time range above or equal to 30 days
+// if the `timeAggregation` is `count_distinct` we can't use the aggregated tables because they don't support it
+func WhichSamplesTableToUse(
+	start, end uint64,
+	metricType metrictypes.Type,
+	timeAggregation metrictypes.TimeAggregation,
+	tableHints *metrictypes.MetricTableHints,
+) string {
+
+	// if we have a hint for the table, we need to use it
+	// the hint will be used to override the default table selection logic
+	if tableHints != nil {
+		if tableHints.SamplesTableName != "" {
+			return tableHints.SamplesTableName
+		}
+	}
+
+	// if the time aggregation is count_distinct, we need to use the distributed_samples table
+	// because the aggregated tables don't support count_distinct
+	if timeAggregation == metrictypes.TimeAggregationCountDistinct {
+		return SamplesTableName
+	}
+
+	if end-start < oneMonthInMilliseconds+offsetBucket {
+		return SamplesTableName
+	}
+	return SamplesAgg1dTableName
+
+}
+
+func AggregationColumnForSamplesTable(
+	start, end uint64,
+	metricType metrictypes.Type,
+	temporality metrictypes.Temporality,
+	timeAggregation metrictypes.TimeAggregation,
+	tableHints *metrictypes.MetricTableHints,
+) string {
+	tableName := WhichSamplesTableToUse(start, end, metricType, timeAggregation, tableHints)
+	var aggregationColumn string
+	switch temporality {
+	case metrictypes.Delta:
+		switch tableName {
+		case SamplesTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(value)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(value)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "avg(value)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(value)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(value)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "count(value)"
+			case metrictypes.TimeAggregationCountDistinct:
+				aggregationColumn = "countDistinct(value)"
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // only these two options give meaningful results
+				aggregationColumn = "sum(value)"
+			}
+		case SamplesAgg1dTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(last)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(sum)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "sum(sum) / sum(count)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(min)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(max)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "sum(count)"
+			// count_distinct is not supported in aggregated tables
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // only these two options give meaningful results
+				aggregationColumn = "sum(sum)"
+			}
+		}
+	case metrictypes.Cumulative:
+		switch tableName {
+		case SamplesTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(value)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(value)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "avg(value)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(value)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(value)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "count(value)"
+			case metrictypes.TimeAggregationCountDistinct:
+				aggregationColumn = "countDistinct(value)"
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // only these two options give meaningful results
+				aggregationColumn = "max(value)"
+			}
+		case SamplesAgg1dTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(last)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(sum)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "sum(sum) / sum(count)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(min)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(max)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "sum(count)"
+			// count_distinct is not supported in aggregated tables
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // only these two options give meaningful results
+				aggregationColumn = "max(max)"
+			}
+		}
+
+	case metrictypes.Unspecified:
+		switch tableName {
+		case SamplesTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(value)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(value)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "avg(value)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(value)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(value)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "count(value)"
+			case metrictypes.TimeAggregationCountDistinct:
+				aggregationColumn = "countDistinct(value)"
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // ideally, this should never happen
+				aggregationColumn = "sum(value)"
+			}
+		case SamplesAgg1dTableName:
+			switch timeAggregation {
+			case metrictypes.TimeAggregationLatest:
+				aggregationColumn = "anyLast(last)"
+			case metrictypes.TimeAggregationSum:
+				aggregationColumn = "sum(sum)"
+			case metrictypes.TimeAggregationAvg:
+				aggregationColumn = "sum(sum) / sum(count)"
+			case metrictypes.TimeAggregationMin:
+				aggregationColumn = "min(min)"
+			case metrictypes.TimeAggregationMax:
+				aggregationColumn = "max(max)"
+			case metrictypes.TimeAggregationCount:
+				aggregationColumn = "sum(count)"
+			// count_distinct is not supported in aggregated tables
+			case metrictypes.TimeAggregationRate, metrictypes.TimeAggregationIncrease: // ideally, this should never happen
+				aggregationColumn = "sum(sum)"
+			}
+		}
+
+	}
+	return aggregationColumn
+}

pkg/telemetrymeter/testdata/keys_map.json

@@ -0,0 +1,34 @@
+{
+    "service.name": [
+        {
+            "name": "service.name",
+            "fieldContext": "resource",
+            "fieldDataType": "string",
+            "signal": "metrics"
+        }
+    ],
+    "http.request.method": [
+        {
+            "name": "http.request.method",
+            "fieldContext": "attribute",
+            "fieldDataType": "string",
+            "signal": "metrics"
+        }
+    ],
+    "http.response.status_code": [
+        {
+            "name": "http.response.status_code",
+            "fieldContext": "attribute",
+            "fieldDataType": "int",
+            "signal": "metrics"
+        }
+    ],
+    "host.name": [
+        {
+            "name": "host.name",
+            "fieldContext": "resource",
+            "fieldDataType": "string",
+            "signal": "metrics"
+        }
+    ]
+}

pkg/telemetrymetrics/statement_builder.go

@@ -19,23 +19,23 @@ const (
 	IncreaseWithoutNegative = `If((per_series_value - lagInFrame(per_series_value, 1, 0) OVER rate_window) < 0, per_series_value, ((per_series_value - lagInFrame(per_series_value, 1, 0) OVER rate_window) / (ts - lagInFrame(ts, 1, toDateTime(fromUnixTimestamp64Milli(%d))) OVER rate_window)) * (ts - lagInFrame(ts, 1, toDateTime(fromUnixTimestamp64Milli(%d))) OVER rate_window))`
 )
 
-type metricQueryStatementBuilder struct {
+type MetricQueryStatementBuilder struct {
 	logger        *slog.Logger
 	metadataStore telemetrytypes.MetadataStore
 	fm            qbtypes.FieldMapper
 	cb            qbtypes.ConditionBuilder
 }
 
-var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*metricQueryStatementBuilder)(nil)
+var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*MetricQueryStatementBuilder)(nil)
 
 func NewMetricQueryStatementBuilder(
 	settings factory.ProviderSettings,
 	metadataStore telemetrytypes.MetadataStore,
 	fieldMapper qbtypes.FieldMapper,
 	conditionBuilder qbtypes.ConditionBuilder,
-) *metricQueryStatementBuilder {
+) *MetricQueryStatementBuilder {
 	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetrymetrics")
-	return &metricQueryStatementBuilder{
+	return &MetricQueryStatementBuilder{
 		logger:        metricsSettings.Logger(),
 		metadataStore: metadataStore,
 		fm:            fieldMapper,
@@ -43,7 +43,7 @@ func NewMetricQueryStatementBuilder(
 	}
 }
 
-func getKeySelectors(query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) []*telemetrytypes.FieldKeySelector {
+func GetKeySelectors(query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) []*telemetrytypes.FieldKeySelector {
 	var keySelectors []*telemetrytypes.FieldKeySelector
 	if query.Filter != nil && query.Filter.Expression != "" {
 		whereClauseSelectors := querybuilder.QueryStringToKeysSelectors(query.Filter.Expression)
@@ -71,7 +71,7 @@ func getKeySelectors(query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation])
 	return keySelectors
 }
 
-func (b *metricQueryStatementBuilder) Build(
+func (b *MetricQueryStatementBuilder) Build(
 	ctx context.Context,
 	start uint64,
 	end uint64,
@@ -79,7 +79,7 @@ func (b *metricQueryStatementBuilder) Build(
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	variables map[string]qbtypes.VariableItem,
 ) (*qbtypes.Statement, error) {
-	keySelectors := getKeySelectors(query)
+	keySelectors := GetKeySelectors(query)
 	keys, err := b.metadataStore.GetKeysMulti(ctx, keySelectors)
 	if err != nil {
 		return nil, err
@@ -112,7 +112,7 @@ func (b *metricQueryStatementBuilder) Build(
 // we can directly use the quantilesDDMerge function
 //
 // all of this is true only for delta metrics
-func (b *metricQueryStatementBuilder) canShortCircuitDelta(q qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) bool {
+func (b *MetricQueryStatementBuilder) CanShortCircuitDelta(q qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) bool {
 	if q.Aggregations[0].Temporality != metrictypes.Delta {
 		return false
 	}
@@ -138,7 +138,7 @@ func (b *metricQueryStatementBuilder) canShortCircuitDelta(q qbtypes.QueryBuilde
 	return false
 }
 
-func (b *metricQueryStatementBuilder) buildPipelineStatement(
+func (b *MetricQueryStatementBuilder) buildPipelineStatement(
 	ctx context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -199,7 +199,7 @@ func (b *metricQueryStatementBuilder) buildPipelineStatement(
 		return nil, err
 	}
 
-	if b.canShortCircuitDelta(query) {
+	if b.CanShortCircuitDelta(query) {
 		// spatial_aggregation_cte directly for certain delta queries
 		frag, args := b.buildTemporalAggDeltaFastPath(start, end, query, timeSeriesCTE, timeSeriesCTEArgs)
 		if frag != "" {
@@ -229,10 +229,10 @@ func (b *metricQueryStatementBuilder) buildPipelineStatement(
 	query.GroupBy = origGroupBy
 
 	// final SELECT
-	return b.buildFinalSelect(cteFragments, cteArgs, query)
+	return b.BuildFinalSelect(cteFragments, cteArgs, query)
 }
 
-func (b *metricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
+func (b *MetricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	timeSeriesCTE string,
@@ -280,7 +280,7 @@ func (b *metricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
 }
 
-func (b *metricQueryStatementBuilder) buildTimeSeriesCTE(
+func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
 	ctx context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -343,7 +343,7 @@ func (b *metricQueryStatementBuilder) buildTimeSeriesCTE(
 	return fmt.Sprintf("(%s) AS filtered_time_series", q), args, nil
 }
 
-func (b *metricQueryStatementBuilder) buildTemporalAggregationCTE(
+func (b *MetricQueryStatementBuilder) buildTemporalAggregationCTE(
 	ctx context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -357,7 +357,7 @@ func (b *metricQueryStatementBuilder) buildTemporalAggregationCTE(
 	return b.buildTemporalAggCumulativeOrUnspecified(ctx, start, end, query, timeSeriesCTE, timeSeriesCTEArgs)
 }
 
-func (b *metricQueryStatementBuilder) buildTemporalAggDelta(
+func (b *MetricQueryStatementBuilder) buildTemporalAggDelta(
 	_ context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -400,7 +400,7 @@ func (b *metricQueryStatementBuilder) buildTemporalAggDelta(
 	return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
 }
 
-func (b *metricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
+func (b *MetricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 	_ context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -465,7 +465,7 @@ func (b *metricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 	}
 }
 
-func (b *metricQueryStatementBuilder) buildSpatialAggregationCTE(
+func (b *MetricQueryStatementBuilder) buildSpatialAggregationCTE(
 	_ context.Context,
 	_ uint64,
 	_ uint64,
@@ -491,7 +491,7 @@ func (b *metricQueryStatementBuilder) buildSpatialAggregationCTE(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
 }
 
-func (b *metricQueryStatementBuilder) buildFinalSelect(
+func (b *MetricQueryStatementBuilder) BuildFinalSelect(
 	cteFragments []string,
 	cteArgs [][]any,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],

pkg/types/querybuildertypes/querybuildertypesv5/builder_query.go

@@ -14,6 +14,9 @@ type QueryBuilderQuery[T any] struct {
 	// signal to query
 	Signal telemetrytypes.Signal `json:"signal,omitempty"`
 
+	// source for query
+	Source telemetrytypes.Source `json:"source,omitempty"`
+
 	// we want to support multiple aggregations
 	// currently supported: []Aggregation, []MetricAggregation
 	Aggregations []T `json:"aggregations,omitempty"`

pkg/types/quickfiltertypes/filter.go

@@ -35,6 +35,7 @@ var (
 	SignalLogs          = Signal{valuer.NewString("logs")}
 	SignalApiMonitoring = Signal{valuer.NewString("api_monitoring")}
 	SignalExceptions    = Signal{valuer.NewString("exceptions")}
+	SignalMeterExplorer = Signal{valuer.NewString("meter_explorer")}
 )
 
 // NewSignal creates a Signal from a string
@@ -48,6 +49,8 @@ func NewSignal(s string) (Signal, error) {
 		return SignalApiMonitoring, nil
 	case "exceptions":
 		return SignalExceptions, nil
+	case "meter_explorer":
+		return SignalMeterExplorer, nil
 	default:
 		return Signal{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid signal: %s", s)
 	}
@@ -178,6 +181,12 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 		{"key": "k8s.pod.name", "dataType": "string", "type": "resource"},
 	}
 
+	meterExplorerFilters := []map[string]interface{}{
+		{"key": "deployment.environment", "dataType": "float64", "type": "Sum"},
+		{"key": "service.name", "dataType": "float64", "type": "Sum"},
+		{"key": "host.name", "dataType": "float64", "type": "Sum"},
+	}
+
 	tracesJSON, err := json.Marshal(tracesFilters)
 	if err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal traces filters")
@@ -190,12 +199,19 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 
 	apiMonitoringJSON, err := json.Marshal(apiMonitoringFilters)
 	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal Api Monitoring filters")
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal api monitoring filters")
 	}
+
 	exceptionsJSON, err := json.Marshal(exceptionsFilters)
 	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal Exceptions filters")
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal exceptions filters")
 	}
+
+	meterExplorerJSON, err := json.Marshal(meterExplorerFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal meter explorer filters")
+	}
+
 	timeRightNow := time.Now()
 
 	return []*StorableQuickFilter{
@@ -247,5 +263,17 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 				UpdatedAt: timeRightNow,
 			},
 		},
+		{
+			Identifiable: types.Identifiable{
+				ID: valuer.GenerateUUID(),
+			},
+			OrgID:  orgID,
+			Filter: string(meterExplorerJSON),
+			Signal: SignalMeterExplorer,
+			TimeAuditable: types.TimeAuditable{
+				CreatedAt: timeRightNow,
+				UpdatedAt: timeRightNow,
+			},
+		},
 	}, nil
 }

pkg/types/telemetrytypes/field.go

@@ -124,6 +124,7 @@ type FieldKeySelector struct {
 	StartUnixMilli    int64                  `json:"startUnixMilli"`
 	EndUnixMilli      int64                  `json:"endUnixMilli"`
 	Signal            Signal                 `json:"signal"`
+	Source            Source                 `json:"source"`
 	FieldContext      FieldContext           `json:"fieldContext"`
 	FieldDataType     FieldDataType          `json:"fieldDataType"`
 	Name              string                 `json:"name"`

pkg/types/telemetrytypes/source.go

@@ -0,0 +1,12 @@
+package telemetrytypes
+
+import "github.com/SigNoz/signoz/pkg/valuer"
+
+type Source struct {
+	valuer.String
+}
+
+var (
+	SourceMeter       = Source{valuer.NewString("meter")}
+	SourceUnspecified = Source{valuer.NewString("")}
+)