feat(rules): extract recent log samples for log-based alerts

Log-based alerts currently attach only a link to the related logs, so a
responder has to navigate to the explorer to see what fired the alert.
This extracts the most recent matching log lines during rule evaluation
and stores them in a new public `related_logs_samples` annotation,
alongside the existing `related_logs` link.

- Refactor the link's filter computation into a shared `logsQueryParams`
  helper so the samples query reuses the exact same per-group where
  clause as the related-logs link (samples == the logs the link opens).
- `fetchLogSamples` issues a RequestTypeRaw query (timestamp,id DESC,
  limit 5) for the breaching group. It is best-effort: any failure is
  logged and yields no samples rather than failing evaluation.
- `formatLogSamples` renders a compact, code-fenced block (one line per
  record), skipping empty bodies and truncating each to 512 runes.
- Skipped for no-data alerts.

Notification-channel rendering (email/Slack) is intentionally out of
scope here; the annotation already flows to webhook and custom
templates as $related_logs_samples.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

@@ -4,6 +4,7 @@ import { Dot } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 import Noz from 'components/Noz/Noz';
+import { NOZ_TOOLTIP_TITLE } from 'components/Noz/Noz.constants';
 import { Popover } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { AIAssistantEvents } from 'container/AIAssistant/events';
@@ -109,7 +110,7 @@ function HeaderRightSection({
 						</span>
 					) : null}
 
-					<TooltipSimple title="Noz">
+					<TooltipSimple title={NOZ_TOOLTIP_TITLE}>
 						<Button
 							variant="solid"
 							color="secondary"

frontend/src/components/Noz/Noz.constants.ts

@@ -0,0 +1,2 @@
+/** Shared hover copy for every Noz entry point (header, floating trigger, sidebar). */
+export const NOZ_TOOLTIP_TITLE = 'Noz, your AI teammate';

frontend/src/components/ShiftOverlay/ShiftHoldOverlayController.tsx

@@ -14,9 +14,7 @@ export function ShiftHoldOverlayController({
 
 	const actions = createShortcutActions({
 		navigate: noop,
-		// Overlay is read-only — actions never fire — so we only need a no-op
-		// that satisfies the typed signature.
-		handleThemeChange: (): void => undefined,
+		handleThemeChange: noop,
 	});
 
 	const visible = useShiftHoldOverlay({

frontend/src/components/cmdKPalette/__test__/cmdkPalette.test.tsx

@@ -116,35 +116,17 @@ jest.mock('hooks/useNotifications', (): unknown => ({
 }));
 
 // mock theme hook
-//
-// We spread jest.requireActual so additions to hooks/useDarkMode (new hooks,
-// re-exports, contexts) keep working in this test without needing the mock to
-// re-enumerate every export. We only override the hooks the palette actually
-// calls.
-jest.mock('hooks/useDarkMode', (): unknown => {
-	const actual = jest.requireActual('hooks/useDarkMode');
-	const useThemeModeMock = (): {
+jest.mock('hooks/useDarkMode', (): unknown => ({
+	useThemeMode: (): {
 		setAutoSwitch: jest.Mock;
 		setTheme: jest.Mock;
-		toggleTheme: jest.Mock;
 		theme: string;
-		autoSwitch: boolean;
 	} => ({
 		setAutoSwitch: jest.fn(),
 		setTheme: jest.fn(),
-		toggleTheme: jest.fn(),
 		theme: 'dark',
-		autoSwitch: false,
-	});
-	return {
-		...actual,
-		__esModule: true,
-		default: useThemeModeMock,
-		useThemeMode: useThemeModeMock,
-		useIsDarkMode: (): boolean => true,
-		useSystemTheme: (): 'dark' | 'light' => 'dark',
-	};
-});
+	}),
+}));
 
 // mock updateUserPreference API and react-query mutation
 jest.mock('api/v1/user/preferences/name/update', (): jest.Mock => jest.fn());

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -21,8 +21,6 @@ import {
 	useAIAssistantStore,
 } from 'container/AIAssistant/store/useAIAssistantStore';
 import { useThemeMode } from 'hooks/useDarkMode';
-import { ThemeMode } from 'hooks/useDarkMode/constant';
-import { useThemeSelection } from 'hooks/useDarkMode/useThemeSelection';
 import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
 import history from 'lib/history';
 import { ROLES as UserRole } from 'types/roles';
@@ -50,8 +48,7 @@ export function CmdKPalette({
 }): JSX.Element | null {
 	const { open, setOpen } = useCmdK();
 
-	const { theme } = useThemeMode();
-	const selectTheme = useThemeSelection();
+	const { setAutoSwitch, setTheme, theme } = useThemeMode();
 	const location = useLocation();
 	const isAIAssistantEnabled = useIsAIAssistantEnabled();
 	const startNewConversation = useAIAssistantStore(
@@ -84,12 +81,14 @@ export function CmdKPalette({
 
 	useEffect(cmdKEffect, [setOpen]);
 
-	function handleThemeChange(value: ThemeMode): void {
+	function handleThemeChange(value: string): void {
 		logEvent('Account Settings: Theme Changed', { theme: value });
-		// Close the palette inside the same flushSync batch as the theme change
-		// so its dismissal is part of the captured "new" frame of the wipe;
-		// otherwise the dialog would be visible in both snapshots and flicker.
-		selectTheme(value, () => setOpen(false));
+		if (value === 'auto') {
+			setAutoSwitch(true);
+		} else {
+			setAutoSwitch(false);
+			setTheme(value);
+		}
 	}
 
 	function onClickHandler(key: string): void {

frontend/src/constants/shortcutActions.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import ROUTES from 'constants/routes';
 import { GlobalShortcutsName } from 'constants/shortcuts/globalShortcuts';
-import { THEME_MODE, ThemeMode } from 'hooks/useDarkMode/constant';
+import { THEME_MODE } from 'hooks/useDarkMode/constant';
 import {
 	BarChart,
 	BellDot,
@@ -34,7 +34,7 @@ export type CmdAction = {
 
 type ActionDeps = {
 	navigate: (path: string) => void;
-	handleThemeChange: (mode: ThemeMode) => void;
+	handleThemeChange: (mode: string) => void;
 	/**
 	 * Provided only when the AI Assistant feature is available for the current
 	 * tenant. When present, the palette surfaces an "Open AI Assistant" entry

frontend/src/container/AIAssistant/AIAssistantTrigger/AIAssistantTrigger.tsx

@@ -5,6 +5,7 @@ import { TooltipSimple } from '@signozhq/ui/tooltip';
 import logEvent from 'api/common/logEvent';
 import ROUTES from 'constants/routes';
 import Noz from 'components/Noz/Noz';
+import { NOZ_TOOLTIP_TITLE } from 'components/Noz/Noz.constants';
 
 import { AIAssistantEvents, AIAssistantOpenSource } from '../events';
 import { normalizePage } from '../hooks/useAIAssistantAnalyticsContext';
@@ -42,16 +43,15 @@ export default function AIAssistantTrigger(): JSX.Element | null {
 	}
 
 	return (
-		<TooltipSimple title="Noz">
+		<TooltipSimple title={NOZ_TOOLTIP_TITLE}>
 			<Button
 				variant="solid"
 				color="primary"
 				className={`${styles.trigger} noz-wave`}
 				onClick={handleOpen}
 				aria-label="Open Noz"
-			>
-				<Noz size={24} />
-			</Button>
+				prefix={<Noz size={24} />}
+			/>
 		</TooltipSimple>
 	);
 }

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

@@ -12,8 +12,6 @@ import APIError from 'types/api/error';
 import { toast } from '@signozhq/ui/sonner';
 
 const toggleThemeFunction = jest.fn();
-const setThemeFunction = jest.fn();
-const setAutoSwitchFunction = jest.fn();
 const logEventFunction = jest.fn();
 const copyToClipboardFn = jest.fn();
 const editUserFn = jest.fn();
@@ -58,11 +56,9 @@ jest.mock('hooks/useDarkMode', () => ({
 	useIsDarkMode: jest.fn(() => true),
 	useSystemTheme: jest.fn(() => 'dark'),
 	default: jest.fn(() => ({
-		theme: 'dark',
-		setTheme: setThemeFunction,
 		toggleTheme: toggleThemeFunction,
 		autoSwitch: false,
-		setAutoSwitch: setAutoSwitchFunction,
+		setAutoSwitch: jest.fn(),
 	})),
 }));
 
@@ -138,8 +134,7 @@ describe('MySettings Flows', () => {
 			fireEvent.click(lightOption);
 
 			await waitFor(() => {
-				expect(setAutoSwitchFunction).toHaveBeenCalledWith(false);
-				expect(setThemeFunction).toHaveBeenCalledWith('light');
+				expect(toggleThemeFunction).toHaveBeenCalled();
 				expect(logEventFunction).toHaveBeenCalledWith(
 					'Account Settings: Theme Changed',
 					{
@@ -147,10 +142,6 @@ describe('MySettings Flows', () => {
 					},
 				);
 			});
-
-			// Lock in that the new selectTheme flow does not call toggleTheme;
-			// otherwise we'd double-flip on top of the explicit setTheme call.
-			expect(toggleThemeFunction).not.toHaveBeenCalled();
 		});
 	});
 

frontend/src/container/MySettings/index.tsx

@@ -9,8 +9,6 @@ import updateUserPreference from 'api/v1/user/preferences/name/update';
 import { AxiosError } from 'axios';
 import { USER_PREFERENCES } from 'constants/userPreferences';
 import useThemeMode, { useIsDarkMode, useSystemTheme } from 'hooks/useDarkMode';
-import { THEME_MODE, ThemeMode } from 'hooks/useDarkMode/constant';
-import { useThemeSelection } from 'hooks/useDarkMode/useThemeSelection';
 import { useNotifications } from 'hooks/useNotifications';
 import { MonitorCog, Moon, Sun } from '@signozhq/icons';
 import { useAppContext } from 'providers/App/App';
@@ -26,10 +24,9 @@ import './MySettings.styles.scss';
 function MySettings(): JSX.Element {
 	const isDarkMode = useIsDarkMode();
 	const { userPreferences, updateUserPreferenceInContext } = useAppContext();
-	const { autoSwitch } = useThemeMode();
+	const { toggleTheme, autoSwitch, setAutoSwitch } = useThemeMode();
 	const systemTheme = useSystemTheme();
 	const { notifications } = useNotifications();
-	const selectTheme = useThemeSelection();
 
 	const [sideNavPinned, setSideNavPinned] = useState(false);
 
@@ -62,7 +59,7 @@ function MySettings(): JSX.Element {
 					<Moon data-testid="dark-theme-icon" size={12} /> Dark{' '}
 				</div>
 			),
-			value: THEME_MODE.DARK,
+			value: 'dark',
 		},
 		{
 			label: (
@@ -71,7 +68,7 @@ function MySettings(): JSX.Element {
 					<Badge color="robin">Beta</Badge>
 				</div>
 			),
-			value: THEME_MODE.LIGHT,
+			value: 'light',
 		},
 		{
 			label: (
@@ -79,31 +76,46 @@ function MySettings(): JSX.Element {
 					<MonitorCog size={12} data-testid="auto-theme-icon" /> System{' '}
 				</div>
 			),
-			value: THEME_MODE.SYSTEM,
+			value: 'auto',
 		},
 	];
 
 	const [theme, setTheme] = useState(() => {
 		if (autoSwitch) {
-			return THEME_MODE.SYSTEM;
+			return 'auto';
 		}
-		return isDarkMode ? THEME_MODE.DARK : THEME_MODE.LIGHT;
+		return isDarkMode ? 'dark' : 'light';
 	});
 
 	const handleThemeChange = (value: string): void => {
-		// ToggleGroupSimple items above are all THEME_MODE values, so narrowing
-		// the string here is safe.
-		const mode = value as ThemeMode;
-		logEvent('Account Settings: Theme Changed', { theme: mode });
-		selectTheme(mode);
+		logEvent('Account Settings: Theme Changed', {
+			theme: value,
+		});
+		setTheme(value);
+
+		if (value === 'auto') {
+			setAutoSwitch(true);
+		} else {
+			setAutoSwitch(false);
+			// Only toggle if the current theme is different from the target
+			const targetIsDark = value === 'dark';
+			if (targetIsDark !== isDarkMode) {
+				toggleTheme();
+			}
+		}
 	};
 
 	useEffect(() => {
 		if (autoSwitch) {
-			setTheme(THEME_MODE.SYSTEM);
+			setTheme('auto');
 			return;
 		}
-		setTheme(isDarkMode ? THEME_MODE.DARK : THEME_MODE.LIGHT);
+
+		if (isDarkMode) {
+			setTheme('dark');
+		} else {
+			setTheme('light');
+		}
 	}, [autoSwitch, isDarkMode]);
 
 	const handleSideNavPinnedChange = (checked: boolean): void => {

frontend/src/container/SideNav/NavItem/NavItem.tsx

@@ -5,7 +5,6 @@ import { Pin, PinOff } from '@signozhq/icons';
 
 import { SidebarItem } from '../sideNav.types';
 
-import './NavItem.styles.scss';
 import './NavItem.styles.scss';
 
 export default function NavItem({
@@ -27,7 +26,7 @@ export default function NavItem({
 	showIcon?: boolean;
 	dataTestId?: string;
 }): JSX.Element {
-	const { label, icon, isBeta, isNew, isEarlyAccess } = item;
+	const { label, icon, isBeta, isNew, isEarlyAccess, tooltip } = item;
 
 	const handleTogglePinClick = (
 		event: React.MouseEvent<SVGSVGElement, MouseEvent>,
@@ -36,7 +35,7 @@ export default function NavItem({
 		onTogglePin?.(item);
 	};
 
-	return (
+	const navItem = (
 		<div
 			className={cx(
 				'nav-item',
@@ -107,6 +106,15 @@ export default function NavItem({
 			</div>
 		</div>
 	);
+
+	// Only non-pinnable items set `tooltip`; it would nest with the pin tooltip.
+	return tooltip ? (
+		<Tooltip title={tooltip} placement="right">
+			{navItem}
+		</Tooltip>
+	) : (
+		navItem
+	);
 }
 
 NavItem.defaultProps = {

frontend/src/container/SideNav/menuItems.tsx

@@ -45,6 +45,7 @@ import {
 } from './sideNav.types';
 import { Style } from '@signozhq/design-tokens';
 import Noz from 'components/Noz/Noz';
+import { NOZ_TOOLTIP_TITLE } from 'components/Noz/Noz.constants';
 
 export const getStartedMenuItem = {
 	key: ROUTES.GET_STARTED,
@@ -97,6 +98,7 @@ export const aiAssistantMenuItem = {
 	icon: <Noz size={16} />,
 	itemKey: 'ai-assistant',
 	isEarlyAccess: true,
+	tooltip: NOZ_TOOLTIP_TITLE,
 };
 
 export const shortcutMenuItem = {

frontend/src/container/SideNav/sideNav.types.ts

@@ -15,6 +15,8 @@ export interface SidebarItem {
 	isBeta?: boolean;
 	isNew?: boolean;
 	isEarlyAccess?: boolean;
+	/** Hover copy for the whole item row (e.g. Noz's early-access tagline). */
+	tooltip?: ReactNode;
 	isPinned?: boolean;
 	children?: SidebarItem[];
 	isExternal?: boolean;

frontend/src/hooks/useDarkMode/__tests__/useThemeSelection.test.tsx

@@ -1,164 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-
-import { useThemeSelection } from '../useThemeSelection';
-
-const setThemeMock = jest.fn();
-const setAutoSwitchMock = jest.fn();
-let themeValue = 'dark';
-let systemThemeValue: 'dark' | 'light' = 'light';
-
-jest.mock('hooks/useDarkMode', () => ({
-	__esModule: true,
-	default: (): {
-		theme: string;
-		setTheme: jest.Mock;
-		setAutoSwitch: jest.Mock;
-		toggleTheme: jest.Mock;
-		autoSwitch: boolean;
-	} => ({
-		theme: themeValue,
-		setTheme: setThemeMock,
-		setAutoSwitch: setAutoSwitchMock,
-		toggleTheme: jest.fn(),
-		autoSwitch: false,
-	}),
-	useThemeMode: (): {
-		theme: string;
-		setTheme: jest.Mock;
-		setAutoSwitch: jest.Mock;
-		toggleTheme: jest.Mock;
-		autoSwitch: boolean;
-	} => ({
-		theme: themeValue,
-		setTheme: setThemeMock,
-		setAutoSwitch: setAutoSwitchMock,
-		toggleTheme: jest.fn(),
-		autoSwitch: false,
-	}),
-	useSystemTheme: (): 'dark' | 'light' => systemThemeValue,
-	useIsDarkMode: (): boolean => themeValue === 'dark',
-}));
-
-const canAnimateMock = jest.fn();
-const runTransitionMock = jest.fn();
-
-jest.mock('utils/themeTransition', () => ({
-	__esModule: true,
-	canAnimateThemeTransition: (): boolean => canAnimateMock(),
-	runThemeTransition: (cb: () => void): void => runTransitionMock(cb),
-}));
-
-describe('useThemeSelection', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		themeValue = 'dark';
-		systemThemeValue = 'light';
-		canAnimateMock.mockReturnValue(false);
-		// Default behaviour: invoke the applyChange callback synchronously.
-		runTransitionMock.mockImplementation((cb: () => void) => cb());
-	});
-
-	it('applies an explicit light theme without auto-switch', () => {
-		themeValue = 'dark';
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('light'));
-
-		expect(setAutoSwitchMock).toHaveBeenCalledWith(false);
-		expect(setThemeMock).toHaveBeenCalledWith('light');
-	});
-
-	it('applies an explicit dark theme without auto-switch', () => {
-		themeValue = 'light';
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('dark'));
-
-		expect(setAutoSwitchMock).toHaveBeenCalledWith(false);
-		expect(setThemeMock).toHaveBeenCalledWith('dark');
-	});
-
-	it('SYSTEM with a light system preference resolves to setTheme("light") + auto on', () => {
-		themeValue = 'dark';
-		systemThemeValue = 'light';
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('auto'));
-
-		expect(setAutoSwitchMock).toHaveBeenCalledWith(true);
-		// Explicit resolved value is what keeps the wipe snapshot accurate;
-		// see the comment in useThemeSelection for the failure mode.
-		expect(setThemeMock).toHaveBeenCalledWith('light');
-	});
-
-	it('SYSTEM with a dark system preference resolves to setTheme("dark") + auto on', () => {
-		themeValue = 'light';
-		systemThemeValue = 'dark';
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('auto'));
-
-		expect(setAutoSwitchMock).toHaveBeenCalledWith(true);
-		expect(setThemeMock).toHaveBeenCalledWith('dark');
-	});
-
-	it('invokes onApplied inside the same batch, after the state mutations', () => {
-		themeValue = 'dark';
-		const onApplied = jest.fn();
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('light', onApplied));
-
-		expect(onApplied).toHaveBeenCalledTimes(1);
-		expect(setThemeMock.mock.invocationCallOrder[0]).toBeLessThan(
-			onApplied.mock.invocationCallOrder[0],
-		);
-	});
-
-	it('routes through runThemeTransition when the dark↔light state actually flips', () => {
-		themeValue = 'dark';
-		canAnimateMock.mockReturnValue(true);
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('light'));
-
-		expect(runTransitionMock).toHaveBeenCalledTimes(1);
-		expect(setThemeMock).toHaveBeenCalledWith('light');
-	});
-
-	it('skips runThemeTransition when no dark↔light flip happens', () => {
-		themeValue = 'dark';
-		canAnimateMock.mockReturnValue(true);
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('dark'));
-
-		expect(runTransitionMock).not.toHaveBeenCalled();
-		// applyChange still ran inline.
-		expect(setThemeMock).toHaveBeenCalledWith('dark');
-	});
-
-	it('skips runThemeTransition when SYSTEM resolves to the currently-rendered theme', () => {
-		themeValue = 'dark';
-		systemThemeValue = 'dark';
-		canAnimateMock.mockReturnValue(true);
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('auto'));
-
-		expect(runTransitionMock).not.toHaveBeenCalled();
-		expect(setAutoSwitchMock).toHaveBeenCalledWith(true);
-		expect(setThemeMock).toHaveBeenCalledWith('dark');
-	});
-
-	it('skips runThemeTransition when capability check is false even if the theme flips', () => {
-		themeValue = 'dark';
-		canAnimateMock.mockReturnValue(false);
-		const { result } = renderHook(() => useThemeSelection());
-
-		act(() => result.current('light'));
-
-		expect(runTransitionMock).not.toHaveBeenCalled();
-		expect(setThemeMock).toHaveBeenCalledWith('light');
-	});
-});

frontend/src/hooks/useDarkMode/constant.ts

@@ -2,6 +2,4 @@ export const THEME_MODE = {
 	LIGHT: 'light',
 	DARK: 'dark',
 	SYSTEM: 'auto',
-} as const;
-
-export type ThemeMode = (typeof THEME_MODE)[keyof typeof THEME_MODE];
+};

frontend/src/hooks/useDarkMode/index.tsx

@@ -18,13 +18,7 @@ import { LOCALSTORAGE } from 'constants/localStorage';
 
 import { THEME_MODE } from './constant';
 
-export const ThemeContext = createContext<{
-	theme: string;
-	toggleTheme: () => void;
-	autoSwitch: boolean;
-	setAutoSwitch: Dispatch<SetStateAction<boolean>>;
-	setTheme: Dispatch<SetStateAction<string>>;
-}>({
+export const ThemeContext = createContext({
 	theme: THEME_MODE.DARK,
 	toggleTheme: (): void => {},
 	autoSwitch: false,

frontend/src/hooks/useDarkMode/useThemeSelection.ts

@@ -1,67 +0,0 @@
-import { useCallback } from 'react';
-import {
-	canAnimateThemeTransition,
-	runThemeTransition,
-} from 'utils/themeTransition';
-
-import useThemeMode, { useSystemTheme } from './index';
-import { THEME_MODE, ThemeMode } from './constant';
-
-type SelectTheme = (value: ThemeMode, onApplied?: () => void) => void;
-
-// Centralises the "apply a theme selection" flow used by MySettings and the
-// command palette: figures out whether the visible (dark↔light) theme is
-// actually flipping, applies the state change, and — when capable — wraps the
-// change in a left→right view-transition wipe.
-//
-// `value` is one of THEME_MODE.{LIGHT,DARK,SYSTEM}; `onApplied` runs inside the
-// same flushSync batch as the theme change (useful for, e.g., closing the
-// command palette so its dismissal is part of the captured "new" snapshot).
-export function useThemeSelection(): SelectTheme {
-	const { theme, setTheme, setAutoSwitch } = useThemeMode();
-	const systemTheme = useSystemTheme();
-
-	return useCallback<SelectTheme>(
-		(value, onApplied) => {
-			const currentIsDark = theme === THEME_MODE.DARK;
-
-			// When switching to SYSTEM, the visible theme flips iff the OS preference
-			// differs from what we're currently rendering. For explicit LIGHT/DARK,
-			// resolvedTargetIsDark is just (value === DARK).
-			const resolvedTargetIsDark =
-				value === THEME_MODE.SYSTEM
-					? systemTheme === THEME_MODE.DARK
-					: value === THEME_MODE.DARK;
-			const isSystem = value === THEME_MODE.SYSTEM;
-
-			// Always push the resolved LIGHT/DARK through setTheme synchronously so
-			// the View Transition snapshot reflects the new theme. If we relied on
-			// ThemeProvider's effect (setAutoSwitch → re-render → effect →
-			// setThemeState), the flip wouldn't be guaranteed to run inside this
-			// flushSync batch and the wipe would capture old → old, then snap.
-			const resolvedTheme = resolvedTargetIsDark
-				? THEME_MODE.DARK
-				: THEME_MODE.LIGHT;
-
-			// runThemeTransition needs a zero-arg callback, so this closure is
-			// unavoidable. It allocates once per selection — cheap enough that
-			// micro-optimising it would just obscure the flow.
-			const apply = (): void => {
-				setAutoSwitch(isSystem);
-				setTheme(resolvedTheme);
-				onApplied?.();
-			};
-
-			const willFlipDarkMode = resolvedTargetIsDark !== currentIsDark;
-			if (!willFlipDarkMode || !canAnimateThemeTransition()) {
-				apply();
-				return;
-			}
-
-			runThemeTransition(apply);
-		},
-		[theme, systemTheme, setTheme, setAutoSwitch],
-	);
-}
-
-export default useThemeSelection;

frontend/src/styles.scss

@@ -827,22 +827,3 @@ body.ai-assistant-panel-open {
 	--input-focus-outline-width: 0;
 	--radius-2: 4px;
 }
-
-// Scoped to .theme-wipe-active (toggled on <html> in runThemeTransition) so
-// these overrides don't leak into any unrelated view transitions added later.
-// We disable the default UA crossfade so the JS-driven clip-path wipe is the
-// only visible effect, and stack the new snapshot above the old.
-html.theme-wipe-active {
-	&::view-transition-old(root),
-	&::view-transition-new(root) {
-		animation: none;
-	}
-
-	&::view-transition-old(root) {
-		z-index: 1;
-	}
-
-	&::view-transition-new(root) {
-		z-index: 2;
-	}
-}

frontend/src/utils/__tests__/themeTransition.test.ts

@@ -1,193 +0,0 @@
-import {
-	canAnimateThemeTransition,
-	runThemeTransition,
-	THEME_WIPE_ACTIVE_CLASS,
-} from '../themeTransition';
-
-type StartVT = (cb: () => void) => {
-	ready: Promise<void>;
-	finished: Promise<void>;
-};
-
-const installStartViewTransition = (impl?: StartVT): jest.Mock => {
-	const defaultImpl: StartVT = (cb) => {
-		cb();
-		return { ready: Promise.resolve(), finished: Promise.resolve() };
-	};
-	const fn = jest.fn(impl ?? defaultImpl);
-	Object.defineProperty(document, 'startViewTransition', {
-		configurable: true,
-		writable: true,
-		value: fn,
-	});
-	return fn;
-};
-
-const removeStartViewTransition = (): void => {
-	Object.defineProperty(document, 'startViewTransition', {
-		configurable: true,
-		writable: true,
-		value: undefined,
-	});
-};
-
-const setReducedMotion = (matches: boolean): void => {
-	(window.matchMedia as jest.Mock) = jest
-		.fn()
-		.mockImplementation((query: string) => ({
-			matches: query === '(prefers-reduced-motion: reduce)' ? matches : false,
-			media: query,
-			addListener: jest.fn(),
-			removeListener: jest.fn(),
-			addEventListener: jest.fn(),
-			removeEventListener: jest.fn(),
-			dispatchEvent: jest.fn(),
-		}));
-};
-
-describe('canAnimateThemeTransition', () => {
-	afterEach(() => {
-		removeStartViewTransition();
-	});
-
-	it('returns false when document.startViewTransition is unavailable', () => {
-		removeStartViewTransition();
-		setReducedMotion(false);
-		expect(canAnimateThemeTransition()).toBe(false);
-	});
-
-	it('returns false when prefers-reduced-motion is reduce', () => {
-		installStartViewTransition();
-		setReducedMotion(true);
-		expect(canAnimateThemeTransition()).toBe(false);
-	});
-
-	it('returns true when API is supported and motion is allowed', () => {
-		installStartViewTransition();
-		setReducedMotion(false);
-		expect(canAnimateThemeTransition()).toBe(true);
-	});
-});
-
-describe('runThemeTransition', () => {
-	afterEach(() => {
-		removeStartViewTransition();
-		document.documentElement.classList.remove(THEME_WIPE_ACTIVE_CLASS);
-	});
-
-	it('falls back to running applyChange directly when API is missing', () => {
-		removeStartViewTransition();
-		const applyChange = jest.fn();
-		runThemeTransition(applyChange);
-		expect(applyChange).toHaveBeenCalledTimes(1);
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(false);
-	});
-
-	it('invokes startViewTransition and runs applyChange inside its callback', () => {
-		const startVT = installStartViewTransition();
-		const applyChange = jest.fn();
-		runThemeTransition(applyChange);
-		expect(startVT).toHaveBeenCalledTimes(1);
-		expect(applyChange).toHaveBeenCalledTimes(1);
-	});
-
-	it('toggles the wipe-active class on <html> for the lifetime of the transition', async () => {
-		let resolveFinished: () => void = (): void => {};
-		installStartViewTransition((cb) => {
-			cb();
-			return {
-				ready: Promise.resolve(),
-				finished: new Promise<void>((resolve) => {
-					resolveFinished = resolve;
-				}),
-			};
-		});
-
-		runThemeTransition(() => undefined);
-
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(true);
-
-		resolveFinished();
-		await Promise.resolve();
-		await Promise.resolve();
-
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(false);
-	});
-
-	it('keeps the wipe-active class through overlapping transitions', async () => {
-		let resolveA: () => void = (): void => {};
-		let resolveB: () => void = (): void => {};
-		let callIndex = 0;
-		installStartViewTransition((cb) => {
-			cb();
-			callIndex += 1;
-			if (callIndex === 1) {
-				return {
-					ready: Promise.resolve(),
-					finished: new Promise<void>((resolve) => {
-						resolveA = resolve;
-					}),
-				};
-			}
-			return {
-				ready: Promise.resolve(),
-				finished: new Promise<void>((resolve) => {
-					resolveB = resolve;
-				}),
-			};
-		});
-
-		runThemeTransition(() => undefined);
-		runThemeTransition(() => undefined);
-
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(true);
-
-		// First transition finishes — class must stay because B is still in flight.
-		resolveA();
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(true);
-
-		resolveB();
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(false);
-	});
-
-	it('falls back to applyChange and releases the class when startViewTransition throws before its callback runs', () => {
-		installStartViewTransition(() => {
-			throw new Error('boom');
-		});
-		const applyChange = jest.fn();
-		runThemeTransition(applyChange);
-		expect(applyChange).toHaveBeenCalledTimes(1);
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(false);
-	});
-
-	it('does not double-invoke applyChange when startViewTransition throws after its callback runs', () => {
-		installStartViewTransition((cb) => {
-			cb();
-			throw new Error('post-cb');
-		});
-		const applyChange = jest.fn();
-		runThemeTransition(applyChange);
-		expect(applyChange).toHaveBeenCalledTimes(1);
-		expect(
-			document.documentElement.classList.contains(THEME_WIPE_ACTIVE_CLASS),
-		).toBe(false);
-	});
-});

frontend/src/utils/themeTransition.ts

@@ -1,115 +0,0 @@
-import { flushSync } from 'react-dom';
-
-const WIPE_DURATION_MS = 400;
-const WIPE_EASING = 'ease-out';
-
-// Toggled on <html> for the duration of the wipe so the CSS overrides
-// (animation: none on ::view-transition-{old,new}(root)) don't leak into
-// any future, unrelated view transitions in the app.
-export const THEME_WIPE_ACTIVE_CLASS = 'theme-wipe-active';
-
-type ViewTransition = {
-	ready: Promise<void>;
-	finished: Promise<void>;
-};
-type DocumentWithVT = Document & {
-	startViewTransition?: (callback: () => void) => ViewTransition;
-};
-
-// Rapid theme switches cancel the in-flight transition and immediately start a
-// new one; if we removed the class on the first transition's settled promise,
-// we'd strip the CSS override mid-way through the next wipe and the user
-// would briefly see the UA crossfade. Refcount so the class only comes off
-// once every transition we started has settled.
-let wipeActiveRefCount = 0;
-const acquireWipeClass = (root: HTMLElement): void => {
-	wipeActiveRefCount += 1;
-	root.classList.add(THEME_WIPE_ACTIVE_CLASS);
-};
-const releaseWipeClass = (root: HTMLElement): void => {
-	wipeActiveRefCount = Math.max(0, wipeActiveRefCount - 1);
-	if (wipeActiveRefCount === 0) {
-		root.classList.remove(THEME_WIPE_ACTIVE_CLASS);
-	}
-};
-
-// Identity of the transition we most recently started. Used to skip the
-// .animate() call on a stale transition whose .ready resolved after a newer
-// transition has already taken over the ::view-transition-new pseudo-element.
-let currentTransition: ViewTransition | null = null;
-
-export function canAnimateThemeTransition(): boolean {
-	const doc = document as DocumentWithVT;
-	if (typeof doc.startViewTransition !== 'function') {
-		return false;
-	}
-	return !window.matchMedia('(prefers-reduced-motion: reduce)').matches;
-}
-
-// Runs `applyChange` inside a View Transition and wipes the new theme in from
-// left to right via a polygon clip-path on ::view-transition-new(root).
-// Callers should gate on canAnimateThemeTransition() first; this is a safe
-// no-animation fallback otherwise.
-export function runThemeTransition(applyChange: () => void): void {
-	const doc = document as DocumentWithVT;
-	if (!doc.startViewTransition) {
-		applyChange();
-		return;
-	}
-
-	const root = document.documentElement;
-	acquireWipeClass(root);
-
-	// Some Chromium versions throw if startViewTransition is called while
-	// another transition is in setup. Track whether the callback ran so we
-	// don't double-apply if the throw happens mid-callback.
-	let applied = false;
-	let transition: ViewTransition;
-	try {
-		transition = doc.startViewTransition(() => {
-			applied = true;
-			flushSync(applyChange);
-		});
-	} catch {
-		releaseWipeClass(root);
-		if (!applied) {
-			applyChange();
-		}
-		return;
-	}
-
-	currentTransition = transition;
-
-	const from = 'polygon(0 0, 0 0, 0 100%, 0 100%)';
-	const to = 'polygon(0 0, 100% 0, 100% 100%, 0 100%)';
-
-	transition.ready
-		.then(() => {
-			// If a newer transition has superseded this one between
-			// startViewTransition() and `ready` resolving, the browser has
-			// already cancelled our pseudo-element. Calling .animate() on it now
-			// would race with the newer transition's own animation.
-			if (currentTransition !== transition) {
-				return;
-			}
-			root.animate(
-				{ clipPath: [from, to] },
-				{
-					duration: WIPE_DURATION_MS,
-					easing: WIPE_EASING,
-					pseudoElement: '::view-transition-new(root)',
-				},
-			);
-		})
-		.catch(() => {
-			// Transition cancelled — applyChange has already run.
-		});
-
-	const cleanup = (): void => {
-		if (currentTransition === transition) {
-			currentTransition = null;
-		}
-		releaseWipeClass(root);
-	};
-	transition.finished.then(cleanup).catch(cleanup);
-}

pkg/query-service/rules/threshold_rule.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net/url"
 	"reflect"
+	"strings"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/contextlinks"
@@ -85,19 +86,35 @@ func (r *ThresholdRule) prepareQueryRange(ctx context.Context, ts time.Time) (*q
 	return req, nil
 }
 
-func (r *ThresholdRule) prepareParamsForLogs(ctx context.Context, ts time.Time, lbls ruletypes.Labels) url.Values {
+// logSamples* bound the recent log lines we attach to a firing log-based alert.
+// They are kept small to bound the notification payload size.
+const (
+	// logSamplesMaxCount is the number of most-recent matching log records sampled.
+	logSamplesMaxCount = 5
+	// logSampleBodyMaxLen truncates each sampled body (in runes) so a single large
+	// record cannot blow up the annotation/notification.
+	logSampleBodyMaxLen = 512
+)
+
+// logsQueryParams extracts, for a log-based alert, the evaluation window and the
+// per-group where clause: the rule's filter combined with the breaching group's
+// label values (lbls). The same where clause backs both the related-logs link and
+// the sample-logs query, so they always refer to the same set of logs. ok is false
+// when the rule is not a single log builder query (e.g. a formula or non-logs
+// signal), in which case there is nothing to link to or sample.
+func (r *ThresholdRule) logsQueryParams(ctx context.Context, ts time.Time, lbls ruletypes.Labels) (start, end time.Time, whereClause string, ok bool) {
 	selectedQuery := r.SelectedQuery(ctx)
 
 	qr, err := r.prepareQueryRange(ctx, ts)
 	if err != nil {
-		return nil
+		return time.Time{}, time.Time{}, "", false
 	}
-	start := time.UnixMilli(int64(qr.Start))
-	end := time.UnixMilli(int64(qr.End))
+	start = time.UnixMilli(int64(qr.Start))
+	end = time.UnixMilli(int64(qr.End))
 
 	// TODO(srikanthccv): handle formula queries
 	if selectedQuery < "A" || selectedQuery > "Z" {
-		return nil
+		return time.Time{}, time.Time{}, "", false
 	}
 
 	var q qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]
@@ -112,7 +129,7 @@ func (r *ThresholdRule) prepareParamsForLogs(ctx context.Context, ts time.Time,
 	}
 
 	if q.Signal != telemetrytypes.SignalLogs {
-		return nil
+		return time.Time{}, time.Time{}, "", false
 	}
 
 	filterExpr := ""
@@ -120,11 +137,153 @@ func (r *ThresholdRule) prepareParamsForLogs(ctx context.Context, ts time.Time,
 		filterExpr = q.Filter.Expression
 	}
 
-	whereClause := contextlinks.PrepareFilterExpression(lbls.Map(), filterExpr, q.GroupBy)
+	whereClause = contextlinks.PrepareFilterExpression(lbls.Map(), filterExpr, q.GroupBy)
+	return start, end, whereClause, true
+}
 
+func (r *ThresholdRule) prepareParamsForLogs(ctx context.Context, ts time.Time, lbls ruletypes.Labels) url.Values {
+	start, end, whereClause, ok := r.logsQueryParams(ctx, ts, lbls)
+	if !ok {
+		return nil
+	}
 	return contextlinks.PrepareParamsForLogsV5(start, end, whereClause)
 }
 
+// fetchLogSamples returns up to logSamplesMaxCount of the most-recent log records
+// matching the alert's filter for the breaching group (lbls), newest first. It
+// reuses the same where clause as the related-logs link, so the samples are exactly
+// the logs that link points to.
+//
+// Sampling is best-effort enrichment: any failure is logged and yields no samples
+// rather than failing the rule evaluation.
+func (r *ThresholdRule) fetchLogSamples(ctx context.Context, ts time.Time, lbls ruletypes.Labels) []*qbtypes.RawRow {
+	start, end, whereClause, ok := r.logsQueryParams(ctx, ts, lbls)
+	if !ok {
+		return nil
+	}
+
+	req := &qbtypes.QueryRangeRequest{
+		Start:       uint64(start.UnixMilli()),
+		End:         uint64(end.UnixMilli()),
+		RequestType: qbtypes.RequestTypeRaw,
+		CompositeQuery: qbtypes.CompositeQuery{
+			Queries: []qbtypes.QueryEnvelope{
+				{
+					Type: qbtypes.QueryTypeBuilder,
+					Spec: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
+						Signal: telemetrytypes.SignalLogs,
+						Name:   "log_samples",
+						Filter: &qbtypes.Filter{Expression: whereClause},
+						Limit:  logSamplesMaxCount,
+						// timestamp,id DESC => most recent first. Both keys with an
+						// identical direction are also what enables the window-list
+						// fast path for raw log queries.
+						Order: []qbtypes.OrderBy{
+							{
+								Direction: qbtypes.OrderDirectionDesc,
+								Key:       qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "timestamp", Materialized: true}},
+							},
+							{
+								Direction: qbtypes.OrderDirectionDesc,
+								Key:       qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "id", Materialized: true}},
+							},
+						},
+					},
+				},
+			},
+		},
+		NoCache: true,
+	}
+
+	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
+		instrumentationtypes.CodeNamespace:    "rules",
+		instrumentationtypes.CodeFunctionName: "fetchLogSamples",
+	})
+
+	resp, err := r.querier.QueryRange(ctx, r.orgID, req)
+	if err != nil {
+		r.logger.WarnContext(ctx, "failed to fetch log samples for alert annotation", errors.Attr(err))
+		return nil
+	}
+
+	for _, item := range resp.Data.Results {
+		if raw, ok := item.(*qbtypes.RawData); ok {
+			return raw.Rows
+		}
+	}
+	return nil
+}
+
+// formatLogSamples renders sampled log records as a compact, monospaced markdown
+// block: one line per record as "[RFC3339] SEVERITY body". Records without a body
+// are skipped (mirroring Datadog), each body is collapsed to a single line and
+// truncated to logSampleBodyMaxLen. Returns "" when there is nothing to show.
+func formatLogSamples(rows []*qbtypes.RawRow) string {
+	lines := make([]string, 0, len(rows))
+	for _, row := range rows {
+		if row == nil {
+			continue
+		}
+
+		body := strings.TrimSpace(rawRowStringField(row, "body"))
+		if body == "" {
+			continue
+		}
+		body = truncateRunes(logSampleSingleLine(body), logSampleBodyMaxLen)
+
+		var sb strings.Builder
+		if !row.Timestamp.IsZero() {
+			sb.WriteString("[")
+			sb.WriteString(row.Timestamp.UTC().Format(time.RFC3339))
+			sb.WriteString("] ")
+		}
+		if sev := strings.TrimSpace(rawRowStringField(row, "severity_text")); sev != "" {
+			sb.WriteString(sev)
+			sb.WriteString(" ")
+		}
+		sb.WriteString(body)
+		lines = append(lines, sb.String())
+	}
+
+	if len(lines) == 0 {
+		return ""
+	}
+	return "```\n" + strings.Join(lines, "\n") + "\n```"
+}
+
+// rawRowStringField returns the named field from a raw row as a string, or "" if it
+// is absent or not a string.
+func rawRowStringField(row *qbtypes.RawRow, key string) string {
+	if row == nil || row.Data == nil {
+		return ""
+	}
+	if v, ok := row.Data[key]; ok {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// logSampleSingleLine collapses newlines so a multi-line log body renders as one
+// line within the samples block.
+func logSampleSingleLine(s string) string {
+	replacer := strings.NewReplacer("\r\n", " ", "\n", " ", "\r", " ")
+	return replacer.Replace(s)
+}
+
+// truncateRunes shortens s to at most max runes, appending an ellipsis when trimmed.
+func truncateRunes(s string, max int) string {
+	if max <= 0 {
+		return s
+	}
+	runes := []rune(s)
+	if len(runes) <= max {
+		return s
+	}
+	return string(runes[:max]) + "…"
+}
+
 func (r *ThresholdRule) prepareParamsForTraces(ctx context.Context, ts time.Time, lbls ruletypes.Labels) url.Values {
 	selectedQuery := r.SelectedQuery(ctx)
 
@@ -352,6 +511,14 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 				r.logger.InfoContext(ctx, "adding logs link to annotations", slog.String("annotation.link", link))
 				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedLogs, Value: link})
 			}
+			// Attach a few recent matching log lines so responders see what fired
+			// the alert without leaving the notification. Skipped for no-data
+			// alerts, which by definition have no matching logs.
+			if !smpl.IsMissing {
+				if samples := formatLogSamples(r.fetchLogSamples(ctx, ts, smpl.Metric)); samples != "" {
+					annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedLogsSamples, Value: samples})
+				}
+			}
 		}
 
 		lbs := lb.Labels()

pkg/query-service/rules/threshold_rule_log_samples_test.go

@@ -0,0 +1,72 @@
+package rules
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatLogSamples(t *testing.T) {
+	ts := time.Date(2026, time.June, 1, 12, 0, 3, 0, time.UTC)
+
+	t.Run("nil and empty yield empty string", func(t *testing.T) {
+		assert.Equal(t, "", formatLogSamples(nil))
+		assert.Equal(t, "", formatLogSamples([]*qbtypes.RawRow{}))
+	})
+
+	t.Run("skips nil rows and rows without a usable body", func(t *testing.T) {
+		rows := []*qbtypes.RawRow{
+			nil,
+			{Timestamp: ts, Data: map[string]any{"body": ""}},
+			{Timestamp: ts, Data: map[string]any{"body": "   "}},
+			{Timestamp: ts, Data: map[string]any{"severity_text": "ERROR"}}, // no body key
+			{Timestamp: ts, Data: map[string]any{"body": 42}},               // body not a string
+		}
+		assert.Equal(t, "", formatLogSamples(rows))
+	})
+
+	t.Run("renders timestamp, severity and body inside a code block", func(t *testing.T) {
+		rows := []*qbtypes.RawRow{
+			{Timestamp: ts, Data: map[string]any{"severity_text": "ERROR", "body": "payment failed"}},
+		}
+		want := "```\n[2026-06-01T12:00:03Z] ERROR payment failed\n```"
+		assert.Equal(t, want, formatLogSamples(rows))
+	})
+
+	t.Run("omits severity when absent and collapses a multi-line body", func(t *testing.T) {
+		rows := []*qbtypes.RawRow{
+			{Timestamp: ts, Data: map[string]any{"body": "line1\nline2\r\nline3"}},
+		}
+		want := "```\n[2026-06-01T12:00:03Z] line1 line2 line3\n```"
+		assert.Equal(t, want, formatLogSamples(rows))
+	})
+
+	t.Run("omits the timestamp prefix when zero", func(t *testing.T) {
+		rows := []*qbtypes.RawRow{
+			{Data: map[string]any{"body": "no ts"}},
+		}
+		assert.Equal(t, "```\nno ts\n```", formatLogSamples(rows))
+	})
+
+	t.Run("renders one line per record and preserves input order", func(t *testing.T) {
+		rows := []*qbtypes.RawRow{
+			{Timestamp: ts, Data: map[string]any{"body": "first"}},
+			{Timestamp: ts.Add(-time.Second), Data: map[string]any{"body": "second"}},
+		}
+		want := "```\n[2026-06-01T12:00:03Z] first\n[2026-06-01T12:00:02Z] second\n```"
+		assert.Equal(t, want, formatLogSamples(rows))
+	})
+
+	t.Run("truncates a long body to logSampleBodyMaxLen runes plus ellipsis", func(t *testing.T) {
+		long := strings.Repeat("a", logSampleBodyMaxLen+50)
+		rows := []*qbtypes.RawRow{
+			{Timestamp: ts, Data: map[string]any{"body": long}},
+		}
+		out := formatLogSamples(rows)
+		assert.Contains(t, out, strings.Repeat("a", logSampleBodyMaxLen)+"…")
+		assert.NotContains(t, out, strings.Repeat("a", logSampleBodyMaxLen+1))
+	})
+}

pkg/types/ruletypes/constants.go

@@ -30,12 +30,13 @@ const (
 // {{ .Annotations.value }}, {{ .Annotations.threshold.value }}, etc. in
 // their channel templates.
 const (
-	AnnotationTitleTemplate  = "_title_template"
-	AnnotationBodyTemplate   = "_body_template"
-	AnnotationRelatedLogs    = "related_logs"
-	AnnotationRelatedTraces  = "related_traces"
-	AnnotationValue          = "value"
-	AnnotationThresholdValue = "threshold.value"
-	AnnotationCompareOp      = "compare_op"
-	AnnotationMatchType      = "match_type"
+	AnnotationTitleTemplate      = "_title_template"
+	AnnotationBodyTemplate       = "_body_template"
+	AnnotationRelatedLogs        = "related_logs"
+	AnnotationRelatedLogsSamples = "related_logs_samples"
+	AnnotationRelatedTraces      = "related_traces"
+	AnnotationValue              = "value"
+	AnnotationThresholdValue     = "threshold.value"
+	AnnotationCompareOp          = "compare_op"
+	AnnotationMatchType          = "match_type"
 )