chore: use typed argument in logs

Gauge for config limit and counter to count large traces

frontend/src/components/FieldsSelector/AddedFields.tsx

@@ -144,10 +144,7 @@ function AddedFields({
 										field={field}
 										onRemove={handleRemove}
 										allowDrag={allowDrag}
-										isRequired={
-											requiredFields.includes(field.name) ||
-											requiredFields.includes(field.key as string)
-										}
+										isRequired={requiredFields.includes(field.key as string)}
 									/>
 								))}
 							</SortableContext>

frontend/src/components/FieldsSelector/__tests__/AddedFields.test.tsx

@@ -25,7 +25,7 @@ describe('AddedFields — requiredFields', () => {
 		expect(screen.getAllByRole('button', { name: /remove/i })).toHaveLength(3);
 	});
 
-	it('hides the Remove button for fields whose name is in requiredFields', () => {
+	it('hides the Remove button for fields whose composite key is in requiredFields', () => {
 		const fields = [makeField('a'), makeField('b'), makeField('c')];
 
 		render(
@@ -33,7 +33,7 @@ describe('AddedFields — requiredFields', () => {
 				inputValue=""
 				fields={fields}
 				onFieldsChange={jest.fn()}
-				requiredFields={['a', 'c']}
+				requiredFields={['log.a', 'log.c']}
 			/>,
 		);
 
@@ -50,7 +50,7 @@ describe('AddedFields — requiredFields', () => {
 				inputValue=""
 				fields={fields}
 				onFieldsChange={jest.fn()}
-				requiredFields={['a']}
+				requiredFields={['log.a']}
 			/>,
 		);
 
@@ -58,9 +58,9 @@ describe('AddedFields — requiredFields', () => {
 		expect(screen.getByText('b')).toBeInTheDocument();
 	});
 
-	it('locks all variants of a required name regardless of fieldContext', () => {
-		// Two `body` fields with different contexts — both should lock when
-		// `body` is in requiredFields.
+	it('locks ONLY the canonical variant — a same-name field from another context stays removable', () => {
+		// Two `body` fields with different contexts. requiredFields holds the
+		// canonical composite key only, so the attribute variant is deletable.
 		const fields = [makeField('body', 'log'), makeField('body', 'attribute')];
 
 		render(
@@ -68,41 +68,6 @@ describe('AddedFields — requiredFields', () => {
 				inputValue=""
 				fields={fields}
 				onFieldsChange={jest.fn()}
-				requiredFields={['body']}
-			/>,
-		);
-
-		// Both 'body' variants locked → zero Remove buttons.
-		expect(screen.queryAllByRole('button', { name: /remove/i })).toHaveLength(0);
-	});
-
-	it('treats requiredFields as exact-name match (substring does not lock)', () => {
-		const fields = [makeField('body'), makeField('body_extra')];
-
-		render(
-			<AddedFields
-				inputValue=""
-				fields={fields}
-				onFieldsChange={jest.fn()}
-				requiredFields={['body']}
-			/>,
-		);
-
-		// 'body' locked, 'body_extra' removable.
-		expect(screen.getAllByRole('button', { name: /remove/i })).toHaveLength(1);
-	});
-
-	it('also accepts composite IDs in requiredFields (locks a specific variant)', () => {
-		// Two `body` fields with different contexts.
-		const fields = [makeField('body', 'log'), makeField('body', 'attribute')];
-
-		render(
-			<AddedFields
-				inputValue=""
-				fields={fields}
-				onFieldsChange={jest.fn()}
-				// Composite ID — locks ONLY the log variant, attribute variant stays
-				// removable.
 				requiredFields={['log.body']}
 			/>,
 		);
@@ -110,4 +75,37 @@ describe('AddedFields — requiredFields', () => {
 		// One Remove button: the attribute variant. log variant is locked.
 		expect(screen.getAllByRole('button', { name: /remove/i })).toHaveLength(1);
 	});
+
+	it('does not lock anything when a bare name is passed (composite key required)', () => {
+		// Bare `body` no longer matches — matching is composite-key only now.
+		const fields = [makeField('body', 'log'), makeField('body', 'attribute')];
+
+		render(
+			<AddedFields
+				inputValue=""
+				fields={fields}
+				onFieldsChange={jest.fn()}
+				requiredFields={['body']}
+			/>,
+		);
+
+		// Neither variant locked → both removable.
+		expect(screen.getAllByRole('button', { name: /remove/i })).toHaveLength(2);
+	});
+
+	it('treats requiredFields as exact composite-key match (substring does not lock)', () => {
+		const fields = [makeField('body'), makeField('body_extra')];
+
+		render(
+			<AddedFields
+				inputValue=""
+				fields={fields}
+				onFieldsChange={jest.fn()}
+				requiredFields={['log.body']}
+			/>,
+		);
+
+		// 'log.body' locked, 'log.body_extra' removable.
+		expect(screen.getAllByRole('button', { name: /remove/i })).toHaveLength(1);
+	});
 });

frontend/src/components/Logs/TableView/__tests__/useLogsTableColumns.test.tsx

@@ -10,9 +10,9 @@ jest.mock('providers/Timezone', () => ({
 	}),
 }));
 
-const field = (name: string): IField => ({
+const field = (name: string, type = ''): IField => ({
 	name,
-	type: '',
+	type,
 	dataType: 'string',
 });
 
@@ -38,18 +38,16 @@ describe('useLogsTableColumns — selectColumns-order respected', () => {
 			useLogsTableColumns({
 				fields: [
 					field('service.name'),
-					field('body'),
+					field('body', 'log'),
 					field('request.id'),
-					field('timestamp'),
+					field('timestamp', 'log'),
 				],
 				fontSize: FontSize.SMALL,
 			}),
 		);
 
-		// body/timestamp are NOT pinned to fixed positions — they appear where the
-		// caller placed them in `fields`. body/timestamp use composite IDs
-		// ('log.body', 'log.timestamp') since their fieldContext is fixed; user
-		// fields here have empty `type` so their composite collapses to bare name.
+		// body/timestamp appear where the caller placed them, keyed by their
+		// composite IDs ('log.*'); contextless user fields collapse to bare name.
 		expect(result.current.map((c) => c.id)).toStrictEqual([
 			'state-indicator',
 			'service.name',
@@ -59,6 +57,43 @@ describe('useLogsTableColumns — selectColumns-order respected', () => {
 		]);
 	});
 
+	it('renders a same-name field from another context as a DISTINCT column (no collision)', () => {
+		const { result } = renderHook(() =>
+			useLogsTableColumns({
+				fields: [field('body', 'log'), field('body', 'attribute')],
+				fontSize: FontSize.SMALL,
+			}),
+		);
+
+		const byId = new Map(result.current.map((c) => [c.id, c]));
+		// Attribute variant is its own column, not a duplicate 'log.body'.
+		expect(result.current.map((c) => c.id)).toStrictEqual([
+			'state-indicator',
+			'log.body',
+			'attribute.body',
+		]);
+		expect(byId.get('log.body')?.enableRemove).toBe(false);
+		expect(byId.get('attribute.body')?.enableRemove).toBe(true);
+	});
+
+	it('applies the same distinct-column treatment to timestamp variants', () => {
+		const { result } = renderHook(() =>
+			useLogsTableColumns({
+				fields: [field('timestamp', 'log'), field('timestamp', 'attribute')],
+				fontSize: FontSize.SMALL,
+			}),
+		);
+
+		const byId = new Map(result.current.map((c) => [c.id, c]));
+		expect(result.current.map((c) => c.id)).toStrictEqual([
+			'state-indicator',
+			'log.timestamp',
+			'attribute.timestamp',
+		]);
+		expect(byId.get('log.timestamp')?.enableRemove).toBe(false);
+		expect(byId.get('attribute.timestamp')?.enableRemove).toBe(true);
+	});
+
 	it('skips the synthetic "id" field name', () => {
 		const { result } = renderHook(() =>
 			useLogsTableColumns({
@@ -77,7 +112,11 @@ describe('useLogsTableColumns — selectColumns-order respected', () => {
 	it('uses the special body/timestamp coldefs (canBeHidden=false), not the generic user field def', () => {
 		const { result } = renderHook(() =>
 			useLogsTableColumns({
-				fields: [field('body'), field('timestamp'), field('user_field')],
+				fields: [
+					field('body', 'log'),
+					field('timestamp', 'log'),
+					field('user_field'),
+				],
 				fontSize: FontSize.SMALL,
 			}),
 		);

frontend/src/components/Logs/TableView/useLogsTableColumns.tsx

@@ -96,15 +96,18 @@ export function useLogsTableColumns({
 			),
 		});
 
+		// Match body/timestamp by composite key, not bare name — else a variant
+		// like `attribute.body` collapses onto `log.body`, duplicating the column.
 		const fieldCols = fields
 			.map((f): TableColumnDef<ILog> | null => {
 				if (f.name === 'id') {
 					return null;
 				}
-				if (f.name === 'timestamp') {
+				const compositeKey = buildCompositeKey(f.name, f.type);
+				if (compositeKey === timestampCol.id) {
 					return timestampCol;
 				}
-				if (f.name === 'body') {
+				if (compositeKey === bodyCol.id) {
 					return bodyCol;
 				}
 				return makeUserFieldCol(f);

frontend/src/container/OptionsMenu/__test__/ensureLogsRequiredColumns.test.ts

@@ -67,13 +67,23 @@ describe('ensureLogsRequiredColumns', () => {
 		]);
 	});
 
-	it('does not duplicate if a required column appears twice in the input', () => {
-		// Tolerant of malformed input — invariant only adds *missing* required
-		// columns; it does not deduplicate existing entries (that's a separate
-		// concern, not its job).
+	it('collapses composite-key duplicates in the input', () => {
+		// Two identical `body` entries → deduped to one, then timestamp prepended.
 		const input = [BODY, BODY, ATTR_A];
 		const result = ensureLogsRequiredColumns(input);
-		expect(result.filter((c) => c.name === 'timestamp')).toHaveLength(1);
-		expect(result[0]).toStrictEqual(TIMESTAMP);
+		expect(result).toStrictEqual([TIMESTAMP, BODY, ATTR_A]);
+		expect(result.filter((c) => c.name === 'body')).toHaveLength(1);
+	});
+
+	it('keeps same-name fields with different contexts as distinct columns', () => {
+		// Different composite keys → both legitimate, neither deduped.
+		const ATTR_BODY: TelemetryFieldKey = {
+			name: 'body',
+			signal: 'logs',
+			fieldContext: 'attribute',
+			fieldDataType: 'string',
+		};
+		const input = [TIMESTAMP, BODY, ATTR_BODY];
+		expect(ensureLogsRequiredColumns(input)).toStrictEqual(input);
 	});
 });

frontend/src/container/OptionsMenu/constants.ts

@@ -2,6 +2,7 @@ import { TelemetryFieldKey } from 'api/v5/v5';
 import { DataSource } from 'types/common/queryBuilder';
 
 import { FontSize, OptionsQuery } from './types';
+import { buildCompositeKey } from './utils';
 
 export const URL_OPTIONS = 'options';
 
@@ -35,22 +36,48 @@ export const defaultLogsSelectedColumns: TelemetryFieldKey[] = [
 	},
 ];
 
-export const LOGS_REQUIRED_COLUMNS = ['timestamp', 'body'] as const;
+// Names that must always be present in logs selectColumns (writer invariant).
+const LOGS_REQUIRED_COLUMN_NAMES = defaultLogsSelectedColumns.map(
+	(c) => c.name,
+);
 
-/**
- * Always-on invariant: every logs selectColumns array must contain `body` and
- * `timestamp`. Applied at both loader and writer boundaries so the picker, the
- * table, and persisted state can never diverge into a "missing required
- * column" state.
- */
+// Composite keys (not bare names) so the picker locks ONLY the canonical
+// `log.body`/`log.timestamp` — a same-name variant like `attribute.body` stays
+// removable.
+export const LOGS_REQUIRED_COLUMNS = defaultLogsSelectedColumns.map((c) =>
+	buildCompositeKey(c.name, c.fieldContext),
+);
+
+// Drop composite-key duplicates (never legitimate — they only come from
+// corrupted state). Returns the same array reference when nothing to dedupe.
+export function dedupeColumnsByCompositeKey(
+	columns: TelemetryFieldKey[],
+): TelemetryFieldKey[] {
+	const seen = new Set<string>();
+	let hasDuplicate = false;
+	const deduped = columns.filter((c) => {
+		const key = buildCompositeKey(c.name, c.fieldContext);
+		if (seen.has(key)) {
+			hasDuplicate = true;
+			return false;
+		}
+		seen.add(key);
+		return true;
+	});
+	return hasDuplicate ? deduped : columns;
+}
+
+// Logs selectColumns invariant: no composite-key duplicates, and body +
+// timestamp always present. Applied at loader + writer boundaries.
 export function ensureLogsRequiredColumns(
 	columns: TelemetryFieldKey[],
 ): TelemetryFieldKey[] {
-	const missing = LOGS_REQUIRED_COLUMNS.filter(
-		(name) => !columns.some((c) => c.name === name),
+	const deduped = dedupeColumnsByCompositeKey(columns);
+	const missing = LOGS_REQUIRED_COLUMN_NAMES.filter(
+		(name) => !deduped.some((c) => c.name === name),
 	);
 	if (missing.length === 0) {
-		return columns;
+		return deduped;
 	}
 	const defaultsByName = new Map(
 		defaultLogsSelectedColumns.map((c) => [c.name, c]),
@@ -58,7 +85,7 @@ export function ensureLogsRequiredColumns(
 	const prepended = missing
 		.map((name) => defaultsByName.get(name))
 		.filter((c): c is TelemetryFieldKey => c !== undefined);
-	return [...prepended, ...columns];
+	return [...prepended, ...deduped];
 }
 
 export const defaultTraceSelectedColumns: TelemetryFieldKey[] = [

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.tsx

@@ -103,7 +103,7 @@ function CreateOrEdit(props: CreateOrEditProps): JSX.Element {
 
 		return {
 			...rest,
-			...(domainToAdminEmail && { domainToAdminEmail }),
+			domainToAdminEmail: domainToAdminEmail ?? {},
 		};
 	}, [form]);
 
@@ -129,7 +129,7 @@ function CreateOrEdit(props: CreateOrEditProps): JSX.Element {
 
 		return {
 			...rest,
-			...(groupMappings && { groupMappings }),
+			groupMappings: groupMappings ?? {},
 		};
 	}, [form]);
 

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.utils.test.ts

@@ -0,0 +1,144 @@
+import { AuthtypesAuthNProviderDTO } from 'api/generated/services/sigNoz.schemas';
+
+import {
+	convertDomainMappingsToList,
+	convertDomainMappingsToRecord,
+	convertGroupMappingsToList,
+	convertGroupMappingsToRecord,
+	prepareInitialValues,
+} from './CreateEdit.utils';
+
+describe('convertGroupMappingsToRecord', () => {
+	it('returns undefined for an empty list', () => {
+		expect(convertGroupMappingsToRecord([])).toBeUndefined();
+	});
+
+	it('returns undefined when input is undefined', () => {
+		expect(convertGroupMappingsToRecord(undefined)).toBeUndefined();
+	});
+
+	it('converts entries to a Record', () => {
+		expect(
+			convertGroupMappingsToRecord([
+				{ groupName: 'admins', role: 'ADMIN' },
+				{ groupName: 'viewers', role: 'VIEWER' },
+			]),
+		).toStrictEqual({ admins: 'ADMIN', viewers: 'VIEWER' });
+	});
+
+	it('skips entries with missing groupName or role', () => {
+		expect(
+			convertGroupMappingsToRecord([
+				{ groupName: 'admins', role: 'ADMIN' },
+				{ groupName: '', role: 'VIEWER' },
+				{ role: 'EDITOR' },
+			]),
+		).toStrictEqual({ admins: 'ADMIN' });
+	});
+});
+
+describe('convertDomainMappingsToRecord', () => {
+	it('returns undefined for an empty list', () => {
+		expect(convertDomainMappingsToRecord([])).toBeUndefined();
+	});
+
+	it('returns undefined when input is undefined', () => {
+		expect(convertDomainMappingsToRecord(undefined)).toBeUndefined();
+	});
+
+	it('converts entries to a Record', () => {
+		expect(
+			convertDomainMappingsToRecord([
+				{ domain: 'example.com', adminEmail: 'admin@example.com' },
+				{ domain: 'corp.io', adminEmail: 'it@corp.io' },
+			]),
+		).toStrictEqual({
+			'example.com': 'admin@example.com',
+			'corp.io': 'it@corp.io',
+		});
+	});
+});
+
+describe('round-trip fidelity', () => {
+	it('Record → list → Record preserves group mappings', () => {
+		const original = { admins: 'ADMIN', devs: 'EDITOR', viewers: 'VIEWER' };
+		expect(
+			convertGroupMappingsToRecord(convertGroupMappingsToList(original)),
+		).toStrictEqual(original);
+	});
+
+	it('Record → list → Record preserves domain mappings', () => {
+		const original = {
+			'example.com': 'admin@example.com',
+			'corp.io': 'it@corp.io',
+		};
+		expect(
+			convertDomainMappingsToRecord(convertDomainMappingsToList(original)),
+		).toStrictEqual(original);
+	});
+});
+
+describe('prepareInitialValues', () => {
+	it('returns empty defaults when no record is provided', () => {
+		expect(prepareInitialValues(undefined)).toStrictEqual({
+			name: '',
+			ssoEnabled: false,
+			ssoType: '',
+		});
+	});
+
+	it('hydrates groupMappings Record into groupMappingsList for the form', () => {
+		const result = prepareInitialValues({
+			id: 'domain-1',
+			name: 'example.com',
+			config: {
+				ssoEnabled: true,
+				ssoType: AuthtypesAuthNProviderDTO.saml,
+				roleMapping: {
+					defaultRole: 'VIEWER',
+					useRoleAttribute: false,
+					groupMappings: { admins: 'ADMIN', viewers: 'VIEWER' },
+				},
+			},
+		});
+
+		expect(result.roleMapping?.groupMappingsList).toStrictEqual([
+			{ groupName: 'admins', role: 'ADMIN' },
+			{ groupName: 'viewers', role: 'VIEWER' },
+		]);
+	});
+
+	it('hydrates domainToAdminEmail Record into domainToAdminEmailList for the form', () => {
+		const result = prepareInitialValues({
+			id: 'domain-1',
+			name: 'example.com',
+			config: {
+				ssoEnabled: true,
+				ssoType: AuthtypesAuthNProviderDTO.google_auth,
+				googleAuthConfig: {
+					clientId: 'id',
+					clientSecret: 'secret',
+					domainToAdminEmail: { 'example.com': 'admin@example.com' },
+				},
+			},
+		});
+
+		expect(result.googleAuthConfig?.domainToAdminEmailList).toStrictEqual([
+			{ domain: 'example.com', adminEmail: 'admin@example.com' },
+		]);
+	});
+
+	it('sets groupMappingsList to empty array when roleMapping has no groupMappings', () => {
+		const result = prepareInitialValues({
+			id: 'domain-1',
+			name: 'example.com',
+			config: {
+				ssoEnabled: true,
+				ssoType: AuthtypesAuthNProviderDTO.oidc,
+				roleMapping: { defaultRole: 'VIEWER', useRoleAttribute: true },
+			},
+		});
+
+		expect(result.roleMapping?.groupMappingsList).toStrictEqual([]);
+	});
+});

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/CreateEdit.payload.test.tsx

@@ -0,0 +1,169 @@
+import { fireEvent, render, screen, waitFor } from 'tests/test-utils';
+import { rest, server } from 'mocks-server/server';
+
+import CreateEdit from '../CreateEdit/CreateEdit';
+import {
+	AUTH_DOMAINS_UPDATE_ENDPOINT,
+	mockDomainWithRoleMapping,
+	mockGoogleAuthWithWorkspaceGroups,
+	mockUpdateSuccessResponse,
+} from './mocks';
+
+// The real @signozhq/ui/button has internal effects that prevent form.validateFields()
+// from resolving inside act(). Mirror the pattern from SSOEnforcementToggle.test.tsx
+// which mocks @signozhq/ui/switch for the same reason.
+jest.mock('@signozhq/ui/button', () => ({
+	...jest.requireActual('@signozhq/ui/button'),
+	Button: ({
+		children,
+		onClick,
+		loading,
+		disabled,
+		'aria-label': ariaLabel,
+		prefix,
+		suffix,
+	}: {
+		children?: React.ReactNode;
+		onClick?: React.MouseEventHandler<HTMLButtonElement>;
+		loading?: boolean;
+		disabled?: boolean;
+		'aria-label'?: string;
+		prefix?: React.ReactNode;
+		suffix?: React.ReactNode;
+	}) => (
+		<button
+			type="button"
+			onClick={onClick}
+			disabled={disabled || loading}
+			aria-label={ariaLabel}
+		>
+			{prefix}
+			{children}
+			{suffix}
+		</button>
+	),
+}));
+
+describe('CreateEdit — save payload correctness', () => {
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('sends groupMappings: {} when all group mappings are deleted', async () => {
+		let capturedPayload: unknown = null;
+
+		server.use(
+			rest.put(AUTH_DOMAINS_UPDATE_ENDPOINT, async (req, res, ctx) => {
+				capturedPayload = await req.json();
+				return res(ctx.status(200), ctx.json(mockUpdateSuccessResponse));
+			}),
+		);
+
+		render(
+			<CreateEdit
+				isCreate={false}
+				record={mockDomainWithRoleMapping}
+				onClose={jest.fn()}
+			/>,
+		);
+
+		// Open the Role Mapping collapse (Ant Design Collapse responds to click events)
+		fireEvent.click(screen.getByText(/role mapping \(advanced\)/i));
+
+		// Wait for the 3 group mapping rows to appear
+		await waitFor(() =>
+			expect(
+				screen.getAllByRole('button', { name: /remove mapping/i }),
+			).toHaveLength(3),
+		);
+
+		// Delete each row; re-query after each removal
+		fireEvent.click(
+			screen.getAllByRole('button', { name: /remove mapping/i })[0],
+		);
+		await waitFor(() =>
+			expect(
+				screen.getAllByRole('button', { name: /remove mapping/i }),
+			).toHaveLength(2),
+		);
+
+		fireEvent.click(
+			screen.getAllByRole('button', { name: /remove mapping/i })[0],
+		);
+		await waitFor(() =>
+			expect(
+				screen.getAllByRole('button', { name: /remove mapping/i }),
+			).toHaveLength(1),
+		);
+
+		fireEvent.click(
+			screen.getAllByRole('button', { name: /remove mapping/i })[0],
+		);
+		await waitFor(() =>
+			expect(
+				screen.queryAllByRole('button', { name: /remove mapping/i }),
+			).toHaveLength(0),
+		);
+
+		// Submit — MSW intercepts the PUT request
+		fireEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+		await waitFor(() => expect(capturedPayload).not.toBeNull());
+
+		expect(capturedPayload).toMatchObject({
+			config: expect.objectContaining({
+				roleMapping: expect.objectContaining({ groupMappings: {} }),
+			}),
+		});
+	});
+
+	it('sends domainToAdminEmail: {} when all domain mappings are deleted', async () => {
+		let capturedPayload: unknown = null;
+
+		server.use(
+			rest.put(AUTH_DOMAINS_UPDATE_ENDPOINT, async (req, res, ctx) => {
+				capturedPayload = await req.json();
+				return res(ctx.status(200), ctx.json(mockUpdateSuccessResponse));
+			}),
+		);
+
+		render(
+			<CreateEdit
+				isCreate={false}
+				record={mockGoogleAuthWithWorkspaceGroups}
+				onClose={jest.fn()}
+			/>,
+		);
+
+		// Open the Google Workspace Groups collapse
+		fireEvent.click(screen.getByText(/google workspace groups/i));
+
+		// Wait for the single domain mapping row
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /remove mapping/i }),
+			).toBeInTheDocument(),
+		);
+
+		// Delete the row
+		fireEvent.click(screen.getByRole('button', { name: /remove mapping/i }));
+		await waitFor(() =>
+			expect(
+				screen.queryAllByRole('button', { name: /remove mapping/i }),
+			).toHaveLength(0),
+		);
+
+		// Submit
+		fireEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+		await waitFor(() => expect(capturedPayload).not.toBeNull());
+
+		expect(capturedPayload).toMatchObject({
+			config: expect.objectContaining({
+				googleAuthConfig: expect.objectContaining({
+					domainToAdminEmail: {},
+				}),
+			}),
+		});
+	});
+});

pkg/modules/tracedetail/impltracedetail/module.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
@@ -13,15 +14,27 @@ type module struct {
 	store    spantypes.TraceStore
 	settings factory.ScopedProviderSettings
 	config   tracedetail.Config
+	metrics  *moduleMetrics
 }
 
 func NewModule(traceStore spantypes.TraceStore, providerSettings factory.ProviderSettings, cfg tracedetail.Config) *module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/tracedetail/impltracedetail")
-	return &module{
+
+	metrics, err := newModuleMetrics(scopedProviderSettings.Meter())
+	if err != nil {
+		scopedProviderSettings.Logger().WarnContext(context.Background(), "tracedetail: failed to initialize metrics", errors.Attr(err))
+	}
+
+	m := &module{
 		config:   cfg,
 		store:    traceStore,
 		settings: scopedProviderSettings,
+		metrics:  metrics,
 	}
+
+	m.metrics.waterfallMaxLimitToSelectAllSpans.Record(context.Background(), int64(cfg.Waterfall.MaxLimitToSelectAllSpans))
+
+	return m
 }
 
 func (m *module) GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error) {
@@ -80,6 +93,7 @@ func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpa
 	}
 	effectiveLimit := min(selectAllLimit, m.config.Waterfall.MaxLimitToSelectAllSpans)
 	if summary.NumSpans > uint64(effectiveLimit) {
+		m.metrics.waterfallWindowedResponseCount.Add(ctx, 1)
 		return m.getWindowedWaterfall(ctx, traceID, selectedSpanID, uncollapsedSpans, summary.Start, summary.End)
 	}
 	return m.getFullWaterfall(ctx, traceID, summary)

pkg/modules/tracedetail/impltracedetail/telemetry.go

@@ -0,0 +1,37 @@
+package impltracedetail
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"go.opentelemetry.io/otel/metric"
+)
+
+type moduleMetrics struct {
+	waterfallMaxLimitToSelectAllSpans metric.Int64Gauge
+	waterfallWindowedResponseCount    metric.Int64Counter
+}
+
+func newModuleMetrics(meter metric.Meter) (*moduleMetrics, error) {
+	var errs error
+
+	maxLimitGauge, err := meter.Int64Gauge(
+		"signoz.traces.waterfall.max_limit_to_select_all_spans",
+		metric.WithDescription("The span count limit above which windowed waterfall is returned instead of the full waterfall."),
+		metric.WithUnit("{spans}"),
+	)
+	if err != nil {
+		errs = errors.Join(errs, err)
+	}
+
+	windowedCounter, err := meter.Int64Counter(
+		"signoz.traces.waterfall.windowed_responses",
+		metric.WithDescription("Total number of waterfall requests that used the windowed path."),
+	)
+	if err != nil {
+		errs = errors.Join(errs, err)
+	}
+
+	return &moduleMetrics{
+		waterfallMaxLimitToSelectAllSpans: maxLimitGauge,
+		waterfallWindowedResponseCount:    windowedCounter,
+	}, errs
+}