feat: updated types after latest rebase change

frontend/jest.config.ts

@@ -24,8 +24,7 @@ const config: Config.InitialOptions = {
 			'<rootDir>/node_modules/@signozhq/icons/dist/index.esm.js',
 		'^react-syntax-highlighter/dist/esm/(.*)$':
 			'<rootDir>/node_modules/react-syntax-highlighter/dist/cjs/$1',
-		'^@signozhq/(?!ui$)([^/]+)$':
-			'<rootDir>/node_modules/@signozhq/$1/dist/$1.js',
+		'^@signozhq/([^/]+)$': '<rootDir>/node_modules/@signozhq/$1/dist/$1.js',
 	},
 	extensionsToTreatAsEsm: ['.ts'],
 	testMatch: ['<rootDir>/src/**/*?(*.)(test).(ts|js)?(x)'],

frontend/package.json

@@ -67,7 +67,6 @@
     "@signozhq/table": "0.3.7",
     "@signozhq/toggle-group": "0.0.1",
     "@signozhq/tooltip": "0.0.2",
-    "@signozhq/ui": "0.0.4",
     "@tanstack/react-table": "8.20.6",
     "@tanstack/react-virtual": "3.11.2",
     "@uiw/codemirror-theme-copilot": "4.23.11",
@@ -137,6 +136,7 @@
     "react-full-screen": "1.1.1",
     "react-grid-layout": "^1.3.4",
     "react-helmet-async": "1.3.0",
+    "react-hook-form": "7.71.2",
     "react-i18next": "^11.16.1",
     "react-lottie": "1.2.10",
     "react-markdown": "8.0.7",

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

@@ -15,5 +15,6 @@
 	"logs_to_metrics": "Logs To Metrics",
 	"roles": "Roles",
 	"role_details": "Role Details",
-	"members": "Members"
+	"members": "Members",
+	"service_accounts": "Service Accounts"
 }

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

@@ -50,5 +50,8 @@
 	"INFRASTRUCTURE_MONITORING_KUBERNETES": "SigNoz | Infra Monitoring",
 	"METER_EXPLORER": "SigNoz | Meter Explorer",
 	"METER_EXPLORER_VIEWS": "SigNoz | Meter Explorer Views",
-	"METER": "SigNoz | Meter"
+	"METER": "SigNoz | Meter",
+	"ROLES_SETTINGS": "SigNoz | Roles",
+	"MEMBERS_SETTINGS": "SigNoz | Members",
+	"SERVICE_ACCOUNTS_SETTINGS": "SigNoz | Service Accounts"
 }

frontend/public/locales/en/routes.json

@@ -15,5 +15,6 @@
 	"logs_to_metrics": "Logs To Metrics",
 	"roles": "Roles",
 	"role_details": "Role Details",
-	"members": "Members"
+	"members": "Members",
+	"service_accounts": "Service Accounts"
 }

frontend/public/locales/en/titles.json

@@ -75,5 +75,6 @@
 	"METER_EXPLORER_VIEWS": "SigNoz | Meter Explorer Views",
 	"METER": "SigNoz | Meter",
 	"ROLES_SETTINGS": "SigNoz | Roles",
-	"MEMBERS_SETTINGS": "SigNoz | Members"
+	"MEMBERS_SETTINGS": "SigNoz | Members",
+	"SERVICE_ACCOUNTS_SETTINGS": "SigNoz | Service Accounts"
 }

frontend/src/auto-import-registry.d.ts

@@ -30,4 +30,3 @@ import '@signozhq/switch';
 import '@signozhq/table';
 import '@signozhq/toggle-group';
 import '@signozhq/tooltip';
-import '@signozhq/ui';

frontend/src/components/AnnouncementBanner/AnnouncementBanner.styles.scss

@@ -0,0 +1,97 @@
+.announcement-banner {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--spacing-4);
+	padding: var(--padding-2) var(--padding-4);
+	height: 40px;
+	font-family: var(--font-sans), sans-serif;
+	font-size: var(--label-base-500-font-size);
+	line-height: var(--label-base-500-line-height);
+	font-weight: var(--label-base-500-font-weight);
+	letter-spacing: -0.065px;
+
+	&--warning {
+		background-color: var(--callout-warning-background);
+		color: var(--callout-warning-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-warning-border);
+		}
+	}
+
+	&--info {
+		background-color: var(--callout-primary-background);
+		color: var(--callout-primary-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-primary-border);
+		}
+	}
+
+	&--error {
+		background-color: var(--callout-error-background);
+		color: var(--callout-error-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-error-border);
+		}
+	}
+
+	&--success {
+		background-color: var(--callout-success-background);
+		color: var(--callout-success-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-success-border);
+		}
+	}
+
+	&__body {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-4);
+		flex: 1;
+		min-width: 0;
+	}
+
+	&__icon {
+		display: flex;
+		align-items: center;
+		flex-shrink: 0;
+	}
+
+	&__message {
+		flex: 1;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		line-height: var(--line-height-normal);
+
+		strong {
+			font-weight: var(--font-weight-semibold);
+		}
+	}
+
+	&__action {
+		height: 24px;
+		font-size: var(--label-small-500-font-size);
+		color: currentColor;
+
+		&:hover {
+			opacity: 0.8;
+		}
+	}
+
+	&__dismiss {
+		width: 24px;
+		height: 24px;
+		padding: 0;
+		color: currentColor;
+
+		&:hover {
+			opacity: 0.8;
+		}
+	}
+}

frontend/src/components/AnnouncementBanner/AnnouncementBanner.test.tsx

@@ -0,0 +1,89 @@
+import { render, screen, userEvent } from 'tests/test-utils';
+
+import {
+	AnnouncementBanner,
+	AnnouncementBannerProps,
+	PersistedAnnouncementBanner,
+} from './index';
+
+const STORAGE_KEY = 'test-banner-dismissed';
+
+function renderBanner(props: Partial<AnnouncementBannerProps> = {}): void {
+	render(<AnnouncementBanner message="Test message" {...props} />);
+}
+
+afterEach(() => {
+	localStorage.removeItem(STORAGE_KEY);
+});
+
+describe('AnnouncementBanner', () => {
+	it('renders message and default warning variant', () => {
+		renderBanner({ message: <strong>Heads up</strong> });
+
+		const alert = screen.getByRole('alert');
+		expect(alert).toHaveClass('announcement-banner--warning');
+		expect(alert).toHaveTextContent('Heads up');
+	});
+
+	it.each(['warning', 'info', 'success', 'error'] as const)(
+		'renders %s variant correctly',
+		(type) => {
+			renderBanner({ type, message: 'Test message' });
+			const alert = screen.getByRole('alert');
+			expect(alert).toHaveClass(`announcement-banner--${type}`);
+		},
+	);
+
+	it('calls action onClick when action button is clicked', async () => {
+		const onClick = jest.fn() as jest.MockedFunction<() => void>;
+		renderBanner({ action: { label: 'Go to Settings', onClick } });
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		await user.click(screen.getByRole('button', { name: /go to settings/i }));
+
+		expect(onClick).toHaveBeenCalledTimes(1);
+	});
+
+	it('hides dismiss button when onClose is not provided and hides icon when icon is null', () => {
+		renderBanner({ onClose: undefined, icon: null });
+
+		expect(
+			screen.queryByRole('button', { name: /dismiss/i }),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('alert')?.querySelector('.announcement-banner__icon'),
+		).not.toBeInTheDocument();
+	});
+});
+
+describe('PersistedAnnouncementBanner', () => {
+	it('dismisses on click, calls onDismiss, and persists to localStorage', async () => {
+		const onDismiss = jest.fn() as jest.MockedFunction<() => void>;
+		render(
+			<PersistedAnnouncementBanner
+				message="Test message"
+				storageKey={STORAGE_KEY}
+				onDismiss={onDismiss}
+			/>,
+		);
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		await user.click(screen.getByRole('button', { name: /dismiss/i }));
+
+		expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+		expect(onDismiss).toHaveBeenCalledTimes(1);
+		expect(localStorage.getItem(STORAGE_KEY)).toBe('true');
+	});
+
+	it('does not render when storageKey is already set in localStorage', () => {
+		localStorage.setItem(STORAGE_KEY, 'true');
+		render(
+			<PersistedAnnouncementBanner
+				message="Test message"
+				storageKey={STORAGE_KEY}
+			/>,
+		);
+
+		expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+	});
+});

frontend/src/components/AnnouncementBanner/AnnouncementBanner.tsx

@@ -0,0 +1,84 @@
+import { ReactNode } from 'react';
+import { Button } from '@signozhq/button';
+import {
+	CircleAlert,
+	CircleCheckBig,
+	Info,
+	TriangleAlert,
+	X,
+} from '@signozhq/icons';
+import cx from 'classnames';
+
+import './AnnouncementBanner.styles.scss';
+
+export type AnnouncementBannerType = 'warning' | 'info' | 'error' | 'success';
+
+export interface AnnouncementBannerAction {
+	label: string;
+	onClick: () => void;
+}
+
+export interface AnnouncementBannerProps {
+	message: ReactNode;
+	type?: AnnouncementBannerType;
+	icon?: ReactNode | null;
+	action?: AnnouncementBannerAction;
+	onClose?: () => void;
+	className?: string;
+}
+
+const DEFAULT_ICONS: Record<AnnouncementBannerType, ReactNode> = {
+	warning: <TriangleAlert size={14} />,
+	info: <Info size={14} />,
+	error: <CircleAlert size={14} />,
+	success: <CircleCheckBig size={14} />,
+};
+
+export default function AnnouncementBanner({
+	message,
+	type = 'warning',
+	icon,
+	action,
+	onClose,
+	className,
+}: AnnouncementBannerProps): JSX.Element {
+	const resolvedIcon = icon === null ? null : icon ?? DEFAULT_ICONS[type];
+
+	return (
+		<div
+			role="alert"
+			className={cx(
+				'announcement-banner',
+				`announcement-banner--${type}`,
+				className,
+			)}
+		>
+			<div className="announcement-banner__body">
+				{resolvedIcon && (
+					<span className="announcement-banner__icon">{resolvedIcon}</span>
+				)}
+				<span className="announcement-banner__message">{message}</span>
+				{action && (
+					<Button
+						type="button"
+						className="announcement-banner__action"
+						onClick={action.onClick}
+					>
+						{action.label}
+					</Button>
+				)}
+			</div>
+
+			{onClose && (
+				<Button
+					type="button"
+					aria-label="Dismiss"
+					className="announcement-banner__dismiss"
+					onClick={onClose}
+				>
+					<X size={14} />
+				</Button>
+			)}
+		</div>
+	);
+}

frontend/src/components/AnnouncementBanner/PersistedAnnouncementBanner.tsx

@@ -0,0 +1,34 @@
+import { useState } from 'react';
+
+import AnnouncementBanner, {
+	AnnouncementBannerProps,
+} from './AnnouncementBanner';
+
+interface PersistedAnnouncementBannerProps extends AnnouncementBannerProps {
+	storageKey: string;
+	onDismiss?: () => void;
+}
+
+function isDismissed(storageKey: string): boolean {
+	return localStorage.getItem(storageKey) === 'true';
+}
+
+export default function PersistedAnnouncementBanner({
+	storageKey,
+	onDismiss,
+	...props
+}: PersistedAnnouncementBannerProps): JSX.Element | null {
+	const [visible, setVisible] = useState(() => !isDismissed(storageKey));
+
+	if (!visible) {
+		return null;
+	}
+
+	const handleClose = (): void => {
+		localStorage.setItem(storageKey, 'true');
+		setVisible(false);
+		onDismiss?.();
+	};
+
+	return <AnnouncementBanner {...props} onClose={handleClose} />;
+}

frontend/src/components/AnnouncementBanner/index.ts

@@ -0,0 +1,12 @@
+import AnnouncementBanner from './AnnouncementBanner';
+import PersistedAnnouncementBanner from './PersistedAnnouncementBanner';
+
+export type {
+	AnnouncementBannerAction,
+	AnnouncementBannerProps,
+	AnnouncementBannerType,
+} from './AnnouncementBanner';
+
+export { AnnouncementBanner, PersistedAnnouncementBanner };
+
+export default AnnouncementBanner;

frontend/src/components/CreateServiceAccountModal/CreateServiceAccountModal.styles.scss

@@ -0,0 +1,106 @@
+.create-sa-modal {
+	max-width: 530px;
+	background: var(--popover);
+	border: 1px solid var(--secondary);
+	border-radius: 4px;
+	box-shadow: 0 4px 9px 0 rgba(0, 0, 0, 0.04);
+
+	[data-slot='dialog-header'] {
+		padding: var(--padding-4);
+		border-bottom: 1px solid var(--secondary);
+		flex-shrink: 0;
+		background: transparent;
+		margin: 0;
+	}
+
+	[data-slot='dialog-title'] {
+		font-size: var(--label-base-400-font-size);
+		font-weight: var(--label-base-400-font-weight);
+		line-height: var(--label-base-400-line-height);
+		letter-spacing: -0.065px;
+		color: var(--bg-base-white);
+		margin: 0;
+	}
+
+	[data-slot='dialog-description'] {
+		padding: 0;
+
+		.create-sa-modal__content {
+			padding: var(--padding-4);
+		}
+	}
+}
+
+.create-sa-form {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-2);
+
+	&__item {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-1);
+		margin-bottom: var(--spacing-4);
+
+		> label {
+			font-size: var(--paragraph-base-400-font-size);
+			font-weight: var(--paragraph-base-400-font-weight);
+			color: var(--foreground);
+			letter-spacing: -0.07px;
+		}
+	}
+
+	&__input {
+		height: 32px;
+		color: var(--l1-foreground);
+		background-color: var(--l2-background);
+		border-color: var(--border);
+		font-size: var(--paragraph-base-400-font-size);
+		border-radius: 2px;
+		width: 100%;
+
+		&::placeholder {
+			color: var(--l3-foreground);
+		}
+
+		&:focus {
+			border-color: var(--primary);
+			box-shadow: none;
+		}
+	}
+
+	&__error {
+		font-size: var(--paragraph-small-400-font-size);
+		color: var(--destructive);
+		line-height: var(--paragraph-small-400-line-height);
+		margin: 0;
+	}
+
+	&__helper {
+		font-size: var(--paragraph-small-400-font-size);
+		color: var(--l3-foreground);
+		margin: calc(var(--spacing-2) * -1) 0 var(--spacing-4) 0;
+		line-height: var(--paragraph-small-400-line-height);
+	}
+}
+
+.create-sa-modal__footer {
+	display: flex;
+	flex-direction: row;
+	align-items: center;
+	justify-content: flex-end;
+	padding: 0 var(--padding-4);
+	height: 56px;
+	min-height: 56px;
+	border-top: 1px solid var(--secondary);
+	gap: var(--spacing-4);
+	flex-shrink: 0;
+}
+
+.lightMode {
+	.create-sa-modal {
+		[data-slot='dialog-title'] {
+			color: var(--bg-base-black);
+		}
+	}
+}

frontend/src/components/CreateServiceAccountModal/CreateServiceAccountModal.tsx

@@ -0,0 +1,228 @@
+import { Controller, useForm } from 'react-hook-form';
+import { useQueryClient } from 'react-query';
+import { Button } from '@signozhq/button';
+import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
+import { X } from '@signozhq/icons';
+import { Input } from '@signozhq/input';
+import { toast } from '@signozhq/sonner';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	invalidateListServiceAccounts,
+	useCreateServiceAccount,
+} from 'api/generated/services/serviceaccount';
+import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import RolesSelect, { useRoles } from 'components/RolesSelect';
+import { parseAsBoolean, useQueryState } from 'nuqs';
+import { EMAIL_REGEX } from 'utils/app';
+
+import './CreateServiceAccountModal.styles.scss';
+
+interface FormValues {
+	name: string;
+	email: string;
+	roles: string[];
+}
+
+function CreateServiceAccountModal(): JSX.Element {
+	const queryClient = useQueryClient();
+	const [isOpen, setIsOpen] = useQueryState(
+		'create-sa',
+		parseAsBoolean.withDefault(false),
+	);
+
+	const {
+		control,
+		handleSubmit,
+		reset,
+		formState: { isValid, errors },
+	} = useForm<FormValues>({
+		mode: 'onChange',
+		defaultValues: {
+			name: '',
+			email: '',
+			roles: [],
+		},
+	});
+
+	const {
+		mutate: createServiceAccount,
+		isLoading: isSubmitting,
+	} = useCreateServiceAccount({
+		mutation: {
+			onSuccess: () => {
+				toast.success('Service account created successfully', {
+					richColors: true,
+				});
+				reset();
+				void setIsOpen(null);
+				void invalidateListServiceAccounts(queryClient);
+			},
+			onError: (err) => {
+				const errMessage =
+					convertToApiError(
+						err as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'An error occurred';
+				toast.error(`Failed to create service account: ${errMessage}`, {
+					richColors: true,
+				});
+			},
+		},
+	});
+	const {
+		roles,
+		isLoading: rolesLoading,
+		isError: rolesError,
+		error: rolesErrorObj,
+		refetch: refetchRoles,
+	} = useRoles();
+
+	function handleClose(): void {
+		reset();
+		void setIsOpen(null);
+	}
+
+	function handleCreate(values: FormValues): void {
+		createServiceAccount({
+			data: {
+				name: values.name.trim(),
+				email: values.email.trim(),
+				roles: values.roles,
+			},
+		});
+	}
+
+	return (
+		<DialogWrapper
+			title="New Service Account"
+			open={isOpen}
+			onOpenChange={(open): void => {
+				if (!open) {
+					handleClose();
+				}
+			}}
+			showCloseButton
+			width="narrow"
+			className="create-sa-modal"
+			disableOutsideClick={false}
+		>
+			<div className="create-sa-modal__content">
+				<form className="create-sa-form">
+					<div className="create-sa-form__item">
+						<label htmlFor="sa-name">Name</label>
+						<Controller
+							name="name"
+							control={control}
+							rules={{ required: 'Name is required' }}
+							render={({ field }): JSX.Element => (
+								<Input
+									id="sa-name"
+									placeholder="Enter a name"
+									className="create-sa-form__input"
+									value={field.value}
+									onChange={field.onChange}
+									onBlur={field.onBlur}
+								/>
+							)}
+						/>
+						{errors.name && (
+							<p className="create-sa-form__error">{errors.name.message}</p>
+						)}
+					</div>
+
+					<div className="create-sa-form__item">
+						<label htmlFor="sa-email">Email Address</label>
+						<Controller
+							name="email"
+							control={control}
+							rules={{
+								required: 'Email Address is required',
+								pattern: {
+									value: EMAIL_REGEX,
+									message: 'Please enter a valid email address',
+								},
+							}}
+							render={({ field }): JSX.Element => (
+								<Input
+									id="sa-email"
+									type="email"
+									placeholder="email@example.com"
+									className="create-sa-form__input"
+									value={field.value}
+									onChange={field.onChange}
+									onBlur={field.onBlur}
+								/>
+							)}
+						/>
+						{errors.email && (
+							<p className="create-sa-form__error">{errors.email.message}</p>
+						)}
+					</div>
+					<p className="create-sa-form__helper">
+						Used only for notifications about this service account. It is not used for
+						authentication.
+					</p>
+
+					<div className="create-sa-form__item">
+						<label htmlFor="sa-roles">Roles</label>
+						<Controller
+							name="roles"
+							control={control}
+							rules={{
+								validate: (value): string | true =>
+									value.length > 0 || 'At least one role is required',
+							}}
+							render={({ field }): JSX.Element => (
+								<RolesSelect
+									id="sa-roles"
+									mode="multiple"
+									roles={roles}
+									loading={rolesLoading}
+									isError={rolesError}
+									error={rolesErrorObj}
+									onRefetch={refetchRoles}
+									placeholder="Select roles"
+									value={field.value}
+									onChange={field.onChange}
+									getPopupContainer={(triggerNode): HTMLElement =>
+										(triggerNode?.closest('.create-sa-modal') as HTMLElement) ||
+										document.body
+									}
+								/>
+							)}
+						/>
+						{errors.roles && (
+							<p className="create-sa-form__error">{errors.roles.message}</p>
+						)}
+					</div>
+				</form>
+			</div>
+
+			<DialogFooter className="create-sa-modal__footer">
+				<Button
+					type="button"
+					variant="solid"
+					color="secondary"
+					size="sm"
+					onClick={handleClose}
+				>
+					<X size={12} />
+					Cancel
+				</Button>
+
+				<Button
+					variant="solid"
+					color="primary"
+					size="sm"
+					onClick={handleSubmit(handleCreate)}
+					loading={isSubmitting}
+					disabled={!isValid}
+				>
+					Create Service Account
+				</Button>
+			</DialogFooter>
+		</DialogWrapper>
+	);
+}
+
+export default CreateServiceAccountModal;

frontend/src/components/CreateServiceAccountModal/__tests__/CreateServiceAccountModal.test.tsx

@@ -0,0 +1,179 @@
+import { toast } from '@signozhq/sonner';
+import { listRolesSuccessResponse } from 'mocks-server/__mockdata__/roles';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import CreateServiceAccountModal from '../CreateServiceAccountModal';
+
+jest.mock('@signozhq/sonner', () => ({
+	toast: { success: jest.fn(), error: jest.fn() },
+}));
+
+const mockToast = jest.mocked(toast);
+
+const ROLES_ENDPOINT = '*/api/v1/roles';
+const SERVICE_ACCOUNTS_ENDPOINT = '*/api/v1/service_accounts';
+
+function renderModal(): ReturnType<typeof render> {
+	return render(
+		<NuqsTestingAdapter searchParams={{ 'create-sa': 'true' }} hasMemory>
+			<CreateServiceAccountModal />
+		</NuqsTestingAdapter>,
+	);
+}
+
+describe('CreateServiceAccountModal', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
+			),
+			rest.post(SERVICE_ACCOUNTS_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(201), ctx.json({ status: 'success', data: {} })),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('submit button is disabled when form is empty', () => {
+		renderModal();
+
+		expect(
+			screen.getByRole('button', { name: /Create Service Account/i }),
+		).toBeDisabled();
+	});
+
+	it('submit button remains disabled when email is invalid', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText('Enter a name'), 'My Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'not-an-email',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
+
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /Create Service Account/i }),
+			).toBeDisabled(),
+		);
+	});
+
+	it('successful submit shows toast.success and closes modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText('Enter a name'), 'Deploy Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'deploy@acme.io',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
+
+		const submitBtn = screen.getByRole('button', {
+			name: /Create Service Account/i,
+		});
+		await waitFor(() => expect(submitBtn).not.toBeDisabled());
+		await user.click(submitBtn);
+
+		await waitFor(() => {
+			expect(mockToast.success).toHaveBeenCalledWith(
+				'Service account created successfully',
+				expect.anything(),
+			);
+		});
+
+		await waitFor(() => {
+			expect(
+				screen.queryByRole('dialog', { name: /New Service Account/i }),
+			).not.toBeInTheDocument();
+		});
+	});
+
+	it('shows toast.error on API error and keeps modal open', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		server.use(
+			rest.post(SERVICE_ACCOUNTS_ENDPOINT, (_, res, ctx) =>
+				res(
+					ctx.status(500),
+					ctx.json({ status: 'error', error: 'Internal Server Error' }),
+				),
+			),
+		);
+
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText('Enter a name'), 'Dupe Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'dupe@acme.io',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
+
+		const submitBtn = screen.getByRole('button', {
+			name: /Create Service Account/i,
+		});
+		await waitFor(() => expect(submitBtn).not.toBeDisabled());
+		await user.click(submitBtn);
+
+		await waitFor(() => {
+			expect(mockToast.error).toHaveBeenCalledWith(
+				expect.stringMatching(/Failed to create service account/i),
+				expect.anything(),
+			);
+		});
+
+		expect(
+			screen.getByRole('dialog', { name: /New Service Account/i }),
+		).toBeInTheDocument();
+	});
+
+	it('Cancel button closes modal without submitting', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await screen.findByRole('dialog', { name: /New Service Account/i });
+		await user.click(screen.getByRole('button', { name: /Cancel/i }));
+
+		expect(
+			screen.queryByRole('dialog', { name: /New Service Account/i }),
+		).not.toBeInTheDocument();
+	});
+
+	it('shows "Name is required" after clearing the name field', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		const nameInput = screen.getByPlaceholderText('Enter a name');
+		await user.type(nameInput, 'Bot');
+		await user.clear(nameInput);
+
+		await screen.findByText('Name is required');
+	});
+
+	it('shows "Please enter a valid email address" for a malformed email', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'not-an-email',
+		);
+
+		await screen.findByText('Please enter a valid email address');
+	});
+});

frontend/src/components/InviteMembersModal/InviteMembersModal.tsx

@@ -254,6 +254,8 @@ function InviteMembersModal({
 											value={row.email}
 											onChange={(e): void => updateEmail(row.id, e.target.value)}
 											className="team-member-email-input"
+											name={`invite-email-${row.id}`}
+											autoComplete="email"
 										/>
 										{emailValidity[row.id] === false && row.email.trim() !== '' && (
 											<span className="email-error-message">Invalid email address</span>

frontend/src/components/MembersTable/MembersTable.styles.scss

@@ -162,7 +162,7 @@
 		font-weight: var(--paragraph-base-400-font-weight);
 		color: var(--foreground);
 		margin: 0;
-		line-height: var(--paragraph-base-400-font-height);
+		line-height: var(--paragraph-base-400-line-height);
 
 		strong {
 			font-weight: var(--font-weight-medium);

frontend/src/components/RolesSelect/RolesSelect.styles.scss

@@ -0,0 +1,90 @@
+.roles-select {
+	width: 100%;
+
+	// todo: styles should easeup once upgrade to select from periscope
+	.ant-select-selector {
+		min-height: 32px;
+		background-color: var(--l2-background) !important;
+		border: 1px solid var(--border) !important;
+		border-radius: 2px;
+		padding: 2px var(--padding-2) !important;
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+	}
+
+	.ant-select-selection-overflow {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: var(--spacing-1);
+		padding: 2px 0;
+	}
+
+	.ant-select-selection-overflow-item {
+		display: flex;
+		align-items: center;
+	}
+
+	.ant-select-selection-item {
+		display: flex;
+		align-items: center;
+		height: 22px;
+		font-size: var(--font-size-sm);
+		color: var(--l1-foreground);
+		background: var(--l3-background);
+		border: 1px solid var(--border);
+		border-radius: 2px;
+		padding: 0 var(--padding-1) 0 6px;
+		line-height: var(--line-height-20);
+		letter-spacing: -0.07px;
+		margin: 0;
+	}
+
+	.ant-select-selection-item-remove {
+		display: flex;
+		align-items: center;
+		color: var(--foreground);
+		margin-left: 2px;
+	}
+
+	.ant-select-selection-placeholder {
+		font-size: var(--font-size-sm);
+		color: var(--l3-foreground);
+	}
+
+	.ant-select-arrow {
+		color: var(--foreground);
+	}
+
+	&.ant-select-focused .ant-select-selector,
+	&:not(.ant-select-disabled):hover .ant-select-selector {
+		border-color: var(--primary) !important;
+	}
+}
+
+.roles-select-error {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--spacing-3);
+	padding: var(--padding-1) var(--padding-2);
+	color: var(--destructive);
+	font-size: var(--font-size-xs);
+
+	&__msg {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-3);
+	}
+
+	&__retry-btn {
+		display: flex;
+		align-items: center;
+		background: none;
+		border: none;
+		cursor: pointer;
+		padding: 2px;
+		color: var(--destructive);
+	}
+}

frontend/src/components/RolesSelect/RolesSelect.tsx

@@ -0,0 +1,172 @@
+import { CircleAlert, RefreshCw } from '@signozhq/icons';
+import { Checkbox, Select } from 'antd';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { useListRoles } from 'api/generated/services/role';
+import type { AuthtypesRoleDTO } from 'api/generated/services/sigNoz.schemas';
+import cx from 'classnames';
+import APIError from 'types/api/error';
+
+import './RolesSelect.styles.scss';
+
+export interface RoleOption {
+	label: string;
+	value: string;
+}
+
+export function useRoles(): {
+	roles: AuthtypesRoleDTO[];
+	isLoading: boolean;
+	isError: boolean;
+	error: APIError | undefined;
+	refetch: () => void;
+} {
+	const { data, isLoading, isError, error, refetch } = useListRoles();
+	return {
+		roles: data?.data ?? [],
+		isLoading,
+		isError,
+		error: convertToApiError(error),
+		refetch,
+	};
+}
+
+export function getRoleOptions(roles: AuthtypesRoleDTO[]): RoleOption[] {
+	return roles.map((role) => ({
+		label: role.name ?? '',
+		value: role.name ?? '',
+	}));
+}
+
+function ErrorContent({
+	error,
+	onRefetch,
+}: {
+	error?: APIError;
+	onRefetch?: () => void;
+}): JSX.Element {
+	const errorMessage = error?.message || 'Failed to load roles';
+
+	return (
+		<div className="roles-select-error">
+			<span className="roles-select-error__msg">
+				<CircleAlert size={12} />
+				{errorMessage}
+			</span>
+			{onRefetch && (
+				<button
+					type="button"
+					onClick={(e): void => {
+						e.stopPropagation();
+						onRefetch();
+					}}
+					className="roles-select-error__retry-btn"
+					title="Retry"
+				>
+					<RefreshCw size={12} />
+				</button>
+			)}
+		</div>
+	);
+}
+
+interface BaseProps {
+	id?: string;
+	placeholder?: string;
+	className?: string;
+	getPopupContainer?: (trigger: HTMLElement) => HTMLElement;
+	roles?: AuthtypesRoleDTO[];
+	loading?: boolean;
+	isError?: boolean;
+	error?: APIError;
+	onRefetch?: () => void;
+}
+
+interface SingleProps extends BaseProps {
+	mode?: 'single';
+	value?: string;
+	onChange?: (role: string) => void;
+}
+
+interface MultipleProps extends BaseProps {
+	mode: 'multiple';
+	value?: string[];
+	onChange?: (roles: string[]) => void;
+}
+
+export type RolesSelectProps = SingleProps | MultipleProps;
+
+function RolesSelect(props: RolesSelectProps): JSX.Element {
+	const externalRoles = props.roles;
+
+	const {
+		data,
+		isLoading: internalLoading,
+		isError: internalError,
+		error: internalErrorObj,
+		refetch: internalRefetch,
+	} = useListRoles({
+		query: { enabled: externalRoles === undefined },
+	});
+
+	const roles = externalRoles ?? data?.data ?? [];
+	const options = getRoleOptions(roles);
+
+	const {
+		mode,
+		id,
+		placeholder = 'Select role',
+		className,
+		getPopupContainer,
+		loading = internalLoading,
+		isError = internalError,
+		error = convertToApiError(internalErrorObj),
+		onRefetch = externalRoles === undefined ? internalRefetch : undefined,
+	} = props;
+
+	const notFoundContent = isError ? (
+		<ErrorContent error={error} onRefetch={onRefetch} />
+	) : undefined;
+
+	if (mode === 'multiple') {
+		const { value = [], onChange } = props as MultipleProps;
+		return (
+			<Select
+				id={id}
+				mode="multiple"
+				value={value}
+				onChange={onChange}
+				placeholder={placeholder}
+				className={cx('roles-select', className)}
+				loading={loading}
+				notFoundContent={notFoundContent}
+				options={options}
+				optionRender={(option): JSX.Element => (
+					<Checkbox
+						checked={value.includes(option.value as string)}
+						style={{ pointerEvents: 'none' }}
+					>
+						{option.label}
+					</Checkbox>
+				)}
+				getPopupContainer={getPopupContainer}
+			/>
+		);
+	}
+
+	const { value, onChange } = props as SingleProps;
+	return (
+		<Select
+			id={id}
+			value={value}
+			onChange={onChange}
+			placeholder={placeholder}
+			className={cx('roles-select', className)}
+			loading={loading}
+			notFoundContent={notFoundContent}
+			options={options}
+			getPopupContainer={getPopupContainer}
+		/>
+	);
+}
+
+export default RolesSelect;

frontend/src/components/RolesSelect/index.ts

@@ -0,0 +1,2 @@
+export type { RoleOption, RolesSelectProps } from './RolesSelect';
+export { default, getRoleOptions, useRoles } from './RolesSelect';

frontend/src/components/ServiceAccountDrawer/AddKeyModal.styles.scss

@@ -0,0 +1,179 @@
+.add-key-modal {
+	[data-slot='dialog-description'] {
+		padding: 0;
+	}
+
+	&__form {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-8);
+		padding: var(--padding-4);
+	}
+
+	&__field {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-4);
+	}
+
+	&__label {
+		font-size: var(--font-size-sm);
+		font-weight: var(--font-weight-normal);
+		color: var(--foreground);
+		line-height: var(--line-height-20);
+		letter-spacing: -0.07px;
+	}
+
+	&__input {
+		height: 32px;
+		background: var(--l2-background);
+		border-color: var(--border);
+		color: var(--l1-foreground);
+		box-shadow: none;
+
+		&::placeholder {
+			color: var(--l3-foreground);
+		}
+	}
+
+	&__expiry-toggle {
+		width: 60%;
+		display: flex;
+		border: 1px solid var(--border);
+		border-radius: 2px;
+		overflow: hidden;
+		padding: 0;
+		gap: 0;
+
+		[data-slot='toggle-group'] {
+			width: 100%;
+			display: flex;
+		}
+
+		&-btn {
+			flex: 1;
+			height: 32px;
+			border-radius: 0;
+			font-size: var(--label-small-400-font-size);
+			font-weight: var(--label-small-400-font-weight);
+			line-height: var(--label-small-400-line-height);
+			justify-content: center;
+			background: transparent;
+			border: none;
+			border-right: 1px solid var(--border);
+			color: var(--foreground);
+
+			&:last-child {
+				border-right: none;
+			}
+
+			&[data-state='on'] {
+				background: var(--l2-background);
+				color: var(--l1-foreground);
+			}
+		}
+	}
+
+	&__datepicker {
+		width: 100%;
+		height: 32px;
+
+		.ant-picker {
+			background: var(--l2-background);
+			border-color: var(--border);
+			border-radius: 2px;
+			width: 100%;
+			height: 32px;
+
+			input {
+				color: var(--l1-foreground);
+				font-size: var(--font-size-sm);
+			}
+
+			.ant-picker-suffix {
+				color: var(--foreground);
+			}
+		}
+
+		.add-key-modal-datepicker-popup {
+			border-radius: 4px;
+			border: 1px solid var(--secondary);
+			background: var(--popover);
+			box-shadow: 0px -4px 16px 2px rgba(0, 0, 0, 0.2);
+		}
+	}
+
+	&__key-display {
+		display: flex;
+		align-items: center;
+		height: 32px;
+		background: var(--l2-background);
+		border: 1px solid var(--border);
+		border-radius: 2px;
+		overflow: hidden;
+	}
+
+	&__key-text {
+		flex: 1;
+		min-width: 0;
+		padding: 0 var(--padding-2);
+		font-size: var(--font-size-sm);
+		color: var(--l1-foreground);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		font-family: monospace;
+	}
+
+	&__copy-btn {
+		flex-shrink: 0;
+		height: 32px;
+		border-radius: 0 2px 2px 0;
+		border-top: none;
+		border-right: none;
+		border-bottom: none;
+		border-left: 1px solid var(--border);
+		min-width: 40px;
+	}
+
+	&__expiry-meta {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-2);
+	}
+
+	&__expiry-label {
+		font-size: var(--font-size-xs);
+		font-weight: var(--font-weight-medium);
+		color: var(--foreground);
+		letter-spacing: 0.48px;
+		text-transform: uppercase;
+	}
+
+	&__footer {
+		display: flex;
+		align-items: center;
+		justify-content: flex-end;
+		padding: var(--padding-4);
+		border-top: 1px solid var(--secondary);
+	}
+
+	&__footer-right {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-4);
+	}
+
+	&__learn-more {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-1);
+		color: var(--primary);
+		font-size: var(--font-size-sm);
+		text-decoration: none;
+
+		&:hover {
+			text-decoration: underline;
+		}
+	}
+}

frontend/src/components/ServiceAccountDrawer/AddKeyModal.tsx

@@ -0,0 +1,302 @@
+import { useCallback, useEffect, useState } from 'react';
+import { Controller, useForm } from 'react-hook-form';
+import { useQueryClient } from 'react-query';
+import { Badge } from '@signozhq/badge';
+import { Button } from '@signozhq/button';
+import { Callout } from '@signozhq/callout';
+import { DialogWrapper } from '@signozhq/dialog';
+import { Check, Copy } from '@signozhq/icons';
+import { Input } from '@signozhq/input';
+import { toast } from '@signozhq/sonner';
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { DatePicker } from 'antd';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	invalidateListServiceAccountKeys,
+	useCreateServiceAccountKey,
+} from 'api/generated/services/serviceaccount';
+import type {
+	RenderErrorResponseDTO,
+	ServiceaccounttypesGettableFactorAPIKeyWithKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import type { Dayjs } from 'dayjs';
+import { parseAsBoolean, useQueryState } from 'nuqs';
+import { popupContainer } from 'utils/selectPopupContainer';
+
+import { disabledDate } from './utils';
+
+import './AddKeyModal.styles.scss';
+
+type Phase = 'form' | 'created';
+type ExpiryMode = 'none' | 'date';
+
+interface FormValues {
+	keyName: string;
+	expiryMode: ExpiryMode;
+	expiryDate: Dayjs | null;
+}
+
+function AddKeyModal(): JSX.Element {
+	const queryClient = useQueryClient();
+	const [accountId] = useQueryState('account');
+	const [isAddKeyOpen, setIsAddKeyOpen] = useQueryState(
+		'add-key',
+		parseAsBoolean.withDefault(false),
+	);
+	const open = isAddKeyOpen && !!accountId;
+
+	const [phase, setPhase] = useState<Phase>('form');
+	const [
+		createdKey,
+		setCreatedKey,
+	] = useState<ServiceaccounttypesGettableFactorAPIKeyWithKeyDTO | null>(null);
+	const [hasCopied, setHasCopied] = useState(false);
+
+	const {
+		control,
+		register,
+		handleSubmit,
+		reset,
+		watch,
+		formState: { isValid },
+	} = useForm<FormValues>({
+		mode: 'onChange',
+		defaultValues: { keyName: '', expiryMode: 'none', expiryDate: null },
+	});
+
+	const expiryMode = watch('expiryMode');
+	const expiryDate = watch('expiryDate');
+
+	useEffect(() => {
+		if (open) {
+			setPhase('form');
+			setCreatedKey(null);
+			setHasCopied(false);
+			reset();
+		}
+	}, [open, reset]);
+
+	const {
+		mutate: createKey,
+		isLoading: isSubmitting,
+	} = useCreateServiceAccountKey({
+		mutation: {
+			onSuccess: (response) => {
+				const keyData = response?.data;
+				if (keyData) {
+					setCreatedKey(keyData);
+					setPhase('created');
+					if (accountId) {
+						void invalidateListServiceAccountKeys(queryClient, { id: accountId });
+					}
+				}
+			},
+			onError: (error) => {
+				const errMessage =
+					convertToApiError(
+						error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'Failed to create key';
+				toast.error(errMessage, { richColors: true });
+			},
+		},
+	});
+
+	function handleCreate({
+		keyName,
+		expiryMode: mode,
+		expiryDate: date,
+	}: FormValues): void {
+		if (!accountId) {
+			return;
+		}
+		const expiresAt = mode === 'date' && date ? date.endOf('day').unix() : 0;
+		createKey({
+			pathParams: { id: accountId },
+			data: { name: keyName.trim(), expiresAt },
+		});
+	}
+
+	const handleCopy = useCallback(async (): Promise<void> => {
+		if (!createdKey?.key) {
+			return;
+		}
+		try {
+			await navigator.clipboard.writeText(createdKey.key);
+			setHasCopied(true);
+			setTimeout(() => setHasCopied(false), 2000);
+			toast.success('Key copied to clipboard', { richColors: true });
+		} catch {
+			toast.error('Failed to copy key', { richColors: true });
+		}
+	}, [createdKey]);
+
+	const handleClose = useCallback((): void => {
+		setIsAddKeyOpen(null);
+	}, [setIsAddKeyOpen]);
+
+	const expiryLabel = (): string => {
+		if (expiryMode === 'none' || !expiryDate) {
+			return 'Never';
+		}
+		try {
+			return expiryDate.format('MMM D, YYYY');
+		} catch {
+			return 'Never';
+		}
+	};
+
+	const title = phase === 'form' ? 'Add a New Key' : 'Key Created Successfully';
+
+	return (
+		<DialogWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					handleClose();
+				}
+			}}
+			title={title}
+			width="base"
+			className="add-key-modal"
+			showCloseButton
+			disableOutsideClick={false}
+		>
+			{phase === 'form' && (
+				<>
+					<div className="add-key-modal__form">
+						<div className="add-key-modal__field">
+							<label className="add-key-modal__label" htmlFor="key-name">
+								Name <span style={{ color: 'var(--destructive)' }}>*</span>
+							</label>
+							<Input
+								id="key-name"
+								placeholder="Enter key name e.g.: Service Owner"
+								className="add-key-modal__input"
+								{...register('keyName', {
+									required: true,
+									validate: (v) => !!v.trim(),
+								})}
+							/>
+						</div>
+
+						<div className="add-key-modal__field">
+							<span className="add-key-modal__label">Expiration</span>
+							<Controller
+								name="expiryMode"
+								control={control}
+								render={({ field }): JSX.Element => (
+									<ToggleGroup
+										type="single"
+										value={field.value}
+										onValueChange={(val): void => {
+											if (val) {
+												field.onChange(val);
+											}
+										}}
+										className="add-key-modal__expiry-toggle"
+									>
+										<ToggleGroupItem
+											value="none"
+											className="add-key-modal__expiry-toggle-btn"
+										>
+											No Expiration
+										</ToggleGroupItem>
+										<ToggleGroupItem
+											value="date"
+											className="add-key-modal__expiry-toggle-btn"
+										>
+											Set Expiration Date
+										</ToggleGroupItem>
+									</ToggleGroup>
+								)}
+							/>
+						</div>
+
+						{expiryMode === 'date' && (
+							<div className="add-key-modal__field">
+								<label className="add-key-modal__label" htmlFor="expiry-date">
+									Expiration Date
+								</label>
+								<div className="add-key-modal__datepicker">
+									<Controller
+										name="expiryDate"
+										control={control}
+										render={({ field }): JSX.Element => (
+											<DatePicker
+												id="expiry-date"
+												value={field.value}
+												onChange={field.onChange}
+												popupClassName="add-key-modal-datepicker-popup"
+												getPopupContainer={popupContainer}
+												disabledDate={disabledDate}
+											/>
+										)}
+									/>
+								</div>
+							</div>
+						)}
+					</div>
+
+					<div className="add-key-modal__footer">
+						<div className="add-key-modal__footer-right">
+							<Button
+								variant="solid"
+								color="secondary"
+								size="sm"
+								onClick={handleClose}
+							>
+								Cancel
+							</Button>
+							<Button
+								variant="solid"
+								color="primary"
+								size="sm"
+								loading={isSubmitting}
+								disabled={!isValid}
+								onClick={handleSubmit(handleCreate)}
+							>
+								Create Key
+							</Button>
+						</div>
+					</div>
+				</>
+			)}
+
+			{phase === 'created' && createdKey && (
+				<>
+					<div className="add-key-modal__form">
+						<div className="add-key-modal__field">
+							<span className="add-key-modal__label">Key</span>
+							<div className="add-key-modal__key-display">
+								<span className="add-key-modal__key-text">{createdKey.key}</span>
+								<Button
+									variant="outlined"
+									color="secondary"
+									size="sm"
+									onClick={handleCopy}
+									className="add-key-modal__copy-btn"
+								>
+									{hasCopied ? <Check size={12} /> : <Copy size={12} />}
+								</Button>
+							</div>
+						</div>
+
+						<div className="add-key-modal__expiry-meta">
+							<span className="add-key-modal__expiry-label">Expiration</span>
+							<Badge color="vanilla">{expiryLabel()}</Badge>
+						</div>
+
+						<Callout
+							type="info"
+							showIcon
+							message="Store the key securely. This is the only time it will be displayed."
+						/>
+					</div>
+				</>
+			)}
+		</DialogWrapper>
+	);
+}
+
+export default AddKeyModal;

frontend/src/components/ServiceAccountDrawer/DisableAccountModal.tsx

@@ -0,0 +1,108 @@
+import { useQueryClient } from 'react-query';
+import { Button } from '@signozhq/button';
+import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
+import { PowerOff, X } from '@signozhq/icons';
+import { toast } from '@signozhq/sonner';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	getGetServiceAccountQueryKey,
+	invalidateListServiceAccounts,
+	useUpdateServiceAccountStatus,
+} from 'api/generated/services/serviceaccount';
+import type {
+	RenderErrorResponseDTO,
+	ServiceaccounttypesServiceAccountDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import { parseAsBoolean, useQueryState } from 'nuqs';
+
+function DisableAccountModal(): JSX.Element {
+	const queryClient = useQueryClient();
+	const [accountId, setAccountId] = useQueryState('account');
+	const [isDisableOpen, setIsDisableOpen] = useQueryState(
+		'disable-sa',
+		parseAsBoolean.withDefault(false),
+	);
+	const open = !!isDisableOpen && !!accountId;
+
+	const cachedAccount = accountId
+		? queryClient.getQueryData<{
+				data: ServiceaccounttypesServiceAccountDTO;
+		  }>(getGetServiceAccountQueryKey({ id: accountId }))
+		: null;
+	const accountName = cachedAccount?.data?.name;
+
+	const {
+		mutate: updateStatus,
+		isLoading: isDisabling,
+	} = useUpdateServiceAccountStatus({
+		mutation: {
+			onSuccess: () => {
+				toast.success('Service account disabled', { richColors: true });
+				void setIsDisableOpen(null);
+				void setAccountId(null);
+				void invalidateListServiceAccounts(queryClient);
+			},
+			onError: (error) => {
+				const errMessage =
+					convertToApiError(
+						error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'Failed to disable service account';
+				toast.error(errMessage, { richColors: true });
+			},
+		},
+	});
+
+	function handleConfirm(): void {
+		if (!accountId) {
+			return;
+		}
+		updateStatus({
+			pathParams: { id: accountId },
+			data: { status: 'DISABLED' },
+		});
+	}
+
+	function handleCancel(): void {
+		void setIsDisableOpen(null);
+	}
+
+	return (
+		<DialogWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					handleCancel();
+				}
+			}}
+			title={`Disable service account ${accountName ?? ''}?`}
+			width="narrow"
+			className="alert-dialog sa-disable-dialog"
+			showCloseButton={false}
+			disableOutsideClick={false}
+		>
+			<p className="sa-disable-dialog__body">
+				Disabling this service account will revoke access for all its keys. Any
+				systems using this account will lose access immediately.
+			</p>
+			<DialogFooter className="sa-disable-dialog__footer">
+				<Button variant="solid" color="secondary" size="sm" onClick={handleCancel}>
+					<X size={12} />
+					Cancel
+				</Button>
+				<Button
+					variant="solid"
+					color="destructive"
+					size="sm"
+					loading={isDisabling}
+					onClick={handleConfirm}
+				>
+					<PowerOff size={12} />
+					Disable
+				</Button>
+			</DialogFooter>
+		</DialogWrapper>
+	);
+}
+
+export default DisableAccountModal;

frontend/src/components/ServiceAccountDrawer/EditKeyModal.styles.scss

@@ -0,0 +1,188 @@
+.edit-key-modal {
+	[data-slot='dialog-description'] {
+		padding: 0;
+	}
+
+	&__form {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-8);
+		padding: var(--padding-4);
+	}
+
+	&__field {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-4);
+	}
+
+	&__label {
+		font-size: 13px;
+		font-weight: var(--font-weight-normal);
+		color: var(--foreground);
+		line-height: var(--line-height-20);
+		letter-spacing: -0.07px;
+	}
+
+	&__input {
+		height: 32px;
+		background: var(--l2-background);
+		border-color: var(--border);
+		color: var(--l1-foreground);
+		box-shadow: none;
+
+		&::placeholder {
+			color: var(--l3-foreground);
+		}
+	}
+
+	&__key-display {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		height: 32px;
+		padding: 0 var(--padding-2);
+		border-radius: 2px;
+		background: var(--l2-background);
+		border: 1px solid var(--border);
+		cursor: not-allowed;
+		opacity: 0.8;
+	}
+
+	&__key-text {
+		font-size: 13px;
+		font-family: monospace;
+		color: var(--foreground);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		flex: 1;
+		letter-spacing: 2px;
+	}
+
+	&__lock-icon {
+		color: var(--foreground);
+		flex-shrink: 0;
+		margin-left: 6px;
+		opacity: 0.6;
+	}
+
+	&__expiry-toggle {
+		width: 60%;
+		display: flex;
+		border: 1px solid var(--border);
+		border-radius: 2px;
+		overflow: hidden;
+		padding: 0;
+		gap: 0;
+
+		[data-slot='toggle-group'] {
+			width: 100%;
+			display: flex;
+		}
+
+		&-btn {
+			flex: 1;
+			height: 32px;
+			border-radius: 0;
+			font-size: var(--label-small-400-font-size);
+			font-weight: var(--label-small-400-font-weight);
+			line-height: var(--label-small-400-line-height);
+			justify-content: center;
+			background: transparent;
+			border: none;
+			border-right: 1px solid var(--border);
+			color: var(--foreground);
+			white-space: nowrap;
+
+			&:last-child {
+				border-right: none;
+			}
+
+			&[data-state='on'] {
+				background: var(--l2-background);
+				color: var(--l1-foreground);
+			}
+		}
+	}
+
+	&__datepicker {
+		width: 100%;
+		height: 32px;
+
+		.ant-picker {
+			background: var(--l2-background);
+			border-color: var(--border);
+			border-radius: 2px;
+			width: 100%;
+			height: 32px;
+
+			input {
+				color: var(--l1-foreground);
+				font-size: 13px;
+			}
+
+			.ant-picker-suffix {
+				color: var(--foreground);
+			}
+		}
+
+		.edit-key-modal-datepicker-popup {
+			border-radius: 4px;
+			border: 1px solid var(--secondary);
+			background: var(--popover);
+			box-shadow: 0px -4px 16px 2px rgba(0, 0, 0, 0.2);
+		}
+	}
+
+	&__meta {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-2);
+	}
+
+	&__meta-label {
+		font-size: var(--font-size-xs);
+		font-weight: var(--font-weight-medium);
+		color: var(--foreground);
+		letter-spacing: 0.48px;
+		text-transform: uppercase;
+	}
+
+	&__footer {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		padding: var(--padding-4);
+		border-top: 1px solid var(--secondary);
+	}
+
+	&__footer-right {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-4);
+	}
+
+	&__footer-danger {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-2);
+		padding: 0;
+		background: transparent;
+		border: none;
+		cursor: pointer;
+		color: var(--destructive);
+		font-size: var(--label-small-400-font-size);
+		font-weight: var(--label-small-400-font-weight);
+		transition: opacity 0.15s ease;
+
+		&:hover {
+			opacity: 0.8;
+		}
+
+		&:disabled {
+			opacity: 0.5;
+			cursor: not-allowed;
+		}
+	}
+}

frontend/src/components/ServiceAccountDrawer/EditKeyModal.tsx

@@ -0,0 +1,314 @@
+import { useEffect, useState } from 'react';
+import { Controller, useForm } from 'react-hook-form';
+import { useQueryClient } from 'react-query';
+import { Badge } from '@signozhq/badge';
+import { Button } from '@signozhq/button';
+import { DialogWrapper } from '@signozhq/dialog';
+import { LockKeyhole, Trash2, X } from '@signozhq/icons';
+import { Input } from '@signozhq/input';
+import { toast } from '@signozhq/sonner';
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { DatePicker } from 'antd';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	invalidateListServiceAccountKeys,
+	useRevokeServiceAccountKey,
+	useUpdateServiceAccountKey,
+} from 'api/generated/services/serviceaccount';
+import type {
+	RenderErrorResponseDTO,
+	ServiceaccounttypesFactorAPIKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import type { Dayjs } from 'dayjs';
+import dayjs from 'dayjs';
+import { parseAsString, useQueryState } from 'nuqs';
+import { useTimezone } from 'providers/Timezone';
+import { popupContainer } from 'utils/selectPopupContainer';
+
+import { RevokeKeyContent } from './RevokeKeyModal';
+import { disabledDate, formatLastObservedAt } from './utils';
+
+import './EditKeyModal.styles.scss';
+
+type ExpiryMode = 'none' | 'date';
+
+interface FormValues {
+	name: string;
+	expiryMode: ExpiryMode;
+	expiresAt: Dayjs | null;
+}
+
+interface EditKeyModalProps {
+	keyItem: ServiceaccounttypesFactorAPIKeyDTO | null;
+}
+
+function EditKeyModal({ keyItem }: EditKeyModalProps): JSX.Element {
+	const queryClient = useQueryClient();
+	const [selectedAccountId] = useQueryState('account');
+	const [editKeyId, setEditKeyId] = useQueryState(
+		'edit-key',
+		parseAsString.withDefault(''),
+	);
+
+	const open = !!editKeyId && !!selectedAccountId;
+
+	const { formatTimezoneAdjustedTimestamp } = useTimezone();
+	const [isRevokeConfirmOpen, setIsRevokeConfirmOpen] = useState(false);
+
+	const {
+		register,
+		control,
+		reset,
+		watch,
+		formState: { isDirty },
+		handleSubmit,
+	} = useForm<FormValues>({
+		defaultValues: { name: '', expiryMode: 'none', expiresAt: null },
+	});
+
+	useEffect(() => {
+		if (keyItem) {
+			reset({
+				name: keyItem.name ?? '',
+				expiryMode: keyItem.expiresAt === 0 ? 'none' : 'date',
+				expiresAt: keyItem.expiresAt === 0 ? null : dayjs.unix(keyItem.expiresAt),
+			});
+		}
+	}, [keyItem?.id, reset]); // eslint-disable-line react-hooks/exhaustive-deps
+
+	const expiryMode = watch('expiryMode');
+
+	const { mutate: updateKey, isLoading: isSaving } = useUpdateServiceAccountKey({
+		mutation: {
+			onSuccess: () => {
+				toast.success('Key updated successfully', { richColors: true });
+				void setEditKeyId(null);
+				if (selectedAccountId) {
+					void invalidateListServiceAccountKeys(queryClient, {
+						id: selectedAccountId,
+					});
+				}
+			},
+			onError: (error) => {
+				const errMessage =
+					convertToApiError(
+						error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'Failed to update key';
+				toast.error(errMessage, { richColors: true });
+			},
+		},
+	});
+
+	const {
+		mutate: revokeKey,
+		isLoading: isRevoking,
+	} = useRevokeServiceAccountKey({
+		mutation: {
+			onSuccess: () => {
+				toast.success('Key revoked successfully', { richColors: true });
+				setIsRevokeConfirmOpen(false);
+				void setEditKeyId(null);
+				if (selectedAccountId) {
+					void invalidateListServiceAccountKeys(queryClient, {
+						id: selectedAccountId,
+					});
+				}
+			},
+			onError: (error) => {
+				const errMessage =
+					convertToApiError(
+						error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'Failed to revoke key';
+				toast.error(errMessage, { richColors: true });
+			},
+		},
+	});
+
+	function handleClose(): void {
+		void setEditKeyId(null);
+		setIsRevokeConfirmOpen(false);
+	}
+
+	const onSubmit = handleSubmit(
+		({ name, expiryMode: mode, expiresAt }): void => {
+			if (!keyItem || !selectedAccountId) {
+				return;
+			}
+			const currentExpiresAt =
+				mode === 'none' || !expiresAt ? 0 : expiresAt.endOf('day').unix();
+			updateKey({
+				pathParams: { id: selectedAccountId, fid: keyItem.id },
+				data: { name, expiresAt: currentExpiresAt },
+			});
+		},
+	);
+
+	function handleRevoke(): void {
+		if (!keyItem || !selectedAccountId) {
+			return;
+		}
+		revokeKey({ pathParams: { id: selectedAccountId, fid: keyItem.id } });
+	}
+
+	return (
+		<DialogWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					if (isRevokeConfirmOpen) {
+						setIsRevokeConfirmOpen(false);
+					} else {
+						handleClose();
+					}
+				}
+			}}
+			title={
+				isRevokeConfirmOpen
+					? `Revoke ${keyItem?.name ?? 'key'}?`
+					: 'Edit Key Details'
+			}
+			width={isRevokeConfirmOpen ? 'narrow' : 'base'}
+			className={
+				isRevokeConfirmOpen ? 'alert-dialog delete-dialog' : 'edit-key-modal'
+			}
+			showCloseButton={!isRevokeConfirmOpen}
+			disableOutsideClick={false}
+		>
+			{isRevokeConfirmOpen ? (
+				<RevokeKeyContent
+					isRevoking={isRevoking}
+					onCancel={(): void => setIsRevokeConfirmOpen(false)}
+					onConfirm={handleRevoke}
+				/>
+			) : (
+				<>
+					<div className="edit-key-modal__form">
+						<div className="edit-key-modal__field">
+							<label className="edit-key-modal__label" htmlFor="edit-key-name">
+								Name
+							</label>
+							<Input
+								id="edit-key-name"
+								className="edit-key-modal__input"
+								placeholder="Enter key name"
+								{...register('name')}
+							/>
+						</div>
+
+						<div className="edit-key-modal__field">
+							<label className="edit-key-modal__label" htmlFor="edit-key-display">
+								Key
+							</label>
+							<div id="edit-key-display" className="edit-key-modal__key-display">
+								<span className="edit-key-modal__key-text">********************</span>
+								<LockKeyhole size={12} className="edit-key-modal__lock-icon" />
+							</div>
+						</div>
+
+						<div className="edit-key-modal__field">
+							<span className="edit-key-modal__label">Expiration</span>
+							<Controller
+								name="expiryMode"
+								control={control}
+								render={({ field }): JSX.Element => (
+									<ToggleGroup
+										type="single"
+										value={field.value}
+										onValueChange={(val): void => {
+											if (val) {
+												field.onChange(val);
+											}
+										}}
+										className="edit-key-modal__expiry-toggle"
+									>
+										<ToggleGroupItem
+											value="none"
+											className="edit-key-modal__expiry-toggle-btn"
+										>
+											No Expiration
+										</ToggleGroupItem>
+										<ToggleGroupItem
+											value="date"
+											className="edit-key-modal__expiry-toggle-btn"
+										>
+											Set Expiration Date
+										</ToggleGroupItem>
+									</ToggleGroup>
+								)}
+							/>
+						</div>
+
+						{expiryMode === 'date' && (
+							<div className="edit-key-modal__field">
+								<label className="edit-key-modal__label" htmlFor="edit-key-datepicker">
+									Expiration Date
+								</label>
+								<div className="edit-key-modal__datepicker">
+									<Controller
+										name="expiresAt"
+										control={control}
+										render={({ field }): JSX.Element => (
+											<DatePicker
+												value={field.value}
+												id="edit-key-datepicker"
+												onChange={field.onChange}
+												popupClassName="edit-key-modal-datepicker-popup"
+												getPopupContainer={popupContainer}
+												disabledDate={disabledDate}
+											/>
+										)}
+									/>
+								</div>
+							</div>
+						)}
+
+						<div className="edit-key-modal__meta">
+							<span className="edit-key-modal__meta-label">Last Observed At</span>
+							<Badge color="vanilla">
+								{formatLastObservedAt(
+									keyItem?.lastObservedAt ?? null,
+									formatTimezoneAdjustedTimestamp,
+								)}
+							</Badge>
+						</div>
+					</div>
+
+					<div className="edit-key-modal__footer">
+						<Button
+							type="button"
+							className="edit-key-modal__footer-danger"
+							onClick={(): void => setIsRevokeConfirmOpen(true)}
+						>
+							<Trash2 size={12} />
+							Revoke Key
+						</Button>
+						<div className="edit-key-modal__footer-right">
+							<Button
+								variant="solid"
+								color="secondary"
+								size="sm"
+								onClick={handleClose}
+							>
+								<X size={12} />
+								Cancel
+							</Button>
+							<Button
+								variant="solid"
+								color="primary"
+								size="sm"
+								loading={isSaving}
+								disabled={!isDirty}
+								onClick={onSubmit}
+							>
+								Save Changes
+							</Button>
+						</div>
+					</div>
+				</>
+			)}
+		</DialogWrapper>
+	);
+}
+
+export default EditKeyModal;

frontend/src/components/ServiceAccountDrawer/KeysTab.tsx

@@ -0,0 +1,238 @@
+import { useCallback, useMemo } from 'react';
+import { Button } from '@signozhq/button';
+import { X } from '@signozhq/icons';
+import { Skeleton, Table, Tooltip } from 'antd';
+import type { ColumnsType } from 'antd/es/table/interface';
+import type { ServiceaccounttypesFactorAPIKeyDTO } from 'api/generated/services/sigNoz.schemas';
+import dayjs from 'dayjs';
+import { parseAsBoolean, parseAsString, useQueryState } from 'nuqs';
+import { useTimezone } from 'providers/Timezone';
+
+import EditKeyModal from './EditKeyModal';
+import RevokeKeyModal from './RevokeKeyModal';
+import { formatLastObservedAt } from './utils';
+
+interface KeysTabProps {
+	keys: ServiceaccounttypesFactorAPIKeyDTO[];
+	isLoading: boolean;
+	isDisabled?: boolean;
+	currentPage: number;
+	pageSize: number;
+}
+
+interface BuildColumnsParams {
+	isDisabled: boolean;
+	onRevokeClick: (keyId: string) => void;
+	handleformatLastObservedAt: (
+		lastObservedAt: Date | null | undefined,
+	) => string;
+}
+
+function formatExpiry(expiresAt: number): JSX.Element {
+	if (expiresAt === 0) {
+		return <span className="keys-tab__expiry--never">Never</span>;
+	}
+	const expiryDate = dayjs.unix(expiresAt);
+	if (expiryDate.isBefore(dayjs())) {
+		return <span className="keys-tab__expiry--expired">Expired</span>;
+	}
+	return <span>{expiryDate.format('MMM D, YYYY')}</span>;
+}
+
+function buildColumns({
+	isDisabled,
+	onRevokeClick,
+	handleformatLastObservedAt,
+}: BuildColumnsParams): ColumnsType<ServiceaccounttypesFactorAPIKeyDTO> {
+	return [
+		{
+			title: 'Name',
+			dataIndex: 'name',
+			key: 'name',
+			className: 'keys-tab__name-column',
+			sorter: (a, b): number => (a.name ?? '').localeCompare(b.name ?? ''),
+			render: (_, record): JSX.Element => (
+				<span className="keys-tab__name-text">{record.name ?? '—'}</span>
+			),
+		},
+		{
+			title: 'Expiry',
+			dataIndex: 'expiresAt',
+			key: 'expiry',
+			width: 160,
+			align: 'right' as const,
+			sorter: (a, b): number => {
+				const aVal = a.expiresAt === 0 ? Infinity : a.expiresAt;
+				const bVal = b.expiresAt === 0 ? Infinity : b.expiresAt;
+				return aVal - bVal;
+			},
+			render: (expiresAt: number): JSX.Element => formatExpiry(expiresAt),
+		},
+		{
+			title: 'Last Observed At',
+			dataIndex: 'lastObservedAt',
+			key: 'lastObservedAt',
+			width: 220,
+			align: 'right' as const,
+			sorter: (a, b): number => {
+				const aVal = a.lastObservedAt
+					? new Date(a.lastObservedAt).getTime()
+					: -Infinity;
+				const bVal = b.lastObservedAt
+					? new Date(b.lastObservedAt).getTime()
+					: -Infinity;
+				return aVal - bVal;
+			},
+			render: (lastObservedAt: Date | null | undefined): string =>
+				handleformatLastObservedAt(lastObservedAt),
+		},
+		{
+			title: '',
+			key: 'action',
+			width: 48,
+			align: 'right' as const,
+			render: (_, record): JSX.Element => (
+				<Tooltip title={isDisabled ? 'Service account disabled' : 'Revoke Key'}>
+					<Button
+						variant="ghost"
+						size="xs"
+						color="destructive"
+						disabled={isDisabled}
+						onClick={(e): void => {
+							e.stopPropagation();
+							onRevokeClick(record.id);
+						}}
+						className="keys-tab__revoke-btn"
+					>
+						<X size={12} />
+					</Button>
+				</Tooltip>
+			),
+		},
+	];
+}
+
+function KeysTab({
+	keys,
+	isLoading,
+	isDisabled = false,
+	currentPage,
+	pageSize,
+}: KeysTabProps): JSX.Element {
+	const [, setIsAddKeyOpen] = useQueryState(
+		'add-key',
+		parseAsBoolean.withDefault(false),
+	);
+	const { formatTimezoneAdjustedTimestamp } = useTimezone();
+	const [editKeyId, setEditKeyId] = useQueryState(
+		'edit-key',
+		parseAsString.withDefault(''),
+	);
+	const [, setRevokeKeyId] = useQueryState(
+		'revoke-key',
+		parseAsString.withDefault(''),
+	);
+	const editKey = keys.find((k) => k.id === editKeyId) ?? null;
+
+	const handleformatLastObservedAt = useCallback(
+		(lastObservedAt: Date | null | undefined): string =>
+			formatLastObservedAt(lastObservedAt, formatTimezoneAdjustedTimestamp),
+		[formatTimezoneAdjustedTimestamp],
+	);
+
+	const onRevokeClick = useCallback(
+		(keyId: string): void => {
+			setRevokeKeyId(keyId);
+		},
+		[setRevokeKeyId],
+	);
+
+	const columns = useMemo(
+		() => buildColumns({ isDisabled, onRevokeClick, handleformatLastObservedAt }),
+		[isDisabled, onRevokeClick, handleformatLastObservedAt],
+	);
+
+	if (isLoading) {
+		return (
+			<div className="keys-tab__loading">
+				<Skeleton active paragraph={{ rows: 4 }} />
+			</div>
+		);
+	}
+
+	if (keys.length === 0) {
+		return (
+			<div className="keys-tab__empty">
+				<span className="keys-tab__empty-emoji" role="img" aria-label="searching">
+					🧐
+				</span>
+				<p className="keys-tab__empty-text">No keys. Start by creating one.</p>
+				<Button
+					type="button"
+					className="keys-tab__learn-more"
+					onClick={(): void => {
+						void setIsAddKeyOpen(true);
+					}}
+					disabled={isDisabled}
+				>
+					+ Add your first key
+				</Button>
+			</div>
+		);
+	}
+
+	return (
+		<>
+			{/* Todo: use new table component from periscope when ready */}
+			<Table<ServiceaccounttypesFactorAPIKeyDTO>
+				columns={columns}
+				dataSource={keys}
+				rowKey="id"
+				pagination={{
+					style: { display: 'none' },
+					current: currentPage,
+					pageSize,
+				}}
+				showSorterTooltip={false}
+				className={`keys-tab__table${
+					isDisabled ? ' keys-tab__table--disabled' : ''
+				}`}
+				rowClassName={(_, index): string =>
+					index % 2 === 0 ? 'keys-tab__table-row--alt' : ''
+				}
+				onRow={(
+					record,
+				): {
+					onClick: () => void;
+					onKeyDown: (e: React.KeyboardEvent) => void;
+					role: string;
+					tabIndex: number;
+					'aria-label': string;
+				} => ({
+					onClick: (): void => {
+						if (!isDisabled) {
+							void setEditKeyId(record.id);
+						}
+					},
+					onKeyDown: (e: React.KeyboardEvent): void => {
+						if ((e.key === 'Enter' || e.key === ' ') && !isDisabled) {
+							if (e.key === ' ') {
+								e.preventDefault();
+							}
+							void setEditKeyId(record.id);
+						}
+					},
+					role: 'button',
+					tabIndex: 0,
+					'aria-label': `Edit key ${record.name || 'options'}`,
+				})}
+			/>
+
+			<EditKeyModal keyItem={editKey} />
+
+			<RevokeKeyModal />
+		</>
+	);
+}
+
+export default KeysTab;

frontend/src/components/ServiceAccountDrawer/OverviewTab.tsx

@@ -0,0 +1,153 @@
+import { useCallback } from 'react';
+import { Badge } from '@signozhq/badge';
+import { LockKeyhole } from '@signozhq/icons';
+import { Input } from '@signozhq/input';
+import type { AuthtypesRoleDTO } from 'api/generated/services/sigNoz.schemas';
+import RolesSelect from 'components/RolesSelect';
+import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
+import { ServiceAccountRow } from 'container/ServiceAccountsSettings/utils';
+import { useTimezone } from 'providers/Timezone';
+import APIError from 'types/api/error';
+
+interface OverviewTabProps {
+	account: ServiceAccountRow;
+	localName: string;
+	onNameChange: (v: string) => void;
+	localRoles: string[];
+	onRolesChange: (v: string[]) => void;
+	isDisabled: boolean;
+	availableRoles: AuthtypesRoleDTO[];
+	rolesLoading?: boolean;
+	rolesError?: boolean;
+	rolesErrorObj?: APIError | undefined;
+	onRefetchRoles?: () => void;
+}
+
+function OverviewTab({
+	account,
+	localName,
+	onNameChange,
+	localRoles,
+	onRolesChange,
+	isDisabled,
+	availableRoles,
+	rolesLoading,
+	rolesError,
+	rolesErrorObj,
+	onRefetchRoles,
+}: OverviewTabProps): JSX.Element {
+	const { formatTimezoneAdjustedTimestamp } = useTimezone();
+
+	const formatTimestamp = useCallback(
+		(ts: string | null | undefined): string => {
+			if (!ts) {
+				return '—';
+			}
+			const d = new Date(ts);
+			if (Number.isNaN(d.getTime())) {
+				return '—';
+			}
+			return formatTimezoneAdjustedTimestamp(ts, DATE_TIME_FORMATS.DASH_DATETIME);
+		},
+		[formatTimezoneAdjustedTimestamp],
+	);
+
+	return (
+		<>
+			<div className="sa-drawer__field">
+				<label className="sa-drawer__label" htmlFor="sa-name">
+					Name
+				</label>
+				{isDisabled ? (
+					<div className="sa-drawer__input-wrapper sa-drawer__input-wrapper--disabled">
+						<span className="sa-drawer__input-text">{localName || '—'}</span>
+						<LockKeyhole size={14} className="sa-drawer__lock-icon" />
+					</div>
+				) : (
+					<Input
+						id="sa-name"
+						value={localName}
+						onChange={(e): void => onNameChange(e.target.value)}
+						className="sa-drawer__input"
+						placeholder="Enter name"
+					/>
+				)}
+			</div>
+
+			<div className="sa-drawer__field">
+				<label className="sa-drawer__label" htmlFor="sa-email">
+					Email Address
+				</label>
+				<div className="sa-drawer__input-wrapper sa-drawer__input-wrapper--disabled">
+					<span className="sa-drawer__input-text">{account.email || '—'}</span>
+					<LockKeyhole size={14} className="sa-drawer__lock-icon" />
+				</div>
+			</div>
+
+			<div className="sa-drawer__field">
+				<label className="sa-drawer__label" htmlFor="sa-roles">
+					Roles
+				</label>
+				{isDisabled ? (
+					<div className="sa-drawer__input-wrapper sa-drawer__input-wrapper--disabled">
+						<div className="sa-drawer__disabled-roles">
+							{localRoles.length > 0 ? (
+								localRoles.map((r) => (
+									<Badge key={r} color="vanilla">
+										{r}
+									</Badge>
+								))
+							) : (
+								<span className="sa-drawer__input-text">—</span>
+							)}
+						</div>
+						<LockKeyhole size={14} className="sa-drawer__lock-icon" />
+					</div>
+				) : (
+					<RolesSelect
+						id="sa-roles"
+						mode="multiple"
+						roles={availableRoles}
+						loading={rolesLoading}
+						isError={rolesError}
+						error={rolesErrorObj}
+						onRefetch={onRefetchRoles}
+						value={localRoles}
+						onChange={onRolesChange}
+						placeholder="Select roles"
+						getPopupContainer={(triggerNode): HTMLElement =>
+							(triggerNode?.closest('.sa-drawer') as HTMLElement) || document.body
+						}
+					/>
+				)}
+			</div>
+
+			<div className="sa-drawer__meta">
+				<div className="sa-drawer__meta-item">
+					<span className="sa-drawer__meta-label">Status</span>
+					{account.status?.toUpperCase() === 'ACTIVE' ? (
+						<Badge color="forest" variant="outline">
+							ACTIVE
+						</Badge>
+					) : (
+						<Badge color="vanilla" variant="outline" className="sa-status-badge">
+							DISABLED
+						</Badge>
+					)}
+				</div>
+
+				<div className="sa-drawer__meta-item">
+					<span className="sa-drawer__meta-label">Created At</span>
+					<Badge color="vanilla">{formatTimestamp(account.createdAt)}</Badge>
+				</div>
+
+				<div className="sa-drawer__meta-item">
+					<span className="sa-drawer__meta-label">Updated At</span>
+					<Badge color="vanilla">{formatTimestamp(account.updatedAt)}</Badge>
+				</div>
+			</div>
+		</>
+	);
+}
+
+export default OverviewTab;

frontend/src/components/ServiceAccountDrawer/RevokeKeyModal.tsx

@@ -0,0 +1,128 @@
+import { useQueryClient } from 'react-query';
+import { Button } from '@signozhq/button';
+import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
+import { Trash2, X } from '@signozhq/icons';
+import { toast } from '@signozhq/sonner';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	getListServiceAccountKeysQueryKey,
+	invalidateListServiceAccountKeys,
+	useRevokeServiceAccountKey,
+} from 'api/generated/services/serviceaccount';
+import type {
+	RenderErrorResponseDTO,
+	ServiceaccounttypesFactorAPIKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import { parseAsString, useQueryState } from 'nuqs';
+
+export interface RevokeKeyContentProps {
+	isRevoking: boolean;
+	onCancel: () => void;
+	onConfirm: () => void;
+}
+
+export function RevokeKeyContent({
+	isRevoking,
+	onCancel,
+	onConfirm,
+}: RevokeKeyContentProps): JSX.Element {
+	return (
+		<>
+			<p className="delete-dialog__body">
+				Revoking this key will permanently invalidate it. Any systems using this key
+				will lose access immediately.
+			</p>
+			<DialogFooter className="delete-dialog__footer">
+				<Button variant="solid" color="secondary" size="sm" onClick={onCancel}>
+					<X size={12} />
+					Cancel
+				</Button>
+				<Button
+					variant="solid"
+					color="destructive"
+					size="sm"
+					loading={isRevoking}
+					onClick={onConfirm}
+				>
+					<Trash2 size={12} />
+					Revoke Key
+				</Button>
+			</DialogFooter>
+		</>
+	);
+}
+
+function RevokeKeyModal(): JSX.Element {
+	const queryClient = useQueryClient();
+	const [accountId] = useQueryState('account');
+	const [revokeKeyId, setRevokeKeyId] = useQueryState(
+		'revoke-key',
+		parseAsString.withDefault(''),
+	);
+	const open = !!revokeKeyId && !!accountId;
+
+	const cachedKeys = accountId
+		? queryClient.getQueryData<{ data: ServiceaccounttypesFactorAPIKeyDTO[] }>(
+				getListServiceAccountKeysQueryKey({ id: accountId }),
+		  )
+		: null;
+	const keyName = cachedKeys?.data?.find((k) => k.id === revokeKeyId)?.name;
+
+	const {
+		mutate: revokeKey,
+		isLoading: isRevoking,
+	} = useRevokeServiceAccountKey({
+		mutation: {
+			onSuccess: () => {
+				toast.success('Key revoked successfully', { richColors: true });
+				void setRevokeKeyId(null);
+				if (accountId) {
+					void invalidateListServiceAccountKeys(queryClient, { id: accountId });
+				}
+			},
+			onError: (error) => {
+				const errMessage =
+					convertToApiError(
+						error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'Failed to revoke key';
+				toast.error(errMessage, { richColors: true });
+			},
+		},
+	});
+
+	function handleConfirm(): void {
+		if (!revokeKeyId || !accountId) {
+			return;
+		}
+		revokeKey({ pathParams: { id: accountId, fid: revokeKeyId } });
+	}
+
+	function handleCancel(): void {
+		void setRevokeKeyId(null);
+	}
+
+	return (
+		<DialogWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					handleCancel();
+				}
+			}}
+			title={`Revoke ${keyName ?? 'key'}?`}
+			width="narrow"
+			className="alert-dialog delete-dialog"
+			showCloseButton={false}
+			disableOutsideClick={false}
+		>
+			<RevokeKeyContent
+				isRevoking={isRevoking}
+				onCancel={handleCancel}
+				onConfirm={handleConfirm}
+			/>
+		</DialogWrapper>
+	);
+}
+
+export default RevokeKeyModal;

frontend/src/components/ServiceAccountDrawer/ServiceAccountDrawer.styles.scss

@@ -0,0 +1,460 @@
+.sa-drawer {
+	[data-slot='drawer-close'] + div {
+		border-left: 1px solid var(--l1-border);
+		padding-left: var(--padding-4);
+		margin-left: var(--margin-2);
+	}
+
+	&__layout {
+		display: flex;
+		flex-direction: column;
+		height: calc(100vh - 48px);
+	}
+
+	&__tabs {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding: var(--padding-3) var(--padding-4) var(--padding-2) var(--padding-4);
+		flex-shrink: 0;
+	}
+
+	&__tab-group {
+		[data-slot='toggle-group'] {
+			height: 32px;
+			border-radius: 2px;
+			border: 1px solid var(--l1-border);
+			background: var(--l2-background);
+			gap: 0;
+		}
+
+		[data-slot='toggle-group-item'] {
+			height: 32px;
+			border-radius: 0;
+			border-left: 1px solid var(--l1-border);
+			background: transparent;
+			color: var(--l2-foreground);
+			font-size: var(--font-size-xs);
+			font-weight: var(--font-weight-normal);
+			font-family: Inter, sans-serif;
+			padding: 0 var(--padding-7);
+			gap: var(--spacing-3);
+			box-shadow: none;
+
+			&:first-child {
+				border-left: none;
+				border-radius: 2px 0 0 2px;
+			}
+
+			&:last-child {
+				border-radius: 0 2px 2px 0;
+			}
+
+			&:hover {
+				background: rgba(171, 189, 255, 0.04);
+				color: var(--l1-foreground);
+			}
+
+			&[data-state='on'] {
+				background: var(--l1-border);
+				color: var(--l1-foreground);
+			}
+		}
+	}
+
+	&__tab {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-2);
+		font-size: var(--font-size-xs);
+		font-weight: var(--font-weight-normal);
+	}
+
+	&__tab-count {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		min-width: 20px;
+		padding: 0 6px;
+		border-radius: 50px;
+		background: var(--secondary);
+		font-size: var(--code-small-400-font-size);
+		font-weight: var(--font-weight-normal);
+		line-height: var(--line-height-20);
+		color: var(--foreground);
+		letter-spacing: -0.06px;
+	}
+
+	&__body {
+		flex: 1;
+		overflow-y: auto;
+		padding: var(--padding-5) var(--padding-4);
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-8);
+	}
+
+	&__footer {
+		height: 56px;
+		flex-shrink: 0;
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		padding: 0 var(--padding-4);
+		border-top: 1px solid var(--secondary);
+		background: var(--card);
+	}
+
+	&__keys-pagination {
+		display: flex;
+		align-items: center;
+		justify-content: flex-end;
+		width: 100%;
+		padding: var(--padding-2) 0;
+
+		.ant-pagination-total-text {
+			margin-right: auto;
+		}
+	}
+
+	&__pagination-range {
+		font-size: var(--font-size-xs);
+		color: var(--foreground);
+		font-weight: var(--font-weight-normal);
+	}
+
+	&__pagination-total {
+		font-size: var(--font-size-xs);
+		color: var(--foreground);
+		opacity: 0.5;
+	}
+
+	&__footer-btn {
+		padding-left: 0;
+		padding-right: 0;
+	}
+
+	&__footer-right {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-6);
+	}
+
+	&__field {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-4);
+	}
+
+	&__label {
+		font-size: var(--font-size-sm);
+		font-weight: var(--font-weight-normal);
+		color: var(--foreground);
+		line-height: var(--line-height-20);
+		letter-spacing: -0.07px;
+		cursor: default;
+	}
+
+	&__input {
+		height: 32px;
+		background: var(--l2-background);
+		border-color: var(--border);
+		color: var(--l1-foreground);
+		box-shadow: none;
+
+		&::placeholder {
+			color: var(--l3-foreground);
+		}
+	}
+
+	&__input-wrapper {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		height: 32px;
+		padding: 0 var(--padding-2);
+		border-radius: 2px;
+		background: var(--l2-background);
+		border: 1px solid var(--border);
+
+		&--disabled {
+			cursor: not-allowed;
+			opacity: 0.8;
+		}
+	}
+
+	&__input-text {
+		font-size: var(--font-size-sm);
+		font-weight: var(--font-weight-normal);
+		color: var(--foreground);
+		line-height: var(--line-height-18);
+		letter-spacing: -0.07px;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		flex: 1;
+	}
+
+	&__lock-icon {
+		color: var(--foreground);
+		flex-shrink: 0;
+		margin-left: 6px;
+		opacity: 0.6;
+	}
+
+	&__disabled-roles {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-2);
+	}
+
+	&__meta {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-8);
+		margin-top: var(--margin-1);
+	}
+
+	&__meta-item {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-2);
+
+		[data-slot='badge'] {
+			padding: var(--padding-1) var(--padding-2);
+			align-items: center;
+			font-size: var(--uppercase-small-500-font-size);
+			font-weight: var(--uppercase-small-500-font-weight);
+			line-height: 100%;
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+		}
+	}
+
+	&__meta-label {
+		font-size: var(--font-size-xs);
+		font-weight: var(--font-weight-medium);
+		color: var(--foreground);
+		line-height: var(--line-height-20);
+		letter-spacing: 0.48px;
+		text-transform: uppercase;
+	}
+}
+
+.keys-tab {
+	&__loading {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: var(--padding-8) var(--padding-4);
+	}
+
+	&__empty {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		padding: var(--padding-8) var(--padding-4);
+		gap: var(--spacing-4);
+		text-align: center;
+		height: 80%;
+	}
+
+	&__empty-emoji {
+		font-size: 32px;
+	}
+
+	&__empty-text {
+		font-size: var(--paragraph-base-400-font-size);
+		font-weight: var(--paragraph-base-400-font-weight);
+		color: var(--foreground);
+		margin: 0;
+	}
+
+	&__learn-more {
+		background: transparent;
+		border: none;
+		color: var(--primary);
+		font-size: var(--font-size-sm);
+		cursor: pointer;
+		text-decoration: none;
+
+		&:hover {
+			text-decoration: underline;
+		}
+	}
+
+	// todo: styles should easeup by upgrading the component with table component from persiscope
+	&__table {
+		.ant-table {
+			background: transparent;
+			border: 1px solid var(--l1-border);
+			border-radius: 4px;
+			overflow: hidden;
+		}
+
+		.ant-table-thead > tr > th,
+		.ant-table-thead > tr > td {
+			height: 38px;
+			padding: 0 var(--padding-4);
+			background: transparent !important;
+			border-bottom: 1px solid var(--l1-border) !important;
+			font-size: var(--uppercase-small-500-font-size);
+			font-weight: var(--uppercase-small-500-font-weight);
+			color: var(--l2-foreground);
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+
+			&::before {
+				display: none !important;
+			}
+
+			.ant-table-column-sorter {
+				color: var(--l2-foreground);
+				opacity: 0.5;
+			}
+
+			&.ant-table-column-sort {
+				background: transparent !important;
+				color: var(--l1-foreground);
+
+				.ant-table-column-sorter {
+					color: var(--l1-foreground);
+					opacity: 1;
+				}
+			}
+
+			&:hover {
+				background: transparent !important;
+				color: var(--l1-foreground);
+
+				.ant-table-column-sorter {
+					opacity: 1;
+				}
+			}
+		}
+
+		.ant-table-tbody > tr > td {
+			height: 38px;
+			padding: 0 var(--padding-4);
+			border-bottom: 1px solid var(--l1-border);
+			font-size: 13px;
+			font-weight: var(--font-weight-normal);
+			color: var(--l2-foreground);
+			letter-spacing: -0.07px;
+			cursor: pointer;
+			background: transparent;
+			transition: none;
+			font-variant-numeric: lining-nums tabular-nums stacked-fractions ordinal
+				slashed-zero;
+
+			&.ant-table-column-sort {
+				background: transparent;
+			}
+		}
+
+		.ant-table-tbody > tr:last-child > td {
+			border-bottom: none;
+		}
+
+		.ant-table-tbody > tr {
+			background: transparent;
+
+			&:hover > td {
+				background: rgba(171, 189, 255, 0.06) !important;
+			}
+
+			&.keys-tab__table-row--alt > td {
+				background: rgba(171, 189, 255, 0.02);
+
+				&:hover {
+					background: rgba(171, 189, 255, 0.06) !important;
+				}
+			}
+		}
+
+		&--disabled {
+			.ant-table-tbody > tr {
+				cursor: not-allowed;
+				opacity: 0.6;
+
+				&:hover > td {
+					background: transparent !important;
+				}
+			}
+		}
+
+		.ant-table-cell-row-hover {
+			background: transparent !important;
+		}
+	}
+
+	&__name-column {
+		.ant-table-column-sorters {
+			justify-content: flex-start;
+			gap: var(--spacing-2);
+		}
+
+		.ant-table-column-title {
+			flex: none;
+		}
+	}
+
+	&__name-text {
+		font-size: 13px;
+		font-weight: var(--font-weight-normal);
+		color: var(--l2-foreground);
+		letter-spacing: -0.07px;
+		text-transform: none;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	&__expiry--never {
+		color: var(--l2-foreground);
+	}
+
+	&__expiry--expired {
+		color: var(--l3-foreground);
+	}
+
+	&__revoke-btn {
+		width: 32px;
+		height: 32px;
+		padding: 0;
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+	}
+}
+
+.sa-disable-dialog {
+	background: var(--l2-background);
+	border: 1px solid var(--l2-border);
+
+	[data-slot='dialog-title'] {
+		color: var(--l1-foreground);
+	}
+
+	&__body {
+		font-size: var(--paragraph-base-400-font-size);
+		font-weight: var(--paragraph-base-400-font-weight);
+		color: var(--l2-foreground);
+		line-height: var(--paragraph-base-400-line-height);
+		letter-spacing: -0.065px;
+		margin: 0;
+
+		strong {
+			font-weight: var(--font-weight-medium);
+			color: var(--l1-foreground);
+		}
+	}
+
+	&__footer {
+		display: flex;
+		justify-content: flex-end;
+		gap: var(--spacing-4);
+		margin-top: var(--margin-6);
+	}
+}

frontend/src/components/ServiceAccountDrawer/ServiceAccountDrawer.tsx

@@ -0,0 +1,366 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Button } from '@signozhq/button';
+import { DrawerWrapper } from '@signozhq/drawer';
+import { Key, LayoutGrid, Plus, PowerOff, X } from '@signozhq/icons';
+import { toast } from '@signozhq/sonner';
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { Pagination, Skeleton } from 'antd';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	useGetServiceAccount,
+	useListServiceAccountKeys,
+	useUpdateServiceAccount,
+} from 'api/generated/services/serviceaccount';
+import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
+import { useRoles } from 'components/RolesSelect';
+import {
+	ServiceAccountRow,
+	toServiceAccountRow,
+} from 'container/ServiceAccountsSettings/utils';
+import {
+	parseAsBoolean,
+	parseAsInteger,
+	parseAsString,
+	parseAsStringEnum,
+	useQueryState,
+} from 'nuqs';
+import { toAPIError } from 'utils/errorUtils';
+
+import AddKeyModal from './AddKeyModal';
+import DisableAccountModal from './DisableAccountModal';
+import KeysTab from './KeysTab';
+import OverviewTab from './OverviewTab';
+import { ServiceAccountDrawerTab } from './utils';
+
+import './ServiceAccountDrawer.styles.scss';
+
+export interface ServiceAccountDrawerProps {
+	onSuccess: (options?: { closeDrawer?: boolean }) => void;
+}
+
+const PAGE_SIZE = 15;
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function ServiceAccountDrawer({
+	onSuccess,
+}: ServiceAccountDrawerProps): JSX.Element {
+	const [selectedAccountId, setSelectedAccountId] = useQueryState('account');
+	const open = !!selectedAccountId;
+	const [activeTab, setActiveTab] = useQueryState(
+		'tab',
+		parseAsStringEnum<ServiceAccountDrawerTab>(
+			Object.values(ServiceAccountDrawerTab),
+		).withDefault(ServiceAccountDrawerTab.Overview),
+	);
+	const [keysPage, setKeysPage] = useQueryState(
+		'keysPage',
+		parseAsInteger.withDefault(1),
+	);
+	const [, setEditKeyId] = useQueryState(
+		'edit-key',
+		parseAsString.withDefault(''),
+	);
+	const [, setIsAddKeyOpen] = useQueryState(
+		'add-key',
+		parseAsBoolean.withDefault(false),
+	);
+	const [, setIsDisableOpen] = useQueryState(
+		'disable-sa',
+		parseAsBoolean.withDefault(false),
+	);
+	const [localName, setLocalName] = useState('');
+	const [localRoles, setLocalRoles] = useState<string[]>([]);
+
+	const {
+		data: accountData,
+		isLoading: isAccountLoading,
+		isError: isAccountError,
+		error: accountError,
+		refetch: refetchAccount,
+	} = useGetServiceAccount(
+		{ id: selectedAccountId ?? '' },
+		{ query: { enabled: !!selectedAccountId } },
+	);
+
+	const account = useMemo(
+		(): ServiceAccountRow | null =>
+			accountData?.data ? toServiceAccountRow(accountData.data) : null,
+		[accountData],
+	);
+
+	useEffect(() => {
+		if (account) {
+			setLocalName(account.name ?? '');
+			setLocalRoles(account.roles ?? []);
+			setKeysPage(1);
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [account?.id]);
+
+	const isDisabled = account?.status?.toUpperCase() !== 'ACTIVE';
+
+	const isDirty =
+		account !== null &&
+		(localName !== (account.name ?? '') ||
+			JSON.stringify(localRoles) !== JSON.stringify(account.roles ?? []));
+
+	const {
+		roles: availableRoles,
+		isLoading: rolesLoading,
+		isError: rolesError,
+		error: rolesErrorObj,
+		refetch: refetchRoles,
+	} = useRoles();
+
+	const { data: keysData, isLoading: keysLoading } = useListServiceAccountKeys(
+		{ id: selectedAccountId ?? '' },
+		{ query: { enabled: !!selectedAccountId } },
+	);
+	const keys = keysData?.data ?? [];
+
+	useEffect(() => {
+		if (keysLoading) {
+			return;
+		}
+		const maxPage = Math.max(1, Math.ceil(keys.length / PAGE_SIZE));
+		if (keysPage > maxPage) {
+			setKeysPage(maxPage);
+		}
+	}, [keysLoading, keys.length, keysPage, setKeysPage]);
+
+	const { mutate: updateAccount, isLoading: isSaving } = useUpdateServiceAccount(
+		{
+			mutation: {
+				onSuccess: () => {
+					toast.success('Service account updated successfully', {
+						richColors: true,
+					});
+					refetchAccount();
+					onSuccess({ closeDrawer: false });
+				},
+				onError: (error) => {
+					const errMessage =
+						convertToApiError(
+							error as AxiosError<RenderErrorResponseDTO, unknown> | null,
+						)?.getErrorMessage() || 'Failed to update service account';
+					toast.error(errMessage, { richColors: true });
+				},
+			},
+		},
+	);
+
+	function handleSave(): void {
+		if (!account || !isDirty) {
+			return;
+		}
+		updateAccount({
+			pathParams: { id: account.id },
+			data: { name: localName, email: account.email, roles: localRoles },
+		});
+	}
+
+	const handleClose = useCallback((): void => {
+		setIsDisableOpen(null);
+		setIsAddKeyOpen(null);
+		setSelectedAccountId(null);
+		setActiveTab(null);
+		setKeysPage(null);
+		setEditKeyId(null);
+	}, [
+		setSelectedAccountId,
+		setActiveTab,
+		setKeysPage,
+		setEditKeyId,
+		setIsAddKeyOpen,
+		setIsDisableOpen,
+	]);
+
+	const drawerContent = (
+		<div className="sa-drawer__layout">
+			<div className="sa-drawer__tabs">
+				<ToggleGroup
+					type="single"
+					value={activeTab}
+					onValueChange={(val): void => {
+						if (val) {
+							setActiveTab(val as ServiceAccountDrawerTab);
+							if (val !== ServiceAccountDrawerTab.Keys) {
+								setKeysPage(null);
+								setEditKeyId(null);
+							}
+						}
+					}}
+					className="sa-drawer__tab-group"
+				>
+					<ToggleGroupItem
+						value={ServiceAccountDrawerTab.Overview}
+						className="sa-drawer__tab"
+					>
+						<LayoutGrid size={14} />
+						Overview
+					</ToggleGroupItem>
+					<ToggleGroupItem
+						value={ServiceAccountDrawerTab.Keys}
+						className="sa-drawer__tab"
+					>
+						<Key size={14} />
+						Keys
+						{keys.length > 0 && (
+							<span className="sa-drawer__tab-count">{keys.length}</span>
+						)}
+					</ToggleGroupItem>
+				</ToggleGroup>
+				{activeTab === ServiceAccountDrawerTab.Keys && (
+					<Button
+						variant="outlined"
+						size="sm"
+						color="secondary"
+						disabled={isDisabled}
+						onClick={(): void => {
+							setIsAddKeyOpen(true);
+						}}
+					>
+						<Plus size={12} />
+						Add Key
+					</Button>
+				)}
+			</div>
+
+			<div
+				className={`sa-drawer__body${
+					activeTab === ServiceAccountDrawerTab.Keys ? ' sa-drawer__body--keys' : ''
+				}`}
+			>
+				{isAccountLoading && <Skeleton active paragraph={{ rows: 6 }} />}
+				{isAccountError && (
+					<ErrorInPlace
+						error={toAPIError(
+							accountError,
+							'An unexpected error occurred while fetching service account details.',
+						)}
+					/>
+				)}
+				{!isAccountLoading && !isAccountError && (
+					<>
+						{activeTab === ServiceAccountDrawerTab.Overview && account && (
+							<OverviewTab
+								account={account}
+								localName={localName}
+								onNameChange={setLocalName}
+								localRoles={localRoles}
+								onRolesChange={setLocalRoles}
+								isDisabled={isDisabled}
+								availableRoles={availableRoles}
+								rolesLoading={rolesLoading}
+								rolesError={rolesError}
+								rolesErrorObj={rolesErrorObj}
+								onRefetchRoles={refetchRoles}
+							/>
+						)}
+						{activeTab === ServiceAccountDrawerTab.Keys && (
+							<KeysTab
+								keys={keys}
+								isLoading={keysLoading}
+								isDisabled={isDisabled}
+								currentPage={keysPage}
+								pageSize={PAGE_SIZE}
+							/>
+						)}
+					</>
+				)}
+			</div>
+
+			<div className="sa-drawer__footer">
+				{activeTab === ServiceAccountDrawerTab.Keys ? (
+					<Pagination
+						current={keysPage}
+						pageSize={PAGE_SIZE}
+						total={keys.length}
+						showTotal={(total: number, range: number[]): JSX.Element => (
+							<>
+								<span className="sa-drawer__pagination-range">
+									{range[0]} &#8212; {range[1]}
+								</span>
+								<span className="sa-drawer__pagination-total"> of {total}</span>
+							</>
+						)}
+						showSizeChanger={false}
+						hideOnSinglePage
+						onChange={(page): void => {
+							void setKeysPage(page);
+						}}
+						className="sa-drawer__keys-pagination"
+					/>
+				) : (
+					<>
+						{!isDisabled && (
+							<Button
+								variant="ghost"
+								color="destructive"
+								className="sa-drawer__footer-btn"
+								onClick={(): void => {
+									setIsDisableOpen(true);
+								}}
+							>
+								<PowerOff size={12} />
+								Disable Service Account
+							</Button>
+						)}
+						{!isDisabled && (
+							<div className="sa-drawer__footer-right">
+								<Button
+									variant="solid"
+									color="secondary"
+									size="sm"
+									onClick={handleClose}
+								>
+									<X size={14} />
+									Cancel
+								</Button>
+								<Button
+									variant="solid"
+									color="primary"
+									size="sm"
+									loading={isSaving}
+									disabled={!isDirty}
+									onClick={handleSave}
+								>
+									Save Changes
+								</Button>
+							</div>
+						)}
+					</>
+				)}
+			</div>
+		</div>
+	);
+
+	return (
+		<>
+			<DrawerWrapper
+				open={open}
+				onOpenChange={(isOpen): void => {
+					if (!isOpen) {
+						handleClose();
+					}
+				}}
+				direction="right"
+				type="panel"
+				showCloseButton
+				showOverlay={false}
+				allowOutsideClick
+				header={{ title: 'Service Account Details' }}
+				content={drawerContent}
+				className="sa-drawer"
+			/>
+
+			<DisableAccountModal />
+
+			<AddKeyModal />
+		</>
+	);
+}
+
+export default ServiceAccountDrawer;

frontend/src/components/ServiceAccountDrawer/__tests__/AddKeyModal.test.tsx

@@ -0,0 +1,139 @@
+import { toast } from '@signozhq/sonner';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import AddKeyModal from '../AddKeyModal';
+
+jest.mock('@signozhq/sonner', () => ({
+	toast: { success: jest.fn(), error: jest.fn() },
+}));
+
+const mockToast = jest.mocked(toast);
+
+const SA_KEYS_ENDPOINT = '*/api/v1/service_accounts/sa-1/keys';
+
+const createdKeyResponse = {
+	data: {
+		id: 'key-1',
+		name: 'Deploy Key',
+		key: 'snz_abc123xyz456secret',
+		expiresAt: 0,
+		lastObservedAt: null,
+	},
+};
+
+function renderModal(): ReturnType<typeof render> {
+	return render(
+		<NuqsTestingAdapter
+			searchParams={{ account: 'sa-1', 'add-key': 'true' }}
+			hasMemory
+		>
+			<AddKeyModal />
+		</NuqsTestingAdapter>,
+	);
+}
+
+describe('AddKeyModal', () => {
+	beforeAll(() => {
+		Object.defineProperty(navigator, 'clipboard', {
+			value: { writeText: jest.fn().mockResolvedValue(undefined) },
+			configurable: true,
+			writable: true,
+		});
+	});
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.post(SA_KEYS_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(201), ctx.json(createdKeyResponse)),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('"Create Key" is disabled when name is empty; enabled after typing a name', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		expect(screen.getByRole('button', { name: /Create Key/i })).toBeDisabled();
+
+		await user.type(screen.getByPlaceholderText(/Enter key name/i), 'My Key');
+
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /Create Key/i }),
+			).not.toBeDisabled(),
+		);
+	});
+
+	it('successful creation transitions to phase 2 with key displayed and security callout', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText(/Enter key name/i), 'Deploy Key');
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /Create Key/i }),
+			).not.toBeDisabled(),
+		);
+		await user.click(screen.getByRole('button', { name: /Create Key/i }));
+
+		await screen.findByText('snz_abc123xyz456secret');
+		expect(screen.getByText(/Store the key securely/i)).toBeInTheDocument();
+		await screen.findByRole('dialog', { name: /Key Created Successfully/i });
+	});
+
+	it('copy button writes key to clipboard and shows toast.success', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const writeTextSpy = jest
+			.spyOn(navigator.clipboard, 'writeText')
+			.mockResolvedValue(undefined);
+
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText(/Enter key name/i), 'Deploy Key');
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /Create Key/i }),
+			).not.toBeDisabled(),
+		);
+		await user.click(screen.getByRole('button', { name: /Create Key/i }));
+
+		await screen.findByText('snz_abc123xyz456secret');
+
+		const copyBtn = screen
+			.getAllByRole('button')
+			.find((btn) => btn.querySelector('svg'));
+		if (!copyBtn) {
+			throw new Error('Copy button not found');
+		}
+		await user.click(copyBtn);
+
+		await waitFor(() => {
+			expect(writeTextSpy).toHaveBeenCalledWith('snz_abc123xyz456secret');
+			expect(mockToast.success).toHaveBeenCalledWith(
+				'Key copied to clipboard',
+				expect.anything(),
+			);
+		});
+
+		writeTextSpy.mockRestore();
+	});
+
+	it('Cancel button closes the modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await screen.findByRole('dialog', { name: /Add a New Key/i });
+		await user.click(screen.getByRole('button', { name: /Cancel/i }));
+
+		expect(
+			screen.queryByRole('dialog', { name: /Add a New Key/i }),
+		).not.toBeInTheDocument();
+	});
+});

frontend/src/components/ServiceAccountDrawer/__tests__/EditKeyModal.test.tsx

@@ -0,0 +1,151 @@
+import { toast } from '@signozhq/sonner';
+import type { ServiceaccounttypesFactorAPIKeyDTO } from 'api/generated/services/sigNoz.schemas';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import EditKeyModal from '../EditKeyModal';
+
+jest.mock('@signozhq/sonner', () => ({
+	toast: { success: jest.fn(), error: jest.fn() },
+}));
+
+const mockToast = jest.mocked(toast);
+
+const SA_KEY_ENDPOINT = '*/api/v1/service_accounts/sa-1/keys/key-1';
+
+const mockKey: ServiceaccounttypesFactorAPIKeyDTO = {
+	id: 'key-1',
+	name: 'Original Key Name',
+	expiresAt: 0,
+	lastObservedAt: null as any,
+	key: 'snz_abc123',
+	serviceAccountId: 'sa-1',
+};
+
+function renderModal(
+	keyItem: ServiceaccounttypesFactorAPIKeyDTO | null = mockKey,
+	searchParams: Record<string, string> = {
+		account: 'sa-1',
+		'edit-key': 'key-1',
+	},
+): ReturnType<typeof render> {
+	return render(
+		<NuqsTestingAdapter searchParams={searchParams} hasMemory>
+			<EditKeyModal keyItem={keyItem} />
+		</NuqsTestingAdapter>,
+	);
+}
+
+describe('EditKeyModal (URL-controlled)', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.put(SA_KEY_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+			rest.delete(SA_KEY_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('renders nothing when edit-key param is absent', () => {
+		renderModal(null, { account: 'sa-1' });
+
+		expect(
+			screen.queryByRole('dialog', { name: /Edit Key Details/i }),
+		).not.toBeInTheDocument();
+	});
+
+	it('renders key data from prop when edit-key param is set', async () => {
+		renderModal();
+
+		expect(
+			await screen.findByDisplayValue('Original Key Name'),
+		).toBeInTheDocument();
+		expect(screen.getByRole('button', { name: /Save Changes/i })).toBeDisabled();
+	});
+
+	it('save calls update API, shows toast, and closes modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		const nameInput = await screen.findByPlaceholderText(/Enter key name/i);
+		await user.clear(nameInput);
+		await user.type(nameInput, 'Updated Key Name');
+
+		await user.click(screen.getByRole('button', { name: /Save Changes/i }));
+
+		await waitFor(() => {
+			expect(mockToast.success).toHaveBeenCalledWith(
+				'Key updated successfully',
+				expect.anything(),
+			);
+		});
+
+		await waitFor(() => {
+			expect(
+				screen.queryByRole('dialog', { name: /Edit Key Details/i }),
+			).not.toBeInTheDocument();
+		});
+	});
+
+	it('cancel clears edit-key param and closes modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await screen.findByDisplayValue('Original Key Name');
+		await user.click(screen.getByRole('button', { name: /Cancel/i }));
+
+		expect(
+			screen.queryByRole('dialog', { name: /Edit Key Details/i }),
+		).not.toBeInTheDocument();
+	});
+
+	it('revoke flow: clicking Revoke Key shows confirmation inside same dialog', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await screen.findByDisplayValue('Original Key Name');
+		await user.click(screen.getByRole('button', { name: /Revoke Key/i }));
+
+		// Same dialog, now showing revoke confirmation
+		expect(
+			await screen.findByRole('dialog', { name: /Revoke Original Key Name/i }),
+		).toBeInTheDocument();
+		expect(
+			screen.getByText(/Revoking this key will permanently invalidate it/i),
+		).toBeInTheDocument();
+	});
+
+	it('revoke flow: confirming revoke shows toast and closes modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await screen.findByDisplayValue('Original Key Name');
+		await user.click(screen.getByRole('button', { name: /Revoke Key/i }));
+
+		const confirmBtn = await screen.findByRole('button', {
+			name: /^Revoke Key$/i,
+		});
+		await user.click(confirmBtn);
+
+		await waitFor(() => {
+			expect(mockToast.success).toHaveBeenCalledWith(
+				'Key revoked successfully',
+				expect.anything(),
+			);
+		});
+
+		await waitFor(() => {
+			expect(
+				screen.queryByRole('dialog', { name: /Edit Key Details/i }),
+			).not.toBeInTheDocument();
+		});
+	});
+});

frontend/src/components/ServiceAccountDrawer/__tests__/KeysTab.test.tsx

@@ -0,0 +1,183 @@
+import { toast } from '@signozhq/sonner';
+import { ServiceaccounttypesFactorAPIKeyDTO } from 'api/generated/services/sigNoz.schemas';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import KeysTab from '../KeysTab';
+
+jest.mock('@signozhq/sonner', () => ({
+	toast: { success: jest.fn(), error: jest.fn() },
+}));
+
+const mockToast = jest.mocked(toast);
+
+const SA_KEY_ENDPOINT = '*/api/v1/service_accounts/sa-1/keys/:fid';
+
+const keys: ServiceaccounttypesFactorAPIKeyDTO[] = [
+	{
+		id: 'key-1',
+		name: 'Production Key',
+		expiresAt: 0,
+		lastObservedAt: null as any,
+		key: 'snz_prod_123',
+		serviceAccountId: 'sa-1',
+	},
+	{
+		id: 'key-2',
+		name: 'Staging Key',
+		expiresAt: 1924905600, // 2030-12-31
+		lastObservedAt: new Date('2026-03-10T10:00:00Z'),
+		key: 'snz_stag_456',
+		serviceAccountId: 'sa-1',
+	},
+];
+
+const defaultProps = {
+	keys,
+	isLoading: false,
+	isDisabled: false,
+	currentPage: 1,
+	pageSize: 10,
+};
+
+function renderKeysTab(
+	props: Partial<typeof defaultProps> = {},
+	searchParams: Record<string, string> = { account: 'sa-1' },
+): ReturnType<typeof render> {
+	return render(
+		<NuqsTestingAdapter searchParams={searchParams} hasMemory>
+			<KeysTab {...defaultProps} {...props} />
+		</NuqsTestingAdapter>,
+	);
+}
+
+describe('KeysTab', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.delete(SA_KEY_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('renders loading state', () => {
+		renderKeysTab({ isLoading: true });
+		expect(document.querySelector('.ant-skeleton')).toBeInTheDocument();
+	});
+
+	it('renders empty state when no keys and clicking add sets add-key param', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const onUrlUpdate = jest.fn();
+		render(
+			<NuqsTestingAdapter
+				searchParams={{ account: 'sa-1' }}
+				onUrlUpdate={onUrlUpdate}
+			>
+				<KeysTab {...defaultProps} keys={[]} />
+			</NuqsTestingAdapter>,
+		);
+
+		expect(
+			screen.getByText(/No keys. Start by creating one./i),
+		).toBeInTheDocument();
+		const addBtn = screen.getByRole('button', { name: /\+ Add your first key/i });
+		await user.click(addBtn);
+		expect(onUrlUpdate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				queryString: expect.stringContaining('add-key=true'),
+			}),
+		);
+	});
+
+	it('renders table with keys', () => {
+		renderKeysTab();
+
+		expect(screen.getByText('Production Key')).toBeInTheDocument();
+		expect(screen.getByText('Staging Key')).toBeInTheDocument();
+		expect(screen.getByText('Never')).toBeInTheDocument();
+		expect(screen.getByText('Dec 31, 2030')).toBeInTheDocument();
+	});
+
+	it('clicking a row sets the edit-key URL param', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const onUrlUpdate = jest.fn();
+
+		render(
+			<NuqsTestingAdapter onUrlUpdate={onUrlUpdate}>
+				<KeysTab {...defaultProps} />
+			</NuqsTestingAdapter>,
+		);
+
+		const row = screen.getByText('Production Key').closest('tr');
+		if (!row) {
+			throw new Error('Row not found');
+		}
+
+		await user.click(row);
+
+		expect(onUrlUpdate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				queryString: expect.stringContaining('edit-key=key-1'),
+			}),
+		);
+	});
+
+	it('clicking revoke icon sets revoke-key URL param', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const onUrlUpdate = jest.fn();
+
+		render(
+			<NuqsTestingAdapter onUrlUpdate={onUrlUpdate}>
+				<KeysTab {...defaultProps} />
+			</NuqsTestingAdapter>,
+		);
+
+		const revokeBtns = screen
+			.getAllByRole('button')
+			.filter((btn) => btn.className.includes('keys-tab__revoke-btn'));
+		await user.click(revokeBtns[0]);
+
+		expect(onUrlUpdate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				queryString: expect.stringContaining('revoke-key=key-1'),
+			}),
+		);
+	});
+
+	it('handles successful key revocation via RevokeKeyModal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		renderKeysTab();
+
+		// Seed the keys cache so RevokeKeyModal can read the key name
+		const revokeBtns = screen
+			.getAllByRole('button')
+			.filter((btn) => btn.className.includes('keys-tab__revoke-btn'));
+		await user.click(revokeBtns[0]);
+
+		const confirmBtn = await screen.findByRole('button', { name: /Revoke Key/i });
+		await user.click(confirmBtn);
+
+		await waitFor(() => {
+			expect(mockToast.success).toHaveBeenCalledWith(
+				'Key revoked successfully',
+				expect.anything(),
+			);
+		});
+	});
+
+	it('disables actions when isDisabled is true', () => {
+		renderKeysTab({ isDisabled: true });
+
+		const revokeBtns = screen
+			.getAllByRole('button')
+			.filter((btn) => btn.className.includes('keys-tab__revoke-btn'));
+		revokeBtns.forEach((btn) => expect(btn).toBeDisabled());
+	});
+});

frontend/src/components/ServiceAccountDrawer/__tests__/ServiceAccountDrawer.test.tsx

@@ -0,0 +1,246 @@
+import type { ReactNode } from 'react';
+import { listRolesSuccessResponse } from 'mocks-server/__mockdata__/roles';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import ServiceAccountDrawer from '../ServiceAccountDrawer';
+
+jest.mock('@signozhq/drawer', () => ({
+	DrawerWrapper: ({
+		content,
+		open,
+	}: {
+		content?: ReactNode;
+		open: boolean;
+	}): JSX.Element | null => (open ? <div>{content}</div> : null),
+}));
+
+jest.mock('@signozhq/sonner', () => ({
+	toast: { success: jest.fn(), error: jest.fn() },
+}));
+
+const ROLES_ENDPOINT = '*/api/v1/roles';
+const SA_KEYS_ENDPOINT = '*/api/v1/service_accounts/:id/keys';
+const SA_ENDPOINT = '*/api/v1/service_accounts/sa-1';
+const SA_STATUS_ENDPOINT = '*/api/v1/service_accounts/sa-1/status';
+
+const activeAccountResponse = {
+	id: 'sa-1',
+	name: 'CI Bot',
+	email: 'ci-bot@signoz.io',
+	roles: ['signoz-admin'],
+	status: 'ACTIVE',
+	createdAt: '2026-01-01T00:00:00Z',
+	updatedAt: '2026-01-02T00:00:00Z',
+};
+
+const disabledAccountResponse = {
+	...activeAccountResponse,
+	id: 'sa-2',
+	status: 'DISABLED',
+};
+
+function renderDrawer(
+	searchParams: Record<string, string> = { account: 'sa-1' },
+): ReturnType<typeof render> {
+	return render(
+		<NuqsTestingAdapter searchParams={searchParams} hasMemory>
+			<ServiceAccountDrawer onSuccess={jest.fn()} />
+		</NuqsTestingAdapter>,
+	);
+}
+
+describe('ServiceAccountDrawer', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
+			),
+			rest.get(SA_KEYS_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [] })),
+			),
+			rest.get(SA_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: activeAccountResponse })),
+			),
+			rest.put(SA_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+			rest.put(SA_STATUS_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('renders Overview tab by default: editable name input, locked email, Save disabled when not dirty', async () => {
+		renderDrawer();
+
+		expect(await screen.findByDisplayValue('CI Bot')).toBeInTheDocument();
+		expect(screen.getByText('ci-bot@signoz.io')).toBeInTheDocument();
+		expect(screen.getByRole('button', { name: /Save Changes/i })).toBeDisabled();
+	});
+
+	it('editing name enables Save; clicking Save sends correct payload and calls onSuccess', async () => {
+		const onSuccess = jest.fn();
+		const updateSpy = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		server.use(
+			rest.put(SA_ENDPOINT, async (req, res, ctx) => {
+				updateSpy(await req.json());
+				return res(ctx.status(200), ctx.json({ status: 'success', data: {} }));
+			}),
+		);
+
+		render(
+			<NuqsTestingAdapter searchParams={{ account: 'sa-1' }} hasMemory>
+				<ServiceAccountDrawer onSuccess={onSuccess} />
+			</NuqsTestingAdapter>,
+		);
+
+		const nameInput = await screen.findByDisplayValue('CI Bot');
+		await user.clear(nameInput);
+		await user.type(nameInput, 'CI Bot Updated');
+
+		const saveBtn = screen.getByRole('button', { name: /Save Changes/i });
+		await waitFor(() => expect(saveBtn).not.toBeDisabled());
+		await user.click(saveBtn);
+
+		await waitFor(() => {
+			expect(updateSpy).toHaveBeenCalledWith(
+				expect.objectContaining({
+					name: 'CI Bot Updated',
+					email: 'ci-bot@signoz.io',
+					roles: ['signoz-admin'],
+				}),
+			);
+			expect(onSuccess).toHaveBeenCalledWith({ closeDrawer: false });
+		});
+	});
+
+	it('changing roles enables Save; clicking Save sends updated roles in payload', async () => {
+		const updateSpy = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		server.use(
+			rest.put(SA_ENDPOINT, async (req, res, ctx) => {
+				updateSpy(await req.json());
+				return res(ctx.status(200), ctx.json({ status: 'success', data: {} }));
+			}),
+		);
+
+		renderDrawer();
+
+		await screen.findByDisplayValue('CI Bot');
+
+		await user.click(screen.getByLabelText('Roles'));
+		await user.click(await screen.findByTitle('signoz-viewer'));
+
+		const saveBtn = screen.getByRole('button', { name: /Save Changes/i });
+		await waitFor(() => expect(saveBtn).not.toBeDisabled());
+		await user.click(saveBtn);
+
+		await waitFor(() => {
+			expect(updateSpy).toHaveBeenCalledWith(
+				expect.objectContaining({
+					roles: expect.arrayContaining(['signoz-admin', 'signoz-viewer']),
+				}),
+			);
+		});
+	});
+
+	it('"Disable Service Account" opens confirm dialog; confirming sends correct status payload', async () => {
+		const statusSpy = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		server.use(
+			rest.put(SA_STATUS_ENDPOINT, async (req, res, ctx) => {
+				statusSpy(await req.json());
+				return res(ctx.status(200), ctx.json({ status: 'success', data: {} }));
+			}),
+		);
+
+		renderDrawer();
+
+		await screen.findByDisplayValue('CI Bot');
+
+		await user.click(
+			screen.getByRole('button', { name: /Disable Service Account/i }),
+		);
+
+		const dialog = await screen.findByRole('dialog', {
+			name: /Disable service account CI Bot/i,
+		});
+		expect(dialog).toBeInTheDocument();
+
+		const confirmBtns = screen.getAllByRole('button', { name: /^Disable$/i });
+		await user.click(confirmBtns[confirmBtns.length - 1]);
+
+		await waitFor(() => {
+			expect(statusSpy).toHaveBeenCalledWith({ status: 'DISABLED' });
+		});
+	});
+
+	it('disabled account shows read-only name, no Save button, no Disable button', async () => {
+		server.use(
+			rest.get('*/api/v1/service_accounts/sa-2', (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: disabledAccountResponse })),
+			),
+			rest.get('*/api/v1/service_accounts/sa-2/keys', (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [] })),
+			),
+		);
+
+		renderDrawer({ account: 'sa-2' });
+
+		await screen.findByText('CI Bot');
+
+		expect(
+			screen.queryByRole('button', { name: /Save Changes/i }),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /Disable Service Account/i }),
+		).not.toBeInTheDocument();
+		expect(screen.queryByDisplayValue('CI Bot')).not.toBeInTheDocument();
+	});
+
+	it('switching to Keys tab shows "No keys" empty state', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		renderDrawer();
+
+		await screen.findByDisplayValue('CI Bot');
+
+		await user.click(screen.getByRole('radio', { name: /Keys/i }));
+
+		await screen.findByText(/No keys/i);
+	});
+
+	it('shows skeleton while loading account data', () => {
+		renderDrawer();
+
+		// Skeleton renders while the fetch is in-flight
+		expect(document.querySelector('.ant-skeleton')).toBeInTheDocument();
+	});
+
+	it('shows error state when account fetch fails', async () => {
+		server.use(
+			rest.get(SA_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(500), ctx.json({ message: 'Server error' })),
+			),
+		);
+
+		renderDrawer();
+
+		expect(
+			await screen.findByText(
+				/An unexpected error occurred while fetching service account details/i,
+			),
+		).toBeInTheDocument();
+	});
+});

frontend/src/components/ServiceAccountDrawer/utils.ts

@@ -0,0 +1,33 @@
+import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
+import type { Dayjs } from 'dayjs';
+import dayjs from 'dayjs';
+
+export enum ServiceAccountDrawerTab {
+	Overview = 'overview',
+	Keys = 'keys',
+}
+
+export function formatLastObservedAt(
+	lastObservedAt: string | Date | null | undefined,
+	formatTimezoneAdjustedTimestamp: (ts: string, format: string) => string,
+): string {
+	if (!lastObservedAt) {
+		return '—';
+	}
+	const str =
+		typeof lastObservedAt === 'string'
+			? lastObservedAt
+			: lastObservedAt.toISOString();
+	// Go zero time means the key has never been used
+	if (str.startsWith('0001-01-01')) {
+		return '—';
+	}
+	const d = new Date(str);
+	if (Number.isNaN(d.getTime())) {
+		return '—';
+	}
+	return formatTimezoneAdjustedTimestamp(str, DATE_TIME_FORMATS.DASH_DATETIME);
+}
+
+export const disabledDate = (current: Dayjs): boolean =>
+	!!current && current < dayjs().startOf('day');

frontend/src/components/ServiceAccountsTable/ServiceAccountsTable.styles.scss

@@ -0,0 +1,218 @@
+.sa-table-wrapper {
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	min-height: 0;
+	overflow: hidden;
+	border-radius: 4px;
+}
+
+.sa-table {
+	.ant-table {
+		background: transparent;
+		font-size: 13px;
+	}
+
+	.ant-table-container {
+		border-radius: 0 !important;
+		border: none !important;
+	}
+
+	.ant-table-thead {
+		> tr > th,
+		> tr > td {
+			background: var(--background);
+			font-size: var(--paragraph-small-600-font-size);
+			font-weight: var(--paragraph-small-600-font-weight);
+			line-height: var(--paragraph-small-600-line-height);
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+			color: var(--foreground);
+			padding: var(--padding-2) var(--padding-4);
+			border-bottom: none !important;
+			border-top: none !important;
+
+			&::before {
+				display: none !important;
+			}
+		}
+	}
+
+	.ant-table-tbody {
+		> tr > td {
+			border-bottom: none !important;
+			padding: var(--padding-2) var(--padding-4);
+			background: transparent;
+			transition: none;
+		}
+
+		> tr.sa-table-row--tinted > td {
+			background: rgba(171, 189, 255, 0.02);
+		}
+
+		> tr:hover > td {
+			background: rgba(171, 189, 255, 0.04) !important;
+		}
+	}
+
+	.ant-table-wrapper,
+	.ant-table-container,
+	.ant-spin-nested-loading,
+	.ant-spin-container {
+		border: none !important;
+		box-shadow: none !important;
+	}
+
+	.sa-name-column {
+		.ant-table-column-sorters {
+			justify-content: flex-start;
+			gap: var(--spacing-2);
+		}
+
+		.ant-table-column-title {
+			flex: none;
+		}
+	}
+
+	.sa-status-cell {
+		[data-slot='badge'] {
+			padding: var(--padding-1) var(--padding-2);
+			align-items: center;
+			font-size: var(--uppercase-small-500-font-size);
+			font-weight: var(--uppercase-small-500-font-weight);
+			line-height: 100%;
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+		}
+	}
+}
+
+.sa-name-email-cell {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+	height: 22px;
+	overflow: hidden;
+
+	.sa-name {
+		font-size: var(--paragraph-base-500-font-size);
+		font-weight: var(--paragraph-base-500-font-weight);
+		color: var(--foreground);
+		line-height: var(--paragraph-base-500-line-height);
+		letter-spacing: -0.07px;
+		white-space: nowrap;
+		flex-shrink: 0;
+	}
+
+	.sa-email {
+		font-size: var(--paragraph-base-400-font-size);
+		font-weight: var(--paragraph-base-400-font-weight);
+		color: var(--l3-foreground-hover);
+		line-height: var(--paragraph-base-400-line-height);
+		letter-spacing: -0.07px;
+		flex: 1 0 0;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+}
+
+.sa-roles-cell {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+}
+
+.sa-dash {
+	font-size: var(--paragraph-base-400-font-size);
+	color: var(--l3-foreground-hover);
+}
+
+.sa-empty-state {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	padding: var(--padding-12) var(--padding-4);
+	gap: var(--spacing-4);
+	color: var(--foreground);
+
+	&__emoji {
+		font-size: var(--font-size-2xl);
+		line-height: 1;
+	}
+
+	&__text {
+		font-size: var(--paragraph-base-400-font-size);
+		font-weight: var(--paragraph-base-400-font-weight);
+		color: var(--foreground);
+		margin: 0;
+		line-height: var(--paragraph-base-400-line-height);
+
+		strong {
+			font-weight: var(--font-weight-medium);
+			color: var(--bg-base-white);
+		}
+	}
+}
+
+.sa-table-pagination {
+	display: flex;
+	align-items: center;
+	justify-content: flex-end;
+	padding: var(--padding-2) var(--padding-4);
+
+	.ant-pagination-total-text {
+		margin-right: auto;
+	}
+
+	.sa-pagination-range {
+		font-size: var(--font-size-xs);
+		color: var(--foreground);
+	}
+
+	.sa-pagination-total {
+		font-size: var(--font-size-xs);
+		color: var(--foreground);
+		opacity: 0.5;
+	}
+}
+
+.sa-tooltip {
+	.ant-tooltip-inner {
+		background-color: var(--bg-slate-500);
+		color: var(--foreground);
+		font-size: var(--font-size-xs);
+		line-height: normal;
+		padding: var(--padding-2) var(--padding-3);
+		border-radius: 4px;
+		text-align: left;
+	}
+
+	.ant-tooltip-arrow-content {
+		background-color: var(--bg-slate-500);
+	}
+}
+
+.lightMode {
+	.sa-table {
+		.ant-table-tbody {
+			> tr.sa-table-row--tinted > td {
+				background: rgba(0, 0, 0, 0.015);
+			}
+
+			> tr:hover > td {
+				background: rgba(0, 0, 0, 0.03) !important;
+			}
+		}
+	}
+
+	.sa-empty-state {
+		&__text {
+			strong {
+				color: var(--bg-base-black);
+			}
+		}
+	}
+}

frontend/src/components/ServiceAccountsTable/ServiceAccountsTable.tsx

@@ -0,0 +1,95 @@
+import React from 'react';
+import { Table } from 'antd';
+import { ServiceAccountRow } from 'container/ServiceAccountsSettings/utils';
+import { parseAsInteger, parseAsString, useQueryState } from 'nuqs';
+
+import {
+	columns,
+	ServiceAccountsEmptyState,
+	showPaginationTotal,
+} from './utils';
+
+import './ServiceAccountsTable.styles.scss';
+
+export const PAGE_SIZE = 20;
+
+interface ServiceAccountsTableProps {
+	data: ServiceAccountRow[];
+	loading: boolean;
+	onRowClick?: (row: ServiceAccountRow) => void;
+}
+
+function ServiceAccountsTable({
+	data,
+	loading,
+	onRowClick,
+}: ServiceAccountsTableProps): JSX.Element {
+	const [currentPage, setPage] = useQueryState(
+		'page',
+		parseAsInteger.withDefault(1),
+	);
+	const [searchQuery] = useQueryState('search', parseAsString.withDefault(''));
+
+	return (
+		<div className="sa-table-wrapper">
+			{/* Todo: use new table component from periscope when ready */}
+			<Table<ServiceAccountRow>
+				columns={columns}
+				dataSource={data}
+				rowKey="id"
+				loading={loading}
+				pagination={
+					data.length > PAGE_SIZE
+						? {
+								current: currentPage,
+								pageSize: PAGE_SIZE,
+								total: data.length,
+								showTotal: showPaginationTotal,
+								showSizeChanger: false,
+								onChange: (page: number): void => void setPage(page),
+								className: 'sa-table-pagination',
+						  }
+						: false
+				}
+				rowClassName={(_, index): string =>
+					index % 2 === 0 ? 'sa-table-row--tinted' : ''
+				}
+				showSorterTooltip={false}
+				locale={{
+					emptyText: <ServiceAccountsEmptyState searchQuery={searchQuery} />,
+				}}
+				className="sa-table"
+				onRow={(
+					record,
+				): {
+					onClick?: () => void;
+					onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => void;
+					style?: React.CSSProperties;
+					tabIndex?: number;
+					role?: string;
+					'aria-label'?: string;
+				} => {
+					if (!onRowClick) {
+						return {};
+					}
+
+					return {
+						onClick: (): void => onRowClick(record),
+						onKeyDown: (e: React.KeyboardEvent<HTMLElement>): void => {
+							if (e.key === 'Enter' || e.key === ' ') {
+								e.preventDefault();
+								onRowClick(record);
+							}
+						},
+						style: { cursor: 'pointer' },
+						tabIndex: 0,
+						role: 'button',
+						'aria-label': `View service account ${record.name || record.email}`,
+					};
+				}}
+			/>
+		</div>
+	);
+}
+
+export default ServiceAccountsTable;

frontend/src/components/ServiceAccountsTable/__tests__/ServiceAccountsTable.test.tsx

@@ -0,0 +1,96 @@
+import { ServiceAccountRow } from 'container/ServiceAccountsSettings/utils';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent } from 'tests/test-utils';
+
+import ServiceAccountsTable from '../ServiceAccountsTable';
+
+const mockActiveAccount: ServiceAccountRow = {
+	id: 'sa-1',
+	name: 'CI Bot',
+	email: 'ci-bot@signoz.io',
+	roles: ['signoz-admin'],
+	status: 'ACTIVE',
+	createdAt: '2026-01-01T00:00:00Z',
+	updatedAt: '2026-01-02T00:00:00Z',
+};
+
+const mockDisabledAccount: ServiceAccountRow = {
+	id: 'sa-2',
+	name: 'Legacy Bot',
+	email: 'legacy@signoz.io',
+	roles: ['signoz-viewer', 'signoz-editor', 'billing-manager'],
+	status: 'DISABLED',
+	createdAt: '2025-06-01T00:00:00Z',
+	updatedAt: '2025-12-01T00:00:00Z',
+};
+
+const defaultProps = {
+	loading: false,
+	onRowClick: jest.fn(),
+};
+
+describe('ServiceAccountsTable', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('renders name, email, role badge, and ACTIVE status badge', () => {
+		render(<ServiceAccountsTable {...defaultProps} data={[mockActiveAccount]} />);
+
+		expect(screen.getByText('CI Bot')).toBeInTheDocument();
+		expect(screen.getByText('ci-bot@signoz.io')).toBeInTheDocument();
+		expect(screen.getByText('signoz-admin')).toBeInTheDocument();
+		expect(screen.getByText('ACTIVE')).toBeInTheDocument();
+	});
+
+	it('shows DISABLED badge and +2 overflow badge for multi-role accounts', () => {
+		render(
+			<ServiceAccountsTable {...defaultProps} data={[mockDisabledAccount]} />,
+		);
+
+		expect(screen.getByText('DISABLED')).toBeInTheDocument();
+		expect(screen.getByText('signoz-viewer')).toBeInTheDocument();
+		expect(screen.getByText('+2')).toBeInTheDocument();
+	});
+
+	it('calls onRowClick with the correct account when a row is clicked', async () => {
+		const onRowClick = jest.fn() as jest.MockedFunction<
+			(row: ServiceAccountRow) => void
+		>;
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(
+			<ServiceAccountsTable
+				{...defaultProps}
+				data={[mockActiveAccount]}
+				onRowClick={onRowClick}
+			/>,
+		);
+
+		await user.click(
+			screen.getByRole('button', { name: /View service account CI Bot/i }),
+		);
+
+		expect(onRowClick).toHaveBeenCalledTimes(1);
+		expect(onRowClick).toHaveBeenCalledWith(
+			expect.objectContaining({ id: 'sa-1', email: 'ci-bot@signoz.io' }),
+		);
+	});
+
+	it('shows "No service accounts" empty state when data is empty and no search query', () => {
+		render(<ServiceAccountsTable {...defaultProps} data={[]} />);
+
+		expect(screen.getByText(/No service accounts/i)).toBeInTheDocument();
+	});
+
+	it('shows "No results for {query}" empty state when search is active', () => {
+		render(
+			<NuqsTestingAdapter searchParams={{ search: 'ghost' }}>
+				<ServiceAccountsTable {...defaultProps} data={[]} />
+			</NuqsTestingAdapter>,
+		);
+
+		expect(screen.getByText(/No results for/i)).toBeInTheDocument();
+		expect(screen.getByText('ghost')).toBeInTheDocument();
+	});
+});

frontend/src/components/ServiceAccountsTable/utils.tsx

@@ -0,0 +1,133 @@
+import { Badge } from '@signozhq/badge';
+import { Tooltip } from 'antd';
+import type { ColumnsType } from 'antd/es/table/interface';
+import { ServiceAccountRow } from 'container/ServiceAccountsSettings/utils';
+
+export function NameEmailCell({
+	name,
+	email,
+}: {
+	name: string;
+	email: string;
+}): JSX.Element {
+	return (
+		<div className="sa-name-email-cell">
+			{name && (
+				<span className="sa-name" title={name}>
+					{name}
+				</span>
+			)}
+			<Tooltip title={email} overlayClassName="sa-tooltip">
+				<span className="sa-email">{email}</span>
+			</Tooltip>
+		</div>
+	);
+}
+
+export function RolesCell({ roles }: { roles: string[] }): JSX.Element {
+	if (!roles || roles.length === 0) {
+		return <span className="sa-dash">—</span>;
+	}
+	const first = roles[0];
+	const overflow = roles.length - 1;
+	const tooltipContent = roles.slice(1).join(', ');
+
+	return (
+		<div className="sa-roles-cell">
+			<Badge color="vanilla">{first}</Badge>
+			{overflow > 0 && (
+				<Tooltip
+					title={tooltipContent}
+					overlayClassName="sa-tooltip"
+					overlayStyle={{ maxWidth: '600px' }}
+				>
+					<Badge color="vanilla" variant="outline" className="sa-status-badge">
+						+{overflow}
+					</Badge>
+				</Tooltip>
+			)}
+		</div>
+	);
+}
+
+export function StatusBadge({ status }: { status: string }): JSX.Element {
+	if (status?.toUpperCase() === 'ACTIVE') {
+		return (
+			<Badge color="forest" variant="outline">
+				ACTIVE
+			</Badge>
+		);
+	}
+	return (
+		<Badge color="vanilla" variant="outline" className="sa-status-badge">
+			DISABLED
+		</Badge>
+	);
+}
+
+export function ServiceAccountsEmptyState({
+	searchQuery,
+}: {
+	searchQuery: string;
+}): JSX.Element {
+	return (
+		<div className="sa-empty-state">
+			<span className="sa-empty-state__emoji" role="img" aria-label="monocle face">
+				🧐
+			</span>
+			{searchQuery ? (
+				<p className="sa-empty-state__text">
+					No results for <strong>{searchQuery}</strong>
+				</p>
+			) : (
+				<p className="sa-empty-state__text">
+					No service accounts. Start by creating one to manage keys.
+				</p>
+			)}
+		</div>
+	);
+}
+
+export const columns: ColumnsType<ServiceAccountRow> = [
+	{
+		title: 'Name / Email',
+		dataIndex: 'name',
+		key: 'name',
+		className: 'sa-name-column',
+		sorter: (a, b): number => a.email.localeCompare(b.email),
+		render: (_, record): JSX.Element => (
+			<NameEmailCell name={record.name} email={record.email} />
+		),
+	},
+	{
+		title: 'Roles',
+		dataIndex: 'roles',
+		key: 'roles',
+		width: 420,
+		render: (roles: string[]): JSX.Element => <RolesCell roles={roles} />,
+	},
+	{
+		title: 'Status',
+		dataIndex: 'status',
+		key: 'status',
+		width: 120,
+		align: 'right' as const,
+		className: 'sa-status-cell',
+		sorter: (a, b): number =>
+			(a.status?.toUpperCase() === 'ACTIVE' ? 0 : 1) -
+			(b.status?.toUpperCase() === 'ACTIVE' ? 0 : 1),
+		render: (status: string): JSX.Element => <StatusBadge status={status} />,
+	},
+];
+
+export const showPaginationTotal = (
+	_total: number,
+	range: number[],
+): JSX.Element => (
+	<>
+		<span className="sa-pagination-range">
+			{range[0]} &#8212; {range[1]}
+		</span>
+		<span className="sa-pagination-total"> of {_total}</span>
+	</>
+);

frontend/src/constants/localStorage.ts

@@ -35,4 +35,5 @@ export enum LOCALSTORAGE {
 	LAST_USED_CUSTOM_TIME_RANGES = 'LAST_USED_CUSTOM_TIME_RANGES',
 	SHOW_FREQUENCY_CHART = 'SHOW_FREQUENCY_CHART',
 	DISSMISSED_COST_METER_INFO = 'DISMISSED_COST_METER_INFO',
+	DISMISSED_API_KEYS_DEPRECATION_BANNER = 'DISMISSED_API_KEYS_DEPRECATION_BANNER',
 }

frontend/src/constants/routes.ts

@@ -86,6 +86,7 @@ const ROUTES = {
 	METER_EXPLORER_VIEWS: '/meter/explorer/views',
 	HOME_PAGE: '/',
 	PUBLIC_DASHBOARD: '/public/dashboard/:dashboardId',
+	SERVICE_ACCOUNTS_SETTINGS: '/settings/service-accounts',
 } as const;
 
 export default ROUTES;

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -123,7 +123,7 @@ export const prepareUPlotConfig = ({
 			drawStyle: hasSingleValidPoint ? DrawStyle.Points : DrawStyle.Line,
 			label: label,
 			colorMapping: widget.customLegendColors ?? {},
-			spanGaps: widget.spanGaps ?? true,
+			spanGaps: true,
 			lineStyle: widget.lineStyle || LineStyle.Solid,
 			lineInterpolation: widget.lineInterpolation || LineInterpolation.Spline,
 			showPoints:

frontend/src/container/Home/Home.tsx

@@ -6,13 +6,16 @@ import { Button, Popover } from 'antd';
 import logEvent from 'api/common/logEvent';
 import listUserPreferences from 'api/v1/user/preferences/list';
 import updateUserPreferenceAPI from 'api/v1/user/preferences/name/update';
+import { PersistedAnnouncementBanner } from 'components/AnnouncementBanner';
 import Header from 'components/Header/Header';
 import { ENTITY_VERSION_V5 } from 'constants/app';
+import { LOCALSTORAGE } from 'constants/localStorage';
 import { ORG_PREFERENCES } from 'constants/orgPreferences';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import ROUTES from 'constants/routes';
 import { getMetricsListQuery } from 'container/MetricsExplorer/Summary/utils';
+import { IS_SERVICE_ACCOUNTS_ENABLED } from 'container/ServiceAccountsSettings/config';
 import { useGetMetricsList } from 'hooks/metricsExplorer/useGetMetricsList';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useIsDarkMode } from 'hooks/useDarkMode';
@@ -291,6 +294,24 @@ export default function Home(): JSX.Element {
 
 	return (
 		<div className="home-container">
+			{IS_SERVICE_ACCOUNTS_ENABLED && (
+				<PersistedAnnouncementBanner
+					type="warning"
+					storageKey={LOCALSTORAGE.DISMISSED_API_KEYS_DEPRECATION_BANNER}
+					message={
+						<>
+							<strong>API Keys</strong> have been deprecated and replaced by{' '}
+							<strong>Service Accounts</strong>. Please migrate to Service Accounts for
+							programmatic API access.
+						</>
+					}
+					action={{
+						label: 'Go to Service Accounts',
+						onClick: (): void => history.push(ROUTES.SERVICE_ACCOUNTS_SETTINGS),
+					}}
+				/>
+			)}
+
 			<div className="sticky-header">
 				<Header
 					leftComponent={

frontend/src/container/MembersSettings/MembersSettings.tsx

@@ -13,6 +13,7 @@ import InviteMembersModal from 'components/InviteMembersModal/InviteMembersModal
 import MembersTable, { MemberRow } from 'components/MembersTable/MembersTable';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { useAppContext } from 'providers/App/App';
+import { toISOString } from 'utils/app';
 
 import { FilterMode, INVITE_PREFIX, MemberStatus } from './utils';
 
@@ -61,8 +62,8 @@ function MembersSettings(): JSX.Element {
 			email: user.email,
 			role: user.role,
 			status: MemberStatus.Active,
-			joinedOn: user.createdAt ? String(user.createdAt) : null,
-			updatedAt: user?.updatedAt ? String(user.updatedAt) : null,
+			joinedOn: toISOString(user.createdAt),
+			updatedAt: toISOString(user?.updatedAt),
 		}));
 
 		const pendingInvites: MemberRow[] = (invitesData?.data ?? []).map(
@@ -72,7 +73,7 @@ function MembersSettings(): JSX.Element {
 				email: invite.email,
 				role: invite.role,
 				status: MemberStatus.Invited,
-				joinedOn: invite.createdAt ? String(invite.createdAt) : null,
+				joinedOn: toISOString(invite.createdAt),
 				token: invite.token ?? null,
 			}),
 		);
@@ -122,6 +123,9 @@ function MembersSettings(): JSX.Element {
 		if (currentPage > maxPage) {
 			setPage(maxPage);
 		}
+		if (currentPage < 1) {
+			setPage(1);
+		}
 	}, [filteredMembers.length, currentPage, setPage]);
 
 	const pendingCount = invitesData?.data?.length ?? 0;
@@ -209,6 +213,7 @@ function MembersSettings(): JSX.Element {
 
 					<div className="members-settings__search">
 						<Input
+							type="search"
 							placeholder="Search by name, email, or role..."
 							value={searchQuery}
 							onChange={(e): void => {
@@ -217,6 +222,7 @@ function MembersSettings(): JSX.Element {
 							}}
 							className="members-search-input"
 							color="secondary"
+							name="members-search"
 						/>
 					</div>
 

frontend/src/container/NewWidget/RightContainer/RightContainer.styles.scss

@@ -30,17 +30,6 @@
 		width: 100%;
 	}
 
-	.section-heading {
-		font-family: 'Space Mono';
-		color: var(--bg-vanilla-400);
-		font-size: 13px;
-		font-style: normal;
-		font-weight: 400;
-		line-height: 18px; /* 138.462% */
-		letter-spacing: 0.52px;
-		text-transform: uppercase;
-	}
-
 	.header {
 		display: flex;
 		padding: 14px 14px 14px 12px;

frontend/src/container/NewWidget/RightContainer/SettingSections/ChartAppearanceSection/ChartAppearanceSection.tsx

@@ -7,10 +7,9 @@ import {
 } from 'lib/uPlotV2/config/types';
 import { Paintbrush } from 'lucide-react';
 
-import DisconnectValuesSelector from '../../components/DisconnectValuesSelector/DisconnectValuesSelector';
-import FillModeSelector from '../../components/FillModeSelector/FillModeSelector';
-import LineInterpolationSelector from '../../components/LineInterpolationSelector/LineInterpolationSelector';
-import LineStyleSelector from '../../components/LineStyleSelector/LineStyleSelector';
+import { FillModeSelector } from '../../components/FillModeSelector/FillModeSelector';
+import { LineInterpolationSelector } from '../../components/LineInterpolationSelector/LineInterpolationSelector';
+import { LineStyleSelector } from '../../components/LineStyleSelector/LineStyleSelector';
 import SettingsSection from '../../components/SettingsSection/SettingsSection';
 
 interface ChartAppearanceSectionProps {
@@ -22,14 +21,10 @@ interface ChartAppearanceSectionProps {
 	setLineInterpolation: Dispatch<SetStateAction<LineInterpolation>>;
 	showPoints: boolean;
 	setShowPoints: Dispatch<SetStateAction<boolean>>;
-	spanGaps: boolean | number;
-	setSpanGaps: Dispatch<SetStateAction<boolean | number>>;
 	allowFillMode: boolean;
 	allowLineStyle: boolean;
 	allowLineInterpolation: boolean;
 	allowShowPoints: boolean;
-	allowSpanGaps: boolean;
-	stepInterval: number;
 }
 
 export default function ChartAppearanceSection({
@@ -41,14 +36,10 @@ export default function ChartAppearanceSection({
 	setLineInterpolation,
 	showPoints,
 	setShowPoints,
-	spanGaps,
-	setSpanGaps,
 	allowFillMode,
 	allowLineStyle,
 	allowLineInterpolation,
 	allowShowPoints,
-	allowSpanGaps,
-	stepInterval,
 }: ChartAppearanceSectionProps): JSX.Element {
 	return (
 		<SettingsSection title="Chart Appearance" icon={<Paintbrush size={14} />}>
@@ -75,13 +66,6 @@ export default function ChartAppearanceSection({
 					<Switch size="small" checked={showPoints} onChange={setShowPoints} />
 				</section>
 			)}
-			{allowSpanGaps && (
-				<DisconnectValuesSelector
-					value={spanGaps}
-					minValue={stepInterval}
-					onChange={setSpanGaps}
-				/>
-			)}
 		</SettingsSection>
 	);
 }

frontend/src/container/NewWidget/RightContainer/__tests__/RightContainer.test.tsx

@@ -178,8 +178,6 @@ describe('RightContainer - Alerts Section', () => {
 		setLineStyle: jest.fn(),
 		showPoints: false,
 		setShowPoints: jest.fn(),
-		spanGaps: false,
-		setSpanGaps: jest.fn(),
 	};
 
 	beforeEach(() => {

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesModeToggle.tsx

@@ -1,44 +0,0 @@
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
-import { Typography } from 'antd';
-import { DisconnectedValuesMode } from 'lib/uPlotV2/config/types';
-
-interface DisconnectValuesModeToggleProps {
-	value: DisconnectedValuesMode;
-	onChange: (value: DisconnectedValuesMode) => void;
-}
-
-export default function DisconnectValuesModeToggle({
-	value,
-	onChange,
-}: DisconnectValuesModeToggleProps): JSX.Element {
-	return (
-		<ToggleGroup
-			type="single"
-			value={value}
-			variant="outline"
-			size="lg"
-			onValueChange={(newValue): void => {
-				if (newValue) {
-					onChange(newValue as DisconnectedValuesMode);
-				}
-			}}
-		>
-			<ToggleGroupItem
-				value={DisconnectedValuesMode.Never}
-				aria-label="Never"
-				title="Never"
-			>
-				<Typography.Text className="section-heading-small">Never</Typography.Text>
-			</ToggleGroupItem>
-			<ToggleGroupItem
-				value={DisconnectedValuesMode.Threshold}
-				aria-label="Threshold"
-				title="Threshold"
-			>
-				<Typography.Text className="section-heading-small">
-					Threshold
-				</Typography.Text>
-			</ToggleGroupItem>
-		</ToggleGroup>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesSelector.styles.scss

@@ -1,21 +0,0 @@
-.disconnect-values-selector {
-	.disconnect-values-input-wrapper {
-		display: flex;
-		flex-direction: column;
-		gap: 16px;
-
-		.disconnect-values-threshold-wrapper {
-			display: flex;
-			flex-direction: column;
-			gap: 8px;
-			.disconnect-values-threshold-input {
-				max-width: 160px;
-				height: auto;
-				.disconnect-values-threshold-prefix {
-					padding: 0 8px;
-					font-size: 20px;
-				}
-			}
-		}
-	}
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesSelector.tsx

@@ -1,91 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Typography } from 'antd';
-import { DisconnectedValuesMode } from 'lib/uPlotV2/config/types';
-
-import DisconnectValuesModeToggle from './DisconnectValuesModeToggle';
-import DisconnectValuesThresholdInput from './DisconnectValuesThresholdInput';
-
-import './DisconnectValuesSelector.styles.scss';
-
-const DEFAULT_THRESHOLD_SECONDS = 60;
-
-interface DisconnectValuesSelectorProps {
-	value: boolean | number;
-	minValue?: number;
-	onChange: (value: boolean | number) => void;
-}
-
-export default function DisconnectValuesSelector({
-	value,
-	minValue,
-	onChange,
-}: DisconnectValuesSelectorProps): JSX.Element {
-	const [mode, setMode] = useState<DisconnectedValuesMode>(() => {
-		if (typeof value === 'number') {
-			return DisconnectedValuesMode.Threshold;
-		}
-		return DisconnectedValuesMode.Never;
-	});
-	const [thresholdSeconds, setThresholdSeconds] = useState<number>(
-		typeof value === 'number' ? value : minValue ?? DEFAULT_THRESHOLD_SECONDS,
-	);
-
-	useEffect(() => {
-		if (typeof value === 'boolean') {
-			setMode(DisconnectedValuesMode.Never);
-		} else if (typeof value === 'number') {
-			setMode(DisconnectedValuesMode.Threshold);
-			setThresholdSeconds(value);
-		}
-	}, [value]);
-
-	useEffect(() => {
-		if (minValue !== undefined) {
-			setThresholdSeconds(minValue);
-			if (mode === DisconnectedValuesMode.Threshold) {
-				onChange(minValue);
-			}
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minValue]);
-
-	const handleModeChange = (newMode: DisconnectedValuesMode): void => {
-		setMode(newMode);
-		switch (newMode) {
-			case DisconnectedValuesMode.Never:
-				onChange(true);
-				break;
-			case DisconnectedValuesMode.Threshold:
-				onChange(thresholdSeconds);
-				break;
-		}
-	};
-
-	const handleThresholdChange = (seconds: number): void => {
-		setThresholdSeconds(seconds);
-		onChange(seconds);
-	};
-
-	return (
-		<section className="disconnect-values-selector control-container">
-			<Typography.Text className="section-heading">
-				Disconnect values
-			</Typography.Text>
-			<div className="disconnect-values-input-wrapper">
-				<DisconnectValuesModeToggle value={mode} onChange={handleModeChange} />
-				{mode === DisconnectedValuesMode.Threshold && (
-					<section className="control-container">
-						<Typography.Text className="section-heading">
-							Threshold Value
-						</Typography.Text>
-						<DisconnectValuesThresholdInput
-							value={thresholdSeconds}
-							minValue={minValue}
-							onChange={handleThresholdChange}
-						/>
-					</section>
-				)}
-			</div>
-		</section>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesThresholdInput.tsx

@@ -1,87 +0,0 @@
-import { useEffect, useState } from 'react';
-import { rangeUtil } from '@grafana/data';
-import { Callout } from '@signozhq/callout';
-import { Input } from '@signozhq/ui';
-interface DisconnectValuesThresholdInputProps {
-	value: number;
-	onChange: (seconds: number) => void;
-	minValue?: number;
-}
-
-export default function DisconnectValuesThresholdInput({
-	value,
-	onChange,
-	minValue,
-}: DisconnectValuesThresholdInputProps): JSX.Element {
-	const [inputValue, setInputValue] = useState<string>(
-		rangeUtil.secondsToHms(value),
-	);
-	const [error, setError] = useState<string | null>(null);
-
-	useEffect(() => {
-		setInputValue(rangeUtil.secondsToHms(value));
-		setError(null);
-	}, [value]);
-
-	const commitValue = (txt: string): void => {
-		if (!txt) {
-			return;
-		}
-		try {
-			let seconds: number;
-			if (rangeUtil.isValidTimeSpan(txt)) {
-				seconds = rangeUtil.intervalToSeconds(txt);
-			} else {
-				const parsed = Number(txt);
-				if (Number.isNaN(parsed) || parsed <= 0) {
-					setError('Enter a valid duration (e.g. 1h, 10m, 1d)');
-					return;
-				}
-				seconds = parsed;
-			}
-			if (minValue !== undefined && seconds <= minValue) {
-				setError(`Threshold should be > ${rangeUtil.secondsToHms(minValue)}`);
-				return;
-			}
-			setError(null);
-			setInputValue(txt);
-			onChange(seconds);
-		} catch {
-			setError('Invalid threshold value');
-		}
-	};
-
-	const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>): void => {
-		if (e.key === 'Enter') {
-			commitValue(e.currentTarget.value);
-		}
-	};
-
-	const handleBlur = (e: React.FocusEvent<HTMLInputElement>): void => {
-		commitValue(e.currentTarget.value);
-	};
-
-	return (
-		<div className="disconnect-values-threshold-wrapper">
-			<Input
-				name="disconnect-values-threshold"
-				type="text"
-				className="disconnect-values-threshold-input"
-				prefix={<span className="disconnect-values-threshold-prefix">&gt;</span>}
-				value={inputValue}
-				onChange={(e): void => {
-					setInputValue(e.currentTarget.value);
-					if (error) {
-						setError(null);
-					}
-				}}
-				onKeyDown={handleKeyDown}
-				onBlur={handleBlur}
-				autoFocus={false}
-				aria-invalid={!!error}
-				aria-describedby={error ? 'threshold-error' : undefined}
-			/>
-			{error && <Callout type="error" size="small" showIcon description={error} />}
-		</div>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/FillModeSelector/FillModeSelector.tsx

@@ -9,7 +9,7 @@ interface FillModeSelectorProps {
 	onChange: (value: FillMode) => void;
 }
 
-export default function FillModeSelector({
+export function FillModeSelector({
 	value,
 	onChange,
 }: FillModeSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/components/LineInterpolationSelector/LineInterpolationSelector.tsx

@@ -9,7 +9,7 @@ interface LineInterpolationSelectorProps {
 	onChange: (value: LineInterpolation) => void;
 }
 
-export default function LineInterpolationSelector({
+export function LineInterpolationSelector({
 	value,
 	onChange,
 }: LineInterpolationSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/components/LineStyleSelector/LineStyleSelector.tsx

@@ -9,7 +9,7 @@ interface LineStyleSelectorProps {
 	onChange: (value: LineStyle) => void;
 }
 
-export default function LineStyleSelector({
+export function LineStyleSelector({
 	value,
 	onChange,
 }: LineStyleSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/constants.ts

@@ -262,17 +262,3 @@ export const panelTypeVsShowPoints: {
 	[PANEL_TYPES.TRACE]: false,
 	[PANEL_TYPES.EMPTY_WIDGET]: false,
 } as const;
-
-export const panelTypeVsSpanGaps: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;

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

@@ -1,7 +1,6 @@
 import { Dispatch, SetStateAction, useMemo } from 'react';
 import { UseQueryResult } from 'react-query';
 import { Typography } from 'antd';
-import { ExecStats } from 'api/v5/v5';
 import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
 import { PANEL_TYPES, PanelDisplay } from 'constants/queryBuilder';
 import { PanelTypesWithData } from 'container/DashboardContainer/PanelTypeSelectionModal/menuItems';
@@ -12,7 +11,6 @@ import {
 	LineInterpolation,
 	LineStyle,
 } from 'lib/uPlotV2/config/types';
-import get from 'lodash-es/get';
 import { SuccessResponse } from 'types/api';
 import {
 	ColumnUnit,
@@ -38,7 +36,6 @@ import {
 	panelTypeVsPanelTimePreferences,
 	panelTypeVsShowPoints,
 	panelTypeVsSoftMinMax,
-	panelTypeVsSpanGaps,
 	panelTypeVsStackingChartPreferences,
 	panelTypeVsThreshold,
 	panelTypeVsYAxisUnit,
@@ -71,8 +68,6 @@ function RightContainer({
 	setLineStyle,
 	showPoints,
 	setShowPoints,
-	spanGaps,
-	setSpanGaps,
 	bucketCount,
 	bucketWidth,
 	stackedBarChart,
@@ -143,7 +138,6 @@ function RightContainer({
 	const allowLineStyle = panelTypeVsLineStyle[selectedGraph];
 	const allowFillMode = panelTypeVsFillMode[selectedGraph];
 	const allowShowPoints = panelTypeVsShowPoints[selectedGraph];
-	const allowSpanGaps = panelTypeVsSpanGaps[selectedGraph];
 
 	const decimapPrecisionOptions = useMemo(
 		() => [
@@ -182,26 +176,10 @@ function RightContainer({
 			(allowFillMode ||
 				allowLineStyle ||
 				allowLineInterpolation ||
-				allowShowPoints ||
-				allowSpanGaps),
-		[
-			allowFillMode,
-			allowLineStyle,
-			allowLineInterpolation,
-			allowShowPoints,
-			allowSpanGaps,
-		],
+				allowShowPoints),
+		[allowFillMode, allowLineStyle, allowLineInterpolation, allowShowPoints],
 	);
 
-	const stepInterval = useMemo(() => {
-		const stepIntervals: ExecStats['stepIntervals'] = get(
-			queryResponse,
-			'data.payload.data.newResult.meta.stepIntervals',
-			{},
-		);
-		return Math.min(...Object.values(stepIntervals));
-	}, [queryResponse]);
-
 	return (
 		<div className="right-container">
 			<section className="header">
@@ -259,14 +237,10 @@ function RightContainer({
 						setLineInterpolation={setLineInterpolation}
 						showPoints={showPoints}
 						setShowPoints={setShowPoints}
-						spanGaps={spanGaps}
-						setSpanGaps={setSpanGaps}
 						allowFillMode={allowFillMode}
 						allowLineStyle={allowLineStyle}
 						allowLineInterpolation={allowLineInterpolation}
 						allowShowPoints={allowShowPoints}
-						allowSpanGaps={allowSpanGaps}
-						stepInterval={stepInterval}
 					/>
 				)}
 
@@ -390,8 +364,6 @@ export interface RightContainerProps {
 	setLineStyle: Dispatch<SetStateAction<LineStyle>>;
 	showPoints: boolean;
 	setShowPoints: Dispatch<SetStateAction<boolean>>;
-	spanGaps: boolean | number;
-	setSpanGaps: Dispatch<SetStateAction<boolean | number>>;
 }
 
 RightContainer.defaultProps = {

frontend/src/container/NewWidget/index.tsx

@@ -220,9 +220,6 @@ function NewWidget({
 	const [showPoints, setShowPoints] = useState<boolean>(
 		selectedWidget?.showPoints ?? false,
 	);
-	const [spanGaps, setSpanGaps] = useState<boolean | number>(
-		selectedWidget?.spanGaps ?? false,
-	);
 	const [customLegendColors, setCustomLegendColors] = useState<
 		Record<string, string>
 	>(selectedWidget?.customLegendColors || {});
@@ -292,7 +289,6 @@ function NewWidget({
 				fillMode,
 				lineStyle,
 				showPoints,
-				spanGaps,
 				columnUnits,
 				bucketCount,
 				stackedBarChart,
@@ -332,7 +328,6 @@ function NewWidget({
 		fillMode,
 		lineStyle,
 		showPoints,
-		spanGaps,
 		customLegendColors,
 		contextLinks,
 		selectedWidget.columnWidths,
@@ -546,7 +541,6 @@ function NewWidget({
 								softMin: selectedWidget?.softMin || 0,
 								softMax: selectedWidget?.softMax || 0,
 								fillSpans: selectedWidget?.fillSpans,
-								spanGaps: selectedWidget?.spanGaps ?? true,
 								isLogScale: selectedWidget?.isLogScale || false,
 								bucketWidth: selectedWidget?.bucketWidth || 0,
 								bucketCount: selectedWidget?.bucketCount || 0,
@@ -578,7 +572,6 @@ function NewWidget({
 								softMin: selectedWidget?.softMin || 0,
 								softMax: selectedWidget?.softMax || 0,
 								fillSpans: selectedWidget?.fillSpans,
-								spanGaps: selectedWidget?.spanGaps ?? true,
 								isLogScale: selectedWidget?.isLogScale || false,
 								bucketWidth: selectedWidget?.bucketWidth || 0,
 								bucketCount: selectedWidget?.bucketCount || 0,
@@ -896,8 +889,6 @@ function NewWidget({
 							setLineStyle={setLineStyle}
 							showPoints={showPoints}
 							setShowPoints={setShowPoints}
-							spanGaps={spanGaps}
-							setSpanGaps={setSpanGaps}
 							opacity={opacity}
 							yAxisUnit={yAxisUnit}
 							columnUnits={columnUnits}

frontend/src/container/ServiceAccountsSettings/ServiceAccountsSettings.styles.scss

@@ -0,0 +1,134 @@
+.sa-settings {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-8);
+	padding: var(--padding-4) var(--padding-2) var(--padding-6) var(--padding-4);
+	height: 100%;
+
+	&__header {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-2);
+	}
+
+	&__title {
+		font-size: var(--label-large-500-font-size);
+		font-weight: var(--label-large-500-font-weight);
+		color: var(--text-base-white);
+		letter-spacing: -0.09px;
+		line-height: var(--line-height-normal);
+		margin: 0;
+	}
+
+	&__subtitle {
+		font-size: var(--paragraph-base-400-font-size);
+		font-weight: var(--paragraph-base-400-font-weight);
+		color: var(--foreground);
+		letter-spacing: -0.07px;
+		line-height: var(--paragraph-base-400-line-height);
+		margin: 0;
+	}
+
+	&__learn-more {
+		color: var(--primary);
+		text-decoration: none;
+
+		&:hover {
+			text-decoration: underline;
+		}
+	}
+
+	&__controls {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-4);
+	}
+
+	&__search {
+		flex: 1;
+		min-width: 0;
+	}
+}
+
+.sa-status-badge {
+	color: var(--l3-foreground);
+	border-color: var(--border);
+}
+
+.sa-settings-filter-trigger {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+	border: 1px solid var(--border);
+	border-radius: 2px;
+	background-color: var(--l2-background);
+
+	> span {
+		color: var(--foreground);
+	}
+
+	&__chevron {
+		flex-shrink: 0;
+		color: var(--foreground);
+	}
+}
+
+.sa-settings-filter-dropdown {
+	.ant-dropdown-menu {
+		padding: var(--padding-3) 14px;
+		border-radius: 4px;
+		border: 1px solid var(--border);
+		background: var(--l2-background);
+		backdrop-filter: blur(20px);
+	}
+
+	.ant-dropdown-menu-item {
+		background: transparent !important;
+		padding: var(--padding-1) 0 !important;
+
+		&:hover {
+			background: transparent !important;
+		}
+	}
+}
+
+.sa-settings-filter-option {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	font-size: var(--paragraph-base-400-font-size);
+	font-weight: var(--paragraph-base-400-font-weight);
+	color: var(--foreground);
+	letter-spacing: 0.14px;
+	min-width: 170px;
+
+	&:hover {
+		color: var(--card-foreground);
+		background: transparent;
+	}
+}
+
+.sa-settings-search-input {
+	height: 32px;
+	color: var(--l1-foreground);
+	background-color: var(--l2-background);
+	border-color: var(--border);
+
+	&::placeholder {
+		color: var(--l3-foreground);
+	}
+}
+
+.lightMode {
+	.sa-settings {
+		&__title {
+			color: var(--text-base-black);
+		}
+	}
+
+	.sa-settings-filter-option {
+		&:hover {
+			color: var(--bg-neutral-light-100);
+		}
+	}
+}

frontend/src/container/ServiceAccountsSettings/ServiceAccountsSettings.tsx

@@ -0,0 +1,306 @@
+import { useCallback, useEffect, useMemo } from 'react';
+import { useQueryClient } from 'react-query';
+import { Button } from '@signozhq/button';
+import { Check, ChevronDown, Plus } from '@signozhq/icons';
+import { Input } from '@signozhq/input';
+import type { MenuProps } from 'antd';
+import { Dropdown } from 'antd';
+import {
+	getGetServiceAccountQueryKey,
+	useListServiceAccounts,
+} from 'api/generated/services/serviceaccount';
+import type {
+	GetServiceAccount200,
+	ListServiceAccounts200,
+} from 'api/generated/services/sigNoz.schemas';
+import CreateServiceAccountModal from 'components/CreateServiceAccountModal/CreateServiceAccountModal';
+import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
+import ServiceAccountDrawer from 'components/ServiceAccountDrawer/ServiceAccountDrawer';
+import ServiceAccountsTable, {
+	PAGE_SIZE,
+} from 'components/ServiceAccountsTable/ServiceAccountsTable';
+import {
+	parseAsBoolean,
+	parseAsInteger,
+	parseAsString,
+	parseAsStringEnum,
+	useQueryState,
+} from 'nuqs';
+import { toAPIError } from 'utils/errorUtils';
+
+import {
+	FilterMode,
+	ServiceAccountRow,
+	ServiceAccountStatus,
+	toServiceAccountRow,
+} from './utils';
+
+import './ServiceAccountsSettings.styles.scss';
+
+function ServiceAccountsSettings(): JSX.Element {
+	const [currentPage, setPage] = useQueryState(
+		'page',
+		parseAsInteger.withDefault(1),
+	);
+	const [searchQuery, setSearchQuery] = useQueryState(
+		'search',
+		parseAsString.withDefault(''),
+	);
+	const [filterMode, setFilterMode] = useQueryState(
+		'filter',
+		parseAsStringEnum<FilterMode>(Object.values(FilterMode)).withDefault(
+			FilterMode.All,
+		),
+	);
+	const [, setSelectedAccountId] = useQueryState('account');
+	const [, setIsCreateModalOpen] = useQueryState(
+		'create-sa',
+		parseAsBoolean.withDefault(false),
+	);
+
+	const queryClient = useQueryClient();
+
+	const seedAccountCache = useCallback(
+		(data: ListServiceAccounts200) => {
+			data.data.forEach((account) => {
+				queryClient.setQueryData<GetServiceAccount200>(
+					getGetServiceAccountQueryKey({ id: account.id }),
+					(old) => old ?? { data: account, status: data.status },
+				);
+			});
+		},
+		[queryClient],
+	);
+
+	const {
+		data: serviceAccountsData,
+		isLoading,
+		isError,
+		error,
+		refetch: handleCreateSuccess,
+	} = useListServiceAccounts({
+		query: { onSuccess: seedAccountCache },
+	});
+
+	const allAccounts = useMemo(
+		(): ServiceAccountRow[] =>
+			(serviceAccountsData?.data ?? []).map(toServiceAccountRow),
+		[serviceAccountsData],
+	);
+
+	const activeCount = useMemo(
+		() =>
+			allAccounts.filter(
+				(a) => a.status?.toUpperCase() === ServiceAccountStatus.Active,
+			).length,
+		[allAccounts],
+	);
+
+	const disabledCount = useMemo(
+		() =>
+			allAccounts.filter(
+				(a) => a.status?.toUpperCase() !== ServiceAccountStatus.Active,
+			).length,
+		[allAccounts],
+	);
+
+	const filteredAccounts = useMemo((): ServiceAccountRow[] => {
+		let result = allAccounts;
+
+		if (filterMode === FilterMode.Active) {
+			result = result.filter(
+				(a) => a.status?.toUpperCase() === ServiceAccountStatus.Active,
+			);
+		} else if (filterMode === FilterMode.Disabled) {
+			result = result.filter(
+				(a) => a.status?.toUpperCase() !== ServiceAccountStatus.Active,
+			);
+		}
+
+		if (searchQuery.trim()) {
+			const q = searchQuery.trim().toLowerCase();
+			result = result.filter(
+				(a) =>
+					a.name?.toLowerCase().includes(q) ||
+					a.email?.toLowerCase().includes(q) ||
+					a.roles?.some((role: string) => role.toLowerCase().includes(q)),
+			);
+		}
+
+		return result;
+	}, [allAccounts, filterMode, searchQuery]);
+
+	useEffect(() => {
+		if (filteredAccounts.length === 0) {
+			return;
+		}
+
+		const maxPage = Math.max(1, Math.ceil(filteredAccounts.length / PAGE_SIZE));
+		if (currentPage > maxPage) {
+			setPage(maxPage);
+		} else if (currentPage < 1) {
+			setPage(1);
+		}
+	}, [filteredAccounts.length, currentPage, setPage]);
+
+	const totalCount = allAccounts.length;
+
+	const filterMenuItems: MenuProps['items'] = [
+		{
+			key: FilterMode.All,
+			label: (
+				<div className="sa-settings-filter-option">
+					<span>All accounts ⎯ {totalCount}</span>
+					{filterMode === FilterMode.All && <Check size={14} />}
+				</div>
+			),
+			onClick: (): void => {
+				setFilterMode(FilterMode.All);
+				setPage(1);
+			},
+		},
+		{
+			key: FilterMode.Active,
+			label: (
+				<div className="sa-settings-filter-option">
+					<span>Active ⎯ {activeCount}</span>
+					{filterMode === FilterMode.Active && <Check size={14} />}
+				</div>
+			),
+			onClick: (): void => {
+				setFilterMode(FilterMode.Active);
+				setPage(1);
+			},
+		},
+		{
+			key: FilterMode.Disabled,
+			label: (
+				<div className="sa-settings-filter-option">
+					<span>Disabled ⎯ {disabledCount}</span>
+					{filterMode === FilterMode.Disabled && <Check size={14} />}
+				</div>
+			),
+			onClick: (): void => {
+				setFilterMode(FilterMode.Disabled);
+				setPage(1);
+			},
+		},
+	];
+
+	function getFilterLabel(): string {
+		switch (filterMode) {
+			case FilterMode.Active:
+				return `Active ⎯ ${activeCount}`;
+			case FilterMode.Disabled:
+				return `Disabled ⎯ ${disabledCount}`;
+			default:
+				return `All accounts ⎯ ${totalCount}`;
+		}
+	}
+	const filterLabel = getFilterLabel();
+
+	const handleRowClick = useCallback(
+		(row: ServiceAccountRow): void => {
+			setSelectedAccountId(row.id);
+		},
+		[setSelectedAccountId],
+	);
+
+	const handleDrawerSuccess = useCallback(
+		(options?: { closeDrawer?: boolean }): void => {
+			if (options?.closeDrawer) {
+				setSelectedAccountId(null);
+			}
+			handleCreateSuccess();
+		},
+		[handleCreateSuccess, setSelectedAccountId],
+	);
+
+	return (
+		<>
+			<div className="sa-settings">
+				<div className="sa-settings__header">
+					<h1 className="sa-settings__title">Service Accounts</h1>
+					<p className="sa-settings__subtitle">
+						Overview of service accounts added to this workspace.{' '}
+						{/* Todo: to add doc links */}
+						{/* <a
+							href="https://signoz.io/docs/service-accounts"
+							target="_blank"
+							rel="noopener noreferrer"
+							className="sa-settings__learn-more"
+						>
+							Learn more
+						</a> */}
+					</p>
+				</div>
+
+				<div className="sa-settings__controls">
+					<Dropdown
+						menu={{ items: filterMenuItems }}
+						trigger={['click']}
+						overlayClassName="sa-settings-filter-dropdown"
+					>
+						<Button
+							variant="solid"
+							size="sm"
+							color="secondary"
+							className="sa-settings-filter-trigger"
+						>
+							<span>{filterLabel}</span>
+							<ChevronDown size={12} className="sa-settings-filter-trigger__chevron" />
+						</Button>
+					</Dropdown>
+
+					<div className="sa-settings__search">
+						<Input
+							type="search"
+							name="service-accounts-search"
+							placeholder="Search by name or email..."
+							value={searchQuery}
+							onChange={(e): void => {
+								setSearchQuery(e.target.value);
+								setPage(1);
+							}}
+							className="sa-settings-search-input"
+							color="secondary"
+						/>
+					</div>
+
+					<Button
+						variant="solid"
+						size="sm"
+						color="primary"
+						onClick={(): void => {
+							void setIsCreateModalOpen(true);
+						}}
+					>
+						<Plus size={12} />
+						New Service Account
+					</Button>
+				</div>
+			</div>
+
+			{isError ? (
+				<ErrorInPlace
+					error={toAPIError(
+						error,
+						'An unexpected error occurred while fetching service accounts.',
+					)}
+				/>
+			) : (
+				<ServiceAccountsTable
+					data={filteredAccounts}
+					loading={isLoading}
+					onRowClick={handleRowClick}
+				/>
+			)}
+
+			<CreateServiceAccountModal />
+
+			<ServiceAccountDrawer onSuccess={handleDrawerSuccess} />
+		</>
+	);
+}
+
+export default ServiceAccountsSettings;

frontend/src/container/ServiceAccountsSettings/__tests__/ServiceAccountsSettings.integration.test.tsx

@@ -0,0 +1,231 @@
+import type { ReactNode } from 'react';
+import { listRolesSuccessResponse } from 'mocks-server/__mockdata__/roles';
+import { rest, server } from 'mocks-server/server';
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
+import { render, screen, userEvent } from 'tests/test-utils';
+
+import ServiceAccountsSettings from '../ServiceAccountsSettings';
+
+const SA_LIST_ENDPOINT = '*/api/v1/service_accounts';
+const SA_ENDPOINT = '*/api/v1/service_accounts/:id';
+const SA_KEYS_ENDPOINT = '*/api/v1/service_accounts/:id/keys';
+const ROLES_ENDPOINT = '*/api/v1/roles';
+
+jest.mock('@signozhq/drawer', () => ({
+	DrawerWrapper: ({
+		content,
+		open,
+	}: {
+		content?: ReactNode;
+		open: boolean;
+	}): JSX.Element | null => (open ? <div>{content}</div> : null),
+}));
+
+const mockServiceAccountsAPI = [
+	{
+		id: 'sa-1',
+		name: 'CI Bot',
+		email: 'ci-bot@signoz.io',
+		roles: ['signoz-admin'],
+		status: 'ACTIVE',
+		createdAt: 1700000000,
+		updatedAt: 1700000001,
+	},
+	{
+		id: 'sa-2',
+		name: 'Monitoring Agent',
+		email: 'monitor@signoz.io',
+		roles: ['signoz-viewer'],
+		status: 'ACTIVE',
+		createdAt: 1700000002,
+		updatedAt: 1700000003,
+	},
+	{
+		id: 'sa-3',
+		name: 'Legacy Bot',
+		email: 'legacy@signoz.io',
+		roles: ['signoz-editor'],
+		status: 'DISABLED',
+		createdAt: 1700000004,
+		updatedAt: 1700000005,
+	},
+];
+
+describe('ServiceAccountsSettings (integration)', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		server.use(
+			rest.get(SA_LIST_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: mockServiceAccountsAPI })),
+			),
+			rest.get(SA_ENDPOINT, (req, res, ctx) => {
+				const { id } = req.params as { id: string };
+				const account = mockServiceAccountsAPI.find((a) => a.id === id);
+				return account
+					? res(ctx.status(200), ctx.json({ data: account }))
+					: res(ctx.status(404), ctx.json({ message: 'Not found' }));
+			}),
+			rest.get(SA_KEYS_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ data: [] })),
+			),
+			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('loads and displays all accounts with correct ACTIVE and DISABLED badges', async () => {
+		render(
+			<NuqsTestingAdapter>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await screen.findByText('CI Bot');
+		expect(screen.getByText('Monitoring Agent')).toBeInTheDocument();
+		expect(screen.getByText('legacy@signoz.io')).toBeInTheDocument();
+		expect(screen.getAllByText('ACTIVE')).toHaveLength(2);
+		expect(screen.getByText('DISABLED')).toBeInTheDocument();
+	});
+
+	it('filter dropdown to "Active" hides DISABLED accounts', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(
+			<NuqsTestingAdapter>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await screen.findByText('CI Bot');
+
+		await user.click(screen.getByRole('button', { name: /All accounts/i }));
+
+		const activeOption = await screen.findByText(/Active ⎯/i);
+		await user.click(activeOption);
+
+		await screen.findByText('CI Bot');
+		expect(screen.queryByText('Legacy Bot')).not.toBeInTheDocument();
+	});
+
+	it('search by name filters accounts in real-time', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(
+			<NuqsTestingAdapter>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await screen.findByText('CI Bot');
+
+		await user.type(
+			screen.getByPlaceholderText(/Search by name or email/i),
+			'legacy',
+		);
+
+		await screen.findByText('Legacy Bot');
+		expect(screen.queryByText('CI Bot')).not.toBeInTheDocument();
+		expect(screen.queryByText('Monitoring Agent')).not.toBeInTheDocument();
+	});
+
+	it('clicking a row opens the drawer with account details visible', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(
+			<NuqsTestingAdapter hasMemory>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await user.click(
+			await screen.findByRole('button', {
+				name: /View service account CI Bot/i,
+			}),
+		);
+
+		expect(
+			await screen.findByRole('button', { name: /Disable Service Account/i }),
+		).toBeInTheDocument();
+	});
+
+	it('saving changes in the drawer refetches the list', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const listRefetchSpy = jest.fn();
+
+		server.use(
+			rest.get(SA_LIST_ENDPOINT, (_, res, ctx) => {
+				listRefetchSpy();
+				return res(ctx.status(200), ctx.json({ data: mockServiceAccountsAPI }));
+			}),
+			rest.put(SA_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json({ status: 'success', data: {} })),
+			),
+		);
+
+		render(
+			<NuqsTestingAdapter hasMemory>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await screen.findByText('CI Bot');
+		listRefetchSpy.mockClear();
+
+		await user.click(
+			await screen.findByRole('button', { name: /View service account CI Bot/i }),
+		);
+
+		const nameInput = await screen.findByDisplayValue('CI Bot');
+		await user.clear(nameInput);
+		await user.type(nameInput, 'CI Bot Updated');
+
+		await user.click(screen.getByRole('button', { name: /Save Changes/i }));
+
+		await screen.findByDisplayValue('CI Bot Updated');
+		expect(listRefetchSpy).toHaveBeenCalled();
+	});
+
+	it('"New Service Account" button opens the Create Service Account modal', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(
+			<NuqsTestingAdapter>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		await screen.findByText('CI Bot');
+
+		await user.click(
+			screen.getByRole('button', { name: /New Service Account/i }),
+		);
+
+		await screen.findByRole('dialog', { name: /New Service Account/i });
+		expect(screen.getByPlaceholderText('Enter a name')).toBeInTheDocument();
+	});
+
+	it('shows error state when API fails', async () => {
+		server.use(
+			rest.get(SA_LIST_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(500), ctx.json({ message: 'Internal Server Error' })),
+			),
+		);
+
+		render(
+			<NuqsTestingAdapter>
+				<ServiceAccountsSettings />
+			</NuqsTestingAdapter>,
+		);
+
+		expect(
+			await screen.findByText(
+				/An unexpected error occurred while fetching service accounts/i,
+			),
+		).toBeInTheDocument();
+	});
+});

frontend/src/container/ServiceAccountsSettings/config.ts

@@ -0,0 +1 @@
+export const IS_SERVICE_ACCOUNTS_ENABLED = false;

frontend/src/container/ServiceAccountsSettings/utils.ts

@@ -0,0 +1,37 @@
+import type { ServiceaccounttypesServiceAccountDTO } from 'api/generated/services/sigNoz.schemas';
+import { toISOString } from 'utils/app';
+
+export function toServiceAccountRow(
+	sa: ServiceaccounttypesServiceAccountDTO,
+): ServiceAccountRow {
+	return {
+		id: sa.id,
+		name: sa.name,
+		email: sa.email,
+		roles: sa.roles,
+		status: sa.status,
+		createdAt: toISOString(sa.createdAt),
+		updatedAt: toISOString(sa.updatedAt),
+	};
+}
+
+export enum FilterMode {
+	All = 'all',
+	Active = 'active',
+	Disabled = 'disabled',
+}
+
+export enum ServiceAccountStatus {
+	Active = 'ACTIVE',
+	Disabled = 'DISABLED',
+}
+
+export interface ServiceAccountRow {
+	id: string;
+	name: string;
+	email: string;
+	roles: string[];
+	status: string;
+	createdAt: string | null;
+	updatedAt: string | null;
+}

frontend/src/container/SideNav/menuItems.tsx

@@ -8,6 +8,7 @@ import {
 	BellDot,
 	Binoculars,
 	Book,
+	Bot,
 	Boxes,
 	BugIcon,
 	Building2,
@@ -358,6 +359,13 @@ export const settingsNavSections: SettingsNavSection[] = [
 				isEnabled: false,
 				itemKey: 'members',
 			},
+			{
+				key: ROUTES.SERVICE_ACCOUNTS_SETTINGS,
+				label: 'Service Accounts',
+				icon: <Bot size={16} />,
+				isEnabled: false,
+				itemKey: 'service-accounts',
+			},
 			{
 				key: ROUTES.API_KEYS,
 				label: 'API Keys',

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

@@ -154,6 +154,7 @@ export const routesToSkip = [
 	ROUTES.ALL_DASHBOARD,
 	ROUTES.ORG_SETTINGS,
 	ROUTES.MEMBERS_SETTINGS,
+	ROUTES.SERVICE_ACCOUNTS_SETTINGS,
 	ROUTES.INGESTION_SETTINGS,
 	ROUTES.API_KEYS,
 	ROUTES.ERROR_DETAIL,

frontend/src/lib/uPlotV2/components/UPlotChart.tsx

@@ -7,7 +7,6 @@ import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFall
 import uPlot, { AlignedData, Options } from 'uplot';
 
 import { usePlotContext } from '../context/PlotContext';
-import { applySpanGapsToAlignedData } from '../utils/dataUtils';
 import { UPlotChartProps } from './types';
 
 /**
@@ -85,13 +84,7 @@ export default function UPlotChart({
 		} as Options;
 
 		// Create new plot instance
-		const seriesSpanGaps = config.getSeriesSpanGapsOptions();
-		const preparedData =
-			seriesSpanGaps.length > 0
-				? applySpanGapsToAlignedData(data, seriesSpanGaps)
-				: (data as AlignedData);
-
-		const plot = new uPlot(plotConfig, preparedData, containerRef.current);
+		const plot = new uPlot(plotConfig, data as AlignedData, containerRef.current);
 
 		if (plotRef) {
 			plotRef(plot);
@@ -169,13 +162,7 @@ export default function UPlotChart({
 		}
 		// Update data if only data changed
 		else if (!sameData(prevProps, currentProps) && plotInstanceRef.current) {
-			const seriesSpanGaps = config.getSeriesSpanGapsOptions?.() ?? [];
-			const preparedData =
-				seriesSpanGaps.length > 0
-					? applySpanGapsToAlignedData(data as AlignedData, seriesSpanGaps)
-					: (data as AlignedData);
-
-			plotInstanceRef.current.setData(preparedData as AlignedData);
+			plotInstanceRef.current.setData(data as AlignedData);
 		}
 
 		prevPropsRef.current = currentProps;

frontend/src/lib/uPlotV2/components/__tests__/UPlotChart.test.tsx

@@ -86,7 +86,6 @@ const createMockConfig = (): UPlotConfigBuilder => {
 		}),
 		getId: jest.fn().mockReturnValue(undefined),
 		getShouldSaveSelectionPreference: jest.fn().mockReturnValue(false),
-		getSeriesSpanGapsOptions: jest.fn().mockReturnValue([]),
 	} as unknown) as UPlotConfigBuilder;
 };
 
@@ -329,78 +328,6 @@ describe('UPlotChart', () => {
 		});
 	});
 
-	describe('spanGaps data transformation', () => {
-		it('inserts null break points before passing data to uPlot when a gap exceeds the numeric threshold', () => {
-			const config = createMockConfig();
-			// gap 0→100 = 100 > threshold 50 → null inserted at midpoint x=50
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-			const data: AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-
-			render(<UPlotChart config={config} data={data} width={600} height={400} />, {
-				wrapper: Wrapper,
-			});
-
-			const [, receivedData] = mockUPlotConstructor.mock.calls[0];
-			expect(receivedData[0]).toEqual([0, 50, 100]);
-			expect(receivedData[1]).toEqual([1, null, 2]);
-		});
-
-		it('passes data through unchanged when no gap exceeds the numeric threshold', () => {
-			const config = createMockConfig();
-			// all gaps = 10, threshold = 50 → no insertions, same reference returned
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-			const data: AlignedData = [
-				[0, 10, 20],
-				[1, 2, 3],
-			];
-
-			render(<UPlotChart config={config} data={data} width={600} height={400} />, {
-				wrapper: Wrapper,
-			});
-
-			const [, receivedData] = mockUPlotConstructor.mock.calls[0];
-			expect(receivedData).toBe(data);
-		});
-
-		it('transforms data passed to setData when data updates and a new gap exceeds the threshold', () => {
-			const config = createMockConfig();
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-
-			// initial render: gap 10 < 50, no transformation
-			const initialData: AlignedData = [
-				[0, 10],
-				[1, 2],
-			];
-			// updated data: gap 100 > 50 → null inserted at midpoint x=50
-			const newData: AlignedData = [
-				[0, 100],
-				[3, 4],
-			];
-
-			const { rerender } = render(
-				<UPlotChart config={config} data={initialData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			rerender(
-				<UPlotChart config={config} data={newData} width={600} height={400} />,
-			);
-
-			const receivedData = instances[0].setData.mock.calls[0][0];
-			expect(receivedData[0]).toEqual([0, 50, 100]);
-			expect(receivedData[1]).toEqual([3, null, 4]);
-		});
-	});
-
 	describe('prop updates', () => {
 		it('calls setData without recreating the plot when only data changes', () => {
 			const config = createMockConfig();

frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts

@@ -14,7 +14,6 @@ import {
 	STEP_INTERVAL_MULTIPLIER,
 } from '../constants';
 import { calculateWidthBasedOnStepInterval } from '../utils';
-import { SeriesSpanGapsOption } from '../utils/dataUtils';
 import {
 	ConfigBuilder,
 	ConfigBuilderProps,
@@ -162,13 +161,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 		this.series.push(new UPlotSeriesBuilder(props));
 	}
 
-	getSeriesSpanGapsOptions(): SeriesSpanGapsOption[] {
-		return this.series.map((s) => {
-			const { spanGaps } = s.props;
-			return { spanGaps };
-		});
-	}
-
 	/**
 	 * Add a hook for extensibility
 	 */

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -4,7 +4,6 @@ import { calculateWidthBasedOnStepInterval } from 'lib/uPlotV2/utils';
 import uPlot, { Series } from 'uplot';
 
 import { generateGradientFill } from '../utils/generateGradientFill';
-import { isolatedPointFilter } from '../utils/seriesPointsFilter';
 import {
 	BarAlignment,
 	ConfigBuilder,
@@ -147,8 +146,20 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 	}: {
 		resolvedLineColor: string;
 	}): Partial<Series.Points> {
-		const { lineWidth, pointSize, pointsFilter } = this.props;
+		const {
+			lineWidth,
+			pointSize,
+			pointsBuilder,
+			pointsFilter,
+			drawStyle,
+			showPoints,
+		} = this.props;
 
+		/**
+		 * If pointSize is not provided, use the lineWidth * POINT_SIZE_FACTOR
+		 * to determine the point size.
+		 * POINT_SIZE_FACTOR is 2, so the point size will be 2x the line width.
+		 */
 		const resolvedPointSize =
 			pointSize ?? (lineWidth ?? DEFAULT_LINE_WIDTH) * POINT_SIZE_FACTOR;
 
@@ -157,44 +168,19 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 			fill: resolvedLineColor,
 			size: resolvedPointSize,
 			filter: pointsFilter || undefined,
-			show: this.resolvePointsShow(),
 		};
 
-		// When spanGaps is in threshold (numeric) mode, points hidden by default
-		// become invisible when isolated by injected gap-nulls (no line connects
-		// to them). Use a gap-based filter to show only those isolated points as
-		// dots. Do NOT set show=true here — the filter is called with show=false
-		// and returns specific indices to render; setting show=true would cause
-		// uPlot to call filter with show=true which short-circuits the logic and
-		// renders all points.
-		if (this.shouldApplyIsolatedPointFilter(pointsConfig.show)) {
-			pointsConfig.filter = isolatedPointFilter;
+		if (pointsBuilder) {
+			pointsConfig.show = pointsBuilder;
+		} else if (drawStyle === DrawStyle.Points) {
+			pointsConfig.show = true;
+		} else {
+			pointsConfig.show = !!showPoints;
 		}
 
 		return pointsConfig;
 	}
 
-	private resolvePointsShow(): Series.Points['show'] {
-		const { pointsBuilder, drawStyle, showPoints } = this.props;
-		if (pointsBuilder) {
-			return pointsBuilder;
-		}
-		if (drawStyle === DrawStyle.Points) {
-			return true;
-		}
-		return !!showPoints;
-	}
-
-	private shouldApplyIsolatedPointFilter(show: Series.Points['show']): boolean {
-		const { drawStyle, spanGaps, pointsFilter } = this.props;
-		return (
-			drawStyle === DrawStyle.Line &&
-			typeof spanGaps === 'number' &&
-			!pointsFilter &&
-			!show
-		);
-	}
-
 	private getLineColor(): string {
 		const { colorMapping, label, lineColor, isDarkMode } = this.props;
 		if (!label) {
@@ -226,12 +212,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 		return {
 			scale: scaleKey,
 			label,
-			// When spanGaps is numeric, we always disable uPlot's internal
-			// spanGaps behavior and rely on data-prep to implement the
-			// threshold-based null handling. When spanGaps is boolean we
-			// map it directly. When spanGaps is undefined we fall back to
-			// the default of false.
-			spanGaps: typeof spanGaps === 'number' ? false : !!spanGaps,
+			spanGaps: typeof spanGaps === 'boolean' ? spanGaps : false,
 			value: (): string => '',
 			pxAlign: true,
 			show,

frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts

@@ -1,7 +1,6 @@
 import { themeColors } from 'constants/theme';
 import uPlot from 'uplot';
 
-import { isolatedPointFilter } from '../../utils/seriesPointsFilter';
 import type { SeriesProps } from '../types';
 import { DrawStyle, LineInterpolation, LineStyle } from '../types';
 import { POINT_SIZE_FACTOR, UPlotSeriesBuilder } from '../UPlotSeriesBuilder';
@@ -41,37 +40,6 @@ describe('UPlotSeriesBuilder', () => {
 		expect(typeof config.value).toBe('function');
 	});
 
-	it('maps boolean spanGaps directly to uPlot spanGaps', () => {
-		const trueBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: true,
-			}),
-		);
-		const falseBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: false,
-			}),
-		);
-
-		const trueConfig = trueBuilder.getConfig();
-		const falseConfig = falseBuilder.getConfig();
-
-		expect(trueConfig.spanGaps).toBe(true);
-		expect(falseConfig.spanGaps).toBe(false);
-	});
-
-	it('disables uPlot spanGaps when spanGaps is a number', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: 10000,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.spanGaps).toBe(false);
-	});
-
 	it('uses explicit lineColor when provided, regardless of mapping', () => {
 		const builder = new UPlotSeriesBuilder(
 			createBaseProps({
@@ -316,50 +284,4 @@ describe('UPlotSeriesBuilder', () => {
 
 		expect(config.points?.filter).toBe(pointsFilter);
 	});
-
-	it('assigns isolatedPointFilter and does not force show=true when spanGaps is numeric and no custom filter', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				showPoints: false,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBe(isolatedPointFilter);
-		expect(config.points?.show).toBe(false);
-	});
-
-	it('does not assign isolatedPointFilter when a custom pointsFilter is provided alongside numeric spanGaps', () => {
-		const customFilter: uPlot.Series.Points.Filter = jest.fn(() => null);
-
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				pointsFilter: customFilter,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBe(customFilter);
-	});
-
-	it('does not assign isolatedPointFilter when showPoints is true even with numeric spanGaps', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				showPoints: true,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBeUndefined();
-		expect(config.points?.show).toBe(true);
-	});
 });

frontend/src/lib/uPlotV2/config/types.ts

@@ -99,11 +99,6 @@ export interface ScaleProps {
 	distribution?: DistributionType;
 }
 
-export enum DisconnectedValuesMode {
-	Never = 'never',
-	Threshold = 'threshold',
-}
-
 /**
  * Props for configuring a series
  */
@@ -180,16 +175,7 @@ export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
 	pointsFilter?: Series.Points.Filter;
 	pointsBuilder?: Series.Points.Show;
 	show?: boolean;
-	/**
-	 * Controls how nulls are treated for this series.
-	 *
-	 * - boolean: mapped directly to uPlot's spanGaps behavior
-	 * - number: interpreted as an X-axis threshold (same unit as ref values),
-	 *           where gaps smaller than this threshold are spanned by
-	 *           converting short null runs to undefined during data prep
-	 *           while uPlot's internal spanGaps is kept disabled.
-	 */
-	spanGaps?: boolean | number;
+	spanGaps?: boolean;
 	fillColor?: string;
 	fillMode?: FillMode;
 	isDarkMode?: boolean;

frontend/src/lib/uPlotV2/utils/__tests__/dataUtils.test.ts

@@ -1,12 +1,4 @@
-import uPlot from 'uplot';
-
-import {
-	applySpanGapsToAlignedData,
-	insertLargeGapNullsIntoAlignedData,
-	isInvalidPlotValue,
-	normalizePlotValue,
-	SeriesSpanGapsOption,
-} from '../dataUtils';
+import { isInvalidPlotValue, normalizePlotValue } from '../dataUtils';
 
 describe('dataUtils', () => {
 	describe('isInvalidPlotValue', () => {
@@ -67,217 +59,4 @@ describe('dataUtils', () => {
 			expect(normalizePlotValue(42.5)).toBe(42.5);
 		});
 	});
-
-	describe('insertLargeGapNullsIntoAlignedData', () => {
-		it('returns original data unchanged when no gap exceeds the threshold', () => {
-			// all gaps = 10, threshold = 25 → no insertions
-			const data: uPlot.AlignedData = [
-				[0, 10, 20, 30],
-				[1, 2, 3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 25 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('does not insert when the gap equals the threshold exactly', () => {
-			// gap = 50, threshold = 50 → condition is gap > threshold, not >=
-			const data: uPlot.AlignedData = [
-				[0, 50],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('inserts a null at the midpoint when a single gap exceeds the threshold', () => {
-			// gap 0→100 = 100 > 50 → insert null at x=50
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100]);
-			expect(result[1]).toEqual([1, null, 2]);
-		});
-
-		it('inserts nulls at every gap that exceeds the threshold', () => {
-			// gaps: 0→100=100, 100→110=10, 110→210=100; threshold=50
-			// → insert at 0→100 and 110→210
-			const data: uPlot.AlignedData = [
-				[0, 100, 110, 210],
-				[1, 2, 3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110, 160, 210]);
-			expect(result[1]).toEqual([1, null, 2, 3, null, 4]);
-		});
-
-		it('inserts null for all series at a gap triggered by any one series', () => {
-			// series 0: threshold=50, gap=100 → triggers insertion
-			// series 1: threshold=200, gap=100 → would not trigger alone
-			// result: both series get null at the inserted x because the x-axis is shared
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-				[3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [
-				{ spanGaps: 50 },
-				{ spanGaps: 200 },
-			];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100]);
-			expect(result[1]).toEqual([1, null, 2]);
-			expect(result[2]).toEqual([3, null, 4]);
-		});
-
-		it('ignores boolean spanGaps options (only numeric values trigger insertion)', () => {
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: true }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('returns original data when series options array is empty', () => {
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, []);
-
-			expect(result).toBe(data);
-		});
-
-		it('returns original data when there is only one x point', () => {
-			const data: uPlot.AlignedData = [[0], [1]];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 10 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('preserves existing null values in the series alongside inserted ones', () => {
-			// original series already has a null; gap 0→100 also triggers insertion
-			const data: uPlot.AlignedData = [
-				[0, 100, 110],
-				[1, null, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110]);
-			expect(result[1]).toEqual([1, null, null, 2]);
-		});
-	});
-
-	describe('applySpanGapsToAlignedData', () => {
-		const xs: uPlot.AlignedData[0] = [0, 10, 20, 30];
-
-		it('returns original data when there are no series', () => {
-			const data: uPlot.AlignedData = [xs];
-			const result = applySpanGapsToAlignedData(data, []);
-
-			expect(result).toBe(data);
-		});
-
-		it('leaves data unchanged when spanGaps is undefined', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{}];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual(ys);
-		});
-
-		it('converts nulls to undefined when spanGaps is true', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: true }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual([1, undefined, 2, undefined]);
-		});
-
-		it('leaves data unchanged when spanGaps is false', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: false }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual(ys);
-		});
-
-		it('inserts a null break point when a gap exceeds the numeric threshold', () => {
-			// gap 0→100 = 100 > 50 → null inserted at midpoint x=50
-			const data: uPlot.AlignedData = [
-				[0, 100, 110],
-				[1, 2, 3],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110]);
-			expect(result[1]).toEqual([1, null, 2, 3]);
-		});
-
-		it('returns original data when no gap exceeds the numeric threshold', () => {
-			// all gaps = 10, threshold = 25 → no insertions
-			const data: uPlot.AlignedData = [xs, [1, 2, 3, 4]];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 25 }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('applies both numeric gap insertion and boolean null-to-undefined in one pass', () => {
-			// series 0: spanGaps: 50 → gap 0→100 triggers a null break at midpoint x=50
-			// series 1: spanGaps: true → the inserted null at x=50 becomes undefined,
-			//   so the line spans over it rather than breaking
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-				[3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [
-				{ spanGaps: 50 },
-				{ spanGaps: true },
-			];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			// x-axis extended with the inserted midpoint
-			expect(result[0]).toEqual([0, 50, 100]);
-			// series 0: null at midpoint breaks the line
-			expect(result[1]).toEqual([1, null, 2]);
-			// series 1: null at midpoint converted to undefined → line spans over it
-			expect(result[2]).toEqual([3, undefined, 4]);
-		});
-	});
 });

frontend/src/lib/uPlotV2/utils/__tests__/seriesPointsFilter.test.ts

@@ -1,251 +0,0 @@
-import type uPlot from 'uplot';
-
-import {
-	findNearestNonNull,
-	findSandwichedIndices,
-	isolatedPointFilter,
-} from '../seriesPointsFilter';
-
-// ---------------------------------------------------------------------------
-// Minimal uPlot stub — only the surface used by seriesPointsFilter
-// ---------------------------------------------------------------------------
-
-function makeUPlot({
-	xData,
-	yData,
-	idxs,
-	valToPosFn,
-	posToIdxFn,
-}: {
-	xData: number[];
-	yData: (number | null | undefined)[];
-	idxs?: [number, number];
-	valToPosFn?: (val: number) => number;
-	posToIdxFn?: (pos: number) => number;
-}): uPlot {
-	return ({
-		data: [xData, yData],
-		series: [{}, { idxs: idxs ?? [0, yData.length - 1] }],
-		valToPos: jest.fn((val: number) => (valToPosFn ? valToPosFn(val) : val)),
-		posToIdx: jest.fn((pos: number) =>
-			posToIdxFn ? posToIdxFn(pos) : Math.round(pos),
-		),
-	} as unknown) as uPlot;
-}
-
-// ---------------------------------------------------------------------------
-// findNearestNonNull
-// ---------------------------------------------------------------------------
-
-describe('findNearestNonNull', () => {
-	it('returns the right neighbor when left side is null', () => {
-		const yData = [null, null, 42, null];
-		expect(findNearestNonNull(yData, 1)).toBe(2);
-	});
-
-	it('returns the left neighbor when right side is null', () => {
-		const yData = [null, 42, null, null];
-		expect(findNearestNonNull(yData, 2)).toBe(1);
-	});
-
-	it('prefers the right neighbor over the left when both exist at the same distance', () => {
-		const yData = [10, null, 20];
-		// j=1: right (idx 3) is out of bounds (undefined == null), left (idx 1) is null
-		// Actually right (idx 2) exists at j=1
-		expect(findNearestNonNull(yData, 1)).toBe(2);
-	});
-
-	it('returns approxIdx unchanged when no non-null value is found within 100 steps', () => {
-		const yData: (number | null)[] = Array(5).fill(null);
-		expect(findNearestNonNull(yData, 2)).toBe(2);
-	});
-
-	it('handles undefined values the same as null', () => {
-		const yData: (number | null | undefined)[] = [undefined, undefined, 99];
-		expect(findNearestNonNull(yData, 0)).toBe(2);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// findSandwichedIndices
-// ---------------------------------------------------------------------------
-
-describe('findSandwichedIndices', () => {
-	it('returns empty array when no consecutive gaps share a pixel boundary', () => {
-		const gaps = [
-			[0, 10],
-			[20, 30],
-		];
-		const yData = [1, null, null, 2];
-		const u = makeUPlot({ xData: [0, 1, 2, 3], yData });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([]);
-	});
-
-	it('returns the index between two gaps that share a pixel boundary', () => {
-		// gaps[0] ends at 10, gaps[1] starts at 10 → sandwiched point at pixel 10
-		const gaps = [
-			[0, 10],
-			[10, 20],
-		];
-		// posToIdx(10) → 2
-		const yData = [null, null, 5, null, null];
-		const u = makeUPlot({ xData: [0, 1, 2, 3, 4], yData, posToIdxFn: () => 2 });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([2]);
-	});
-
-	it('scans to nearest non-null when posToIdx lands on a null', () => {
-		// posToIdx returns 2 which is null; nearest non-null is index 3
-		const gaps = [
-			[0, 10],
-			[10, 20],
-		];
-		const yData = [null, null, null, 7, null];
-		const u = makeUPlot({ xData: [0, 1, 2, 3, 4], yData, posToIdxFn: () => 2 });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([3]);
-	});
-
-	it('returns multiple indices when several gap pairs share boundaries', () => {
-		// Three consecutive gaps: [0,10], [10,20], [20,30]
-		// → two sandwiched points: between gaps 0-1 at px 10, between gaps 1-2 at px 20
-		const gaps = [
-			[0, 10],
-			[10, 20],
-			[20, 30],
-		];
-		const yData = [null, 1, null, 2, null];
-		const u = makeUPlot({
-			xData: [0, 1, 2, 3, 4],
-			yData,
-			posToIdxFn: (pos) => (pos === 10 ? 1 : 3),
-		});
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([1, 3]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// isolatedPointFilter
-// ---------------------------------------------------------------------------
-
-describe('isolatedPointFilter', () => {
-	it('returns null when show is true (normal point rendering active)', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, true, [[0, 10]])).toBeNull();
-	});
-
-	it('returns null when gaps is null', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, false, null)).toBeNull();
-	});
-
-	it('returns null when gaps is empty', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, false, [])).toBeNull();
-	});
-
-	it('returns null when series idxs is undefined', () => {
-		const u = ({
-			data: [
-				[0, 1],
-				[1, null],
-			],
-			series: [{}, { idxs: undefined }],
-			valToPos: jest.fn(() => 0),
-			posToIdx: jest.fn(() => 0),
-		} as unknown) as uPlot;
-		expect(isolatedPointFilter(u, 1, false, [[0, 10]])).toBeNull();
-	});
-
-	it('includes firstIdx when the first gap starts at the first data point pixel', () => {
-		// xData[firstIdx=0] → valToPos → 5; gaps[0][0] === 5 → isolated leading point
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [10, null, null, null, 20];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 5 : 40), // firstPos=5, lastPos=40
-		});
-		// gaps[0][0] === 5 (firstPos), gaps last end !== 40
-		const result = isolatedPointFilter(u, 1, false, [
-			[5, 15],
-			[20, 30],
-		]);
-		expect(result).toContain(0); // firstIdx
-	});
-
-	it('includes lastIdx when the last gap ends at the last data point pixel', () => {
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [10, null, null, null, 20];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 5 : 40), // firstPos=5, lastPos=40
-		});
-		// gaps last end === 40 (lastPos), gaps[0][0] !== 5
-		const result = isolatedPointFilter(u, 1, false, [
-			[10, 20],
-			[30, 40],
-		]);
-		expect(result).toContain(4); // lastIdx
-	});
-
-	it('includes sandwiched index between two gaps sharing a pixel boundary', () => {
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [null, null, 5, null, null];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: () => 99, // firstPos/lastPos won't match gap boundaries
-			posToIdxFn: () => 2,
-		});
-		const result = isolatedPointFilter(u, 1, false, [
-			[0, 50],
-			[50, 100],
-		]);
-		expect(result).toContain(2);
-	});
-
-	it('returns null when no isolated points are found', () => {
-		const xData = [0, 1, 2];
-		const yData = [1, 2, 3];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 2],
-			// firstPos = 10, lastPos = 30 — neither matches any gap boundary
-			valToPosFn: (val) => (val === 0 ? 10 : 30),
-		});
-		// gaps don't share boundaries and don't touch firstPos/lastPos
-		const result = isolatedPointFilter(u, 1, false, [
-			[0, 5],
-			[15, 20],
-		]);
-		expect(result).toBeNull();
-	});
-
-	it('returns all three kinds of isolated points in one pass', () => {
-		// Leading (firstPos=0 === gaps[0][0]), sandwiched (gaps[1] and gaps[2] share 50),
-		// trailing (lastPos=100 === gaps last end)
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [1, null, 2, null, 3];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 0 : 100),
-			posToIdxFn: () => 2, // sandwiched point at idx 2
-		});
-		const gaps = [
-			[0, 20],
-			[40, 50],
-			[50, 80],
-			[90, 100],
-		];
-		const result = isolatedPointFilter(u, 1, false, gaps);
-		expect(result).toContain(0); // leading
-		expect(result).toContain(2); // sandwiched
-		expect(result).toContain(4); // trailing
-	});
-});

frontend/src/lib/uPlotV2/utils/dataUtils.ts

@@ -51,163 +51,3 @@ export function normalizePlotValue(
 	// Already a valid number
 	return value as number;
 }
-
-export interface SeriesSpanGapsOption {
-	spanGaps?: boolean | number;
-}
-
-// Internal type alias: a series value array that may contain nulls/undefineds.
-// uPlot uses null to draw a visible gap and undefined to represent "no sample"
-// (the line continues across undefined points but breaks at null ones).
-type SeriesArray = Array<number | null | undefined>;
-
-/**
- * Returns true if the given gap size exceeds the numeric spanGaps threshold
- * of at least one series. Used to decide whether to insert a null break point.
- */
-function gapExceedsThreshold(
-	gapSize: number,
-	seriesOptions: SeriesSpanGapsOption[],
-): boolean {
-	return seriesOptions.some(
-		({ spanGaps }) =>
-			typeof spanGaps === 'number' && spanGaps > 0 && gapSize > spanGaps,
-	);
-}
-
-/**
- * For each series with a numeric spanGaps threshold, insert a null data point
- * between consecutive x timestamps whose gap exceeds the threshold.
- *
- * Why: uPlot draws a continuous line between all non-null points. When the
- * time gap between two consecutive samples is larger than the configured
- * spanGaps value, we inject a synthetic null at the midpoint so uPlot renders
- * a visible break instead of a misleading straight line across the gap.
- *
- * Because uPlot's AlignedData shares a single x-axis across all series, a null
- * is inserted for every series at each position where any series needs a break.
- *
- * Two-pass approach for performance:
- *   Pass 1 — count how many nulls will be inserted (no allocations).
- *   Pass 2 — fill pre-allocated output arrays by index (no push/reallocation).
- */
-export function insertLargeGapNullsIntoAlignedData(
-	data: uPlot.AlignedData,
-	seriesOptions: SeriesSpanGapsOption[],
-): uPlot.AlignedData {
-	const [xValues, ...seriesValues] = data;
-
-	if (
-		!Array.isArray(xValues) ||
-		xValues.length < 2 ||
-		seriesValues.length === 0
-	) {
-		return data;
-	}
-
-	const xs = xValues as number[];
-	const n = xs.length;
-
-	// Pass 1: count insertions needed so we know the exact output length.
-	// This lets us pre-allocate arrays rather than growing them dynamically.
-	let insertionCount = 0;
-	for (let i = 0; i < n - 1; i += 1) {
-		if (gapExceedsThreshold(xs[i + 1] - xs[i], seriesOptions)) {
-			insertionCount += 1;
-		}
-	}
-
-	// No gaps exceed any threshold — return the original data unchanged.
-	if (insertionCount === 0) {
-		return data;
-	}
-
-	// Pass 2: build output arrays of exact size and fill them.
-	// `out` is the write cursor into the output arrays.
-	const outputLen = n + insertionCount;
-	const newX = new Array<number>(outputLen);
-	const newSeries: SeriesArray[] = seriesValues.map(
-		() => new Array<number | null | undefined>(outputLen),
-	);
-
-	let out = 0;
-	for (let i = 0; i < n; i += 1) {
-		// Copy the real data point at position i
-		newX[out] = xs[i];
-		for (let s = 0; s < seriesValues.length; s += 1) {
-			newSeries[s][out] = (seriesValues[s] as SeriesArray)[i];
-		}
-		out += 1;
-
-		// If the gap to the next x timestamp exceeds the threshold, insert a
-		// synthetic null at the midpoint. The midpoint x is placed halfway
-		// between xs[i] and xs[i+1] (minimum 1 unit past xs[i] to stay unique).
-		if (i < n - 1 && gapExceedsThreshold(xs[i + 1] - xs[i], seriesOptions)) {
-			newX[out] = xs[i] + Math.max(1, Math.floor((xs[i + 1] - xs[i]) / 2));
-			for (let s = 0; s < seriesValues.length; s += 1) {
-				newSeries[s][out] = null; // null tells uPlot to break the line here
-			}
-			out += 1;
-		}
-	}
-
-	return [newX, ...newSeries] as uPlot.AlignedData;
-}
-
-/**
- * Apply per-series spanGaps (boolean | number) handling to an aligned dataset.
- *
- * spanGaps controls how uPlot handles gaps in a series:
- *   - boolean true  → convert null → undefined so uPlot spans over every gap
- *                     (draws a continuous line, skipping missing samples)
- *   - boolean false → no change; nulls render as visible breaks (default)
- *   - number        → insert a null break point between any two consecutive
- *                     timestamps whose difference exceeds the threshold;
- *                     gaps smaller than the threshold are left as-is
- *
- * The input data is expected to be of the form:
- * [xValues, series1Values, series2Values, ...]
- */
-export function applySpanGapsToAlignedData(
-	data: uPlot.AlignedData,
-	seriesOptions: SeriesSpanGapsOption[],
-): uPlot.AlignedData {
-	const [xValues, ...seriesValues] = data;
-
-	if (!Array.isArray(xValues) || seriesValues.length === 0) {
-		return data;
-	}
-
-	// Numeric spanGaps: operates on the whole dataset at once because inserting
-	// null break points requires modifying the shared x-axis.
-	const hasNumericSpanGaps = seriesOptions.some(
-		({ spanGaps }) => typeof spanGaps === 'number',
-	);
-	const gapProcessed = hasNumericSpanGaps
-		? insertLargeGapNullsIntoAlignedData(data, seriesOptions)
-		: data;
-
-	// Boolean spanGaps === true: convert null → undefined per series so uPlot
-	// draws a continuous line across missing samples instead of breaking it.
-	// Skip this pass entirely if no series uses spanGaps: true.
-	const hasBooleanTrue = seriesOptions.some(({ spanGaps }) => spanGaps === true);
-	if (!hasBooleanTrue) {
-		return gapProcessed;
-	}
-
-	const [newX, ...newSeries] = gapProcessed;
-	const transformedSeries = newSeries.map((ys, idx) => {
-		const { spanGaps } = seriesOptions[idx] ?? {};
-		if (spanGaps !== true) {
-			// This series doesn't use spanGaps: true — leave it unchanged.
-			return ys;
-		}
-		// Replace null with undefined: uPlot skips undefined points without
-		// breaking the line, effectively spanning over the gap.
-		return (ys as SeriesArray).map((v) =>
-			v === null ? undefined : v,
-		) as uPlot.AlignedData[0];
-	});
-
-	return [newX, ...transformedSeries] as uPlot.AlignedData;
-}

frontend/src/lib/uPlotV2/utils/seriesPointsFilter.ts

@@ -1,90 +0,0 @@
-import uPlot from 'uplot';
-
-/**
- * Scans outward from approxIdx to find the nearest non-null data index.
- * posToIdx can land on a null when pixel density exceeds 1 point-per-pixel.
- */
-export function findNearestNonNull(
-	yData: (number | null | undefined)[],
-	approxIdx: number,
-): number {
-	for (let j = 1; j < 100; j++) {
-		if (yData[approxIdx + j] != null) {
-			return approxIdx + j;
-		}
-		if (yData[approxIdx - j] != null) {
-			return approxIdx - j;
-		}
-	}
-	return approxIdx;
-}
-
-/**
- * Returns data indices of points sandwiched between two consecutive gaps that
- * share a pixel boundary — meaning a point (or cluster) is isolated between them.
- */
-export function findSandwichedIndices(
-	gaps: number[][],
-	yData: (number | null | undefined)[],
-	u: uPlot,
-): number[] {
-	const indices: number[] = [];
-	for (let i = 0; i < gaps.length; i++) {
-		const nextGap = gaps[i + 1];
-		if (nextGap && gaps[i][1] === nextGap[0]) {
-			const approxIdx = u.posToIdx(gaps[i][1], true);
-			indices.push(
-				yData[approxIdx] == null ? findNearestNonNull(yData, approxIdx) : approxIdx,
-			);
-		}
-	}
-	return indices;
-}
-
-/**
- * Points filter that shows data points isolated by gap-nulls (no connecting line).
- * Used when spanGaps threshold mode injects nulls around gaps — without this,
- * lone points become invisible because no line connects to them.
- *
- * Uses uPlot's gap pixel array rather than checking raw null neighbors in the
- * data array. Returns an array of data indices (not a bitmask); null = no points.
- *
- */
-// eslint-disable-next-line max-params
-export function isolatedPointFilter(
-	u: uPlot,
-	seriesIdx: number,
-	show: boolean,
-	gaps?: null | number[][],
-): number[] | null {
-	if (show || !gaps || gaps.length === 0) {
-		return null;
-	}
-
-	const idxs = u.series[seriesIdx].idxs;
-	if (!idxs) {
-		return null;
-	}
-
-	const [firstIdx, lastIdx] = idxs;
-	const xData = u.data[0] as number[];
-	const yData = u.data[seriesIdx] as (number | null | undefined)[];
-
-	// valToPos with canvas=true matches the pixel space used by the gaps array.
-	const firstPos = Math.round(u.valToPos(xData[firstIdx], 'x', true));
-	const lastPos = Math.round(u.valToPos(xData[lastIdx], 'x', true));
-
-	const filtered: number[] = [];
-
-	if (gaps[0][0] === firstPos) {
-		filtered.push(firstIdx);
-	}
-
-	filtered.push(...findSandwichedIndices(gaps, yData, u));
-
-	if (gaps[gaps.length - 1][1] === lastPos) {
-		filtered.push(lastIdx);
-	}
-
-	return filtered.length ? filtered : null;
-}

frontend/src/pages/ServiceAccountsSettings/index.tsx

@@ -0,0 +1 @@
+export { default } from 'container/ServiceAccountsSettings/ServiceAccountsSettings';

frontend/src/pages/Settings/Settings.tsx

@@ -5,6 +5,7 @@ import logEvent from 'api/common/logEvent';
 import RouteTab from 'components/RouteTab';
 import { FeatureKeys } from 'constants/features';
 import ROUTES from 'constants/routes';
+import { IS_SERVICE_ACCOUNTS_ENABLED } from 'container/ServiceAccountsSettings/config';
 import { routeConfig } from 'container/SideNav/config';
 import { getQueryString } from 'container/SideNav/helper';
 import { settingsNavSections } from 'container/SideNav/menuItems';
@@ -85,6 +86,8 @@ function SettingsPage(): JSX.Element {
 							item.key === ROUTES.INGESTION_SETTINGS ||
 							item.key === ROUTES.ORG_SETTINGS ||
 							item.key === ROUTES.MEMBERS_SETTINGS ||
+							(IS_SERVICE_ACCOUNTS_ENABLED &&
+								item.key === ROUTES.SERVICE_ACCOUNTS_SETTINGS) ||
 							item.key === ROUTES.SHORTCUTS
 								? true
 								: item.isEnabled,
@@ -116,6 +119,8 @@ function SettingsPage(): JSX.Element {
 							item.key === ROUTES.API_KEYS ||
 							item.key === ROUTES.ORG_SETTINGS ||
 							item.key === ROUTES.MEMBERS_SETTINGS ||
+							(IS_SERVICE_ACCOUNTS_ENABLED &&
+								item.key === ROUTES.SERVICE_ACCOUNTS_SETTINGS) ||
 							item.key === ROUTES.INGESTION_SETTINGS
 								? true
 								: item.isEnabled,
@@ -141,7 +146,9 @@ function SettingsPage(): JSX.Element {
 						isEnabled:
 							item.key === ROUTES.API_KEYS ||
 							item.key === ROUTES.ORG_SETTINGS ||
-							item.key === ROUTES.MEMBERS_SETTINGS
+							item.key === ROUTES.MEMBERS_SETTINGS ||
+							(IS_SERVICE_ACCOUNTS_ENABLED &&
+								item.key === ROUTES.SERVICE_ACCOUNTS_SETTINGS)
 								? true
 								: item.isEnabled,
 					}));

frontend/src/pages/Settings/config.tsx

@@ -17,6 +17,7 @@ import { TFunction } from 'i18next';
 import {
 	Backpack,
 	BellDot,
+	Bot,
 	Building,
 	Cpu,
 	CreditCard,
@@ -30,6 +31,7 @@ import {
 } from 'lucide-react';
 import ChannelsEdit from 'pages/ChannelsEdit';
 import MembersSettings from 'pages/MembersSettings';
+import ServiceAccountsSettings from 'pages/ServiceAccountsSettings';
 import Shortcuts from 'pages/Shortcuts';
 
 export const organizationSettings = (t: TFunction): RouteTabProps['routes'] => [
@@ -203,6 +205,21 @@ export const mySettings = (t: TFunction): RouteTabProps['routes'] => [
 	},
 ];
 
+export const serviceAccountsSettings = (
+	t: TFunction,
+): RouteTabProps['routes'] => [
+	{
+		Component: ServiceAccountsSettings,
+		name: (
+			<div className="periscope-tab">
+				<Bot size={16} /> {t('routes:service_accounts').toString()}
+			</div>
+		),
+		route: ROUTES.SERVICE_ACCOUNTS_SETTINGS,
+		key: ROUTES.SERVICE_ACCOUNTS_SETTINGS,
+	},
+];
+
 export const createAlertChannels = (t: TFunction): RouteTabProps['routes'] => [
 	{
 		Component: (): JSX.Element => (

frontend/src/pages/Settings/utils.ts

@@ -1,4 +1,5 @@
 import { RouteTabProps } from 'components/RouteTab/types';
+import { IS_SERVICE_ACCOUNTS_ENABLED } from 'container/ServiceAccountsSettings/config';
 import { TFunction } from 'i18next';
 import { ROLES, USER_ROLES } from 'types/roles';
 
@@ -17,6 +18,7 @@ import {
 	organizationSettings,
 	roleDetails,
 	rolesSettings,
+	serviceAccountsSettings,
 } from './config';
 
 export const getRoutes = (
@@ -63,6 +65,10 @@ export const getRoutes = (
 
 	if (isAdmin) {
 		settings.push(...apiKeys(t), ...membersSettings(t));
+
+		if (IS_SERVICE_ACCOUNTS_ENABLED) {
+			settings.push(...serviceAccountsSettings(t));
+		}
 	}
 
 	// todo: Sagar - check the condition for role list and details page, to whom we want to serve

frontend/src/types/api/dashboard/getAll.ts

@@ -141,7 +141,6 @@ export interface IBaseWidget {
 	showPoints?: boolean;
 	lineStyle?: LineStyle;
 	fillMode?: FillMode;
-	spanGaps?: boolean | number;
 }
 export interface Widgets extends IBaseWidget {
 	query: Query;

frontend/src/utils/app.ts

@@ -1,6 +1,7 @@
 import getLocalStorage from 'api/browser/localstorage/get';
 import { FeatureKeys } from 'constants/features';
 import { SKIP_ONBOARDING } from 'constants/onboarding';
+import dayjs from 'dayjs';
 import { get } from 'lodash-es';
 import { getLocation } from 'utils/getLocation';
 
@@ -73,3 +74,19 @@ export function buildAbsolutePath({
 }
 
 export const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export function toISOString(
+	date: Date | string | number | null | undefined,
+): string | null {
+	if (date == null) {
+		return null;
+	}
+
+	const d = dayjs(date);
+
+	if (!d.isValid()) {
+		return null;
+	}
+
+	return d.toISOString();
+}

frontend/src/utils/permission/index.ts

@@ -100,6 +100,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	ROLES_SETTINGS: ['ADMIN'],
 	ROLE_DETAILS: ['ADMIN'],
 	MEMBERS_SETTINGS: ['ADMIN'],
+	SERVICE_ACCOUNTS_SETTINGS: ['ADMIN'],
 	BILLING: ['ADMIN'],
 	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SOMETHING_WENT_WRONG: ['ADMIN', 'EDITOR', 'VIEWER'],

frontend/yarn.lock

@@ -4506,19 +4506,6 @@
     "@radix-ui/react-use-callback-ref" "1.1.1"
     "@radix-ui/react-use-escape-keydown" "1.1.1"
 
-"@radix-ui/react-dropdown-menu@^2.1.16":
-  version "2.1.16"
-  resolved "https://registry.yarnpkg.com/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.16.tgz#5ee045c62bad8122347981c479d92b1ff24c7254"
-  integrity sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==
-  dependencies:
-    "@radix-ui/primitive" "1.1.3"
-    "@radix-ui/react-compose-refs" "1.1.2"
-    "@radix-ui/react-context" "1.1.2"
-    "@radix-ui/react-id" "1.1.1"
-    "@radix-ui/react-menu" "2.1.16"
-    "@radix-ui/react-primitive" "2.1.3"
-    "@radix-ui/react-use-controllable-state" "1.2.2"
-
 "@radix-ui/react-focus-guards@1.0.0":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@radix-ui/react-focus-guards/-/react-focus-guards-1.0.0.tgz#339c1c69c41628c1a5e655f15f7020bf11aa01fa"
@@ -4578,30 +4565,6 @@
   dependencies:
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
-"@radix-ui/react-menu@2.1.16":
-  version "2.1.16"
-  resolved "https://registry.yarnpkg.com/@radix-ui/react-menu/-/react-menu-2.1.16.tgz#528a5a973c3a7413d3d49eb9ccd229aa52402911"
-  integrity sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==
-  dependencies:
-    "@radix-ui/primitive" "1.1.3"
-    "@radix-ui/react-collection" "1.1.7"
-    "@radix-ui/react-compose-refs" "1.1.2"
-    "@radix-ui/react-context" "1.1.2"
-    "@radix-ui/react-direction" "1.1.1"
-    "@radix-ui/react-dismissable-layer" "1.1.11"
-    "@radix-ui/react-focus-guards" "1.1.3"
-    "@radix-ui/react-focus-scope" "1.1.7"
-    "@radix-ui/react-id" "1.1.1"
-    "@radix-ui/react-popper" "1.2.8"
-    "@radix-ui/react-portal" "1.1.9"
-    "@radix-ui/react-presence" "1.1.5"
-    "@radix-ui/react-primitive" "2.1.3"
-    "@radix-ui/react-roving-focus" "1.1.11"
-    "@radix-ui/react-slot" "1.2.3"
-    "@radix-ui/react-use-callback-ref" "1.1.1"
-    aria-hidden "^1.2.4"
-    react-remove-scroll "^2.6.3"
-
 "@radix-ui/react-popover@^1.1.15", "@radix-ui/react-popover@^1.1.2":
   version "1.1.15"
   resolved "https://registry.yarnpkg.com/@radix-ui/react-popover/-/react-popover-1.1.15.tgz#9c852f93990a687ebdc949b2c3de1f37cdc4c5d5"
@@ -4841,20 +4804,6 @@
     "@radix-ui/react-roving-focus" "1.0.4"
     "@radix-ui/react-use-controllable-state" "1.0.1"
 
-"@radix-ui/react-tabs@^1.1.3":
-  version "1.1.13"
-  resolved "https://registry.yarnpkg.com/@radix-ui/react-tabs/-/react-tabs-1.1.13.tgz#3537ce379d7e7ff4eeb6b67a0973e139c2ac1f15"
-  integrity sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A==
-  dependencies:
-    "@radix-ui/primitive" "1.1.3"
-    "@radix-ui/react-context" "1.1.2"
-    "@radix-ui/react-direction" "1.1.1"
-    "@radix-ui/react-id" "1.1.1"
-    "@radix-ui/react-presence" "1.1.5"
-    "@radix-ui/react-primitive" "2.1.3"
-    "@radix-ui/react-roving-focus" "1.1.11"
-    "@radix-ui/react-use-controllable-state" "1.2.2"
-
 "@radix-ui/react-toggle-group@^1.1.7":
   version "1.1.11"
   resolved "https://registry.yarnpkg.com/@radix-ui/react-toggle-group/-/react-toggle-group-1.1.11.tgz#e513d6ffdb07509b400ab5b26f2523747c0d51c1"
@@ -5726,42 +5675,6 @@
     tailwind-merge "^2.5.2"
     tailwindcss-animate "^1.0.7"
 
-"@signozhq/ui@0.0.4":
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/@signozhq/ui/-/ui-0.0.4.tgz#2a9c403900311298d881ca9feb6245d94ca0aa0e"
-  integrity sha512-ViiLsAciCzUgHCu3uDCOEMmjE6OkLpA2g8xvjjbbzi4XFosYBhEASx1Pf3a4f5wlh/JID7z12DOc5YnjzEcn4Q==
-  dependencies:
-    "@radix-ui/react-checkbox" "^1.2.3"
-    "@radix-ui/react-dialog" "^1.1.11"
-    "@radix-ui/react-dropdown-menu" "^2.1.16"
-    "@radix-ui/react-icons" "^1.3.0"
-    "@radix-ui/react-popover" "^1.1.15"
-    "@radix-ui/react-radio-group" "^1.3.4"
-    "@radix-ui/react-slot" "^1.2.3"
-    "@radix-ui/react-switch" "^1.1.4"
-    "@radix-ui/react-tabs" "^1.1.3"
-    "@radix-ui/react-toggle" "^1.1.6"
-    "@radix-ui/react-toggle-group" "^1.1.7"
-    "@radix-ui/react-tooltip" "^1.2.6"
-    "@tanstack/react-table" "^8.21.3"
-    "@tanstack/react-virtual" "^3.13.9"
-    "@types/lodash-es" "^4.17.12"
-    class-variance-authority "^0.7.0"
-    clsx "^2.1.1"
-    cmdk "^1.1.1"
-    date-fns "^4.1.0"
-    dayjs "^1.11.10"
-    lodash-es "^4.17.21"
-    lucide-react "^0.445.0"
-    lucide-solid "^0.510.0"
-    motion "^11.11.17"
-    next-themes "^0.4.6"
-    nuqs "^2.8.9"
-    react-day-picker "^9.8.1"
-    react-resizable-panels "^4.7.1"
-    sonner "^2.0.7"
-    tailwind-merge "^3.5.0"
-
 "@sinclair/typebox@^0.25.16":
   version "0.25.24"
   resolved "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.25.24.tgz"
@@ -9660,11 +9573,6 @@ dayjs@^1.10.7, dayjs@^1.11.1:
   resolved "https://registry.npmjs.org/dayjs/-/dayjs-1.11.7.tgz"
   integrity sha512-+Yw9U6YO5TQohxLcIkrXBeY73WP3ejHWVvx8XCk3gxvQDCTEmS48ZrSZCKciI7Bhl/uCMyxYtE9UqRILmFphkQ==
 
-dayjs@^1.11.10:
-  version "1.11.20"
-  resolved "https://registry.yarnpkg.com/dayjs/-/dayjs-1.11.20.tgz#88d919fd639dc991415da5f4cb6f1b6650811938"
-  integrity sha512-YbwwqR/uYpeoP4pu043q+LTDLFBLApUP6VxRihdfNTqu4ubqMlGDLd6ErXhEgsyvY0K6nCs7nggYumAN+9uEuQ==
-
 debounce@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/debounce/-/debounce-1.2.1.tgz#38881d8f4166a5c5848020c11827b834bcb3e0a5"
@@ -11184,15 +11092,6 @@ fraction.js@^4.3.7:
   resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.3.7.tgz#06ca0085157e42fda7f9e726e79fefc4068840f7"
   integrity sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==
 
-framer-motion@^11.18.2:
-  version "11.18.2"
-  resolved "https://registry.yarnpkg.com/framer-motion/-/framer-motion-11.18.2.tgz#0c6bd05677f4cfd3b3bdead4eb5ecdd5ed245718"
-  integrity sha512-5F5Och7wrvtLVElIpclDT0CBzMVg3dL22B64aZwHtsIY8RB4mXICLrkajK4G9R+ieSAGcgrLeae2SeUTg2pr6w==
-  dependencies:
-    motion-dom "^11.18.1"
-    motion-utils "^11.18.1"
-    tslib "^2.4.0"
-
 framer-motion@^12.4.13:
   version "12.4.13"
   resolved "https://registry.yarnpkg.com/framer-motion/-/framer-motion-12.4.13.tgz#1efd954f95e6a54685b660929c00f5a61e35256a"
@@ -15103,13 +15002,6 @@ moment@^2.29.4:
   resolved "https://registry.yarnpkg.com/moment/-/moment-2.29.4.tgz#3dbe052889fe7c1b2ed966fcb3a77328964ef108"
   integrity sha512-5LC9SOxjSc2HF6vO2CyuTDNivEdoz2IvyJJGj6X8DJ0eFyfszE0QiEd+iXmBvUP3WHxSjFH/vIsA0EN00cgr8w==
 
-motion-dom@^11.18.1:
-  version "11.18.1"
-  resolved "https://registry.yarnpkg.com/motion-dom/-/motion-dom-11.18.1.tgz#e7fed7b7dc6ae1223ef1cce29ee54bec826dc3f2"
-  integrity sha512-g76KvA001z+atjfxczdRtw/RXOM3OMSdd1f4DL77qCTF/+avrRJiawSG4yDibEQ215sr9kpinSlX2pCTJ9zbhw==
-  dependencies:
-    motion-utils "^11.18.1"
-
 motion-dom@^12.4.11:
   version "12.4.11"
   resolved "https://registry.yarnpkg.com/motion-dom/-/motion-dom-12.4.11.tgz#0419c8686cda4d523f08249deeb8fa6683a9b9d3"
@@ -15117,11 +15009,6 @@ motion-dom@^12.4.11:
   dependencies:
     motion-utils "^12.4.10"
 
-motion-utils@^11.18.1:
-  version "11.18.1"
-  resolved "https://registry.yarnpkg.com/motion-utils/-/motion-utils-11.18.1.tgz#671227669833e991c55813cf337899f41327db5b"
-  integrity sha512-49Kt+HKjtbJKLtgO/LKj9Ld+6vw9BjH5d9sc40R/kVyH8GLAXgT42M2NnuPcJNuA3s9ZfZBUcwIgpmZWGEE+hA==
-
 motion-utils@^12.4.10:
   version "12.4.10"
   resolved "https://registry.yarnpkg.com/motion-utils/-/motion-utils-12.4.10.tgz#3d93acea5454419eaaad8d5e5425cb71cbfa1e7f"
@@ -15135,14 +15022,6 @@ motion@12.4.13:
     framer-motion "^12.4.13"
     tslib "^2.4.0"
 
-motion@^11.11.17:
-  version "11.18.2"
-  resolved "https://registry.yarnpkg.com/motion/-/motion-11.18.2.tgz#17fb372f3ed94fc9ee1384a25a9068e9da1951e7"
-  integrity sha512-JLjvFDuFr42NFtcVoMAyC2sEjnpA8xpy6qWPyzQvCloznAyQ8FIXioxWfHiLtgYhoVpfUqSWpn1h9++skj9+Wg==
-  dependencies:
-    framer-motion "^11.18.2"
-    tslib "^2.4.0"
-
 mri@^1.1.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/mri/-/mri-1.2.0.tgz#6721480fec2a11a4889861115a48b6cbe7cc8f0b"
@@ -15413,13 +15292,6 @@ nuqs@2.8.8:
   dependencies:
     "@standard-schema/spec" "1.0.0"
 
-nuqs@^2.8.9:
-  version "2.8.9"
-  resolved "https://registry.yarnpkg.com/nuqs/-/nuqs-2.8.9.tgz#e2c27d87c0dd0e3b4412fe867bcd0947cc4c998f"
-  integrity sha512-8ou6AEwsxMWSYo2qkfZtYFVzngwbKmg4c00HVxC1fF6CEJv3Fwm6eoZmfVPALB+vw8Udo7KL5uy96PFcYe1BIQ==
-  dependencies:
-    "@standard-schema/spec" "1.0.0"
-
 nwsapi@^2.2.2:
   version "2.2.23"
   resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.23.tgz#59712c3a88e6de2bb0b6ccc1070397267019cf6c"
@@ -16952,6 +16824,11 @@ react-helmet-async@*, react-helmet-async@1.3.0:
     react-fast-compare "^3.2.0"
     shallowequal "^1.1.0"
 
+react-hook-form@7.71.2:
+  version "7.71.2"
+  resolved "https://registry.yarnpkg.com/react-hook-form/-/react-hook-form-7.71.2.tgz#a5f1d2b855be9ecf1af6e74df9b80f54beae7e35"
+  integrity sha512-1CHvcDYzuRUNOflt4MOq3ZM46AronNJtQ1S7tnX6YN4y72qhgiUItpacZUAQ0TyWYci3yz1X+rXaSxiuEm86PA==
+
 react-hooks-testing-library@0.6.0:
   version "0.6.0"
   resolved "https://registry.npmjs.org/react-hooks-testing-library/-/react-hooks-testing-library-0.6.0.tgz"
@@ -17085,11 +16962,6 @@ react-resizable-panels@^3.0.5:
   resolved "https://registry.yarnpkg.com/react-resizable-panels/-/react-resizable-panels-3.0.5.tgz#50a20645263eed02344de4a70d1319bbc0014bbd"
   integrity sha512-3z1yN25DMTXLg2wfyFrW32r5k4WEcUa3F7cJ2EgtNK07lnOs4mpM8yWLGunCpkhcQRwJX4fqoLcIh/pHPxzlmQ==
 
-react-resizable-panels@^4.7.1:
-  version "4.7.3"
-  resolved "https://registry.yarnpkg.com/react-resizable-panels/-/react-resizable-panels-4.7.3.tgz#4040aa0f5c5c4cc4bb685cb69973601ccda3b014"
-  integrity sha512-PYcYMLtvJD+Pr0TQNeMvddcnLOwUa/Yb4iNwU7ThNLlHaQYEEC9MIBWHaBGODzYuXIkPRZ/OWe5sbzG1Rzq5ew==
-
 react-resizable@3.0.4:
   version "3.0.4"
   resolved "https://registry.npmjs.org/react-resizable/-/react-resizable-3.0.4.tgz"
@@ -18930,11 +18802,6 @@ tailwind-merge@^2.5.2:
   resolved "https://registry.yarnpkg.com/tailwind-merge/-/tailwind-merge-2.6.0.tgz#ac5fb7e227910c038d458f396b7400d93a3142d5"
   integrity sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA==
 
-tailwind-merge@^3.5.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/tailwind-merge/-/tailwind-merge-3.5.0.tgz#06502f4496ba15151445d97d916a26564d50d1ca"
-  integrity sha512-I8K9wewnVDkL1NTGoqWmVEIlUcB9gFriAEkXkfCjX5ib8ezGxtR3xD7iZIxrfArjEsH7F1CHD4RFUtxefdqV/A==
-
 tailwindcss-animate@^1.0.7:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz#318b692c4c42676cc9e67b19b78775742388bef4"