chore: fmt

.github/workflows/integrationci.yaml

@@ -51,6 +51,7 @@ jobs:
           - role
           - rootuser
           - serviceaccount
+          - querier_json_body
           - ttl
         sqlstore-provider:
           - postgres
@@ -61,7 +62,7 @@ jobs:
           - 25.5.6
           - 25.12.5
         schema-migrator-version:
-          - v0.142.0
+          - v0.144.3
         postgres-version:
           - 15
     if: |

frontend/knip.json

@@ -1,5 +0,0 @@
-{
-  "$schema": "https://unpkg.com/knip@5/schema.json",
-  "project": ["src/**/*.ts", "src/**/*.tsx"],
-  "ignore": ["src/api/generated/**/*.ts"]
-}

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -105,7 +105,7 @@ function createMockLicense(
 			status: '',
 			updated_at: '0',
 		},
-		state: LicenseState.ACTIVATED,
+		state: LicenseState.ACTIVE,
 		status: LicenseStatus.VALID,
 		platform: LicensePlatform.CLOUD,
 		created_at: '0',
@@ -931,7 +931,7 @@ describe('PrivateRoute', () => {
 					isFetchingActiveLicense: false,
 					activeLicense: createMockLicense({
 						platform: LicensePlatform.CLOUD,
-						state: LicenseState.ACTIVATED,
+						state: LicenseState.ACTIVE,
 					}),
 				},
 				isCloudUser: true,
@@ -1522,7 +1522,7 @@ describe('PrivateRoute', () => {
 					isFetchingActiveLicense: false,
 					activeLicense: createMockLicense({
 						platform: LicensePlatform.CLOUD,
-						state: LicenseState.ACTIVATED,
+						state: LicenseState.ACTIVE,
 					}),
 					trialInfo: createMockTrialInfo({ workSpaceBlock: false }),
 					user: createMockUser({ role: USER_ROLES.ADMIN as ROLES }),

frontend/src/container/BillingContainer/BillingContainer.test.tsx

@@ -4,13 +4,7 @@ import {
 	notOfTrailResponse,
 	trialConvertedToSubscriptionResponse,
 } from 'mocks-server/__mockdata__/licenses';
-import { act, render, screen, getAppContextMock } from 'tests/test-utils';
-import APIError from 'types/api/error';
-import {
-	LicensePlatform,
-	LicenseResModel,
-	LicenseState,
-} from 'types/api/licensesV3/getActive';
+import { act, render, screen } from 'tests/test-utils';
 import { getFormattedDate } from 'utils/timeUtils';
 
 import BillingContainer from './BillingContainer';
@@ -26,7 +20,7 @@ window.ResizeObserver =
 describe('BillingContainer', () => {
 	jest.setTimeout(30000);
 
-	it('Component should render', async () => {
+	test('Component should render', async () => {
 		render(<BillingContainer />);
 
 		const dataInjection = screen.getByRole('columnheader', {
@@ -67,7 +61,7 @@ describe('BillingContainer', () => {
 			jest.useRealTimers();
 		});
 
-		it('OnTrail', async () => {
+		test('OnTrail', async () => {
 			// Pin "now" so trial end (20 Oct 2023) is tomorrow => "1 days_remaining"
 
 			render(
@@ -79,19 +73,17 @@ describe('BillingContainer', () => {
 			// If the component schedules any setTimeout on mount, flush them:
 			jest.runOnlyPendingTimers();
 
-			await expect(screen.findByText('Free Trial')).resolves.toBeInTheDocument();
-			await expect(screen.findByText('billing')).resolves.toBeInTheDocument();
-			await expect(screen.findByText(/\$0/i)).resolves.toBeInTheDocument();
+			expect(await screen.findByText('Free Trial')).toBeInTheDocument();
+			expect(await screen.findByText('billing')).toBeInTheDocument();
+			expect(await screen.findByText(/\$0/i)).toBeInTheDocument();
 
-			await expect(
-				screen.findByText(
+			expect(
+				await screen.findByText(
 					/You are in free trial period. Your free trial will end on 20 Oct 2023/i,
 				),
-			).resolves.toBeInTheDocument();
+			).toBeInTheDocument();
 
-			await expect(
-				screen.findByText(/1 days_remaining/i),
-			).resolves.toBeInTheDocument();
+			expect(await screen.findByText(/1 days_remaining/i)).toBeInTheDocument();
 
 			const upgradeButtons = await screen.findAllByRole('button', {
 				name: /upgrade_plan/i,
@@ -99,19 +91,13 @@ describe('BillingContainer', () => {
 			expect(upgradeButtons).toHaveLength(2);
 			expect(upgradeButtons[1]).toBeInTheDocument();
 
-			await expect(
-				screen.findByText(/checkout_plans/i),
-			).resolves.toBeInTheDocument();
-			await expect(
-				screen.findByRole('link', { name: /here/i }),
-			).resolves.toBeInTheDocument();
-
-			await expect(
-				screen.findByText('Cancel Subscription', { selector: 'span' }),
-			).resolves.toBeInTheDocument();
+			expect(await screen.findByText(/checkout_plans/i)).toBeInTheDocument();
+			expect(
+				await screen.findByRole('link', { name: /here/i }),
+			).toBeInTheDocument();
 		});
 
-		it('OnTrail but trialConvertedToSubscription', async () => {
+		test('OnTrail but trialConvertedToSubscription', async () => {
 			await act(async () => {
 				render(
 					<BillingContainer />,
@@ -148,89 +134,10 @@ describe('BillingContainer', () => {
 			const dayRemainingInBillingPeriod =
 				await screen.findByText(/1 days_remaining/i);
 			expect(dayRemainingInBillingPeriod).toBeInTheDocument();
-
-			await expect(
-				screen.findByText('Cancel Subscription', { selector: 'span' }),
-			).resolves.toBeInTheDocument();
 		});
 	});
 
-	describe('CancelSubscriptionBanner visibility', () => {
-		const baseActiveLicense = getAppContextMock('ADMIN')
-			.activeLicense as LicenseResModel;
-
-		it('should render when license is ACTIVATED and platform is CLOUD', async () => {
-			render(<BillingContainer />);
-			await expect(
-				screen.findByText('Cancel Subscription', { selector: 'span' }),
-			).resolves.toBeInTheDocument();
-		});
-
-		it.each([
-			['EXPIRED', LicenseState.EXPIRED],
-			['TERMINATED', LicenseState.TERMINATED],
-			['CANCELLED', LicenseState.CANCELLED],
-			['EVALUATION_EXPIRED', LicenseState.EVALUATION_EXPIRED],
-			['DEFAULTED', LicenseState.DEFAULTED],
-			['ISSUED', LicenseState.ISSUED],
-			['EVALUATING', LicenseState.EVALUATING],
-		])('should not render when license state is %s', async (_, state) => {
-			render(
-				<BillingContainer />,
-				{},
-				{
-					appContextOverrides: {
-						activeLicense: { ...baseActiveLicense, state },
-					},
-				},
-			);
-			await screen.findByText('billing');
-			expect(
-				screen.queryByText('Cancel Subscription', { selector: 'span' }),
-			).not.toBeInTheDocument();
-		});
-
-		const makeAPIError = (statusCode: number): APIError =>
-			new APIError({
-				httpStatusCode: statusCode as any,
-				error: { code: 'error', message: 'error', url: '', errors: [] },
-			});
-
-		it.each([
-			[
-				'Self-Hosted platform',
-				{
-					activeLicense: {
-						...baseActiveLicense,
-						platform: LicensePlatform.SELF_HOSTED,
-					},
-					activeLicenseFetchError: null,
-				},
-			],
-			[
-				'Community Enterprise user (license API 404)',
-				{
-					activeLicense: null,
-					activeLicenseFetchError: makeAPIError(404),
-				},
-			],
-			[
-				'Community user (license API 501)',
-				{
-					activeLicense: null,
-					activeLicenseFetchError: makeAPIError(501),
-				},
-			],
-		])('should not render for %s', async (_, overrides) => {
-			render(<BillingContainer />, {}, { appContextOverrides: overrides });
-			await screen.findByText('billing');
-			expect(
-				screen.queryByText('Cancel Subscription', { selector: 'span' }),
-			).not.toBeInTheDocument();
-		});
-	});
-
-	it('Not on ontrail', async () => {
+	test('Not on ontrail', async () => {
 		const { findByText } = render(
 			<BillingContainer />,
 			{},

frontend/src/container/BillingContainer/BillingContainer.tsx

@@ -34,12 +34,10 @@ import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
 import { getBaseUrl } from 'utils/basePath';
 import { getFormattedDate, getRemainingDays } from 'utils/timeUtils';
 
-import CancelSubscriptionBanner from './CancelSubscriptionBanner';
 import { BillingUsageGraph } from './BillingUsageGraph/BillingUsageGraph';
 import { prepareCsvData } from './BillingUsageGraph/utils';
 
 import './BillingContainer.styles.scss';
-import { LicenseState } from 'types/api/licensesV3/getActive';
 
 interface DataType {
 	key: string;
@@ -319,7 +317,7 @@ export default function BillingContainer(): JSX.Element {
 
 	const handleBilling = useCallback(async () => {
 		if (!trialInfo?.trialConvertedToSubscription) {
-			void logEvent('Billing : Upgrade Plan', {
+			logEvent('Billing : Upgrade Plan', {
 				user: pick(user, ['email', 'userId', 'name']),
 				org,
 			});
@@ -328,7 +326,7 @@ export default function BillingContainer(): JSX.Element {
 				url: getBaseUrl(),
 			});
 		} else {
-			void logEvent('Billing : Manage Billing', {
+			logEvent('Billing : Manage Billing', {
 				user: pick(user, ['email', 'userId', 'name']),
 				org,
 			});
@@ -537,10 +535,6 @@ export default function BillingContainer(): JSX.Element {
 				{(isLoading || isFetchingBillingData) && renderTableSkeleton()}
 			</div>
 
-			{isCloudUserVal && activeLicense?.state === LicenseState.ACTIVATED && (
-				<CancelSubscriptionBanner />
-			)}
-
 			{!trialInfo?.trialConvertedToSubscription && (
 				<div className="upgrade-plan-benefits">
 					<Row

frontend/src/container/BillingContainer/CancelSubscriptionBanner.module.scss

@@ -1,35 +0,0 @@
-.banner {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-	padding: var(--padding-4);
-	border-radius: 4px;
-	border: 1px solid var(--callout-error-border);
-	background-color: var(--callout-error-background);
-	margin: var(--spacing-4) 0 var(--spacing-12);
-}
-
-.info {
-	display: flex;
-	flex-direction: column;
-	gap: var(--spacing-2);
-}
-
-.title {
-	font-size: var(--font-size-sm);
-	font-weight: var(--font-weight-medium);
-	color: var(--callout-error-title);
-}
-
-.subtitle {
-	font-size: var(--paragraph-base-400-font-size);
-	font-weight: var(--paragraph-base-400-font-weight);
-	line-height: var(--paragraph-base-400-line-height);
-	color: var(--callout-error-icon);
-}
-
-.dialogBody {
-	font-size: var(--font-size-sm);
-	line-height: var(--line-height-relaxed);
-	color: var(--l2-foreground);
-}

frontend/src/container/BillingContainer/CancelSubscriptionBanner.test.tsx

@@ -1,68 +0,0 @@
-import { render, screen, userEvent } from 'tests/test-utils';
-
-import CancelSubscriptionBanner from './CancelSubscriptionBanner';
-
-jest.mock('utils/basePath', () => ({
-	getBasePath: (): string => '/',
-	withBasePath: (path: string): string => path,
-	getAbsoluteUrl: (path: string): string => `https://test.signoz.io${path}`,
-	getBaseUrl: (): string => 'https://test.signoz.io',
-}));
-
-describe('CancelSubscriptionBanner', () => {
-	it('renders banner with title and subtitle', () => {
-		render(<CancelSubscriptionBanner />);
-		expect(
-			screen.getByText('Cancel Subscription', { selector: 'span' }),
-		).toBeInTheDocument();
-		expect(
-			screen.getByText('Cancel your SigNoz subscription.'),
-		).toBeInTheDocument();
-	});
-
-	it('opens dialog with correct content when Cancel Subscription is clicked', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<CancelSubscriptionBanner />);
-
-		await user.click(
-			screen.getByRole('button', { name: /cancel subscription/i }),
-		);
-
-		expect(screen.getByRole('dialog')).toBeInTheDocument();
-		expect(
-			screen.getByText(/reach out to our support team/i),
-		).toBeInTheDocument();
-		expect(
-			screen.getByRole('button', { name: /keep subscription/i }),
-		).toBeInTheDocument();
-		expect(
-			screen.getByRole('button', { name: /contact support/i }),
-		).toBeInTheDocument();
-	});
-
-	it('sends mailto to cloud-support with correct subject on Contact Support', async () => {
-		const realCreateElement = document.createElement.bind(document);
-		const mockClick = jest.fn();
-		const mockAnchor = { href: '', click: mockClick };
-		jest.spyOn(document, 'createElement').mockImplementation((tag: string) => {
-			if (tag === 'a') {
-				return mockAnchor as unknown as HTMLAnchorElement;
-			}
-			return realCreateElement(tag);
-		});
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<CancelSubscriptionBanner />);
-
-		await user.click(
-			screen.getByRole('button', { name: /cancel subscription/i }),
-		);
-		await user.click(screen.getByRole('button', { name: /contact support/i }));
-
-		expect(mockAnchor.href).toContain('mailto:cloud-support@signoz.io');
-		expect(mockAnchor.href).toContain('Cancel%20My%20SigNoz%20Subscription');
-		expect(mockClick).toHaveBeenCalledTimes(1);
-
-		jest.restoreAllMocks();
-	});
-});

frontend/src/container/BillingContainer/CancelSubscriptionBanner.tsx

@@ -1,106 +0,0 @@
-import { useState } from 'react';
-import { X } from '@signozhq/icons';
-import { Button, DialogWrapper } from '@signozhq/ui';
-import logEvent from 'api/common/logEvent';
-import { pick } from 'lodash-es';
-import { useAppContext } from 'providers/App/App';
-import { getBaseUrl } from 'utils/basePath';
-
-import styles from './CancelSubscriptionBanner.module.scss';
-
-function CancelSubscriptionBanner(): JSX.Element {
-	const [open, setOpen] = useState(false);
-	const { user, org } = useAppContext();
-
-	const handleOpenCancelDialog = (): void => {
-		void logEvent('Billing : Cancel Subscription Clicked', {
-			user: pick(user, ['email', 'displayName', 'role', 'organization']),
-			role: user?.role,
-		});
-		setOpen(true);
-	};
-
-	const handleContactSupport = (): void => {
-		void logEvent('Billing : Cancel Subscription Confirmed', {
-			user: pick(user, ['email', 'displayName', 'role', 'organization']),
-			role: user?.role,
-		});
-		const subject = encodeURIComponent('Cancel My SigNoz Subscription');
-		const orgName = org?.[0]?.displayName ?? '';
-		const body = encodeURIComponent(
-			[
-				'Hi SigNoz Team,',
-				'',
-				'I would like to cancel my SigNoz Cloud subscription.',
-				'Please find my account details below.',
-				'',
-				'Account Details:',
-				`  • SigNoz URL:      ${getBaseUrl()}`,
-				...(orgName ? [`  • Organization:   ${orgName}`] : []),
-				`  • Account Email:  ${user?.email ?? ''}`,
-				'',
-				'Reason for Cancellation:',
-				'[Please share the reason for cancellation]',
-				'',
-				'Additional feedback (optional):',
-				'[Any other feedback]',
-				'',
-				'Regards,',
-				'[user name or team name]',
-			].join('\n'),
-		);
-		const link = document.createElement('a');
-		link.href = `mailto:cloud-support@signoz.io?subject=${subject}&body=${body}`;
-		link.click();
-		setOpen(false);
-	};
-
-	const footer = (
-		<>
-			<Button
-				variant="solid"
-				color="secondary"
-				onClick={(): void => setOpen(false)}
-			>
-				Keep Subscription
-			</Button>
-			<Button variant="solid" color="destructive" onClick={handleContactSupport}>
-				Contact Support
-			</Button>
-		</>
-	);
-
-	return (
-		<>
-			<div className={styles.banner}>
-				<div className={styles.info}>
-					<span className={styles.title}>Cancel Subscription</span>
-					<span className={styles.subtitle}>Cancel your SigNoz subscription.</span>
-				</div>
-				<Button
-					variant="solid"
-					color="destructive"
-					prefix={<X size={12} />}
-					onClick={handleOpenCancelDialog}
-				>
-					Cancel Subscription
-				</Button>
-			</div>
-			<DialogWrapper
-				open={open}
-				onOpenChange={setOpen}
-				title="Cancel your subscription"
-				width="narrow"
-				showCloseButton
-				footer={footer}
-			>
-				<p className={styles.dialogBody}>
-					To cancel your SigNoz subscription, please reach out to our support team.
-					We&apos;ll be happy to assist you.
-				</p>
-			</DialogWrapper>
-		</>
-	);
-}
-
-export default CancelSubscriptionBanner;

frontend/src/container/OnboardingQuestionaire/AboutSigNozQuestions/AboutSigNozQuestions.tsx

@@ -27,7 +27,6 @@ const interestedInOptions: Record<string, string> = {
 	singleTool:
 		'Single Tool (logs, metrics & traces) to reduce operational overhead',
 	correlateSignals: 'Correlate signals for faster troubleshooting',
-	openSourceTooling: 'Prefer open-source tooling',
 };
 
 export function AboutSigNozQuestions({

frontend/src/pages/AlertChannelCreate/config.tsx

@@ -0,0 +1,22 @@
+import ROUTES from 'constants/routes';
+import CreateAlertChannels from 'container/CreateAlertChannels';
+import { ChannelType } from 'container/CreateAlertChannels/config';
+import GeneralSettings from 'container/GeneralSettings';
+import { t } from 'i18next';
+
+export const alertsRoutesConfig = [
+	{
+		Component: GeneralSettings,
+		name: t('routes.general'),
+		route: ROUTES.SETTINGS,
+		key: ROUTES.SETTINGS,
+	},
+	{
+		Component: (): JSX.Element => (
+			<CreateAlertChannels preType={ChannelType.Slack} />
+		),
+		name: t('routes.alert_channels'),
+		route: ROUTES.CHANNELS_NEW,
+		key: ROUTES.CHANNELS_NEW,
+	},
+];

frontend/src/pages/AlertChannelCreate/index.tsx

@@ -0,0 +1,19 @@
+import { useLocation } from 'react-router-dom';
+import RouteTab from 'components/RouteTab';
+import history from 'lib/history';
+
+import { alertsRoutesConfig } from './config';
+
+function SettingsPage(): JSX.Element {
+	const { pathname } = useLocation();
+
+	return (
+		<RouteTab
+			history={history}
+			routes={alertsRoutesConfig}
+			activeKey={pathname}
+		/>
+	);
+}
+
+export default SettingsPage;

frontend/src/pages/AlertDetails/AlertHeader/AlertStatus/AlertStatus.tsx

@@ -0,0 +1,54 @@
+import { useMemo } from 'react';
+import { Color } from '@signozhq/design-tokens';
+import { CircleCheck, Siren } from 'lucide-react';
+import { getDurationFromNow } from 'utils/timeUtils';
+
+import { AlertStatusProps, StatusConfig } from './types';
+
+import './AlertStatus.styles.scss';
+
+export default function AlertStatus({
+	status,
+	timestamp,
+}: AlertStatusProps): JSX.Element {
+	const statusConfig: StatusConfig = useMemo(
+		() => ({
+			firing: {
+				icon: <Siren size={14} color={Color.TEXT_VANILLA_400} />,
+				text: 'Firing since',
+				extraInfo: timestamp ? (
+					<>
+						<div>⎯</div>
+						<div className="time">{getDurationFromNow(timestamp)}</div>
+					</>
+				) : null,
+				className: 'alert-status-info--firing',
+			},
+			resolved: {
+				icon: (
+					<CircleCheck
+						size={14}
+						fill={Color.BG_VANILLA_400}
+						color={Color.BG_INK_400}
+					/>
+				),
+				text: 'Resolved',
+				extraInfo: null,
+				className: 'alert-status-info--resolved',
+			},
+		}),
+		[timestamp],
+	);
+
+	const currentStatus = statusConfig[status];
+
+	return (
+		<div className={`alert-status-info ${currentStatus.className}`}>
+			<div className="alert-status-info__icon">{currentStatus.icon}</div>
+			<div className="alert-status-info__details">
+				<div className="text">{currentStatus.text}</div>
+				{currentStatus.extraInfo}
+			</div>
+		</div>
+	);
+}

frontend/src/pages/AlertDetails/AlertHeader/AlertStatus/types.ts

@@ -0,0 +1,18 @@
+export type AlertStatusProps =
+	| { status: 'firing'; timestamp: number }
+	| { status: 'resolved'; timestamp?: number };
+
+export type StatusConfig = {
+	firing: {
+		icon: JSX.Element;
+		text: string;
+		extraInfo: JSX.Element | null;
+		className: string;
+	};
+	resolved: {
+		icon: JSX.Element;
+		text: string;
+		extraInfo: JSX.Element | null;
+		className: string;
+	};
+};

frontend/src/pages/AlertHistory/index.tsx

@@ -0,0 +1,3 @@
+import AlertHistory from 'container/AlertHistory';
+
+export default AlertHistory;

frontend/src/pages/AllErrors/utils.tsx

@@ -0,0 +1,86 @@
+import {
+	FiltersType,
+	IQuickFiltersConfig,
+} from 'components/QuickFilters/types';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { DataSource } from 'types/common/queryBuilder';
+
+export const ExceptionsQuickFiltersConfig: IQuickFiltersConfig[] = [
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'Environment',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'deployment.environment',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: true,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'Service Name',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'service.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'Hostname',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'host.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'K8s Cluster Name',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'k8s.cluster.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'K8s Deployment Name',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'k8s.deployment.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'K8s Namespace Name',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'k8s.namespace.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'K8s Pod Name',
+		dataSource: DataSource.TRACES,
+		attributeKey: {
+			key: 'k8s.pod.name',
+			dataType: DataTypes.String,
+			type: 'resource',
+		},
+		defaultOpen: false,
+	},
+];

frontend/src/pages/Billing/BillingPage.tsx

@@ -0,0 +1,13 @@
+import BillingContainer from 'container/BillingContainer/BillingContainer';
+
+import './BillingPage.styles.scss';
+
+function BillingPage(): JSX.Element {
+	return (
+		<div className="billingPageContainer">
+			<BillingContainer />
+		</div>
+	);
+}
+
+export default BillingPage;

frontend/src/pages/Billing/index.tsx

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

frontend/src/pages/CreateAlert/styles.ts

@@ -0,0 +1,18 @@
+import { Typography } from 'antd';
+import styled from 'styled-components';
+
+export const Title = styled(Typography)`
+	&&& {
+		margin-top: 1rem;
+		margin-bottom: 1rem;
+	}
+`;
+
+export const ButtonContainer = styled.div`
+	&&& {
+		display: flex;
+		justify-content: flex-end;
+		align-items: center;
+		margin-top: 1rem;
+	}
+`;

frontend/src/pages/HomePage/index.tsx

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

frontend/src/pages/LogsExplorer/styles.ts

@@ -0,0 +1,14 @@
+import { Col } from 'antd';
+import { themeColors } from 'constants/theme';
+import styled from 'styled-components';
+
+export const WrapperStyled = styled.div`
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	color: ${themeColors.lightWhite};
+`;
+
+export const ButtonWrapperStyled = styled(Col)`
+	margin-left: auto;
+`;

frontend/src/pages/LogsModulePage/utils.ts

@@ -0,0 +1,7 @@
+export const removeSourcePageFromPath = (path: string): string => {
+	const lastSlashIndex = path.lastIndexOf('/');
+	if (lastSlashIndex !== -1) {
+		return path.substring(0, lastSlashIndex);
+	}
+	return path;
+};

frontend/src/pages/MySettings/index.tsx

@@ -0,0 +1,6 @@
+import MySettingsContainer from 'container/MySettings';
+
+function MySettings(): JSX.Element {
+	return <MySettingsContainer />;
+}
+export default MySettings;

frontend/src/pages/SomethingWentWrong/index.tsx

@@ -0,0 +1,25 @@
+import { Button, Typography } from 'antd';
+import SomethingWentWrongAsset from 'assets/SomethingWentWrong';
+import { Container } from 'components/NotFound/styles';
+import ROUTES from 'constants/routes';
+import history from 'lib/history';
+
+function SomethingWentWrong(): JSX.Element {
+	return (
+		<Container>
+			<SomethingWentWrongAsset />
+			<Typography.Title level={3}>Oops! Something went wrong</Typography.Title>
+			<Button
+				type="primary"
+				onClick={(): void => {
+					history.push(ROUTES.HOME);
+				}}
+				className="periscope-btn primary"
+			>
+				Return to Home
+			</Button>
+		</Container>
+	);
+}
+
+export default SomethingWentWrong;

frontend/src/pages/TracesExplorer/styles.ts

@@ -0,0 +1,10 @@
+import styled from 'styled-components';
+
+export const Container = styled.div`
+	margin: 1rem 0;
+`;
+
+export const ActionsWrapper = styled.div`
+	display: flex;
+	justify-content: flex-end;
+`;

frontend/src/tests/test-utils.tsx

@@ -119,7 +119,7 @@ export function getAppContextMock(
 				status: '',
 				updated_at: '0',
 			},
-			state: LicenseState.ACTIVATED,
+			state: LicenseState.ACTIVE,
 			status: LicenseStatus.VALID,
 			platform: LicensePlatform.CLOUD,
 			created_at: '0',

frontend/src/types/api/licensesV3/getActive.ts

@@ -11,7 +11,7 @@ export enum LicenseStatus {
 
 export enum LicenseState {
 	DEFAULTED = 'DEFAULTED',
-	ACTIVATED = 'ACTIVATED',
+	ACTIVE = 'ACTIVE',
 	EXPIRED = 'EXPIRED',
 	ISSUED = 'ISSUED',
 	EVALUATING = 'EVALUATING',

tests/conftest.py

@@ -23,6 +23,7 @@ pytest_plugins = [
     "fixtures.notification_channel",
     "fixtures.alerts",
     "fixtures.cloudintegrations",
+    "fixtures.jsontypes",
     "fixtures.seeder",
 ]
 
@@ -79,6 +80,6 @@ def pytest_addoption(parser: pytest.Parser):
     parser.addoption(
         "--schema-migrator-version",
         action="store",
-        default="v0.144.2",
+        default="v0.144.3",
         help="schema migrator version",
     )

tests/fixtures/clickhouse.py

@@ -1,5 +1,6 @@
 import os
-from collections.abc import Generator
+from collections.abc import Callable, Generator
+from datetime import datetime
 from typing import Any
 
 import clickhouse_connect
@@ -262,3 +263,76 @@ def clickhouse(
         delete=delete,
         restore=restore,
     )
+
+
+@pytest.fixture(name="check_query_log")
+def check_query_log(
+    signoz: types.SigNoz,
+) -> Callable[..., None]:
+    """
+    Returns a callable that flushes system.query_log and asserts that at
+    least one recent SELECT satisfies check_fn.
+
+    Args:
+        after_ts:         Only consider queries logged after this timestamp.
+        case_name:        Label used in assertion failure messages.
+        check_fn:         Predicate run against each candidate query string.
+        tables:           Filter to queries that touched all of these tables, as
+                          'db.table' strings (uses hasAll(tables, [...])).
+        must_contain:     Substrings that must appear in the query text (AND-ed).
+        must_not_contain: Substrings that must not appear in the query text (AND-ed).
+        limit:            How many most-recent queries to examine (default 10).
+
+    Usage:
+        before = datetime.now(tz=timezone.utc)
+        # ... trigger the query under test ...
+        check_query_log(
+            before, "my.case",
+            lambda q: "assumeNotNull" in q,
+            tables=["signoz_logs.distributed_logs_v2"],
+        )
+    """
+
+    def _check(
+        after_ts: datetime,
+        case_name: str,
+        check_fn: Callable[[str], bool],
+        *,
+        tables: list[str] | None = None,
+        must_contain: list[str] | None = None,
+        must_not_contain: list[str] | None = None,
+        limit: int = 10,
+    ) -> None:
+        conn = signoz.telemetrystore.conn
+        conn.command("SYSTEM FLUSH LOGS")
+
+        # Use millisecond precision to avoid timestamp collisions between
+        # adjacent test cases (second-level precision causes bleed-through).
+        params: dict = {"after_ms": int(after_ts.timestamp() * 1000)}
+        conditions = [
+            "type = 'QueryFinish'",
+            "query_kind = 'Select'",
+            "toUnixTimestamp64Milli(event_time_microseconds) >= %(after_ms)s",
+        ]
+        if tables:
+            params["tables"] = tables
+            conditions.append("hasAll(tables, %(tables)s)")
+        for i, pattern in enumerate(must_contain or []):
+            key = f"mc_{i}"
+            params[key] = pattern
+            conditions.append(f"position(query, %({key})s) > 0")
+        for i, pattern in enumerate(must_not_contain or []):
+            key = f"mnc_{i}"
+            params[key] = pattern
+            conditions.append(f"position(query, %({key})s) = 0")
+
+        where = " AND ".join(conditions)
+        result = conn.query(
+            f"SELECT query FROM system.query_log WHERE {where} ORDER BY event_time_microseconds DESC LIMIT {limit}",
+            parameters=params,
+        )
+        queries = [row[0] for row in result.result_rows]
+        assert queries, f"No matching SELECT in system.query_log for case '{case_name}'"
+        assert all(check_fn(q) for q in queries), f"query_log check failed for case '{case_name}'.\n" + "Queries:\n" + "\n---\n".join(queries)
+
+    return _check

tests/fixtures/jsontypes.py

@@ -0,0 +1,441 @@
+"""
+Simpler version of metadataexporter for exporting jsontypes for test fixtures.
+This exports JSON type metadata to the path_types table by parsing JSON bodies
+and extracting all paths with their types, similar to how the real metadataexporter works.
+"""
+
+import datetime
+import json
+from abc import ABC
+from collections.abc import Callable, Generator
+from http import HTTPStatus
+from typing import (
+    Any,
+)
+
+import numpy as np
+import pytest
+import requests
+
+from fixtures import types
+
+
+class JSONPathType(ABC):
+    """Represents a JSON path with its type information"""
+
+    field_name: str
+    field_data_type: str
+    last_seen: np.uint64
+    signal: str = "logs"
+    field_context: str = "body"
+
+    def __init__(
+        self,
+        field_name: str,
+        field_data_type: str,
+        last_seen: datetime.datetime | None = None,
+    ) -> None:
+        self.field_name = field_name
+        self.field_data_type = field_data_type
+        self.signal = "logs"
+        self.field_context = "body"
+        if last_seen is None:
+            last_seen = datetime.datetime.now()
+        self.last_seen = np.uint64(int(last_seen.timestamp() * 1e9))
+
+    def np_arr(self) -> np.array:
+        """Return path type data as numpy array for database insertion"""
+        return np.array([self.signal, self.field_context, self.field_name, self.field_data_type, self.last_seen])
+
+
+# Constants matching metadataexporter
+ARRAY_SEPARATOR = "[]."  # Used in paths like "education[].name"
+ARRAY_SUFFIX = "[]"  # Used when traversing into array element objects
+
+
+def _infer_array_type_from_type_strings(types: list[str]) -> str | None:
+    """
+    Infer array type from a list of pre-classified type strings.
+    Matches metadataexporter's inferArrayMask logic.
+
+    Internal type strings are: "JSON", "String", "Bool", "Float64", "Int64"
+
+    SuperTyping rules (matching Go inferArrayMask):
+    - JSON alone → []json
+    - JSON + any primitive → []dynamic
+    - String alone → []string; String + other → []dynamic
+    - Float64 wins over Int64 and Bool
+    - Int64 wins over Bool
+    - Bool alone → []bool
+    """
+    if len(types) == 0:
+        return None
+
+    unique = set(types)
+
+    has_json = "JSON" in unique
+    # hasPrimitive mirrors Go: (hasJSON && len(unique) > 1) || (!hasJSON && len(unique) > 0)
+    has_primitive = (has_json and len(unique) > 1) or (not has_json and len(unique) > 0)
+
+    if has_json:
+        if not has_primitive:
+            return "[]json"
+        return "[]dynamic"
+
+    # ---- Primitive Type Resolution (Float > Int > Bool) ----
+    if "String" in unique:
+        if len(unique) > 1:
+            return "[]dynamic"
+        return "[]string"
+
+    if "Float64" in unique:
+        return "[]float64"
+    if "Int64" in unique:
+        return "[]int64"
+    if "Bool" in unique:
+        return "[]bool"
+
+    return "[]dynamic"
+
+
+def _infer_array_type(elements: list[Any]) -> str | None:
+    """
+    Infer array type from raw Python list elements.
+    Classifies each element then delegates to _infer_array_type_from_type_strings.
+    """
+    if len(elements) == 0:
+        return None
+
+    types = []
+    for elem in elements:
+        if elem is None:
+            continue
+        if isinstance(elem, dict):
+            types.append("JSON")
+        elif isinstance(elem, str):
+            types.append("String")
+        elif isinstance(elem, bool):  # must be before int (bool is subclass of int)
+            types.append("Bool")
+        elif isinstance(elem, float):
+            types.append("Float64")
+        elif isinstance(elem, int):
+            types.append("Int64")
+
+    return _infer_array_type_from_type_strings(types)
+
+
+def _python_type_to_clickhouse_type(value: Any) -> str:
+    """
+    Convert Python type to ClickHouse JSON type string.
+    Maps Python types to ClickHouse JSON data types.
+    Matches metadataexporter's mapPCommonValueTypeToDataType.
+    """
+    if isinstance(value, bool):
+        return "bool"
+    elif isinstance(value, int):
+        return "int64"
+    elif isinstance(value, float):
+        return "float64"
+    elif isinstance(value, str):
+        return "string"
+    elif isinstance(value, list):
+        # Use the sophisticated array type inference
+        array_type = _infer_array_type(value)
+        return array_type if array_type else "[]dynamic"
+    elif isinstance(value, dict):
+        return "json"
+    else:
+        return "string"  # Default fallback
+
+
+def _extract_json_paths(
+    obj: Any,
+    current_path: str = "",
+    path_types: dict[str, set[str]] | None = None,
+    level: int = 0,
+) -> dict[str, set[str]]:
+    """
+    Recursively extract all paths and their types from a JSON object.
+    Matches metadataexporter's analyzePValue logic.
+
+    Args:
+        obj: The JSON object to traverse
+        current_path: Current path being built (e.g., "user.name")
+        path_types: Dictionary mapping paths to sets of types found
+        level: Current nesting level (for depth limiting)
+
+    Returns:
+        Dictionary mapping paths to sets of type strings
+    """
+    if path_types is None:
+        path_types = {}
+
+    if obj is None:
+        # Skip null values — matches Go walkNode which errors on ValueTypeEmpty
+        return path_types
+
+    if isinstance(obj, dict):
+        # For objects, recurse into keys without recording the object itself as a type.
+        # Matches Go walkMap which recurses without calling ta.record on the map node.
+
+        for key, value in obj.items():
+            # Build the path for this key
+            if current_path:
+                new_path = f"{current_path}.{key}"
+            else:
+                new_path = key
+
+            # Recurse into the value
+            _extract_json_paths(value, new_path, path_types, level + 1)
+
+    elif isinstance(obj, list):
+        # Skip empty arrays
+        if len(obj) == 0:
+            return path_types
+
+        # Collect types from array elements (matching Go: types := make([]pcommon.ValueType, 0, s.Len()))
+        types = []
+
+        for item in obj:
+            if isinstance(item, dict):
+                # When traversing into array element objects, use ArraySuffix ([])
+                # This matches: prefix+ArraySuffix in the Go code
+                # Example: if current_path is "education", we use "education[]" to traverse into objects
+                array_prefix = current_path + ARRAY_SUFFIX if current_path else ""
+                for key, value in item.items():
+                    if array_prefix:
+                        # Use array separator: education[].name
+                        array_path = f"{array_prefix}.{key}"
+                    else:
+                        array_path = key
+                    # Recurse without increasing level (matching Go behavior)
+                    _extract_json_paths(value, array_path, path_types, level)
+                types.append("JSON")
+            elif isinstance(item, list):
+                # Arrays inside arrays are not supported - skip the whole path
+                # Matching Go: e.logger.Error("arrays inside arrays are not supported!", ...); return nil
+                return path_types
+            elif isinstance(item, str):
+                types.append("String")
+            elif isinstance(item, bool):
+                types.append("Bool")
+            elif isinstance(item, float):
+                types.append("Float64")
+            elif isinstance(item, int):
+                types.append("Int64")
+
+        # Infer array type from collected types (matching Go: if mask := inferArrayMask(types); mask != 0)
+        if len(types) > 0:
+            array_type = _infer_array_type_from_type_strings(types)
+            if array_type and current_path:
+                if current_path not in path_types:
+                    path_types[current_path] = set()
+                path_types[current_path].add(array_type)
+
+    # Primitive value (string, number, bool)
+    elif current_path:
+        if current_path not in path_types:
+            path_types[current_path] = set()
+        obj_type = _python_type_to_clickhouse_type(obj)
+        path_types[current_path].add(obj_type)
+
+    return path_types
+
+
+def _parse_json_bodies_and_extract_paths(
+    json_bodies: list[str],
+    timestamp: datetime.datetime | None = None,
+) -> list[JSONPathType]:
+    """
+    Parse JSON bodies and extract all paths with their types.
+    This mimics the behavior of metadataexporter.
+
+    Args:
+        json_bodies: List of JSON body strings to parse
+        timestamp: Timestamp to use for last_seen (defaults to now)
+
+    Returns:
+        List of JSONPathType objects with all discovered paths and types
+    """
+    if timestamp is None:
+        timestamp = datetime.datetime.now()
+
+    # Aggregate all paths and their types across all JSON bodies
+    all_path_types: dict[str, set[str]] = {}
+
+    for json_body in json_bodies:
+        try:
+            parsed = json.loads(json_body)
+            _extract_json_paths(parsed, "", all_path_types, level=0)
+        except (json.JSONDecodeError, TypeError):
+            # Skip invalid JSON
+            continue
+
+    # Convert to list of JSONPathType objects
+    # Each path can have multiple types, so we create one JSONPathType per type
+    path_type_objects: list[JSONPathType] = []
+    for path, types_set in all_path_types.items():
+        for type_str in types_set:
+            path_type_objects.append(JSONPathType(field_name=path, field_data_type=type_str, last_seen=timestamp))
+
+    return path_type_objects
+
+
+@pytest.fixture(name="export_json_types", scope="function")
+def export_json_types(
+    clickhouse: types.TestContainerClickhouse,
+) -> Generator[Callable[[list[JSONPathType] | list[str] | list[Any]], None], Any]:
+    """
+    Fixture for exporting JSON type metadata to the path_types table.
+    This is a simpler version of metadataexporter for test fixtures.
+
+    The function can accept:
+    1. List of JSONPathType objects (manual specification)
+    2. List of JSON body strings (auto-extract paths)
+    3. List of Logs objects (extract from body_json field)
+
+    Usage examples:
+        # Manual specification
+        export_json_types([
+            JSONPathType(field_name="user.name", field_data_type="string"),
+            JSONPathType(field_name="user.age", field_data_type="int64"),
+        ])
+
+        # Auto-extract from JSON strings
+        export_json_types([
+            '{"user": {"name": "alice", "age": 25}}',
+            '{"user": {"name": "bob", "age": 30}}',
+        ])
+
+        # Auto-extract from Logs objects
+        export_json_types(logs_list)
+    """
+
+    def _export_json_types(
+        data: list[JSONPathType] | list[str] | list[Any],  # List[Logs] but avoiding circular import
+    ) -> None:
+        """
+        Export JSON type metadata to signoz_metadata.distributed_field_keys table.
+        This table stores signal, context, path, and type information for body JSON fields.
+        """
+        path_types: list[JSONPathType] = []
+
+        if len(data) == 0:
+            return
+
+        # Determine input type and convert to JSONPathType list
+        first_item = data[0]
+
+        if isinstance(first_item, JSONPathType):
+            # Already JSONPathType objects
+            path_types = data  # type: ignore
+        elif isinstance(first_item, str):
+            # List of JSON strings - parse and extract paths
+            path_types = _parse_json_bodies_and_extract_paths(data)  # type: ignore
+        else:
+            # Assume it's a list of Logs objects - extract body_v2
+            json_bodies: list[str] = []
+            for log in data:  # type: ignore
+                # Try to get body_v2 attribute
+                if hasattr(log, "body_v2") and log.body_v2:
+                    json_bodies.append(log.body_v2)
+                elif hasattr(log, "body") and log.body:
+                    # Fallback to body if body_v2 not available
+                    try:
+                        # Try to parse as JSON
+                        json.loads(log.body)
+                        json_bodies.append(log.body)
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+
+            if json_bodies:
+                path_types = _parse_json_bodies_and_extract_paths(json_bodies)
+
+        if len(path_types) == 0:
+            return
+
+        clickhouse.conn.insert(
+            database="signoz_metadata",
+            table="distributed_field_keys",
+            data=[path_type.np_arr() for path_type in path_types],
+            column_names=[
+                "signal",
+                "field_context",
+                "field_name",
+                "field_data_type",
+                "last_seen",
+            ],
+        )
+
+    yield _export_json_types
+
+    # Cleanup - truncate the local table after tests (following pattern from logs fixture)
+    clickhouse.conn.query(f"TRUNCATE TABLE signoz_metadata.field_keys ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC")
+
+
+@pytest.fixture(name="create_json_index", scope="function")
+def create_json_index(
+    signoz: types.SigNoz,
+) -> Generator[Callable[[str, list[dict[str, Any]]], None]]:
+    """
+    Create ClickHouse data-skipping indexes on body_v2 JSON sub-columns via
+    POST /api/v1/logs/promote_paths.
+
+    **Must be called BEFORE insert_logs** so that newly inserted data parts are
+    covered by the index and the QB uses the indexed condition path.
+
+    Each entry in `paths` follows the PromotePath API shape:
+        {
+            "path": "body.user.name",          # must start with "body."
+            "indexes": [
+                {
+                    "fieldDataType": "string",   # string | int64 | float64
+                    "type": "ngrambf_v1(3, 256, 2, 0)",  # or "minmax", "tokenbf_v1(...)"
+                    "granularity": 1,
+                }
+            ],
+        }
+
+    Teardown drops every index created during the test by querying
+    system.data_skipping_indices for matching expressions.
+
+    Example::
+
+        def test_foo(signoz, get_token, insert_logs, export_json_types, create_json_body_index):
+            token = get_token(...)
+            export_json_types(logs_list)
+            create_json_body_index(token, [
+                {"path": "body.user.name",
+                 "indexes": [{"fieldDataType": "string", "type": "ngrambf_v1(3, 256, 2, 0)", "granularity": 1}]},
+                {"path": "body.user.age",
+                 "indexes": [{"fieldDataType": "int64", "type": "minmax", "granularity": 1}]},
+            ])
+            insert_logs(logs_list)   # data inserted after index exists — index is built automatically
+    """
+    created_paths: list[str] = []
+
+    def _create_json_body_index(token: str, paths: list[dict[str, Any]]) -> None:
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v1/logs/promote_paths"),
+            headers={"authorization": f"Bearer {token}"},
+            json=paths,
+            timeout=30,
+        )
+        assert response.status_code == HTTPStatus.CREATED, f"Failed to create JSON body indexes: {response.status_code} {response.text}"
+        for path in paths:
+            # The API strips the "body." prefix before storing — mirror that here
+            # so our cleanup query uses the bare path (e.g. "user.name").
+            raw = path["path"].removeprefix("body.")
+            if raw not in created_paths:
+                created_paths.append(raw)
+
+    yield _create_json_body_index
+
+    if not created_paths:
+        return
+
+    cluster = signoz.telemetrystore.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"]
+    for path in created_paths:
+        result = signoz.telemetrystore.conn.query(f"SELECT name FROM system.data_skipping_indices WHERE database = 'signoz_logs' AND table = 'logs_v2' AND expr LIKE '%{path}%'")
+        for (index_name,) in result.result_rows:
+            signoz.telemetrystore.conn.query(f"ALTER TABLE signoz_logs.logs_v2 ON CLUSTER '{cluster}' DROP INDEX IF EXISTS `{index_name}`")

tests/fixtures/logs.py

@@ -121,6 +121,8 @@ class Logs(ABC):
         resources: dict[str, Any] = {},
         attributes: dict[str, Any] = {},
         body: str = "default body",
+        body_v2: str | None = None,
+        body_promoted: str | None = None,
         severity_text: str = "INFO",
         trace_id: str = "",
         span_id: str = "",
@@ -166,6 +168,33 @@ class Logs(ABC):
         # Set body
         self.body = body
 
+        # Set body_v2 - if body is JSON, parse and stringify it, otherwise use empty string
+        # ClickHouse accepts String input for JSON column
+        if body_v2 is not None:
+            self.body_v2 = body_v2
+        else:
+            # Try to parse body as JSON; if successful use it directly,
+            # otherwise wrap as {"message": body} matching the normalize operator behavior.
+            try:
+                json.loads(body)
+                self.body_v2 = body
+            except (json.JSONDecodeError, TypeError):
+                self.body_v2 = json.dumps({"message": body})
+
+        # Set body_promoted - must be valid JSON
+        # Tests will explicitly pass promoted column's content, but we validate it
+        if body_promoted is not None:
+            # Validate that it's valid JSON
+            try:
+                json.loads(body_promoted)
+                self.body_promoted = body_promoted
+            except (json.JSONDecodeError, TypeError):
+                # If invalid, default to empty JSON object
+                self.body_promoted = "{}"
+        else:
+            # Default to empty JSON object (valid JSON)
+            self.body_promoted = "{}"
+
         # Process resources and attributes
         self.resources_string = {k: str(v) for k, v in resources.items()}
         self.resource_json = {} if resource_write_mode == "legacy_only" else dict(self.resources_string)
@@ -309,6 +338,8 @@ class Logs(ABC):
                 self.severity_text,
                 self.severity_number,
                 self.body,
+                self.body_v2,
+                self.body_promoted,
                 self.attributes_string,
                 self.attributes_number,
                 self.attributes_bool,
@@ -436,31 +467,47 @@ def insert_logs_to_clickhouse(conn, logs: list[Logs]) -> None:
             data=[resource_key.np_arr() for resource_key in resource_keys],
         )
 
+    all_column_names = [
+        "ts_bucket_start",
+        "resource_fingerprint",
+        "timestamp",
+        "observed_timestamp",
+        "id",
+        "trace_id",
+        "span_id",
+        "trace_flags",
+        "severity_text",
+        "severity_number",
+        "body",
+        "body_v2",
+        "body_promoted",
+        "attributes_string",
+        "attributes_number",
+        "attributes_bool",
+        "resources_string",
+        "scope_name",
+        "scope_version",
+        "scope_string",
+        "resource",
+    ]
+
+    result = conn.query("SELECT count() FROM system.columns WHERE database = 'signoz_logs' AND table = 'logs_v2' AND name = 'body_v2'")
+    has_json_body = result.result_rows[0][0] > 0
+
+    if has_json_body:
+        column_names = all_column_names
+        data = [log.np_arr() for log in logs]
+    else:
+        json_body_cols = {"body_v2", "body_promoted"}
+        keep_indices = [i for i, c in enumerate(all_column_names) if c not in json_body_cols]
+        column_names = [all_column_names[i] for i in keep_indices]
+        data = [log.np_arr()[keep_indices] for log in logs]
+
     conn.insert(
         database="signoz_logs",
         table="distributed_logs_v2",
-        data=[log.np_arr() for log in logs],
-        column_names=[
-            "ts_bucket_start",
-            "resource_fingerprint",
-            "timestamp",
-            "observed_timestamp",
-            "id",
-            "trace_id",
-            "span_id",
-            "trace_flags",
-            "severity_text",
-            "severity_number",
-            "body",
-            "attributes_string",
-            "attributes_number",
-            "attributes_bool",
-            "resources_string",
-            "scope_name",
-            "scope_version",
-            "scope_string",
-            "resource",
-        ],
+        data=data,
+        column_names=column_names,
     )
 
 

tests/fixtures/migrator.py

@@ -8,27 +8,32 @@ from fixtures.logger import setup_logger
 logger = setup_logger(__name__)
 
 
-@pytest.fixture(name="migrator", scope="package")
-def migrator(
+def create_migrator(
     network: Network,
     clickhouse: types.TestContainerClickhouse,
     request: pytest.FixtureRequest,
     pytestconfig: pytest.Config,
+    cache_key: str = "migrator",
+    env_overrides: dict | None = None,
 ) -> types.Operation:
     """
-    Package-scoped fixture for running schema migrations.
+    Factory function for running schema migrations.
+    Accepts optional env_overrides to customize the migrator environment.
     """
 
     def create() -> None:
         version = request.config.getoption("--schema-migrator-version")
         client = docker.from_env()
 
+        environment = dict(env_overrides) if env_overrides else {}
+
         container = client.containers.run(
             image=f"signoz/signoz-schema-migrator:{version}",
             command=f"sync --replication=true --cluster-name=cluster --up= --dsn={clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_DSN']}",
             detach=True,
             auto_remove=False,
             network=network.id,
+            environment=environment,
         )
 
         result = container.wait()
@@ -47,6 +52,7 @@ def migrator(
             detach=True,
             auto_remove=False,
             network=network.id,
+            environment=environment,
         )
 
         result = container.wait()
@@ -59,7 +65,7 @@ def migrator(
 
         container.remove()
 
-        return types.Operation(name="migrator")
+        return types.Operation(name=cache_key)
 
     def delete(_: types.Operation) -> None:
         pass
@@ -70,9 +76,27 @@ def migrator(
     return reuse.wrap(
         request,
         pytestconfig,
-        "migrator",
+        cache_key,
         lambda: types.Operation(name=""),
         create,
         delete,
         restore,
     )
+
+
+@pytest.fixture(name="migrator", scope="package")
+def migrator(
+    network: Network,
+    clickhouse: types.TestContainerClickhouse,
+    request: pytest.FixtureRequest,
+    pytestconfig: pytest.Config,
+) -> types.Operation:
+    """
+    Package-scoped fixture for running schema migrations.
+    """
+    return create_migrator(
+        network=network,
+        clickhouse=clickhouse,
+        request=request,
+        pytestconfig=pytestconfig,
+    )

tests/fixtures/querier.py

@@ -500,6 +500,14 @@ def get_scalar_columns(response_json: dict) -> list[dict]:
     return results[0].get("columns", [])
 
 
+def get_rows(response: requests.Response) -> list[dict[str, Any]]:
+    assert response.json()["status"] == "success"
+    results = response.json()["data"]["data"]["results"]
+    assert len(results) == 1
+    # The server returns rows:null (not []) when there are 0 matching logs.
+    return results[0].get("rows") or []
+
+
 def get_column_data_from_response(response_json: dict, column_name: str) -> list[Any]:
     results = response_json.get("data", {}).get("data", {}).get("results", [])
     if not results:

tests/integration/tests/querier_json_body/conftest.py

@@ -0,0 +1,67 @@
+import pytest
+from testcontainers.core.container import Network
+
+from fixtures import types
+from fixtures.migrator import create_migrator
+from fixtures.signoz import create_signoz
+
+UNSUPPORTED_CLICKHOUSE_VERSIONS = {"25.5.6"}
+
+
+def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
+    version = config.getoption("--clickhouse-version")
+    if version in UNSUPPORTED_CLICKHOUSE_VERSIONS:
+        skip = pytest.mark.skip(reason=f"JSON body QB tests require ClickHouse > {version}")
+        for item in items:
+            item.add_marker(skip)
+
+
+@pytest.fixture(name="migrator", scope="package")
+def migrator_json(
+    network: Network,
+    clickhouse: types.TestContainerClickhouse,
+    request: pytest.FixtureRequest,
+    pytestconfig: pytest.Config,
+) -> types.Operation:
+    """
+    Package-scoped migrator with ENABLE_LOGS_MIGRATIONS_V2=1.
+    """
+    return create_migrator(
+        network=network,
+        clickhouse=clickhouse,
+        request=request,
+        pytestconfig=pytestconfig,
+        cache_key="migrator-json-body",
+        env_overrides={
+            "ENABLE_LOGS_MIGRATIONS_V2": "1",
+        },
+    )
+
+
+@pytest.fixture(name="signoz", scope="package")
+def signoz_json_body(
+    network: Network,
+    migrator: types.Operation,  # pylint: disable=unused-argument
+    zeus: types.TestContainerDocker,
+    gateway: types.TestContainerDocker,
+    sqlstore: types.TestContainerSQL,
+    clickhouse: types.TestContainerClickhouse,
+    request: pytest.FixtureRequest,
+    pytestconfig: pytest.Config,
+) -> types.SigNoz:
+    """
+    Package-scoped fixture for SigNoz with BODY_JSON_QUERY_ENABLED=true.
+    """
+    return create_signoz(
+        network=network,
+        zeus=zeus,
+        gateway=gateway,
+        sqlstore=sqlstore,
+        clickhouse=clickhouse,
+        request=request,
+        pytestconfig=pytestconfig,
+        cache_key="signoz-json-body",
+        env_overrides={
+            "BODY_JSON_QUERY_ENABLED": "true",
+        },
+    )