feat: algo change

.github/CODEOWNERS

@@ -169,22 +169,3 @@ go.mod @therealpandey
 ## Dashboard V2
 /frontend/src/pages/DashboardPageV2/ @SigNoz/pulse-frontend
 /frontend/src/pages/DashboardsListPageV2/ @SigNoz/pulse-frontend
-
-## Infrastructure Monitoring
-/frontend/src/pages/InfrastructureMonitoring/ @SigNoz/pulse-frontend
-/frontend/src/container/InfraMonitoringHosts/ @SigNoz/pulse-frontend
-/frontend/src/container/InfraMonitoringK8s/ @SigNoz/pulse-frontend
-
-## Alerts
-/frontend/src/pages/AlertList/ @SigNoz/pulse-frontend
-/frontend/src/pages/AlertDetails/ @SigNoz/pulse-frontend
-/frontend/src/pages/CreateAlert/ @SigNoz/pulse-frontend
-/frontend/src/pages/EditRules/ @SigNoz/pulse-frontend
-/frontend/src/container/AlertHistory/ @SigNoz/pulse-frontend
-/frontend/src/container/CreateAlertRule/ @SigNoz/pulse-frontend
-/frontend/src/container/CreateAlertV2/ @SigNoz/pulse-frontend
-/frontend/src/container/EditAlertV2/ @SigNoz/pulse-frontend
-/frontend/src/container/FormAlertRules/ @SigNoz/pulse-frontend
-/frontend/src/container/ListAlertRules/ @SigNoz/pulse-frontend
-/frontend/src/container/TriggeredAlerts/ @SigNoz/pulse-frontend
-/frontend/src/container/AnomalyAlertEvaluationView/ @SigNoz/pulse-frontend

docs/api/openapi.yml

@@ -870,6 +870,14 @@ components:
       - timestampMillis
       - data
       type: object
+    CloudintegrationtypesAssets:
+      properties:
+        dashboards:
+          items:
+            $ref: '#/components/schemas/CloudintegrationtypesDashboard'
+          nullable: true
+          type: array
+      type: object
     CloudintegrationtypesAzureAccountConfig:
       properties:
         deploymentRegion:
@@ -1017,6 +1025,17 @@ components:
       - ingestionUrl
       - ingestionKey
       type: object
+    CloudintegrationtypesDashboard:
+      properties:
+        definition:
+          $ref: '#/components/schemas/DashboardtypesStorableDashboardData'
+        description:
+          type: string
+        id:
+          type: string
+        title:
+          type: string
+      type: object
     CloudintegrationtypesDataCollected:
       properties:
         logs:
@@ -1190,7 +1209,7 @@ components:
     CloudintegrationtypesService:
       properties:
         assets:
-          $ref: '#/components/schemas/CloudintegrationtypesServiceAssets'
+          $ref: '#/components/schemas/CloudintegrationtypesAssets'
         cloudIntegrationService:
           $ref: '#/components/schemas/CloudintegrationtypesCloudIntegrationService'
         dataCollected:
@@ -1203,6 +1222,8 @@ components:
           type: string
         supportedSignals:
           $ref: '#/components/schemas/CloudintegrationtypesSupportedSignals'
+        telemetryCollectionStrategy:
+          $ref: '#/components/schemas/CloudintegrationtypesTelemetryCollectionStrategy'
         title:
           type: string
       required:
@@ -1213,17 +1234,9 @@ components:
       - assets
       - supportedSignals
       - dataCollected
+      - telemetryCollectionStrategy
       - cloudIntegrationService
       type: object
-    CloudintegrationtypesServiceAssets:
-      properties:
-        dashboards:
-          items:
-            $ref: '#/components/schemas/CloudintegrationtypesServiceDashboard'
-          type: array
-      required:
-      - dashboards
-      type: object
     CloudintegrationtypesServiceConfig:
       properties:
         aws:
@@ -1231,18 +1244,6 @@ components:
         azure:
           $ref: '#/components/schemas/CloudintegrationtypesAzureServiceConfig'
       type: object
-    CloudintegrationtypesServiceDashboard:
-      properties:
-        description:
-          type: string
-        integrationDashboard:
-          $ref: '#/components/schemas/CloudintegrationtypesStorableIntegrationDashboard'
-        title:
-          type: string
-      required:
-      - title
-      - description
-      type: object
     CloudintegrationtypesServiceID:
       enum:
       - alb
@@ -1277,30 +1278,6 @@ components:
       - icon
       - enabled
       type: object
-    CloudintegrationtypesStorableIntegrationDashboard:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        dashboardId:
-          type: string
-        id:
-          type: string
-        provider:
-          type: string
-        slug:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-      required:
-      - id
-      - dashboardId
-      - provider
-      - slug
-      - createdAt
-      - updatedAt
-      type: object
     CloudintegrationtypesSupportedSignals:
       properties:
         logs:
@@ -1308,6 +1285,13 @@ components:
         metrics:
           type: boolean
       type: object
+    CloudintegrationtypesTelemetryCollectionStrategy:
+      properties:
+        aws:
+          $ref: '#/components/schemas/CloudintegrationtypesAWSTelemetryCollectionStrategy'
+        azure:
+          $ref: '#/components/schemas/CloudintegrationtypesAzureTelemetryCollectionStrategy'
+      type: object
     CloudintegrationtypesUpdatableAccount:
       properties:
         config:

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -355,32 +355,26 @@ func (module *module) GetService(ctx context.Context, orgID valuer.UUID, service
 
 	var integrationService *cloudintegrationtypes.CloudIntegrationService
 
-	if cloudIntegrationID.IsZero() {
-		return cloudintegrationtypes.NewService(provider, serviceDefinition, nil, nil), nil
+	if !cloudIntegrationID.IsZero() {
+		storedService, err := module.store.GetServiceByServiceID(ctx, cloudIntegrationID, serviceID)
+		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+			return nil, err
+		}
+		if storedService != nil {
+			serviceConfig, err := cloudintegrationtypes.NewServiceConfigFromJSON(provider, storedService.Config)
+			if err != nil {
+				return nil, err
+			}
+
+			integrationService = cloudintegrationtypes.NewCloudIntegrationServiceFromStorable(storedService, serviceConfig)
+		}
+
+		if err := module.enrichDashboardIDs(ctx, orgID, provider, serviceID, serviceDefinition); err != nil {
+			return nil, err
+		}
 	}
 
-	storedService, err := module.store.GetServiceByServiceID(ctx, cloudIntegrationID, serviceID)
-	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		return nil, err
-	}
-	if storedService == nil {
-		return cloudintegrationtypes.NewService(provider, serviceDefinition, nil, nil), nil
-	}
-
-	serviceConfig, err := cloudintegrationtypes.NewServiceConfigFromJSON(provider, storedService.Config)
-	if err != nil {
-		return nil, err
-	}
-
-	integrationService = cloudintegrationtypes.NewCloudIntegrationServiceFromStorable(storedService, serviceConfig)
-
-	slugPrefix := cloudintegrationtypes.CloudIntegrationDashboardSlugPrefix(provider, serviceID)
-	integrationDashboards, err := module.store.ListIntegrationDashboardsBySlugPrefix(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slugPrefix)
-	if err != nil {
-		return nil, err
-	}
-
-	return cloudintegrationtypes.NewService(provider, serviceDefinition, integrationService, integrationDashboards), nil
+	return cloudintegrationtypes.NewService(*serviceDefinition, integrationService), nil
 }
 
 func (module *module) CreateService(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, service *cloudintegrationtypes.CloudIntegrationService, provider cloudintegrationtypes.CloudProviderType) error {
@@ -589,3 +583,20 @@ func (module *module) deprovisionDashboards(ctx context.Context, orgID valuer.UU
 	}
 	return nil
 }
+
+// enrichDashboardIDs replaces the raw dashboard name in each Dashboard.ID with the provisioned UUID.
+// TODO: remove this hack and send idiomatic response to client.
+func (module *module) enrichDashboardIDs(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, serviceID cloudintegrationtypes.ServiceID, serviceDefinition *cloudintegrationtypes.ServiceDefinition) error {
+	for i, d := range serviceDefinition.Assets.Dashboards {
+		slug := cloudintegrationtypes.CloudIntegrationDashboardSlug(provider, serviceID, d.ID)
+		row, err := module.store.GetIntegrationDashboardBySlug(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slug)
+		if err != nil {
+			if errors.Ast(err, errors.TypeNotFound) {
+				continue
+			}
+			return err
+		}
+		serviceDefinition.Assets.Dashboards[i].ID = row.DashboardID
+	}
+	return nil
+}

frontend/src/api/index.ts

@@ -120,8 +120,7 @@ export const interceptorRejected = async (
 				!(
 					response.config.url === '/sessions' && response.config.method === 'delete'
 				) &&
-				response.config.url !== '/authz/check' &&
-				response.config.url !== '/api/v2/reset_password_tokens/verify'
+				response.config.url !== '/authz/check'
 			) {
 				try {
 					const accessToken = getLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN);

frontend/src/assets/Icons/solid-x-circle.svg

@@ -0,0 +1 @@
+<svg width="14" height="14" fill="none" xmlns="http://www.w3.org/2000/svg"><g clip-path="url(#prefix__clip0_4062_7291)" stroke-width="1.167" stroke-linecap="round" stroke-linejoin="round"><path d="M7 12.833A5.833 5.833 0 107 1.167a5.833 5.833 0 000 11.666z" fill="#E5484D" stroke="#E5484D"/><path d="M8.75 5.25l-3.5 3.5M5.25 5.25l3.5 3.5" stroke="#121317"/></g><defs><clipPath id="prefix__clip0_4062_7291"><path fill="#fff" d="M0 0h14v14H0z"/></clipPath></defs></svg>

frontend/src/container/CreateAlertV2/Footer/Footer.tsx

@@ -196,11 +196,7 @@ function Footer(): JSX.Element {
 			</Button>
 		);
 		if (alertValidationMessage) {
-			button = (
-				<Tooltip title={alertValidationMessage}>
-					<span>{button}</span>
-				</Tooltip>
-			);
+			button = <Tooltip title={alertValidationMessage}>{button}</Tooltip>;
 		}
 		return button;
 	}, [
@@ -228,11 +224,7 @@ function Footer(): JSX.Element {
 			</Button>
 		);
 		if (alertValidationMessage) {
-			button = (
-				<Tooltip title={alertValidationMessage}>
-					<span>{button}</span>
-				</Tooltip>
-			);
+			button = <Tooltip title={alertValidationMessage}>{button}</Tooltip>;
 		}
 		return button;
 	}, [

frontend/src/container/LogsExplorerViews/LogsActionsContainer.tsx

@@ -9,6 +9,8 @@ import { useOptionsMenu } from 'container/OptionsMenu';
 import { ArrowUp10, Minus } from '@signozhq/icons';
 import { DataSource, StringOperators } from 'types/common/queryBuilder';
 
+import QueryStatus from './QueryStatus';
+
 function LogsActionsContainer({
 	listQuery,
 	selectedPanelType,
@@ -16,6 +18,10 @@ function LogsActionsContainer({
 	handleToggleFrequencyChart,
 	orderBy,
 	setOrderBy,
+	isFetching,
+	isLoading,
+	isError,
+	isSuccess,
 }: {
 	listQuery: any;
 	selectedPanelType: PANEL_TYPES;
@@ -23,6 +29,10 @@ function LogsActionsContainer({
 	handleToggleFrequencyChart: () => void;
 	orderBy: string;
 	setOrderBy: (value: string) => void;
+	isFetching: boolean;
+	isLoading: boolean;
+	isError: boolean;
+	isSuccess: boolean;
 }): JSX.Element {
 	const { options, config } = useOptionsMenu({
 		storageKey: LOCALSTORAGE.LOGS_LIST_OPTIONS,
@@ -96,6 +106,17 @@ function LogsActionsContainer({
 							</div>
 						</>
 					)}
+
+					{(selectedPanelType === PANEL_TYPES.TIME_SERIES ||
+						selectedPanelType === PANEL_TYPES.TABLE) && (
+						<div className="query-stats">
+							<QueryStatus
+								loading={isLoading || isFetching}
+								error={isError}
+								success={isSuccess}
+							/>
+						</div>
+					)}
 				</div>
 			</div>
 		</div>

frontend/src/container/LogsExplorerViews/LogsExplorerViews.styles.scss

@@ -155,6 +155,40 @@
 				}
 			}
 
+			.query-stats {
+				display: flex;
+				align-items: center;
+				gap: 12px;
+
+				align-self: flex-end;
+
+				.rows {
+					color: var(--l2-foreground);
+					font-family: 'Geist Mono';
+					font-size: 12px;
+					font-style: normal;
+					font-weight: 400;
+					line-height: 18px; /* 150% */
+					letter-spacing: 0.36px;
+				}
+
+				.divider {
+					width: 1px;
+					height: 14px;
+					background: var(--l3-background);
+				}
+
+				.time {
+					color: var(--l2-foreground);
+					font-family: 'Geist Mono';
+					font-size: 12px;
+					font-style: normal;
+					font-weight: 400;
+					line-height: 18px; /* 150% */
+					letter-spacing: 0.36px;
+				}
+			}
+
 			.ant-btn {
 				border: none;
 			}

frontend/src/container/LogsExplorerViews/QueryStatus.styles.scss

@@ -0,0 +1,4 @@
+.query-status {
+	display: flex;
+	align-items: center;
+}

frontend/src/container/LogsExplorerViews/QueryStatus.tsx

@@ -0,0 +1,49 @@
+import React, { useMemo } from 'react';
+import { Color } from '@signozhq/design-tokens';
+import { LoaderCircle, CircleCheck } from '@signozhq/icons';
+import { Spin } from 'antd';
+
+import solidXCircleUrl from '@/assets/Icons/solid-x-circle.svg';
+
+import './QueryStatus.styles.scss';
+
+interface IQueryStatusProps {
+	loading: boolean;
+	error: boolean;
+	success: boolean;
+}
+
+export default function QueryStatus(
+	props: IQueryStatusProps,
+): React.ReactElement {
+	const { loading, error, success } = props;
+
+	const content = useMemo((): React.ReactElement => {
+		if (loading) {
+			return (
+				<Spin
+					spinning
+					size="small"
+					indicator={<LoaderCircle className="animate-spin" size="md" />}
+				/>
+			);
+		}
+		if (error) {
+			return (
+				<img
+					src={solidXCircleUrl}
+					alt="header"
+					className="error"
+					style={{ height: '14px', width: '14px' }}
+				/>
+			);
+		}
+		if (success) {
+			return (
+				<CircleCheck className="success" size={14} fill={Color.BG_ROBIN_500} />
+			);
+		}
+		return <div />;
+	}, [error, loading, success]);
+	return <div className="query-status">{content}</div>;
+}

frontend/src/container/LogsExplorerViews/index.tsx

@@ -160,7 +160,7 @@ function LogsExplorerViewsContainer({
 		'custom',
 	);
 
-	const { data, isLoading, isFetching, isError, error } =
+	const { data, isLoading, isFetching, isError, isSuccess, error } =
 		useGetExplorerQueryRange(
 			requestData,
 			selectedPanelType,
@@ -437,6 +437,10 @@ function LogsExplorerViewsContainer({
 						handleToggleFrequencyChart={handleToggleFrequencyChart}
 						orderBy={orderBy}
 						setOrderBy={setOrderBy}
+						isFetching={isFetching}
+						isLoading={isLoading}
+						isError={isError}
+						isSuccess={isSuccess}
 					/>
 				)}
 

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

@@ -59,7 +59,7 @@ function AllAttributes({
 	);
 
 	const attributes = useMemo(
-		() => attributesData?.data?.attributes ?? [],
+		() => attributesData?.data.attributes ?? [],
 		[attributesData],
 	);
 

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

@@ -56,7 +56,7 @@ function MetricDetails({
 	);
 
 	const metadata = useMemo(() => {
-		if (!metricMetadataResponse?.data) {
+		if (!metricMetadataResponse) {
 			return null;
 		}
 		const { type, description, unit, temporality, isMonotonic } =

frontend/src/container/ResetPassword/ResetPassword.styles.scss

@@ -21,10 +21,6 @@
 			justify-content: center;
 			margin-bottom: 8px;
 			color: var(--semantic-primary-foreground);
-
-			&--error {
-				color: var(--destructive);
-			}
 		}
 
 		.reset-password-header-title {

frontend/src/container/ResetPassword/TokenError.tsx

@@ -1,67 +0,0 @@
-import { CircleAlert } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-import AuthError from 'components/AuthError/AuthError';
-import AuthPageContainer from 'components/AuthPageContainer';
-import APIError from 'types/api/error';
-
-import './ResetPassword.styles.scss';
-
-interface TokenErrorContent {
-	title: string;
-	subtitle: string;
-}
-
-function getErrorContent(error?: APIError): TokenErrorContent {
-	const code = error?.getErrorCode();
-
-	if (code === 'reset_password_token_expired') {
-		return {
-			title: 'Reset Password token is expired',
-			subtitle:
-				'Password reset links are single-use and expire after a set period. Please request a new password reset link.',
-		};
-	}
-
-	if (code === 'reset_password_token_not_found') {
-		return {
-			title: 'Invalid Reset Link',
-			subtitle:
-				'This reset password link is invalid or has already been used. Please request a new password reset link.',
-		};
-	}
-
-	return {
-		title: 'Reset Link Unavailable',
-		subtitle:
-			'We could not validate your reset password link. Please request a new one.',
-	};
-}
-
-interface TokenErrorProps {
-	error?: APIError;
-}
-
-function TokenError({ error }: TokenErrorProps): JSX.Element {
-	const { title, subtitle } = getErrorContent(error);
-
-	return (
-		<AuthPageContainer>
-			<div className="reset-password-card reset-password-card--centered">
-				<div className="reset-password-header">
-					<div className="reset-password-header-icon reset-password-header-icon--error">
-						<CircleAlert size={32} />
-					</div>
-					<Typography.Title level={4} className="reset-password-header-title">
-						{title}
-					</Typography.Title>
-					<Typography.Text className="reset-password-header-subtitle">
-						{subtitle}
-					</Typography.Text>
-				</div>
-				{error && <AuthError error={error} />}
-			</div>
-		</AuthPageContainer>
-	);
-}
-
-export default TokenError;

frontend/src/container/ResetPassword/__tests__/ResetPassword.test.tsx

@@ -1,3 +1,4 @@
+import { Logout } from 'api/utils';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
 import { rest, server } from 'mocks-server/server';
@@ -16,6 +17,10 @@ jest.mock('lib/history', () => ({
 	},
 }));
 
+jest.mock('api/utils', () => ({
+	Logout: jest.fn(),
+}));
+
 const mockSuccessNotification = jest.fn();
 const mockErrorNotification = jest.fn();
 
@@ -65,6 +70,17 @@ describe('ResetPassword Component', () => {
 			).toBeInTheDocument();
 			expect(screen.getByText(/signoz 1\.0\.0/i)).toBeInTheDocument();
 		});
+
+		it('redirects to login when token is missing', () => {
+			window.history.pushState({}, '', '/password-reset');
+
+			render(<ResetPassword version="1.0.0" />, undefined, {
+				initialRoute: '/password-reset',
+			});
+
+			expect(Logout).toHaveBeenCalled();
+			expect(mockHistoryPush).toHaveBeenCalledWith(ROUTES.LOGIN);
+		});
 	});
 
 	describe('Form Validation', () => {

frontend/src/container/ResetPassword/index.tsx

@@ -1,10 +1,11 @@
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useLocation } from 'react-use';
 import { Button } from '@signozhq/ui/button';
 import { Callout } from '@signozhq/ui/callout';
 import { Form, Input as AntdInput } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
+import { Logout } from 'api/utils';
 import resetPasswordApi from 'api/v1/factor_password/resetPassword';
 import AuthError from 'components/AuthError/AuthError';
 import AuthPageContainer from 'components/AuthPageContainer';
@@ -37,6 +38,13 @@ function ResetPassword({ version }: ResetPasswordProps): JSX.Element {
 	const { notifications } = useNotifications();
 
 	const [form] = Form.useForm<FormValues>();
+	useEffect(() => {
+		if (!token) {
+			Logout();
+			history.push(ROUTES.LOGIN);
+		}
+	}, [token]);
+
 	const handleFormSubmit: () => Promise<void> = async () => {
 		try {
 			setLoading(true);

frontend/src/pages/ResetPassword/__tests__/ResetPasswordPage.test.tsx

@@ -1,155 +0,0 @@
-import { Logout } from 'api/utils';
-import ROUTES from 'constants/routes';
-import history from 'lib/history';
-import { createErrorResponse, rest, server } from 'mocks-server/server';
-import { render, screen, waitFor } from 'tests/test-utils';
-
-import ResetPassword from '../index';
-
-jest.mock('lib/history', () => ({
-	__esModule: true,
-	default: {
-		push: jest.fn(),
-		location: { search: '' },
-	},
-}));
-
-jest.mock('api/utils', () => ({
-	Logout: jest.fn().mockResolvedValue(undefined),
-}));
-
-const VERIFY_TOKEN_ENDPOINT = '*/api/v2/reset_password_tokens/verify';
-const VERSION_ENDPOINT = '*/version';
-
-const mockHistoryPush = history.push as jest.MockedFunction<
-	typeof history.push
->;
-
-const successVerifyResponse = {
-	data: { id: 'token-id', token: 'valid-token' },
-};
-
-const successVersionResponse = {
-	version: '0.0.1',
-	ee: 'Y',
-	setupCompleted: true,
-};
-
-describe('ResetPassword Page', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		server.use(
-			rest.get(VERSION_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(successVersionResponse)),
-			),
-		);
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	describe('Token validation on page load', () => {
-		it('shows spinner then form when token is valid', async () => {
-			server.use(
-				rest.post(VERIFY_TOKEN_ENDPOINT, (_, res, ctx) =>
-					res(ctx.delay(50), ctx.status(200), ctx.json(successVerifyResponse)),
-				),
-			);
-
-			window.history.pushState({}, '', '/password-reset?token=valid-token');
-			render(<ResetPassword />, undefined, {
-				initialRoute: '/password-reset?token=valid-token',
-			});
-
-			// Loading state: spinner visible, form and error absent
-			expect(screen.getByRole('img', { name: /loading/i })).toBeInTheDocument();
-			expect(screen.queryByTestId('password')).not.toBeInTheDocument();
-			expect(
-				screen.queryByText(/reset password token is expired/i),
-			).not.toBeInTheDocument();
-
-			// After verification resolves: form is shown
-			await waitFor(() => {
-				expect(screen.getByTestId('password')).toBeInTheDocument();
-			});
-			expect(screen.getByTestId('confirmPassword')).toBeInTheDocument();
-		});
-
-		it('shows "Invalid Reset Link" when token is not found (404)', async () => {
-			server.use(
-				rest.post(
-					VERIFY_TOKEN_ENDPOINT,
-					createErrorResponse(
-						404,
-						'reset_password_token_not_found',
-						'reset password token does not exist',
-					),
-				),
-			);
-
-			window.history.pushState({}, '', '/password-reset?token=invalid-token');
-			render(<ResetPassword />, undefined, {
-				initialRoute: '/password-reset?token=invalid-token',
-			});
-
-			await waitFor(() => {
-				expect(screen.getByText(/invalid reset link/i)).toBeInTheDocument();
-			});
-
-			expect(
-				screen.getByText(/invalid or has already been used/i),
-			).toBeInTheDocument();
-			expect(
-				screen.getByText(/reset password token does not exist/i),
-			).toBeInTheDocument();
-		});
-
-		it('shows "token is expired" when token is expired (401) without redirecting to login', async () => {
-			server.use(
-				rest.post(
-					VERIFY_TOKEN_ENDPOINT,
-					createErrorResponse(
-						401,
-						'reset_password_token_expired',
-						'reset password token has expired',
-					),
-				),
-			);
-
-			window.history.pushState({}, '', '/password-reset?token=expired-token');
-			render(<ResetPassword />, undefined, {
-				initialRoute: '/password-reset?token=expired-token',
-			});
-
-			await waitFor(() => {
-				expect(
-					screen.getByText(/reset password token is expired/i),
-				).toBeInTheDocument();
-			});
-
-			expect(
-				screen.getByText(/single-use and expire after a set period/i),
-			).toBeInTheDocument();
-			expect(
-				screen.getByText(/reset password token has expired/i),
-			).toBeInTheDocument();
-			// 401 from this endpoint must NOT trigger logout/redirect
-			expect(mockHistoryPush).not.toHaveBeenCalledWith(ROUTES.LOGIN);
-			expect(Logout).not.toHaveBeenCalled();
-		});
-
-		it('redirects to login when no token is in the URL', async () => {
-			window.history.pushState({}, '', '/password-reset');
-			render(<ResetPassword />, undefined, {
-				initialRoute: '/password-reset',
-			});
-
-			await waitFor(() => {
-				expect(mockHistoryPush).toHaveBeenCalledWith(ROUTES.LOGIN);
-			});
-
-			expect(Logout).toHaveBeenCalled();
-		});
-	});
-});

frontend/src/pages/ResetPassword/index.tsx

@@ -1,17 +1,8 @@
-import { useEffect, useMemo } from 'react';
+import { useEffect } from 'react';
 import { useQuery } from 'react-query';
-import { useLocation } from 'react-use';
-import { AxiosError } from 'axios';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import getUserVersion from 'api/v1/version/get';
-import { verifyResetPasswordToken } from 'api/generated/services/users';
-import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
-import { Logout } from 'api/utils';
 import Spinner from 'components/Spinner';
 import ResetPasswordContainer from 'container/ResetPassword';
-import TokenError from 'container/ResetPassword/TokenError';
-import ROUTES from 'constants/routes';
-import history from 'lib/history';
 import { useAppContext } from 'providers/App/App';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
@@ -19,65 +10,24 @@ import APIError from 'types/api/error';
 function ResetPassword(): JSX.Element {
 	const { user, isLoggedIn } = useAppContext();
 	const { showErrorModal } = useErrorModal();
-	const { search } = useLocation();
-	const params = new URLSearchParams(search || '');
-	const token = params.get('token') || '';
 
-	useEffect(() => {
-		if (!token) {
-			void Logout();
-			history.push(ROUTES.LOGIN);
-		}
-	}, [token]);
-
-	const {
-		data: versionData,
-		isLoading: isVersionLoading,
-		error: versionError,
-	} = useQuery({
+	const { data, isLoading, error } = useQuery({
 		queryFn: getUserVersion,
 		queryKey: ['getUserVersion', user?.accessJwt],
 		enabled: !isLoggedIn,
 	});
 
-	const {
-		isLoading: isVerifying,
-		isError: isTokenError,
-		error: tokenError,
-	} = useQuery<
-		Awaited<ReturnType<typeof verifyResetPasswordToken>>,
-		AxiosError<RenderErrorResponseDTO>
-	>({
-		queryFn: () => verifyResetPasswordToken({ token }),
-		queryKey: ['verifyResetPasswordToken', token],
-		enabled: !!token,
-		retry: false,
-	});
-
-	const tokenApiError = useMemo(
-		() => convertToApiError(tokenError),
-		[tokenError],
-	);
-
 	useEffect(() => {
-		if (versionError) {
-			showErrorModal(versionError as APIError);
+		if (error) {
+			showErrorModal(error as APIError);
 		}
-	}, [versionError, showErrorModal]);
+	}, [error, showErrorModal]);
 
-	if (!token) {
+	if (isLoading) {
 		return <Spinner tip="Loading..." />;
 	}
 
-	if (isVersionLoading || isVerifying) {
-		return <Spinner tip="Validating your reset password token..." />;
-	}
-
-	if (isTokenError) {
-		return <TokenError error={tokenApiError} />;
-	}
-
-	return <ResetPasswordContainer version={versionData?.data.version || ''} />;
+	return <ResetPasswordContainer version={data?.data.version || ''} />;
 }
 
 export default ResetPassword;

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/__tests__/computeVisualLayout.test.ts

@@ -472,4 +472,98 @@ describe('computeVisualLayout', () => {
 		expect(aRow).toBeGreaterThan(1); // must NOT be at row 1
 		expect(aRow).toBe(3); // next free row after B at row 2 (A overlaps B)
 	});
+
+	// --- Wide-group fast path (> WIDE_GROUP_THRESHOLD siblings) ---
+	// Past the threshold the layout switches to exact overlap-only packing to
+	// avoid the O(N^2) connector-avoidance spiral. These lock in correctness and
+	// the no-overlap invariant at scale.
+
+	function noRowHasOverlap(
+		layout: ReturnType<typeof computeVisualLayout>,
+	): void {
+		for (const row of layout.visualRows) {
+			const sorted = [...row].sort((a, b) => a.timestamp - b.timestamp);
+			for (let i = 1; i < sorted.length; i++) {
+				const prevEnd = sorted[i - 1].timestamp + sorted[i - 1].durationNano / 1e6;
+				expect(sorted[i].timestamp).toBeGreaterThanOrEqual(prevEnd);
+			}
+		}
+	}
+
+	it('should pack thousands of sequential leaf siblings into 1 row (wide path)', () => {
+		const root = makeSpan({ spanId: 'root', timestamp: 0, durationNano: 1e12 });
+		const kids: FlamegraphSpan[] = [];
+		// 2000 strictly sequential (non-overlapping) children
+		for (let i = 0; i < 2000; i++) {
+			kids.push(
+				makeSpan({
+					spanId: `k${i}`,
+					parentSpanId: 'root',
+					timestamp: i * 10,
+					durationNano: 5e6, // 5ms, ends before next starts
+				}),
+			);
+		}
+
+		const layout = computeVisualLayout([[root], kids]);
+
+		expect(layout.spanToVisualRow['root']).toBe(0);
+		expect(layout.totalVisualRows).toBe(2); // all siblings share row 1
+		for (const k of kids) {
+			expect(layout.spanToVisualRow[k.spanId]).toBe(1);
+		}
+		noRowHasOverlap(layout);
+	});
+
+	it('should pack thousands of fully-overlapping leaf siblings without violations (wide path)', () => {
+		const root = makeSpan({ spanId: 'root', timestamp: 0, durationNano: 1e12 });
+		const kids: FlamegraphSpan[] = [];
+		// 1000 children all spanning the same window → each needs its own row
+		for (let i = 0; i < 1000; i++) {
+			kids.push(
+				makeSpan({
+					spanId: `k${i}`,
+					parentSpanId: 'root',
+					timestamp: 0,
+					durationNano: 100e6,
+				}),
+			);
+		}
+
+		const layout = computeVisualLayout([[root], kids]);
+
+		expect(layout.totalVisualRows).toBe(1001); // root + 1000 stacked rows
+		expect(Object.keys(layout.spanToVisualRow)).toHaveLength(1001);
+		noRowHasOverlap(layout);
+	});
+
+	it('should keep non-leaf subtrees adjacent within a wide mixed group (wide path)', () => {
+		const root = makeSpan({ spanId: 'root', timestamp: 0, durationNano: 1e12 });
+		const kids: FlamegraphSpan[] = [];
+		for (let i = 0; i < 1000; i++) {
+			kids.push(
+				makeSpan({
+					spanId: `k${i}`,
+					parentSpanId: 'root',
+					timestamp: i * 10,
+					durationNano: 5e6,
+				}),
+			);
+		}
+		// One of the wide siblings has a child of its own
+		const grandchild = makeSpan({
+			spanId: 'gc',
+			parentSpanId: 'k500',
+			timestamp: 5000,
+			durationNano: 2e6,
+		});
+
+		const layout = computeVisualLayout([[root], kids, [grandchild]]);
+
+		const parentRow = layout.spanToVisualRow['k500'];
+		const gcRow = layout.spanToVisualRow['gc'];
+		expect(gcRow - parentRow).toBe(1); // subtree adjacency preserved
+		expect(Object.keys(layout.spanToVisualRow)).toHaveLength(1002);
+		noRowHasOverlap(layout);
+	});
 });

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/computeVisualLayout.ts

@@ -18,6 +18,81 @@ export interface VisualLayout {
 	totalVisualRows: number;
 }
 
+// Above this many siblings under one parent, the connector-avoidance refinement
+// (Checks 2 & 3) is both visually meaningless — the row is already a dense wall —
+// and quadratic: every child deposits a connector point on each intermediate row,
+// which pushes later children even higher, which deposits more points. That
+// feedback loop inflates a layout needing ~50 rows to thousands and never
+// finishes on wide traces. Past the threshold we pack by overlap only.
+const WIDE_GROUP_THRESHOLD = 512;
+
+/**
+ * Segment tree over rows that answers "lowest row index >= `from` whose smallest
+ * span start-time is >= `end`" in O(log rows). Used to place a large group of
+ * leaf siblings by overlap only: because siblings are processed in descending
+ * start order, every already-placed span on a row starts at or after the current
+ * one, so [start, end] overlaps a row iff some span there starts before `end` —
+ * i.e. the row is free iff its minimum start >= end. Each node stores the max of
+ * its subtree's per-row minimum starts so a free row can be found by descent.
+ */
+class LowestFreeRow {
+	private readonly size: number;
+
+	private readonly tree: Float64Array;
+
+	constructor(rows: number) {
+		let size = 1;
+		while (size < rows) {
+			size *= 2;
+		}
+		this.size = size;
+		this.tree = new Float64Array(size * 2).fill(Infinity);
+	}
+
+	place(row: number, start: number): void {
+		let i = row + this.size;
+		// A row's key is the minimum start among its spans. Children are processed
+		// in descending start order so a leaf's start is the new minimum, but a
+		// non-leaf subtree's descendant can land on a row out of order — take min.
+		if (start >= this.tree[i]) {
+			return;
+		}
+		this.tree[i] = start;
+		for (i >>= 1; i >= 1; i >>= 1) {
+			const next = Math.max(this.tree[2 * i], this.tree[2 * i + 1]);
+			if (this.tree[i] === next) {
+				break;
+			}
+			this.tree[i] = next;
+		}
+	}
+
+	lowestFrom(from: number, end: number): number {
+		return this.descend(1, 0, this.size - 1, from, end);
+	}
+
+	private descend(
+		node: number,
+		lo: number,
+		hi: number,
+		from: number,
+		end: number,
+	): number {
+		if (hi < from || this.tree[node] < end) {
+			return -1;
+		}
+		if (lo === hi) {
+			return lo;
+		}
+		const mid = (lo + hi) >> 1;
+		const left = this.descend(2 * node, lo, mid, from, end);
+		if (left !== -1) {
+			return left;
+		}
+		return this.descend(2 * node + 1, mid + 1, hi, from, end);
+	}
+}
+
 /**
  * Computes an overlap-safe visual layout for flamegraph spans using DFS ordering.
  *
@@ -214,7 +289,53 @@ export function computeVisualLayout(spans: FlamegraphSpan[][]): VisualLayout {
 		arr.push(point);
 	}
 
+	// Fast path for a parent with a very large group of children: pack by overlap
+	// only (descending greedy), skipping the quadratic connector-avoidance that
+	// spirals at this scale. Leaf children — the bulk of a wide trace — are placed
+	// in O(log rows) via the segment tree; the rare non-leaf subtree falls back to
+	// findPlacement against the shared interval map. Both structures are kept in
+	// sync so each placement sees all prior occupancy. Same ShapeEntry[] contract.
+	function computeWideShape(
+		rootSpan: FlamegraphSpan,
+		children: FlamegraphSpan[],
+	): ShapeEntry[] {
+		const shape: ShapeEntry[] = [{ span: rootSpan, relativeRow: 0 }];
+		const localIntervals = new Map<number, Array<[number, number]>>();
+		// Children occupy relative rows 1..children.length in the worst case.
+		const finder = new LowestFreeRow(children.length + 2);
+
+		const occupy = (row: number, span: FlamegraphSpan): void => {
+			const s = span.timestamp;
+			const e = span.timestamp + span.durationNano / 1e6;
+			shape.push({ span, relativeRow: row });
+			addIntervalTo(localIntervals, row, s, e);
+			finder.place(row, s);
+		};
+
+		for (const child of children) {
+			if (childrenMap.has(child.spanId)) {
+				// Non-leaf: place its whole subtree shape as a unit via findPlacement.
+				const childShape = computeSubtreeShape(child);
+				const offset = findPlacement(childShape, 1, localIntervals);
+				for (const entry of childShape) {
+					occupy(entry.relativeRow + offset, entry.span);
+				}
+			} else {
+				const end = child.timestamp + child.durationNano / 1e6;
+				occupy(finder.lowestFrom(1, end), child);
+			}
+		}
+
+		return shape;
+	}
+
 	function computeSubtreeShape(rootSpan: FlamegraphSpan): ShapeEntry[] {
+		const children = childrenMap.get(rootSpan.spanId);
+
+		if (children && children.length > WIDE_GROUP_THRESHOLD) {
+			return computeWideShape(rootSpan, children);
+		}
+
 		const localIntervals = new Map<number, Array<[number, number]>>();
 		const localConnectorPoints = new Map<number, number[]>();
 		const shape: ShapeEntry[] = [];
@@ -225,7 +346,6 @@ export function computeVisualLayout(spans: FlamegraphSpan[][]): VisualLayout {
 		shape.push({ span: rootSpan, relativeRow: 0 });
 		addIntervalTo(localIntervals, 0, rootStart, rootEnd);
 
-		const children = childrenMap.get(rootSpan.spanId);
 		if (children) {
 			for (const child of children) {
 				const childShape = computeSubtreeShape(child);

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useVisualLayoutWorker.ts

@@ -94,7 +94,7 @@ export function useVisualLayoutWorker(spans: FlamegraphSpan[][]): {
 			cleanup();
 		};
 
-		// Timeout: if worker doesn't respond in 30s, terminate and error
+		// Timeout: if worker doesn't respond in 15s, terminate and error
 		const WORKER_TIMEOUT_MS = 15000;
 		const timeoutId = setTimeout(() => {
 			if (requestIdRef.current === currentId && isComputingRef.current) {

pkg/modules/cloudintegration/implcloudintegration/handler.go

@@ -440,3 +440,4 @@ func (handler *handler) AgentCheckIn(rw http.ResponseWriter, r *http.Request) {
 
 	render.Success(rw, http.StatusOK, cloudintegrationtypes.NewGettableAgentCheckIn(provider, resp))
 }
+

pkg/types/cloudintegrationtypes/integration_dashboard.go

@@ -18,16 +18,14 @@ var (
 type StorableIntegrationDashboard struct {
 	bun.BaseModel `bun:"table:integration_dashboard"`
 
-	ID          string                           `json:"id" bun:"id,pk,type:text" required:"true"`
-	DashboardID string                           `json:"dashboardId" bun:"dashboard_id,type:text" required:"true"`
-	Provider    IntegrationDashboardProviderType `json:"provider" bun:"provider,type:text" required:"true"`
-	Slug        string                           `json:"slug" bun:"slug,type:text" required:"true"`
-	CreatedAt   time.Time                        `json:"createdAt" bun:"created_at" required:"true"`
-	UpdatedAt   time.Time                        `json:"updatedAt" bun:"updated_at" required:"true"`
+	ID          string                           `bun:"id,pk,type:text"`
+	DashboardID string                           `bun:"dashboard_id,type:text"`
+	Provider    IntegrationDashboardProviderType `bun:"provider,type:text"`
+	Slug        string                           `bun:"slug,type:text"`
+	CreatedAt   time.Time                        `bun:"created_at"`
+	UpdatedAt   time.Time                        `bun:"updated_at"`
 }
 
-type IntegrationDashboard = StorableIntegrationDashboard
-
 func NewStorableIntegrationDashboard(dashboardID string, provider IntegrationDashboardProviderType, slug string) *StorableIntegrationDashboard {
 	now := time.Now()
 	return &StorableIntegrationDashboard{

pkg/types/cloudintegrationtypes/service.go

@@ -50,18 +50,10 @@ type ListServicesMetadataParams struct {
 // Service represents a cloud integration service with its definition,
 // cloud integration service is non nil only when the service entry exists in DB with ANY config (enabled or disabled).
 type Service struct {
-	ServiceDefinitionMetadata
-	Overview                string                   `json:"overview" required:"true"` // markdown
-	ServiceAssets           ServiceAssets            `json:"assets" required:"true"`
-	SupportedSignals        SupportedSignals         `json:"supportedSignals" required:"true"`
-	DataCollected           DataCollected            `json:"dataCollected" required:"true"`
+	ServiceDefinition
 	CloudIntegrationService *CloudIntegrationService `json:"cloudIntegrationService" required:"true" nullable:"true"`
 }
 
-type ServiceAssets struct {
-	Dashboards []*ServiceDashboard `json:"dashboards" required:"true" nullable:"false"`
-}
-
 type GetServiceParams struct {
 	CloudIntegrationID valuer.UUID `query:"cloud_integration_id" required:"false"`
 }
@@ -129,12 +121,6 @@ type Dashboard struct {
 	Definition  dashboardtypes.StorableDashboardData `json:"definition,omitempty"`
 }
 
-type ServiceDashboard struct {
-	Title                string                `json:"title" required:"true"`
-	Description          string                `json:"description" required:"true"`
-	IntegrationDashboard *IntegrationDashboard `json:"integrationDashboard,omitempty" required:"false"`
-}
-
 func NewCloudIntegrationService(serviceID ServiceID, cloudIntegrationID valuer.UUID, provider CloudProviderType, config *ServiceConfig) (*CloudIntegrationService, error) {
 	switch provider {
 	case CloudProviderTypeAWS:
@@ -178,41 +164,11 @@ func NewServiceMetadata(definition ServiceDefinition, enabled bool) *ServiceMeta
 	}
 }
 
-func NewService(provider CloudProviderType, def *ServiceDefinition, integrationService *CloudIntegrationService, integrationDashboards []*StorableIntegrationDashboard) *Service {
-	service := &Service{
-		ServiceDefinitionMetadata: def.ServiceDefinitionMetadata,
-		Overview:                  def.Overview,
-		SupportedSignals:          def.SupportedSignals,
-		DataCollected:             def.DataCollected,
-		CloudIntegrationService:   integrationService,
-		ServiceAssets:             ServiceAssets{Dashboards: make([]*ServiceDashboard, 0, len(def.Assets.Dashboards))},
+func NewService(def ServiceDefinition, storableService *CloudIntegrationService) *Service {
+	return &Service{
+		ServiceDefinition:       def,
+		CloudIntegrationService: storableService,
 	}
-
-	integrationDashboardsMap := make(map[string]*IntegrationDashboard)
-	for _, d := range integrationDashboards {
-		integrationDashboardsMap[d.Slug] = d
-	}
-
-	for _, d := range def.Assets.Dashboards {
-		dashboard := &ServiceDashboard{
-			Title:       d.Title,
-			Description: d.Description,
-		}
-
-		if integrationService != nil {
-			slug := CloudIntegrationDashboardSlug(provider, integrationService.Type, d.ID)
-
-			if integrationDashboard, exists := integrationDashboardsMap[slug]; exists {
-				if integrationDashboard != nil {
-					dashboard.IntegrationDashboard = integrationDashboard
-				}
-			}
-		}
-
-		service.ServiceAssets.Dashboards = append(service.ServiceAssets.Dashboards, dashboard)
-	}
-
-	return service
 }
 
 func NewGettableServicesMetadata(services []*ServiceMetadata) *GettableServicesMetadata {