chore: api migration

frontend/src/api/metricsExplorer/v2/getMetricAlerts.ts

@@ -0,0 +1,29 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { GetMetricAlertsResponse } from 'types/api/metricsExplorer/v2';
+
+export const getMetricAlerts = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<GetMetricAlertsResponse>> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.get('/metric/alerts', {
+			params: {
+				metricName: encodedMetricName,
+			},
+			signal,
+			headers,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/api/metricsExplorer/v2/getMetricAttributes.ts

@@ -0,0 +1,37 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	GetMetricAttributesRequest,
+	GetMetricAttributesResponse,
+} from 'types/api/metricsExplorer/v2';
+
+export const getMetricAttributes = async (
+	{ metricName, start, end }: GetMetricAttributesRequest,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<GetMetricAttributesResponse>> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.post(
+			'/metrics/attributes',
+			{
+				metricName: encodedMetricName,
+				start,
+				end,
+			},
+			{
+				signal,
+				headers,
+			},
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/api/metricsExplorer/v2/getMetricDashboards.ts

@@ -0,0 +1,29 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { GetMetricDashboardsResponse } from 'types/api/metricsExplorer/v2';
+
+export const getMetricDashboards = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<GetMetricDashboardsResponse>> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.get('/metric/dashboards', {
+			params: {
+				metricName: encodedMetricName,
+			},
+			signal,
+			headers,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/api/metricsExplorer/v2/getMetricHighlights.ts

@@ -0,0 +1,29 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { GetMetricHighlightsResponse } from 'types/api/metricsExplorer/v2';
+
+export const getMetricHighlights = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<GetMetricHighlightsResponse>> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.get('/metric/highlights', {
+			params: {
+				metricName: encodedMetricName,
+			},
+			signal,
+			headers,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/api/metricsExplorer/v2/getMetricMetadata.ts

@@ -0,0 +1,29 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { GetMetricMetadataResponse } from 'types/api/metricsExplorer/v2';
+
+export const getMetricMetadata = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<GetMetricMetadataResponse>> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.get('/metrics/metadata', {
+			params: {
+				metricName: encodedMetricName,
+			},
+			signal,
+			headers,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/api/metricsExplorer/v2/updateMetricMetadata.ts

@@ -0,0 +1,28 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	UpdateMetricMetadataRequest,
+	UpdateMetricMetadataResponse,
+} from 'types/api/metricsExplorer/v2';
+
+const updateMetricMetadata = async (
+	metricName: string,
+	props: UpdateMetricMetadataRequest,
+): Promise<SuccessResponseV2<UpdateMetricMetadataResponse>> => {
+	try {
+		const response = await axios.post(`/metrics/${metricName}/metadata`, {
+			...props,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default updateMetricMetadata;

frontend/src/constants/reactQueryKeys.ts

@@ -56,6 +56,13 @@ export const REACT_QUERY_KEY = {
 	GET_RELATED_METRICS: 'GET_RELATED_METRICS',
 	GET_INSPECT_METRICS_DETAILS: 'GET_INSPECT_METRICS_DETAILS',
 
+	// Metrics Explorer V2 Query Keys
+	GET_METRIC_HIGHLIGHTS: 'GET_METRIC_HIGHLIGHTS',
+	GET_METRIC_METADATA: 'GET_METRIC_METADATA',
+	GET_METRIC_ATTRIBUTES: 'GET_METRIC_ATTRIBUTES',
+	GET_METRIC_ALERTS: 'GET_METRIC_ALERTS',
+	GET_METRIC_DASHBOARDS: 'GET_METRIC_DASHBOARDS',
+
 	// Traces Funnels Query Keys
 	GET_DOMAINS_LIST: 'GET_DOMAINS_LIST',
 	GET_DOMAIN_METRICS_DATA: 'GET_DOMAIN_METRICS_DATA',

frontend/src/container/MetricsExplorer/MetricDetails/AllAttributes.tsx

@@ -1,8 +1,17 @@
-import { Button, Collapse, Input, Menu, Popover, Typography } from 'antd';
+import {
+	Button,
+	Collapse,
+	Input,
+	Menu,
+	Popover,
+	Skeleton,
+	Typography,
+} from 'antd';
 import { ColumnsType } from 'antd/es/table';
 import logEvent from 'api/common/logEvent';
 import { ResizeTable } from 'components/ResizeTable';
 import { DataType } from 'container/LogDetailedView/TableView';
+import { useGetMetricAttributes } from 'hooks/metricsExplorer/v2/useGetMetricAttributes';
 import { useNotifications } from 'hooks/useNotifications';
 import { Compass, Copy, Search } from 'lucide-react';
 import { useCallback, useMemo, useState } from 'react';
@@ -13,7 +22,9 @@ import ROUTES from '../../../constants/routes';
 import { useHandleExplorerTabChange } from '../../../hooks/useHandleExplorerTabChange';
 import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
 import { AllAttributesProps, AllAttributesValueProps } from './types';
-import { getMetricDetailsQuery } from './utils';
+import { getMetricDetailsQuery, transformMetricAttributes } from './utils';
+
+const ALL_ATTRIBUTES_KEY = 'all-attributes';
 
 export function AllAttributesValue({
 	filterKey,
@@ -110,13 +121,20 @@ export function AllAttributesValue({
 
 function AllAttributes({
 	metricName,
-	attributes,
 	metricType,
 }: AllAttributesProps): JSX.Element {
 	const [searchString, setSearchString] = useState('');
-	const [activeKey, setActiveKey] = useState<string | string[]>(
-		'all-attributes',
-	);
+	const [activeKey, setActiveKey] = useState<string[]>([ALL_ATTRIBUTES_KEY]);
+
+	const {
+		data: attributesData,
+		isLoading: isLoadingAttributes,
+		isError: isErrorAttributes,
+	} = useGetMetricAttributes({
+		metricName,
+	});
+
+	const { attributes } = transformMetricAttributes(attributesData);
 
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
 
@@ -178,7 +196,7 @@ function AllAttributes({
 			attributes.filter(
 				(attribute) =>
 					attribute.key.toLowerCase().includes(searchString.toLowerCase()) ||
-					attribute.value.some((value) =>
+					attribute.values.some((value) =>
 						value.toLowerCase().includes(searchString.toLowerCase()),
 					),
 			),
@@ -195,7 +213,7 @@ function AllAttributes({
 						},
 						value: {
 							key: attribute.key,
-							value: attribute.value,
+							value: attribute.values,
 						},
 				  }))
 				: [],
@@ -252,8 +270,38 @@ function AllAttributes({
 		],
 	);
 
-	const items = useMemo(
-		() => [
+	const emptyText = useMemo(
+		() =>
+			isErrorAttributes ? 'Error fetching attributes' : 'No attributes found',
+		[isErrorAttributes],
+	);
+
+	const items = useMemo(() => {
+		let children;
+		if (isLoadingAttributes) {
+			children = (
+				<div className="all-attributes-skeleton-container">
+					<Skeleton active title={false} paragraph={{ rows: 8 }} />
+				</div>
+			);
+		} else {
+			children = (
+				<ResizeTable
+					columns={columns}
+					loading={isLoadingAttributes}
+					tableLayout="fixed"
+					dataSource={tableData}
+					pagination={false}
+					showHeader={false}
+					className="metrics-accordion-content all-attributes-content"
+					scroll={{ y: 600 }}
+					locale={{
+						emptyText,
+					}}
+				/>
+			);
+		}
+		return [
 			{
 				label: (
 					<div className="metrics-accordion-header">
@@ -270,32 +318,22 @@ function AllAttributes({
 							onClick={(e): void => {
 								e.stopPropagation();
 							}}
+							disabled={isLoadingAttributes}
 						/>
 					</div>
 				),
 				key: 'all-attributes',
-				children: (
-					<ResizeTable
-						columns={columns}
-						tableLayout="fixed"
-						dataSource={tableData}
-						pagination={false}
-						showHeader={false}
-						className="metrics-accordion-content all-attributes-content"
-						scroll={{ y: 600 }}
-					/>
-				),
+				children,
 			},
-		],
-		[columns, tableData, searchString],
-	);
+		];
+	}, [searchString, columns, isLoadingAttributes, tableData, emptyText]);
 
 	return (
 		<Collapse
 			bordered
-			className="metrics-accordion metrics-metadata-accordion"
+			className="metrics-accordion metrics-all-attributes-accordion"
 			activeKey={activeKey}
-			onChange={(keys): void => setActiveKey(keys)}
+			onChange={(keys): void => setActiveKey(keys as string[])}
 			items={items}
 		/>
 	);

frontend/src/container/MetricsExplorer/MetricDetails/DashboardsAndAlertsPopover.tsx

@@ -1,37 +1,56 @@
 import { Color } from '@signozhq/design-tokens';
 import { Dropdown, Typography } from 'antd';
+import { Skeleton } from 'antd/lib';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
+import { useGetMetricAlerts } from 'hooks/metricsExplorer/v2/useGetMetricAlerts';
+import { useGetMetricDashboards } from 'hooks/metricsExplorer/v2/useGetMetricDashboards';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import history from 'lib/history';
 import { Bell, Grid } from 'lucide-react';
 import { useMemo } from 'react';
 import { generatePath } from 'react-router-dom';
+import { pluralize } from 'utils/pluralize';
 
 import { DashboardsAndAlertsPopoverProps } from './types';
+import { transformMetricAlerts, transformMetricDashboards } from './utils';
 
 function DashboardsAndAlertsPopover({
-	alerts,
-	dashboards,
+	metricName,
 }: DashboardsAndAlertsPopoverProps): JSX.Element | null {
 	const { safeNavigate } = useSafeNavigate();
 	const params = useUrlQuery();
 
+	const {
+		data: alertsData,
+		isLoading: isLoadingAlerts,
+		isError: isErrorAlerts,
+	} = useGetMetricAlerts(metricName);
+
+	const {
+		data: dashboardsData,
+		isLoading: isLoadingDashboards,
+		isError: isErrorDashboards,
+	} = useGetMetricDashboards(metricName);
+
+	const alerts = transformMetricAlerts(alertsData);
+	const dashboards = transformMetricDashboards(dashboardsData);
+
 	const alertsPopoverContent = useMemo(() => {
 		if (alerts && alerts.length > 0) {
 			return alerts.map((alert) => ({
-				key: alert.alert_id,
+				key: alert.alertId,
 				label: (
 					<Typography.Link
-						key={alert.alert_id}
+						key={alert.alertId}
 						onClick={(): void => {
-							params.set(QueryParams.ruleId, alert.alert_id);
+							params.set(QueryParams.ruleId, alert.alertId);
 							history.push(`${ROUTES.ALERT_OVERVIEW}?${params.toString()}`);
 						}}
 						className="dashboards-popover-content-item"
 					>
-						{alert.alert_name || alert.alert_id}
+						{alert.alertName || alert.alertId}
 					</Typography.Link>
 				),
 			}));
@@ -39,41 +58,44 @@ function DashboardsAndAlertsPopover({
 		return null;
 	}, [alerts, params]);
 
-	const uniqueDashboards = useMemo(
-		() =>
-			dashboards?.filter(
-				(item, index, self) =>
-					index === self.findIndex((t) => t.dashboard_id === item.dashboard_id),
-			),
-		[dashboards],
-	);
-
 	const dashboardsPopoverContent = useMemo(() => {
-		if (uniqueDashboards && uniqueDashboards.length > 0) {
-			return uniqueDashboards.map((dashboard) => ({
-				key: dashboard.dashboard_id,
+		if (dashboards && dashboards.length > 0) {
+			return dashboards.map((dashboard) => ({
+				key: dashboard.dashboardId,
 				label: (
 					<Typography.Link
-						key={dashboard.dashboard_id}
+						key={dashboard.dashboardId}
 						onClick={(): void => {
 							safeNavigate(
 								generatePath(ROUTES.DASHBOARD, {
-									dashboardId: dashboard.dashboard_id,
+									dashboardId: dashboard.dashboardId,
 								}),
 							);
 						}}
 						className="dashboards-popover-content-item"
 					>
-						{dashboard.dashboard_name || dashboard.dashboard_id}
+						{dashboard.dashboardName || dashboard.dashboardId}
 					</Typography.Link>
 				),
 			}));
 		}
 		return null;
-	}, [uniqueDashboards, safeNavigate]);
+	}, [dashboards, safeNavigate]);
 
-	if (!dashboardsPopoverContent && !alertsPopoverContent) {
-		return null;
+	if (isLoadingAlerts || isLoadingDashboards) {
+		return (
+			<div className="dashboards-and-alerts-popover-container">
+				<Skeleton title={false} paragraph={{ rows: 1 }} active />
+			</div>
+		);
+	}
+
+	// If there are no dashboards or alerts or both have errors, don't show the popover
+	const hidePopover =
+		(!dashboardsPopoverContent && !alertsPopoverContent) ||
+		(isErrorAlerts && isErrorDashboards);
+	if (hidePopover) {
+		return <div className="dashboards-and-alerts-popover-container" />;
 	}
 
 	return (
@@ -92,8 +114,7 @@ function DashboardsAndAlertsPopover({
 					>
 						<Grid size={12} color={Color.BG_SIENNA_500} />
 						<Typography.Text>
-							{uniqueDashboards?.length} dashboard
-							{uniqueDashboards?.length === 1 ? '' : 's'}
+							{pluralize(dashboards.length, 'dashboard', 'dashboards')}
 						</Typography.Text>
 					</div>
 				</Dropdown>
@@ -112,7 +133,7 @@ function DashboardsAndAlertsPopover({
 					>
 						<Bell size={12} color={Color.BG_SAKURA_500} />
 						<Typography.Text>
-							{alerts?.length} alert {alerts?.length === 1 ? 'rule' : 'rules'}
+							{pluralize(alerts.length, 'alert rule', 'alert rules')}
 						</Typography.Text>
 					</div>
 				</Dropdown>

frontend/src/container/MetricsExplorer/MetricDetails/Highlights.tsx

@@ -0,0 +1,115 @@
+import { Skeleton, Tooltip, Typography } from 'antd';
+import { useGetMetricHighlights } from 'hooks/metricsExplorer/v2/useGetMetricHighlights';
+import { useMemo } from 'react';
+
+import { formatNumberIntoHumanReadableFormat } from '../Summary/utils';
+import { HighlightsProps } from './types';
+import {
+	formatNumberToCompactFormat,
+	formatTimestampToReadableDate,
+	transformMetricHighlights,
+} from './utils';
+
+function Highlights({ metricName }: HighlightsProps): JSX.Element {
+	const {
+		data: metricHighlightsData,
+		isLoading: isLoadingMetricHighlights,
+		isError: isErrorMetricHighlights,
+	} = useGetMetricHighlights(metricName ?? '', {
+		enabled: !!metricName,
+	});
+
+	const metricHighlights = transformMetricHighlights(metricHighlightsData);
+
+	const dataPoints = useMemo(() => {
+		if (!metricHighlights) return null;
+		if (isErrorMetricHighlights) {
+			return (
+				<Typography.Text className="metric-details-grid-value">-</Typography.Text>
+			);
+		}
+		return (
+			<Typography.Text className="metric-details-grid-value">
+				<Tooltip title={metricHighlights?.dataPoints.toLocaleString()}>
+					{formatNumberIntoHumanReadableFormat(metricHighlights?.dataPoints ?? 0)}
+				</Tooltip>
+			</Typography.Text>
+		);
+	}, [metricHighlights, isErrorMetricHighlights]);
+
+	const timeSeries = useMemo(() => {
+		if (!metricHighlights) return null;
+		if (isErrorMetricHighlights) {
+			return (
+				<Typography.Text className="metric-details-grid-value">-</Typography.Text>
+			);
+		}
+
+		const timeSeriesActive = formatNumberToCompactFormat(
+			metricHighlights.activeTimeSeries,
+		);
+		const timeSeriesTotal = formatNumberToCompactFormat(
+			metricHighlights.totalTimeSeries,
+		);
+
+		return (
+			<Typography.Text className="metric-details-grid-value">
+				<Tooltip
+					title="Active time series are those that have received data points in the last 1
+					hour."
+					placement="top"
+				>
+					<span>{`${timeSeriesTotal} total ⎯ ${timeSeriesActive} active`}</span>
+				</Tooltip>
+			</Typography.Text>
+		);
+	}, [metricHighlights, isErrorMetricHighlights]);
+
+	const lastReceived = useMemo(() => {
+		if (!metricHighlights) return null;
+		if (isErrorMetricHighlights) {
+			return (
+				<Typography.Text className="metric-details-grid-value">-</Typography.Text>
+			);
+		}
+		const displayText = formatTimestampToReadableDate(
+			metricHighlights.lastReceived,
+		);
+		return (
+			<Typography.Text className="metric-details-grid-value">
+				<Tooltip title={displayText}>{displayText}</Tooltip>
+			</Typography.Text>
+		);
+	}, [metricHighlights, isErrorMetricHighlights]);
+
+	if (isLoadingMetricHighlights) {
+		return (
+			<div className="metric-details-content-grid">
+				<Skeleton title={false} paragraph={{ rows: 2 }} active />
+			</div>
+		);
+	}
+
+	return (
+		<div className="metric-details-content-grid">
+			<div className="labels-row">
+				<Typography.Text type="secondary" className="metric-details-grid-label">
+					SAMPLES
+				</Typography.Text>
+				<Typography.Text type="secondary" className="metric-details-grid-label">
+					TIME SERIES
+				</Typography.Text>
+				<Typography.Text type="secondary" className="metric-details-grid-label">
+					LAST RECEIVED
+				</Typography.Text>
+			</div>
+			<div className="values-row">
+				{dataPoints}
+				{timeSeries}
+				{lastReceived}
+			</div>
+		</div>
+	);
+}
+
+export default Highlights;

frontend/src/container/MetricsExplorer/MetricDetails/Metadata.tsx

@@ -1,19 +1,19 @@
-import { Button, Collapse, Input, Select, Typography } from 'antd';
+import { Button, Collapse, Input, Select, Skeleton, Typography } from 'antd';
 import { ColumnsType } from 'antd/es/table';
 import logEvent from 'api/common/logEvent';
 import { Temporality } from 'api/metricsExplorer/getMetricDetails';
 import { MetricType } from 'api/metricsExplorer/getMetricsList';
-import { UpdateMetricMetadataProps } from 'api/metricsExplorer/updateMetricMetadata';
 import { ResizeTable } from 'components/ResizeTable';
 import YAxisUnitSelector from 'components/YAxisUnitSelector';
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
 import { getUniversalNameFromMetricUnit } from 'components/YAxisUnitSelector/utils';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import FieldRenderer from 'container/LogDetailedView/FieldRenderer';
 import { DataType } from 'container/LogDetailedView/TableView';
-import { useUpdateMetricMetadata } from 'hooks/metricsExplorer/useUpdateMetricMetadata';
+import { useUpdateMetricMetadata } from 'hooks/metricsExplorer/v2/useUpdateMetricMetadata';
 import { useNotifications } from 'hooks/useNotifications';
 import { Edit2, Save, X } from 'lucide-react';
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useQueryClient } from 'react-query';
 
 import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
@@ -23,23 +23,22 @@ import {
 } from '../Summary/constants';
 import { MetricTypeRenderer } from '../Summary/utils';
 import { METRIC_METADATA_KEYS } from './constants';
-import { MetadataProps } from './types';
-import { determineIsMonotonic } from './utils';
+import { MetadataProps, MetricMetadataState, TableFields } from './types';
+import { transformUpdateMetricMetadataRequest } from './utils';
 
 function Metadata({
 	metricName,
 	metadata,
-	refetchMetricDetails,
+	isErrorMetricMetadata,
+	isLoadingMetricMetadata,
 }: MetadataProps): JSX.Element {
 	const [isEditing, setIsEditing] = useState(false);
-	const [
-		metricMetadata,
-		setMetricMetadata,
-	] = useState<UpdateMetricMetadataProps>({
-		metricType: metadata?.metric_type || MetricType.SUM,
-		description: metadata?.description || '',
-		temporality: metadata?.temporality,
-		unit: metadata?.unit,
+
+	const [metricMetadata, setMetricMetadata] = useState<MetricMetadataState>({
+		metricType: MetricType.SUM,
+		description: '',
+		temporality: undefined,
+		unit: undefined,
 	});
 	const { notifications } = useNotifications();
 	const {
@@ -51,6 +50,18 @@ function Metadata({
 	);
 	const queryClient = useQueryClient();
 
+	// Initialize state from metadata api data
+	useEffect(() => {
+		if (metadata) {
+			setMetricMetadata({
+				metricType: metadata.metricType,
+				description: metadata.description,
+				temporality: metadata.temporality,
+				unit: metadata.unit,
+			});
+		}
+	}, [metadata]);
+
 	const tableData = useMemo(
 		() =>
 			metadata
@@ -59,7 +70,7 @@ function Metadata({
 						temporality: metadata?.temporality,
 				  })
 						// Filter out monotonic as user input is not required
-						.filter((key) => key !== 'monotonic')
+						.filter((key) => key !== TableFields.IS_MONOTONIC)
 						.map((key) => ({
 							key,
 							value: {
@@ -72,30 +83,37 @@ function Metadata({
 	);
 
 	// Render un-editable field value
-	const renderUneditableField = useCallback((key: string, value: string) => {
-		if (key === 'metric_type') {
-			return <MetricTypeRenderer type={value as MetricType} />;
-		}
-		let fieldValue = value;
-		if (key === 'unit') {
-			fieldValue = getUniversalNameFromMetricUnit(value);
-		}
-		return <FieldRenderer field={fieldValue || '-'} />;
-	}, []);
+	const renderUneditableField = useCallback(
+		(key: keyof MetricMetadataState, value: string) => {
+			if (isErrorMetricMetadata) {
+				return <FieldRenderer field="-" />;
+			}
+			if (key === TableFields.METRIC_TYPE) {
+				return <MetricTypeRenderer type={value as MetricType} />;
+			}
+			let fieldValue = value;
+			if (key === TableFields.UNIT) {
+				fieldValue = getUniversalNameFromMetricUnit(value);
+			}
+			return <FieldRenderer field={fieldValue || '-'} />;
+		},
+		[isErrorMetricMetadata],
+	);
 
 	const renderColumnValue = useCallback(
-		(field: { value: string; key: string }): JSX.Element => {
+		(field: { value: string; key: keyof MetricMetadataState }): JSX.Element => {
 			if (!isEditing) {
 				return renderUneditableField(field.key, field.value);
 			}
 
 			// Don't allow editing of unit if it's already set
-			const metricUnitAlreadySet = field.key === 'unit' && Boolean(metadata?.unit);
+			const metricUnitAlreadySet =
+				field.key === TableFields.UNIT && Boolean(metadata?.unit);
 			if (metricUnitAlreadySet) {
 				return renderUneditableField(field.key, field.value);
 			}
 
-			if (field.key === 'metric_type') {
+			if (field.key === TableFields.METRIC_TYPE) {
 				return (
 					<Select
 						data-testid="metric-type-select"
@@ -113,7 +131,7 @@ function Metadata({
 					/>
 				);
 			}
-			if (field.key === 'unit') {
+			if (field.key === TableFields.UNIT) {
 				return (
 					<YAxisUnitSelector
 						value={metricMetadata.unit}
@@ -125,7 +143,7 @@ function Metadata({
 					/>
 				);
 			}
-			if (field.key === 'temporality') {
+			if (field.key === TableFields.Temporality) {
 				return (
 					<Select
 						data-testid="temporality-select"
@@ -143,16 +161,12 @@ function Metadata({
 					/>
 				);
 			}
-			if (field.key === 'description') {
+			if (field.key === TableFields.DESCRIPTION) {
 				return (
 					<Input
 						data-testid="description-input"
 						name={field.key}
-						defaultValue={
-							metricMetadata[
-								field.key as Exclude<keyof UpdateMetricMetadataProps, 'isMonotonic'>
-							]
-						}
+						defaultValue={metricMetadata.description}
 						onChange={(e): void => {
 							setMetricMetadata((prev) => ({
 								...prev,
@@ -202,17 +216,11 @@ function Metadata({
 		updateMetricMetadata(
 			{
 				metricName,
-				payload: {
-					...metricMetadata,
-					isMonotonic: determineIsMonotonic(
-						metricMetadata.metricType,
-						metricMetadata.temporality,
-					),
-				},
+				payload: transformUpdateMetricMetadataRequest(metricMetadata),
 			},
 			{
 				onSuccess: (response): void => {
-					if (response?.statusCode === 200) {
+					if (response?.httpStatusCode === 200) {
 						logEvent(MetricsExplorerEvents.MetricMetadataUpdated, {
 							[MetricsExplorerEventKeys.MetricName]: metricName,
 							[MetricsExplorerEventKeys.Tab]: 'summary',
@@ -221,9 +229,12 @@ function Metadata({
 						notifications.success({
 							message: 'Metadata updated successfully',
 						});
-						refetchMetricDetails();
 						setIsEditing(false);
-						queryClient.invalidateQueries(['metricsList']);
+						queryClient.invalidateQueries([REACT_QUERY_KEY.GET_METRICS_LIST]);
+						queryClient.invalidateQueries([
+							REACT_QUERY_KEY.GET_METRIC_METADATA,
+							metricName,
+						]);
 					} else {
 						notifications.error({
 							message:
@@ -243,21 +254,36 @@ function Metadata({
 		metricName,
 		metricMetadata,
 		notifications,
-		refetchMetricDetails,
 		queryClient,
 	]);
 
+	const cancelEdit = useCallback(
+		(e: React.MouseEvent<HTMLElement, MouseEvent>): void => {
+			e.stopPropagation();
+			if (metadata) {
+				setMetricMetadata({
+					metricType: metadata.metricType,
+					description: metadata.description,
+					temporality: metadata.temporality,
+					unit: metadata.unit,
+				});
+			}
+			setIsEditing(false);
+		},
+		[metadata],
+	);
+
 	const actionButton = useMemo(() => {
+		if (isLoadingMetricMetadata) {
+			return null;
+		}
 		if (isEditing) {
 			return (
 				<div className="action-menu">
 					<Button
 						className="action-button"
 						type="text"
-						onClick={(e): void => {
-							e.stopPropagation();
-							setIsEditing(false);
-						}}
+						onClick={cancelEdit}
 						disabled={isUpdatingMetricsMetadata}
 					>
 						<X size={14} />
@@ -294,10 +320,35 @@ function Metadata({
 				</Button>
 			</div>
 		);
-	}, [handleSave, isEditing, isUpdatingMetricsMetadata]);
+	}, [
+		isLoadingMetricMetadata,
+		isEditing,
+		isUpdatingMetricsMetadata,
+		cancelEdit,
+		handleSave,
+	]);
 
-	const items = useMemo(
-		() => [
+	const items = useMemo(() => {
+		let children;
+		if (isLoadingMetricMetadata) {
+			children = (
+				<div className="metrics-metadata-skeleton-container">
+					<Skeleton active title={false} paragraph={{ rows: 8 }} />
+				</div>
+			);
+		} else {
+			children = (
+				<ResizeTable
+					columns={columns}
+					tableLayout="fixed"
+					dataSource={tableData}
+					pagination={false}
+					showHeader={false}
+					className="metrics-accordion-content metrics-metadata-container"
+				/>
+			);
+		}
+		return [
 			{
 				label: (
 					<div className="metrics-accordion-header metrics-metadata-header">
@@ -306,20 +357,10 @@ function Metadata({
 					</div>
 				),
 				key: 'metric-metadata',
-				children: (
-					<ResizeTable
-						columns={columns}
-						tableLayout="fixed"
-						dataSource={tableData}
-						pagination={false}
-						showHeader={false}
-						className="metrics-accordion-content metrics-metadata-container"
-					/>
-				),
+				children,
 			},
-		],
-		[actionButton, columns, tableData],
-	);
+		];
+	}, [actionButton, columns, isLoadingMetricMetadata, tableData]);
 
 	return (
 		<Collapse

frontend/src/container/MetricsExplorer/MetricDetails/MetricDetails.styles.scss

@@ -39,6 +39,7 @@
 		gap: 12px;
 
 		.metric-details-content-grid {
+			height: 50px;
 			.labels-row,
 			.values-row {
 				display: grid;
@@ -72,6 +73,7 @@
 		.dashboards-and-alerts-popover-container {
 			display: flex;
 			gap: 16px;
+			height: 32px;
 
 			.dashboards-and-alerts-popover {
 				border-radius: 20px;
@@ -148,7 +150,6 @@
 
 				.all-attributes-search-input {
 					width: 300px;
-					border: 1px solid var(--bg-slate-300);
 				}
 			}
 
@@ -161,6 +162,7 @@
 							.ant-typography:first-child {
 								font-family: 'Geist Mono';
 								color: var(--bg-robin-400);
+								background-color: transparent;
 							}
 						}
 						.all-attributes-contribution {
@@ -237,6 +239,7 @@
 			}
 
 			.metric-metadata-value {
+				height: 67px;
 				background: rgba(22, 25, 34, 0.4);
 				overflow-x: scroll;
 				.field-renderer-container {
@@ -266,6 +269,33 @@
 				border-top-width: 0.5px !important;
 			}
 		}
+
+		.metrics-metadata-accordion {
+			.ant-collapse-item {
+				.ant-collapse-content {
+					height: 268px;
+
+					.ant-collapse-content-box {
+						.metrics-metadata-skeleton-container {
+							margin: 12px;
+						}
+					}
+				}
+			}
+		}
+
+		.metrics-all-attributes-accordion {
+			.ant-collapse-item {
+				.ant-collapse-content {
+					height: 600px;
+					.ant-collapse-content-box {
+						.all-attributes-skeleton-container {
+							margin: 12px;
+						}
+					}
+				}
+			}
+		}
 	}
 
 	.ant-select {
@@ -330,18 +360,26 @@
 	.metric-details-content {
 		.metrics-accordion {
 			.metrics-accordion-header {
-				.action-button {
-					.ant-typography {
-						color: var(--bg-slate-400);
+				.action-menu {
+					.action-button {
+						.ant-typography {
+							color: var(--bg-slate-400);
+						}
 					}
 				}
 			}
 
 			.metrics-accordion-content {
 				.metric-metadata-key {
+					.field-renderer-container {
+						.label {
+							color: var(--bg-slate-300);
+						}
+					}
+
 					.all-attributes-key {
 						.ant-typography:last-child {
-							color: var(--bg-slate-400);
+							color: var(--bg-vanilla-200);
 							background-color: var(--bg-robin-300);
 						}
 					}

frontend/src/container/MetricsExplorer/MetricDetails/MetricDetails.tsx

@@ -2,17 +2,9 @@ import './MetricDetails.styles.scss';
 import '../Summary/Summary.styles.scss';
 
 import { Color } from '@signozhq/design-tokens';
-import {
-	Button,
-	Divider,
-	Drawer,
-	Empty,
-	Skeleton,
-	Tooltip,
-	Typography,
-} from 'antd';
+import { Button, Divider, Drawer, Empty, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
-import { useGetMetricDetails } from 'hooks/metricsExplorer/useGetMetricDetails';
+import { useGetMetricMetadata } from 'hooks/metricsExplorer/v2/useGetMetricMetadata';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { Compass, Crosshair, X } from 'lucide-react';
 import { useCallback, useEffect, useMemo } from 'react';
@@ -22,16 +14,12 @@ import ROUTES from '../../../constants/routes';
 import { useHandleExplorerTabChange } from '../../../hooks/useHandleExplorerTabChange';
 import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
 import { isInspectEnabled } from '../Inspect/utils';
-import { formatNumberIntoHumanReadableFormat } from '../Summary/utils';
 import AllAttributes from './AllAttributes';
 import DashboardsAndAlertsPopover from './DashboardsAndAlertsPopover';
+import Highlights from './Highlights';
 import Metadata from './Metadata';
 import { MetricDetailsProps } from './types';
-import {
-	formatNumberToCompactFormat,
-	formatTimestampToReadableDate,
-	getMetricDetailsQuery,
-} from './utils';
+import { getMetricDetailsQuery, transformMetricMetadata } from './utils';
 
 function MetricDetails({
 	onClose,
@@ -43,50 +31,25 @@ function MetricDetails({
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
 
 	const {
-		data,
-		isLoading,
-		isFetching,
-		error: metricDetailsError,
-		refetch: refetchMetricDetails,
-	} = useGetMetricDetails(metricName ?? '', {
+		data: metricMetadataResponse,
+		isLoading: isLoadingMetricMetadata,
+		isError: isErrorMetricMetadata,
+	} = useGetMetricMetadata(metricName ?? '', {
 		enabled: !!metricName,
 	});
 
-	const metric = data?.payload?.data;
-
-	const lastReceived = useMemo(() => {
-		if (!metric) return null;
-		return formatTimestampToReadableDate(metric.lastReceived);
-	}, [metric]);
+	const metadata = transformMetricMetadata(metricMetadataResponse);
 
 	const showInspectFeature = useMemo(
-		() => isInspectEnabled(metric?.metadata?.metric_type),
-		[metric],
+		() => isInspectEnabled(metadata?.metricType),
+		[metadata],
 	);
 
-	const isMetricDetailsLoading = isLoading || isFetching;
-
-	const timeSeries = useMemo(() => {
-		if (!metric) return null;
-		const timeSeriesActive = formatNumberToCompactFormat(metric.timeSeriesActive);
-		const timeSeriesTotal = formatNumberToCompactFormat(metric.timeSeriesTotal);
-
-		return (
-			<Tooltip
-				title="Active time series are those that have received data points in the last 1
-					hour."
-				placement="top"
-			>
-				<span>{`${timeSeriesTotal} total ⎯ ${timeSeriesActive} active`}</span>
-			</Tooltip>
-		);
-	}, [metric]);
-
 	const goToMetricsExplorerwithSelectedMetric = useCallback(() => {
 		if (metricName) {
 			const compositeQuery = getMetricDetailsQuery(
 				metricName,
-				metric?.metadata?.metric_type,
+				metadata?.metricType,
 			);
 			handleExplorerTabChange(
 				PANEL_TYPES.TIME_SERIES,
@@ -103,9 +66,7 @@ function MetricDetails({
 				[MetricsExplorerEventKeys.Modal]: 'metric-details',
 			});
 		}
-	}, [metricName, handleExplorerTabChange, metric?.metadata?.metric_type]);
-
-	const isMetricDetailsError = metricDetailsError || !metric;
+	}, [metricName, handleExplorerTabChange, metadata?.metricType]);
 
 	useEffect(() => {
 		logEvent(MetricsExplorerEvents.ModalOpened, {
@@ -113,6 +74,10 @@ function MetricDetails({
 		});
 	}, []);
 
+	if (!metricName) {
+		return <Empty description="Metric not found" />;
+	}
+
 	return (
 		<Drawer
 			width="60%"
@@ -120,7 +85,7 @@ function MetricDetails({
 				<div className="metric-details-header">
 					<div className="metric-details-title">
 						<Divider type="vertical" />
-						<Typography.Text>{metric?.name}</Typography.Text>
+						<Typography.Text>{metricName}</Typography.Text>
 					</div>
 					<div className="metric-details-header-buttons">
 						<Button
@@ -138,8 +103,8 @@ function MetricDetails({
 								aria-label="Inspect Metric"
 								icon={<Crosshair size={18} />}
 								onClick={(): void => {
-									if (metric?.name) {
-										openInspectModal(metric.name);
+									if (metricName) {
+										openInspectModal(metricName);
 									}
 								}}
 								data-testid="inspect-metric-button"
@@ -159,60 +124,17 @@ function MetricDetails({
 			destroyOnClose
 			closeIcon={<X size={16} />}
 		>
-			{isMetricDetailsLoading && (
-				<div data-testid="metric-details-skeleton">
-					<Skeleton active />
-				</div>
-			)}
-			{isMetricDetailsError && !isMetricDetailsLoading && (
-				<Empty description="Error fetching metric details" />
-			)}
-			{!isMetricDetailsLoading && !isMetricDetailsError && (
-				<div className="metric-details-content">
-					<div className="metric-details-content-grid">
-						<div className="labels-row">
-							<Typography.Text type="secondary" className="metric-details-grid-label">
-								SAMPLES
-							</Typography.Text>
-							<Typography.Text type="secondary" className="metric-details-grid-label">
-								TIME SERIES
-							</Typography.Text>
-							<Typography.Text type="secondary" className="metric-details-grid-label">
-								LAST RECEIVED
-							</Typography.Text>
-						</div>
-						<div className="values-row">
-							<Typography.Text className="metric-details-grid-value">
-								<Tooltip title={metric?.samples.toLocaleString()}>
-									{formatNumberIntoHumanReadableFormat(metric?.samples)}
-								</Tooltip>
-							</Typography.Text>
-							<Typography.Text className="metric-details-grid-value">
-								<Tooltip title={timeSeries}>{timeSeries}</Tooltip>
-							</Typography.Text>
-							<Typography.Text className="metric-details-grid-value">
-								<Tooltip title={lastReceived}>{lastReceived}</Tooltip>
-							</Typography.Text>
-						</div>
-					</div>
-					<DashboardsAndAlertsPopover
-						dashboards={metric.dashboards}
-						alerts={metric.alerts}
-					/>
-					<Metadata
-						metricName={metric?.name}
-						metadata={metric.metadata}
-						refetchMetricDetails={refetchMetricDetails}
-					/>
-					{metric.attributes && (
-						<AllAttributes
-							metricName={metric?.name}
-							attributes={metric.attributes}
-							metricType={metric?.metadata?.metric_type}
-						/>
-					)}
-				</div>
-			)}
+			<div className="metric-details-content">
+				<Highlights metricName={metricName} />
+				<DashboardsAndAlertsPopover metricName={metricName} />
+				<Metadata
+					metricName={metricName}
+					metadata={metadata}
+					isErrorMetricMetadata={isErrorMetricMetadata}
+					isLoadingMetricMetadata={isLoadingMetricMetadata}
+				/>
+				<AllAttributes metricName={metricName} metricType={metadata?.metricType} />
+			</div>
 		</Drawer>
 	);
 }

frontend/src/container/MetricsExplorer/MetricDetails/constants.ts

@@ -1,6 +1,6 @@
 export const METRIC_METADATA_KEYS = {
 	description: 'Description',
 	unit: 'Unit',
-	metric_type: 'Metric Type',
+	metricType: 'Metric Type',
 	temporality: 'Temporality',
 };

frontend/src/container/MetricsExplorer/MetricDetails/types.ts

@@ -1,9 +1,4 @@
-import {
-	MetricDetails,
-	MetricDetailsAlert,
-	MetricDetailsAttribute,
-	MetricDetailsDashboard,
-} from 'api/metricsExplorer/getMetricDetails';
+import { Temporality } from 'api/metricsExplorer/getMetricDetails';
 import { MetricType } from 'api/metricsExplorer/getMetricsList';
 
 export interface MetricDetailsProps {
@@ -14,19 +9,21 @@ export interface MetricDetailsProps {
 	openInspectModal: (metricName: string) => void;
 }
 
+export interface HighlightsProps {
+	metricName: string;
+}
 export interface DashboardsAndAlertsPopoverProps {
-	dashboards: MetricDetailsDashboard[] | null;
-	alerts: MetricDetailsAlert[] | null;
+	metricName: string;
 }
 
 export interface MetadataProps {
 	metricName: string;
-	metadata: MetricDetails['metadata'] | undefined;
-	refetchMetricDetails: () => void;
+	metadata: MetricMetadata | null;
+	isErrorMetricMetadata: boolean;
+	isLoadingMetricMetadata: boolean;
 }
 
 export interface AllAttributesProps {
-	attributes: MetricDetailsAttribute[];
 	metricName: string;
 	metricType: MetricType | undefined;
 }
@@ -36,3 +33,51 @@ export interface AllAttributesValueProps {
 	filterValue: string[];
 	goToMetricsExploreWithAppliedAttribute: (key: string, value: string) => void;
 }
+
+export interface MetricHighlight {
+	dataPoints: number;
+	lastReceived: number;
+	totalTimeSeries: number;
+	activeTimeSeries: number;
+}
+
+export interface MetricAlert {
+	alertName: string;
+	alertId: string;
+}
+
+export interface MetricDashboard {
+	dashboardName: string;
+	dashboardId: string;
+	widgetId: string;
+	widgetName: string;
+}
+
+export interface MetricMetadata {
+	metricType: MetricType;
+	description: string;
+	unit: string;
+	temporality: Temporality;
+	isMonotonic: boolean;
+}
+
+export interface MetricMetadataState {
+	metricType: MetricType;
+	description: string;
+	temporality: Temporality | undefined;
+	unit: string | undefined;
+}
+
+export interface MetricAttribute {
+	key: string;
+	values: string[];
+	valueCount: number;
+}
+
+export enum TableFields {
+	DESCRIPTION = 'description',
+	UNIT = 'unit',
+	METRIC_TYPE = 'metricType',
+	Temporality = 'temporality',
+	IS_MONOTONIC = 'isMonotonic',
+}

frontend/src/container/MetricsExplorer/MetricDetails/utils.tsx

@@ -2,11 +2,29 @@ import { Temporality } from 'api/metricsExplorer/getMetricDetails';
 import { MetricType } from 'api/metricsExplorer/getMetricsList';
 import { SpaceAggregation, TimeAggregation } from 'api/v5/v5';
 import { initialQueriesMap } from 'constants/queryBuilder';
+import { SuccessResponseV2 } from 'types/api';
+import {
+	GetMetricAlertsResponse,
+	GetMetricAttributesResponse,
+	GetMetricDashboardsResponse,
+	GetMetricHighlightsResponse,
+	GetMetricMetadataResponse,
+	UpdateMetricMetadataRequest,
+} from 'types/api/metricsExplorer/v2';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-export function formatTimestampToReadableDate(timestamp: string): string {
+import {
+	MetricAlert,
+	MetricAttribute,
+	MetricDashboard,
+	MetricHighlight,
+	MetricMetadata,
+	MetricMetadataState,
+} from './types';
+
+export function formatTimestampToReadableDate(timestamp: number): string {
 	const date = new Date(timestamp);
 	const now = new Date();
 	const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000);
@@ -154,3 +172,149 @@ export function getMetricDetailsQuery(
 		},
 	};
 }
+
+export function transformMetricHighlights(
+	apiData: SuccessResponseV2<GetMetricHighlightsResponse> | undefined,
+): MetricHighlight | null {
+	if (!apiData || !apiData.data || !apiData.data.data) {
+		return null;
+	}
+
+	const {
+		dataPoints,
+		lastReceived,
+		totalTimeSeries,
+		activeTimeSeries,
+	} = apiData.data.data;
+
+	return {
+		dataPoints,
+		lastReceived,
+		totalTimeSeries,
+		activeTimeSeries,
+	};
+}
+
+export function transformMetricAlerts(
+	apiData: SuccessResponseV2<GetMetricAlertsResponse> | undefined,
+): MetricAlert[] {
+	if (
+		!apiData ||
+		!apiData.data ||
+		!apiData.data.data ||
+		!apiData.data.data.alerts
+	) {
+		return [];
+	}
+	return apiData.data.data.alerts.map((alert) => ({
+		alertName: alert.alertName,
+		alertId: alert.alertId,
+	}));
+}
+
+export function transformMetricDashboards(
+	apiData: SuccessResponseV2<GetMetricDashboardsResponse> | undefined,
+): MetricDashboard[] {
+	if (
+		!apiData ||
+		!apiData.data ||
+		!apiData.data.data ||
+		!apiData.data.data.dashboards
+	) {
+		return [];
+	}
+	const dashboards = apiData.data.data.dashboards.map((dashboard) => ({
+		dashboardName: dashboard.dashboardName,
+		dashboardId: dashboard.dashboardId,
+		widgetId: dashboard.widgetId,
+		widgetName: dashboard.widgetName,
+	}));
+	// Remove duplicate dashboards
+	return dashboards.filter(
+		(dashboard, index, self) =>
+			index === self.findIndex((t) => t.dashboardId === dashboard.dashboardId),
+	);
+}
+
+export function transformTemporality(temporality: string): Temporality {
+	switch (temporality) {
+		case 'delta':
+			return Temporality.DELTA;
+		case 'cumulative':
+			return Temporality.CUMULATIVE;
+		default:
+			return Temporality.DELTA;
+	}
+}
+
+export function transformMetricType(type: string): MetricType {
+	switch (type) {
+		case 'sum':
+			return MetricType.SUM;
+		case 'gauge':
+			return MetricType.GAUGE;
+		case 'summary':
+			return MetricType.SUMMARY;
+		case 'histogram':
+			return MetricType.HISTOGRAM;
+		case 'exponential_histogram':
+			return MetricType.EXPONENTIAL_HISTOGRAM;
+		default:
+			return MetricType.SUM;
+	}
+}
+
+export function transformMetricMetadata(
+	apiData: SuccessResponseV2<GetMetricMetadataResponse> | undefined,
+): MetricMetadata | null {
+	if (!apiData || !apiData.data || !apiData.data.data) {
+		return null;
+	}
+	const {
+		type,
+		description,
+		unit,
+		temporality,
+		isMonotonic,
+	} = apiData.data.data;
+
+	return {
+		metricType: transformMetricType(type),
+		description,
+		unit,
+		temporality: transformTemporality(temporality),
+		isMonotonic,
+	};
+}
+
+export function transformUpdateMetricMetadataRequest(
+	metricMetadata: MetricMetadataState,
+): UpdateMetricMetadataRequest {
+	return {
+		type: metricMetadata.metricType,
+		description: metricMetadata.description,
+		unit: metricMetadata.unit || '',
+		temporality: metricMetadata.temporality || '',
+		isMonotonic: determineIsMonotonic(
+			metricMetadata.metricType,
+			metricMetadata.temporality,
+		),
+	};
+}
+
+export function transformMetricAttributes(
+	apiData: SuccessResponseV2<GetMetricAttributesResponse> | undefined,
+): { attributes: MetricAttribute[]; totalKeys: number } {
+	if (!apiData || !apiData.data || !apiData.data.data) {
+		return { attributes: [], totalKeys: 0 };
+	}
+	const { attributes, totalKeys } = apiData.data.data;
+	return {
+		attributes: attributes.map((attribute) => ({
+			key: attribute.key,
+			values: attribute.values,
+			valueCount: attribute.valueCount,
+		})),
+		totalKeys,
+	};
+}

frontend/src/hooks/metricsExplorer/v2/useGetMetricAlerts.ts

@@ -0,0 +1,22 @@
+import { getMetricAlerts } from 'api/metricsExplorer/v2/getMetricAlerts';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import { GetMetricAlertsResponse } from 'types/api/metricsExplorer/v2';
+
+type UseGetMetricAlerts = (
+	metricName: string,
+	options?: UseQueryOptions<SuccessResponseV2<GetMetricAlertsResponse>, Error>,
+	headers?: Record<string, string>,
+) => UseQueryResult<SuccessResponseV2<GetMetricAlertsResponse>, Error>;
+
+export const useGetMetricAlerts: UseGetMetricAlerts = (
+	metricName,
+	options,
+	headers,
+) =>
+	useQuery<SuccessResponseV2<GetMetricAlertsResponse>, Error>({
+		queryFn: ({ signal }) => getMetricAlerts(metricName, signal, headers),
+		...options,
+		queryKey: [REACT_QUERY_KEY.GET_METRIC_ALERTS, metricName],
+	});

frontend/src/hooks/metricsExplorer/v2/useGetMetricAttributes.ts

@@ -0,0 +1,36 @@
+import { getMetricAttributes } from 'api/metricsExplorer/v2/getMetricAttributes';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import {
+	GetMetricAttributesRequest,
+	GetMetricAttributesResponse,
+} from 'types/api/metricsExplorer/v2';
+
+type UseGetMetricAttributes = (
+	requestData: GetMetricAttributesRequest,
+	options?: UseQueryOptions<
+		SuccessResponseV2<GetMetricAttributesResponse>,
+		Error
+	>,
+	headers?: Record<string, string>,
+) => UseQueryResult<SuccessResponseV2<GetMetricAttributesResponse>, Error>;
+
+export const useGetMetricAttributes: UseGetMetricAttributes = (
+	requestData,
+	options,
+	headers,
+) => {
+	const queryKey = [
+		REACT_QUERY_KEY.GET_METRIC_ATTRIBUTES,
+		requestData.metricName,
+		requestData.start,
+		requestData.end,
+	];
+
+	return useQuery<SuccessResponseV2<GetMetricAttributesResponse>, Error>({
+		queryFn: ({ signal }) => getMetricAttributes(requestData, signal, headers),
+		...options,
+		queryKey,
+	});
+};

frontend/src/hooks/metricsExplorer/v2/useGetMetricDashboards.ts

@@ -0,0 +1,25 @@
+import { getMetricDashboards } from 'api/metricsExplorer/v2/getMetricDashboards';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import { GetMetricDashboardsResponse } from 'types/api/metricsExplorer/v2';
+
+type UseGetMetricDashboards = (
+	metricName: string,
+	options?: UseQueryOptions<
+		SuccessResponseV2<GetMetricDashboardsResponse>,
+		Error
+	>,
+	headers?: Record<string, string>,
+) => UseQueryResult<SuccessResponseV2<GetMetricDashboardsResponse>, Error>;
+
+export const useGetMetricDashboards: UseGetMetricDashboards = (
+	metricName,
+	options,
+	headers,
+) =>
+	useQuery<SuccessResponseV2<GetMetricDashboardsResponse>, Error>({
+		queryFn: ({ signal }) => getMetricDashboards(metricName, signal, headers),
+		...options,
+		queryKey: [REACT_QUERY_KEY.GET_METRIC_DASHBOARDS, metricName],
+	});

frontend/src/hooks/metricsExplorer/v2/useGetMetricHighlights.ts

@@ -0,0 +1,25 @@
+import { getMetricHighlights } from 'api/metricsExplorer/v2/getMetricHighlights';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import { GetMetricHighlightsResponse } from 'types/api/metricsExplorer/v2';
+
+type UseGetMetricHighlights = (
+	metricName: string,
+	options?: UseQueryOptions<
+		SuccessResponseV2<GetMetricHighlightsResponse>,
+		Error
+	>,
+	headers?: Record<string, string>,
+) => UseQueryResult<SuccessResponseV2<GetMetricHighlightsResponse>, Error>;
+
+export const useGetMetricHighlights: UseGetMetricHighlights = (
+	metricName,
+	options,
+	headers,
+) =>
+	useQuery<SuccessResponseV2<GetMetricHighlightsResponse>, Error>({
+		queryFn: ({ signal }) => getMetricHighlights(metricName, signal, headers),
+		...options,
+		queryKey: [REACT_QUERY_KEY.GET_METRIC_HIGHLIGHTS, metricName],
+	});

frontend/src/hooks/metricsExplorer/v2/useGetMetricMetadata.ts

@@ -0,0 +1,22 @@
+import { getMetricMetadata } from 'api/metricsExplorer/v2/getMetricMetadata';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import { GetMetricMetadataResponse } from 'types/api/metricsExplorer/v2';
+
+type UseGetMetricMetadata = (
+	metricName: string,
+	options?: UseQueryOptions<SuccessResponseV2<GetMetricMetadataResponse>, Error>,
+	headers?: Record<string, string>,
+) => UseQueryResult<SuccessResponseV2<GetMetricMetadataResponse>, Error>;
+
+export const useGetMetricMetadata: UseGetMetricMetadata = (
+	metricName,
+	options,
+	headers,
+) =>
+	useQuery<SuccessResponseV2<GetMetricMetadataResponse>, Error>({
+		queryFn: ({ signal }) => getMetricMetadata(metricName, signal, headers),
+		...options,
+		queryKey: [REACT_QUERY_KEY.GET_METRIC_METADATA, metricName],
+	});

frontend/src/hooks/metricsExplorer/v2/useUpdateMetricMetadata.ts

@@ -0,0 +1,22 @@
+import updateMetricMetadata from 'api/metricsExplorer/v2/updateMetricMetadata';
+import { useMutation, UseMutationResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import {
+	UpdateMetricMetadataResponse,
+	UseUpdateMetricMetadataProps,
+} from 'types/api/metricsExplorer/v2';
+
+export function useUpdateMetricMetadata(): UseMutationResult<
+	SuccessResponseV2<UpdateMetricMetadataResponse>,
+	Error,
+	UseUpdateMetricMetadataProps
+> {
+	return useMutation<
+		SuccessResponseV2<UpdateMetricMetadataResponse>,
+		Error,
+		UseUpdateMetricMetadataProps
+	>({
+		mutationFn: ({ metricName, payload }) =>
+			updateMetricMetadata(metricName, payload),
+	});
+}

frontend/src/types/api/metricsExplorer/v2.ts

@@ -0,0 +1,77 @@
+export interface GetMetricMetadataResponse {
+	status: string;
+	data: {
+		description: string;
+		type: string;
+		unit: string;
+		temporality: string;
+		isMonotonic: boolean;
+	};
+}
+
+export interface GetMetricHighlightsResponse {
+	status: string;
+	data: {
+		dataPoints: number;
+		lastReceived: number;
+		totalTimeSeries: number;
+		activeTimeSeries: number;
+	};
+}
+
+export interface GetMetricAttributesRequest {
+	metricName: string;
+	start?: number;
+	end?: number;
+}
+
+export interface GetMetricAttributesResponse {
+	status: string;
+	data: {
+		attributes: {
+			key: string;
+			values: string[];
+			valueCount: number;
+		}[];
+		totalKeys: number;
+	};
+}
+
+export interface GetMetricAlertsResponse {
+	status: string;
+	data: {
+		alerts: {
+			alertName: string;
+			alertId: string;
+		}[];
+	};
+}
+
+export interface GetMetricDashboardsResponse {
+	status: string;
+	data: {
+		dashboards: {
+			dashboardName: string;
+			dashboardId: string;
+			widgetId: string;
+			widgetName: string;
+		}[];
+	};
+}
+
+export interface UpdateMetricMetadataRequest {
+	type: string;
+	description: string;
+	temporality: string;
+	unit: string;
+	isMonotonic: boolean;
+}
+
+export interface UpdateMetricMetadataResponse {
+	status: string;
+}
+
+export interface UseUpdateMetricMetadataProps {
+	metricName: string;
+	payload: UpdateMetricMetadataRequest;
+}

frontend/src/utils/pluralize.ts

@@ -0,0 +1,10 @@
+export function pluralize(
+	count: number,
+	singular: string,
+	plural: string,
+): string {
+	if (count === 1) {
+		return `${count} ${singular}`;
+	}
+	return `${count} ${plural}`;
+}