fix: use name from evolutions

* fix: added fix for panel rerenders on interaction

* fix: fixed tsc issue

.gitignore

@@ -49,6 +49,7 @@ ee/query-service/tests/test-deploy/data/
 # local data
 *.backup
 *.db
+**/db
 /deploy/docker/clickhouse-setup/data/
 /deploy/docker-swarm/clickhouse-setup/data/
 bin/

Makefile

@@ -72,6 +72,12 @@ devenv-up: devenv-clickhouse devenv-signoz-otel-collector ## Start both clickhou
 	@echo "   - ClickHouse: http://localhost:8123"
 	@echo "   - Signoz OTel Collector: grpc://localhost:4317, http://localhost:4318"
 
+.PHONY: devenv-clickhouse-clean
+devenv-clickhouse-clean: ## Clean all ClickHouse data from filesystem
+	@echo "Removing ClickHouse data..."
+	@rm -rf .devenv/docker/clickhouse/fs/tmp/*
+	@echo "ClickHouse data cleaned!"
+
 ##############################################################
 # go commands
 ##############################################################

docs/api/openapi.yml

@@ -849,6 +849,75 @@ paths:
       summary: Deprecated create session by email password
       tags:
       - sessions
+  /api/v1/logs/promote_paths:
+    get:
+      deprecated: false
+      description: This endpoints promotes and indexes paths
+      operationId: PromotePaths
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    items:
+                      $ref: '#/components/schemas/PromotetypesPromotePath'
+                    nullable: true
+                    type: array
+                  status:
+                    type: string
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      summary: Promote and index paths
+      tags:
+      - promoted_paths
+      - logs
+      - json_logs
+    post:
+      deprecated: false
+      description: This endpoints promotes and indexes paths
+      operationId: PromotePaths
+      requestBody:
+        content:
+          application/json:
+            schema:
+              items:
+                $ref: '#/components/schemas/PromotetypesPromotePath'
+              nullable: true
+              type: array
+      responses:
+        "201":
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      summary: Promote and index paths
+      tags:
+      - promoted_paths
+      - logs
+      - json_logs
   /api/v1/org/preferences:
     get:
       deprecated: false
@@ -2137,6 +2206,26 @@ components:
       type: object
     PreferencetypesValue:
       type: object
+    PromotetypesPromotePath:
+      properties:
+        indexes:
+          items:
+            $ref: '#/components/schemas/PromotetypesWrappedIndex'
+          type: array
+        path:
+          type: string
+        promote:
+          type: boolean
+      type: object
+    PromotetypesWrappedIndex:
+      properties:
+        column_type:
+          type: string
+        granularity:
+          type: integer
+        type:
+          type: string
+      type: object
     RenderErrorResponse:
       properties:
         error:

frontend/src/AppRoutes/index.tsx

@@ -6,6 +6,7 @@ import logEvent from 'api/common/logEvent';
 import AppLoading from 'components/AppLoading/AppLoading';
 import { CmdKPalette } from 'components/cmdKPalette/cmdKPalette';
 import NotFound from 'components/NotFound';
+import { ShiftHoldOverlayController } from 'components/ShiftOverlay/ShiftHoldOverlayController';
 import Spinner from 'components/Spinner';
 import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -368,6 +369,9 @@ function App(): JSX.Element {
 							<NotificationProvider>
 								<ErrorModalProvider>
 									{isLoggedInState && <CmdKPalette userRole={user.role} />}
+									{isLoggedInState && (
+										<ShiftHoldOverlayController userRole={user.role} />
+									)}
 									<PrivateRoute>
 										<ResourceProvider>
 											<QueryBuilderProvider>

frontend/src/components/Logs/ListLogView/ListLogView.styles.scss

@@ -1,11 +1,15 @@
-.log-field-key {
-	padding-right: 5px;
+.log-field-container {
+	display: flex;
+	overflow: hidden;
+	width: 100%;
+	align-items: baseline;
+}
+.log-field-key,
+.log-field-key-colon {
 	color: var(--text-vanilla-400, #c0c1c3);
 	font-size: 14px;
 	font-style: normal;
 	font-weight: 400;
-	line-height: 18px; /* 128.571% */
-	letter-spacing: -0.07px;
 
 	&.small {
 		font-size: 11px;
@@ -22,6 +26,20 @@
 		line-height: 24px;
 	}
 }
+.log-field-key {
+	line-height: 18px; /* 128.571% */
+	letter-spacing: -0.07px;
+	white-space: nowrap;
+	display: inline-block;
+	max-width: 20vw;
+	text-overflow: ellipsis;
+	overflow: hidden;
+	margin: 0;
+}
+.log-field-key-colon {
+	min-width: 0.8rem;
+	flex-shrink: 0;
+}
 .log-value {
 	color: var(--text-vanilla-400, #c0c1c3);
 	font-size: 14px;
@@ -158,7 +176,8 @@
 }
 
 .lightMode {
-	.log-field-key {
+	.log-field-key,
+	.log-field-key-colon {
 		color: var(--text-slate-400);
 	}
 	.log-value {
@@ -170,3 +189,10 @@
 		}
 	}
 }
+
+.dark {
+	.log-field-key,
+	.log-field-key-colon {
+		color: rgba(255, 255, 255, 0.45);
+	}
+}

frontend/src/components/Logs/ListLogView/index.tsx

@@ -25,13 +25,7 @@ import LogLinesActionButtons from '../LogLinesActionButtons/LogLinesActionButton
 import LogStateIndicator from '../LogStateIndicator/LogStateIndicator';
 import { getLogIndicatorType } from '../LogStateIndicator/utils';
 // styles
-import {
-	Container,
-	LogContainer,
-	LogText,
-	Text,
-	TextContainer,
-} from './styles';
+import { Container, LogContainer, LogText } from './styles';
 import { isValidLogField } from './util';
 
 interface LogFieldProps {
@@ -58,16 +52,18 @@ function LogGeneralField({
 	);
 
 	return (
-		<TextContainer>
-			<Text ellipsis type="secondary" className={cx('log-field-key', fontSize)}>
-				{`${fieldKey} : `}
-			</Text>
+		<div className="log-field-container">
+			<p className={cx('log-field-key', fontSize)} title={fieldKey}>
+				{fieldKey}
+			</p>
+			<span className={cx('log-field-key-colon', fontSize)}>&nbsp;:&nbsp;</span>
 			<LogText
 				dangerouslySetInnerHTML={html}
 				className={cx('log-value', fontSize)}
+				title={fieldValue}
 				linesPerRow={linesPerRow > 1 ? linesPerRow : undefined}
 			/>
-		</TextContainer>
+		</div>
 	);
 }
 

frontend/src/components/Logs/ListLogView/styles.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-nested-ternary */
-import { Card, Typography } from 'antd';
+import { Card } from 'antd';
 import { FontSize } from 'container/OptionsMenu/types';
 import styled from 'styled-components';
 import { getActiveLogBackground } from 'utils/logs';
@@ -46,19 +46,6 @@ export const Container = styled(Card)<{
 			getActiveLogBackground($isActiveLog, $isDarkMode, $logType)}
 `;
 
-export const Text = styled(Typography.Text)`
-	&&& {
-		min-width: 2.5rem;
-		white-space: nowrap;
-	}
-`;
-
-export const TextContainer = styled.div`
-	display: flex;
-	overflow: hidden;
-	width: 100%;
-`;
-
 export const LogContainer = styled.div<LogContainerProps>`
 	margin-left: 0.5rem;
 	display: flex;

frontend/src/components/ShiftOverlay/ShiftHoldOverlayController.tsx

@@ -0,0 +1,27 @@
+import { createShortcutActions } from '../../constants/shortcutActions';
+import { useCmdK } from '../../providers/cmdKProvider';
+import { ShiftOverlay } from './ShiftOverlay';
+import { useShiftHoldOverlay } from './useShiftHoldOverlay';
+
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+export function ShiftHoldOverlayController({
+	userRole,
+}: {
+	userRole: UserRole;
+}): JSX.Element | null {
+	const { open: isCmdKOpen } = useCmdK();
+	const noop = (): void => undefined;
+
+	const actions = createShortcutActions({
+		navigate: noop,
+		handleThemeChange: noop,
+	});
+
+	const visible = useShiftHoldOverlay({
+		isModalOpen: isCmdKOpen,
+	});
+
+	return (
+		<ShiftOverlay visible={visible} actions={actions} userRole={userRole} />
+	);
+}

frontend/src/components/ShiftOverlay/ShiftOverlay.tsx

@@ -0,0 +1,77 @@
+import './shiftOverlay.scss';
+
+import { useMemo } from 'react';
+import ReactDOM from 'react-dom';
+
+import { formatShortcut } from './formatShortcut';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+export type CmdAction = {
+	id: string;
+	name: string;
+	shortcut?: string[];
+	keywords?: string;
+	section?: string;
+	roles?: UserRole[];
+	perform: () => void;
+};
+
+interface ShortcutProps {
+	label: string;
+	keyHint: React.ReactNode;
+}
+
+function Shortcut({ label, keyHint }: ShortcutProps): JSX.Element {
+	return (
+		<div className="shift-overlay__item">
+			<span className="shift-overlay__label">{label}</span>
+			<kbd className="shift-overlay__kbd">{keyHint}</kbd>
+		</div>
+	);
+}
+
+interface ShiftOverlayProps {
+	visible: boolean;
+	actions: CmdAction[];
+	userRole: UserRole;
+}
+
+export function ShiftOverlay({
+	visible,
+	actions,
+	userRole,
+}: ShiftOverlayProps): JSX.Element | null {
+	const navigationActions = useMemo(() => {
+		// RBAC filter: show action if no roles set OR current user role is included
+		const permitted = actions.filter(
+			(a) => !a.roles || a.roles.includes(userRole),
+		);
+
+		// Navigation only + must have shortcut
+		return permitted.filter(
+			(a) =>
+				a.section?.toLowerCase() === 'navigation' &&
+				a.shortcut &&
+				a.shortcut.length > 0,
+		);
+	}, [actions, userRole]);
+
+	if (!visible || navigationActions.length === 0) {
+		return null;
+	}
+
+	return ReactDOM.createPortal(
+		<div className="shift-overlay">
+			<div className="shift-overlay__panel">
+				{navigationActions.map((action) => (
+					<Shortcut
+						key={action.id}
+						label={action.name.replace(/^Go to\s+/i, '')}
+						keyHint={formatShortcut(action.shortcut)}
+					/>
+				))}
+			</div>
+		</div>,
+		document.body,
+	);
+}

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

@@ -0,0 +1,102 @@
+import '@testing-library/jest-dom';
+
+import { render, screen } from '@testing-library/react';
+
+import type { CmdAction } from '../ShiftOverlay';
+import { ShiftOverlay } from '../ShiftOverlay';
+
+jest.mock('../formatShortcut', () => ({
+	formatShortcut: (shortcut: string[]): string => shortcut.join('+'),
+}));
+
+const baseActions: CmdAction[] = [
+	{
+		id: '1',
+		name: 'Go to Traces',
+		section: 'navigation',
+		shortcut: ['Shift', 'T'],
+		perform: jest.fn(),
+	},
+	{
+		id: '2',
+		name: 'Go to Metrics',
+		section: 'navigation',
+		shortcut: ['Shift', 'M'],
+		roles: ['ADMIN'], // ✅ now UserRole[]
+		perform: jest.fn(),
+	},
+	{
+		id: '3',
+		name: 'Create Alert',
+		section: 'actions',
+		shortcut: ['A'],
+		perform: jest.fn(),
+	},
+	{
+		id: '4',
+		name: 'Go to Logs',
+		section: 'navigation',
+		perform: jest.fn(),
+	},
+];
+
+describe('ShiftOverlay', () => {
+	it('renders nothing when not visible', () => {
+		const { container } = render(
+			<ShiftOverlay visible={false} actions={baseActions} userRole="ADMIN" />,
+		);
+
+		expect(container.firstChild).toBeNull();
+	});
+
+	it('renders nothing when no navigation shortcuts exist', () => {
+		const { container } = render(
+			<ShiftOverlay
+				visible
+				actions={[
+					{
+						id: 'x',
+						name: 'Create Alert',
+						section: 'actions',
+						perform: jest.fn(),
+					},
+				]}
+				userRole="ADMIN"
+			/>,
+		);
+
+		expect(container.firstChild).toBeNull();
+	});
+
+	it('renders navigation shortcuts in a portal', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(document.body.querySelector('.shift-overlay')).toBeInTheDocument();
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.getByText('Metrics')).toBeInTheDocument();
+
+		expect(screen.getByText('Shift+T')).toBeInTheDocument();
+		expect(screen.getByText('Shift+M')).toBeInTheDocument();
+	});
+
+	it('applies RBAC filtering correctly', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="VIEWER" />);
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.queryByText('Metrics')).not.toBeInTheDocument();
+	});
+
+	it('strips "Go to" prefix from labels', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.queryByText('Go to Traces')).not.toBeInTheDocument();
+	});
+
+	it('does not render actions without shortcuts', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(screen.queryByText('Logs')).not.toBeInTheDocument();
+	});
+});

frontend/src/components/ShiftOverlay/__tests__/useShiftHoldOverlay.test.tsx

@@ -0,0 +1,144 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { useShiftHoldOverlay } from '../useShiftHoldOverlay';
+
+jest.useFakeTimers();
+
+function pressShift(target: EventTarget = window): void {
+	const event = new KeyboardEvent('keydown', {
+		key: 'Shift',
+		bubbles: true,
+	});
+	Object.defineProperty(event, 'target', { value: target });
+	window.dispatchEvent(event);
+}
+
+function releaseShift(): void {
+	window.dispatchEvent(
+		new KeyboardEvent('keyup', {
+			key: 'Shift',
+			bubbles: true,
+		}),
+	);
+}
+
+describe('useShiftHoldOverlay', () => {
+	afterEach(() => {
+		jest.clearAllTimers();
+	});
+
+	it('shows overlay after holding Shift for 600ms', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+	});
+
+	it('does not show overlay if Shift is released early', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(300);
+			releaseShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('hides overlay on Shift key release', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			releaseShift();
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does not activate when modal is open', () => {
+		const { result } = renderHook(() =>
+			useShiftHoldOverlay({ isModalOpen: true }),
+		);
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does not activate in typing context (input)', () => {
+		const input = document.createElement('input');
+		document.body.appendChild(input);
+
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift(input);
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+
+		document.body.removeChild(input);
+	});
+
+	it('cleans up on window blur', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			window.dispatchEvent(new Event('blur'));
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('cleans up on document visibility change', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			document.dispatchEvent(new Event('visibilitychange'));
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does nothing when disabled', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({ disabled: true }));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+});

frontend/src/components/ShiftOverlay/formatShortcut.tsx

@@ -0,0 +1,44 @@
+import './shiftOverlay.scss';
+
+import { ArrowUp, ChevronUp, Command, Option } from 'lucide-react';
+import { ReactNode } from 'react';
+
+export function formatShortcut(shortcut?: string[]): ReactNode {
+	if (!shortcut || shortcut.length === 0) return null;
+
+	const combo = shortcut.find((s) => typeof s === 'string' && s.trim());
+	if (!combo) return null;
+
+	return combo.split('+').map((key) => {
+		const k = key.trim().toLowerCase();
+
+		let node: ReactNode;
+		switch (k) {
+			case 'shift':
+				node = <ArrowUp size={14} />;
+				break;
+			case 'cmd':
+			case 'meta':
+				node = <Command size={14} />;
+				break;
+			case 'alt':
+				node = <Option size={14} />;
+				break;
+			case 'ctrl':
+			case 'control':
+				node = <ChevronUp size={14} />;
+				break;
+			case 'arrowup':
+				node = <ArrowUp size={14} />;
+				break;
+			default:
+				node = k.toUpperCase();
+		}
+
+		return (
+			<span key={`shortcut-${k}`} className="shift-overlay__key">
+				{node}
+			</span>
+		);
+	});
+}

frontend/src/components/ShiftOverlay/shiftOverlay.scss

@@ -0,0 +1,75 @@
+.shift-overlay {
+	position: fixed;
+	bottom: 20px;
+	left: 50%;
+	transform: translateX(-50%);
+	z-index: 9999;
+	pointer-events: none;
+
+	&__panel {
+		display: flex;
+		gap: 20px;
+		padding: 8px 12px;
+
+		background: var(--bg-ink-500);
+		color: var(--bg-vanilla-300);
+
+		border-radius: 8px;
+		font-size: 13px;
+		line-height: 1.2;
+
+		box-shadow: 0 6px 20px var(--bg-ink-500);
+		animation: shift-overlay-fade-in 120ms ease-out;
+	}
+
+	&__item {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		white-space: nowrap;
+	}
+
+	&__label {
+		opacity: 0.9;
+	}
+
+	&__kbd {
+		font-family: monospace;
+		font-size: 12px;
+		padding: 2px 6px;
+		display: flex;
+
+		border-radius: 4px;
+		background: var(--bg-slate-100);
+	}
+
+	&__key {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+
+		min-width: 15px;
+		height: 20px;
+
+		border-radius: 4px;
+
+		background-color: var(--bg-slate-100);
+
+		font-size: 12px;
+		font-weight: 500;
+		line-height: 1;
+		color: var(--bg-vanilla-300);
+		flex-shrink: 0;
+	}
+}
+
+@keyframes shift-overlay-fade-in {
+	from {
+		opacity: 0;
+		transform: translateY(-4px);
+	}
+	to {
+		opacity: 1;
+		transform: translateY(0);
+	}
+}

frontend/src/components/ShiftOverlay/useShiftHoldOverlay.ts

@@ -0,0 +1,87 @@
+import { useEffect, useRef, useState } from 'react';
+
+const HOLD_DELAY_MS = 500;
+
+function isTypingContext(target: EventTarget | null): boolean {
+	if (!(target instanceof HTMLElement)) return false;
+
+	const tag = target.tagName;
+	return tag === 'INPUT' || tag === 'TEXTAREA' || target.isContentEditable;
+}
+
+interface UseShiftHoldOverlayOptions {
+	disabled?: boolean;
+	isModalOpen?: boolean;
+}
+
+export function useShiftHoldOverlay({
+	disabled = false,
+	isModalOpen = false,
+}: UseShiftHoldOverlayOptions): boolean {
+	const [visible, setVisible] = useState<boolean>(false);
+
+	const timerRef = useRef<number | null>(null);
+	const isHoldingRef = useRef<boolean>(false);
+
+	useEffect((): (() => void) | void => {
+		if (disabled) return;
+
+		function cleanup(): void {
+			isHoldingRef.current = false;
+
+			if (timerRef.current !== null) {
+				window.clearTimeout(timerRef.current);
+				timerRef.current = null;
+			}
+
+			setVisible(false);
+		}
+
+		function onKeyDown(e: KeyboardEvent): void {
+			if (e.key !== 'Shift') return;
+			if (e.repeat) return;
+
+			// Suppress in bad contexts
+			if (
+				isModalOpen ||
+				e.metaKey ||
+				e.ctrlKey ||
+				e.altKey ||
+				isTypingContext(e.target)
+			) {
+				return;
+			}
+
+			isHoldingRef.current = true;
+
+			timerRef.current = window.setTimeout(() => {
+				if (isHoldingRef.current) {
+					setVisible(true);
+				}
+			}, HOLD_DELAY_MS);
+		}
+
+		function onKeyUp(e: KeyboardEvent): void {
+			if (e.key !== 'Shift') return;
+			cleanup();
+		}
+
+		function onBlur(): void {
+			cleanup();
+		}
+
+		window.addEventListener('keydown', onKeyDown);
+		window.addEventListener('keyup', onKeyUp);
+		window.addEventListener('blur', onBlur);
+		document.addEventListener('visibilitychange', cleanup);
+
+		return (): void => {
+			window.removeEventListener('keydown', onKeyDown);
+			window.removeEventListener('keyup', onKeyUp);
+			window.removeEventListener('blur', onBlur);
+			document.removeEventListener('visibilitychange', cleanup);
+		};
+	}, [disabled, isModalOpen]);
+
+	return visible;
+}

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

@@ -159,7 +159,6 @@ describe('CmdKPalette', () => {
 
 		expect(screen.getByText(HOME_LABEL)).toBeInTheDocument();
 		expect(screen.getByText('Go to Dashboards')).toBeInTheDocument();
-		expect(screen.getByText('Open Sidebar')).toBeInTheDocument();
 		expect(screen.getByText('Switch to Dark Mode')).toBeInTheDocument();
 	});
 

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -9,34 +9,12 @@ import {
 	CommandList,
 	CommandShortcut,
 } from '@signozhq/command';
-import setLocalStorageApi from 'api/browser/localstorage/set';
 import logEvent from 'api/common/logEvent';
-import updateUserPreference from 'api/v1/user/preferences/name/update';
-import { AxiosError } from 'axios';
-import ROUTES from 'constants/routes';
-import { USER_PREFERENCES } from 'constants/userPreferences';
 import { useThemeMode } from 'hooks/useDarkMode';
-import { THEME_MODE } from 'hooks/useDarkMode/constant';
-import { useNotifications } from 'hooks/useNotifications';
 import history from 'lib/history';
-import {
-	BellDot,
-	BugIcon,
-	DraftingCompass,
-	Expand,
-	HardDrive,
-	Home,
-	LayoutGrid,
-	ListMinus,
-	ScrollText,
-	Settings,
-} from 'lucide-react';
 import React, { useEffect } from 'react';
-import { useMutation } from 'react-query';
-import { UserPreference } from 'types/api/preferences/preference';
-import { showErrorNotification } from 'utils/error';
 
-import { useAppContext } from '../../providers/App/App';
+import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
 
 type CmdAction = {
@@ -58,19 +36,8 @@ export function CmdKPalette({
 }): JSX.Element | null {
 	const { open, setOpen } = useCmdK();
 
-	const { updateUserPreferenceInContext } = useAppContext();
-	const { notifications } = useNotifications();
 	const { setAutoSwitch, setTheme, theme } = useThemeMode();
 
-	const { mutate: updateUserPreferenceMutation } = useMutation(
-		updateUserPreference,
-		{
-			onError: (error) => {
-				showErrorNotification(notifications, error as AxiosError);
-			},
-		},
-	);
-
 	// toggle palette with ⌘/Ctrl+K
 	function handleGlobalCmdK(
 		e: KeyboardEvent,
@@ -111,164 +78,10 @@ export function CmdKPalette({
 		history.push(key);
 	}
 
-	function handleOpenSidebar(): void {
-		setLocalStorageApi(USER_PREFERENCES.SIDENAV_PINNED, 'true');
-		const save = { name: USER_PREFERENCES.SIDENAV_PINNED, value: true };
-		updateUserPreferenceInContext(save as UserPreference);
-		updateUserPreferenceMutation({
-			name: USER_PREFERENCES.SIDENAV_PINNED,
-			value: true,
-		});
-	}
-
-	function handleCloseSidebar(): void {
-		setLocalStorageApi(USER_PREFERENCES.SIDENAV_PINNED, 'false');
-		const save = { name: USER_PREFERENCES.SIDENAV_PINNED, value: false };
-		updateUserPreferenceInContext(save as UserPreference);
-		updateUserPreferenceMutation({
-			name: USER_PREFERENCES.SIDENAV_PINNED,
-			value: false,
-		});
-	}
-
-	const actions: CmdAction[] = [
-		{
-			id: 'home',
-			name: 'Go to Home',
-			shortcut: ['shift + h'],
-			keywords: 'home',
-			section: 'Navigation',
-			icon: <Home size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.HOME),
-		},
-		{
-			id: 'dashboards',
-			name: 'Go to Dashboards',
-			shortcut: ['shift + d'],
-			keywords: 'dashboards',
-			section: 'Navigation',
-			icon: <LayoutGrid size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.ALL_DASHBOARD),
-		},
-		{
-			id: 'services',
-			name: 'Go to Services',
-			shortcut: ['shift + s'],
-			keywords: 'services monitoring',
-			section: 'Navigation',
-			icon: <HardDrive size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.APPLICATION),
-		},
-		{
-			id: 'traces',
-			name: 'Go to Traces',
-			shortcut: ['shift + t'],
-			keywords: 'traces',
-			section: 'Navigation',
-			icon: <DraftingCompass size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.TRACES_EXPLORER),
-		},
-		{
-			id: 'logs',
-			name: 'Go to Logs',
-			shortcut: ['shift + l'],
-			keywords: 'logs',
-			section: 'Navigation',
-			icon: <ScrollText size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.LOGS),
-		},
-		{
-			id: 'alerts',
-			name: 'Go to Alerts',
-			shortcut: ['shift + a'],
-			keywords: 'alerts',
-			section: 'Navigation',
-			icon: <BellDot size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.LIST_ALL_ALERT),
-		},
-		{
-			id: 'exceptions',
-			name: 'Go to Exceptions',
-			shortcut: ['shift + e'],
-			keywords: 'exceptions errors',
-			section: 'Navigation',
-			icon: <BugIcon size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.ALL_ERROR),
-		},
-		{
-			id: 'messaging-queues',
-			name: 'Go to Messaging Queues',
-			shortcut: ['shift + m'],
-			keywords: 'messaging queues mq',
-			section: 'Navigation',
-			icon: <ListMinus size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.MESSAGING_QUEUES_OVERVIEW),
-		},
-		{
-			id: 'my-settings',
-			name: 'Go to Account Settings',
-			keywords: 'account settings',
-			section: 'Navigation',
-			icon: <Settings size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.MY_SETTINGS),
-		},
-
-		// Settings
-		{
-			id: 'open-sidebar',
-			name: 'Open Sidebar',
-			keywords: 'sidebar navigation menu expand',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleOpenSidebar(),
-		},
-		{
-			id: 'collapse-sidebar',
-			name: 'Collapse Sidebar',
-			keywords: 'sidebar navigation menu collapse',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleCloseSidebar(),
-		},
-		{
-			id: 'dark-mode',
-			name: 'Switch to Dark Mode',
-			keywords: 'theme dark mode appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.DARK),
-		},
-		{
-			id: 'light-mode',
-			name: 'Switch to Light Mode [Beta]',
-			keywords: 'theme light mode appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.LIGHT),
-		},
-		{
-			id: 'system-theme',
-			name: 'Switch to System Theme',
-			keywords: 'system theme appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.SYSTEM),
-		},
-	];
+	const actions = createShortcutActions({
+		navigate: onClickHandler,
+		handleThemeChange,
+	});
 
 	// RBAC filter: show action if no roles set OR current user role is included
 	const permitted = actions.filter(

frontend/src/constants/shortcutActions.tsx

@@ -0,0 +1,263 @@
+import ROUTES from 'constants/routes';
+import { GlobalShortcutsName } from 'constants/shortcuts/globalShortcuts';
+import { THEME_MODE } from 'hooks/useDarkMode/constant';
+import {
+	BarChart2,
+	BellDot,
+	BugIcon,
+	Compass,
+	DraftingCompass,
+	Expand,
+	HardDrive,
+	Home,
+	LayoutGrid,
+	ListMinus,
+	ScrollText,
+	Settings,
+	TowerControl,
+	Workflow,
+} from 'lucide-react';
+import React from 'react';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+
+export type CmdAction = {
+	id: string;
+	name: string;
+	shortcut?: string[];
+	keywords?: string;
+	section?: string;
+	icon?: React.ReactNode;
+	roles?: UserRole[];
+	perform: () => void;
+};
+
+type ActionDeps = {
+	navigate: (path: string) => void;
+	handleThemeChange: (mode: string) => void;
+};
+
+export function createShortcutActions(deps: ActionDeps): CmdAction[] {
+	const { navigate, handleThemeChange } = deps;
+
+	return [
+		{
+			id: 'home',
+			name: 'Go to Home',
+			shortcut: [GlobalShortcutsName.NavigateToHome],
+			keywords: 'home',
+			section: 'Navigation',
+			icon: <Home size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.HOME),
+		},
+		{
+			id: 'dashboards',
+			name: 'Go to Dashboards',
+			shortcut: [GlobalShortcutsName.NavigateToDashboards],
+			keywords: 'dashboards',
+			section: 'Navigation',
+			icon: <LayoutGrid size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.ALL_DASHBOARD),
+		},
+		{
+			id: 'services',
+			name: 'Go to Services',
+			shortcut: [GlobalShortcutsName.NavigateToServices],
+			keywords: 'services monitoring',
+			section: 'Navigation',
+			icon: <HardDrive size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.APPLICATION),
+		},
+		{
+			id: 'alerts',
+			name: 'Go to Alerts',
+			shortcut: [GlobalShortcutsName.NavigateToAlerts],
+			keywords: 'alerts',
+			section: 'Navigation',
+			icon: <BellDot size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LIST_ALL_ALERT),
+		},
+		{
+			id: 'exceptions',
+			name: 'Go to Exceptions',
+			shortcut: [GlobalShortcutsName.NavigateToExceptions],
+			keywords: 'exceptions errors',
+			section: 'Navigation',
+			icon: <BugIcon size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.ALL_ERROR),
+		},
+		{
+			id: 'messaging-queues',
+			name: 'Go to Messaging Queues',
+			shortcut: [GlobalShortcutsName.NavigateToMessagingQueues],
+			keywords: 'messaging queues mq',
+			section: 'Navigation',
+			icon: <ListMinus size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.MESSAGING_QUEUES_OVERVIEW),
+		},
+
+		// logs
+		{
+			id: 'logs',
+			name: 'Go to Logs',
+			shortcut: [GlobalShortcutsName.NavigateToLogs],
+			keywords: 'logs',
+			section: 'Logs',
+			icon: <ScrollText size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS),
+		},
+		{
+			id: 'logs',
+			name: 'Go to Logs Pipelines',
+			shortcut: [GlobalShortcutsName.NavigateToLogsPipelines],
+			keywords: 'logs pipelines',
+			section: 'Logs',
+			icon: <Workflow size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS_PIPELINES),
+		},
+		{
+			id: 'logs',
+			name: 'Go to Logs Views',
+			shortcut: [GlobalShortcutsName.NavigateToLogsViews],
+			keywords: 'logs views',
+			section: 'Logs',
+			icon: <TowerControl size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS_SAVE_VIEWS),
+		},
+
+		// metrics
+		{
+			id: 'metrics-summary',
+			name: 'Go to Metrics Summary',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsSummary],
+			keywords: 'metrics summary',
+			section: 'Metrics',
+			icon: <BarChart2 size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER),
+		},
+		{
+			id: 'metrics-explorer',
+			name: 'Go to Metrics Explorer',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsExplorer],
+			keywords: 'metrics explorer',
+			section: 'Metrics',
+			icon: <Compass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER_EXPLORER),
+		},
+		{
+			id: 'metrics-views',
+			name: 'Go to Metrics Views',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsViews],
+			keywords: 'metrics views',
+			section: 'Metrics',
+			icon: <TowerControl size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER_VIEWS),
+		},
+
+		// Traces
+		{
+			id: 'traces',
+			name: 'Go to Traces',
+			shortcut: [GlobalShortcutsName.NavigateToTraces],
+			keywords: 'traces',
+			section: 'Traces',
+			icon: <DraftingCompass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.TRACES_EXPLORER),
+		},
+		{
+			id: 'traces-funnel',
+			name: 'Go to Traces Funnels',
+			shortcut: [GlobalShortcutsName.NavigateToTracesFunnel],
+			keywords: 'traces funnel',
+			section: 'Traces',
+			icon: <DraftingCompass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.TRACES_FUNNELS),
+		},
+
+		// Common actions
+		{
+			id: 'dark-mode',
+			name: 'Switch to Dark Mode',
+			keywords: 'theme dark mode appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.DARK),
+		},
+		{
+			id: 'light-mode',
+			name: 'Switch to Light Mode [Beta]',
+			keywords: 'theme light mode appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.LIGHT),
+		},
+		{
+			id: 'system-theme',
+			name: 'Switch to System Theme',
+			keywords: 'system theme appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.SYSTEM),
+		},
+
+		// settings sub-pages
+		{
+			id: 'my-settings',
+			name: 'Go to Account Settings',
+			shortcut: [GlobalShortcutsName.NavigateToSettings],
+			keywords: 'account settings',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.MY_SETTINGS),
+		},
+		{
+			id: 'my-settings-ingestion',
+			name: 'Go to Account Settings Ingestion',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsIngestion],
+			keywords: 'account settings',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.INGESTION_SETTINGS),
+		},
+
+		{
+			id: 'my-settings-billing',
+			name: 'Go to Account Settings Billing',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsBilling],
+			keywords: 'account settings billing',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.BILLING),
+		},
+		{
+			id: 'my-settings-api-keys',
+			name: 'Go to Account Settings API Keys',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsAPIKeys],
+			keywords: 'account settings api keys',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.API_KEYS),
+		},
+	];
+}

frontend/src/constants/shortcuts/globalShortcuts.ts

@@ -1,25 +1,57 @@
 export const GlobalShortcuts = {
-	NavigateToServices: 's+shift',
-	NavigateToTraces: 't+shift',
-	NavigateToLogs: 'l+shift',
-	NavigateToDashboards: 'd+shift',
-	NavigateToAlerts: 'a+shift',
-	NavigateToExceptions: 'e+shift',
-	NavigateToMessagingQueues: 'm+shift',
-	ToggleSidebar: 'b+shift',
-	NavigateToHome: 'h+shift',
+	NavigateToServices: 'shift+s',
+	NavigateToDashboards: 'shift+d',
+	NavigateToAlerts: 'shift+a',
+	NavigateToExceptions: 'shift+e',
+	NavigateToMessagingQueues: 'shift+q',
+	ToggleSidebar: 'shift+b',
+	NavigateToHome: 'shift+h',
+
+	// logs
+	NavigateToLogs: 'shift+l',
+	NavigateToLogsPipelines: 'shift+l+p',
+	NavigateToLogsViews: 'shift+l+v',
+
+	// traces
+	NavigateToTraces: 'shift+t',
+	NavigateToTracesFunnel: 'shift+t+f',
+	NavigateToTracesViews: 'shift+t+v',
+
+	// metrics
+	NavigateToMetricsSummary: 'shift+m',
+	NavigateToMetricsExplorer: 'shift+m+e',
+	NavigateToMetricsViews: 'shift+m+v',
+
+	// settings
+	NavigateToSettings: 'shift+g',
+	NavigateToSettingsIngestion: 'shift+g+i',
+	NavigateToSettingsBilling: 'shift+g+b',
+	NavigateToSettingsAPIKeys: 'shift+g+k',
+	NavigateToSettingsNotificationChannels: 'shift+g+n',
 };
 
 export const GlobalShortcutsName = {
 	NavigateToServices: 'shift+s',
 	NavigateToTraces: 'shift+t',
-	NavigateToLogs: 'shift+l',
 	NavigateToDashboards: 'shift+d',
 	NavigateToAlerts: 'shift+a',
 	NavigateToExceptions: 'shift+e',
-	NavigateToMessagingQueues: 'shift+m',
+	NavigateToMessagingQueues: 'shift+q',
 	ToggleSidebar: 'shift+b',
 	NavigateToHome: 'shift+h',
+	NavigateToTracesFunnel: 'shift+t+f',
+	NavigateToTracesViews: 'shift+t+v',
+	NavigateToMetricsSummary: 'shift+m',
+	NavigateToMetricsExplorer: 'shift+m+e',
+	NavigateToMetricsViews: 'shift+m+v',
+	NavigateToSettings: 'shift+g',
+	NavigateToSettingsIngestion: 'shift+g+i',
+	NavigateToSettingsBilling: 'shift+g+b',
+	NavigateToSettingsAPIKeys: 'shift+g+k',
+	NavigateToSettingsNotificationChannels: 'shift+g+n',
+	NavigateToLogs: 'shift+l',
+	NavigateToLogsPipelines: 'shift+l+p',
+	NavigateToLogsViews: 'shift+l+v',
 };
 
 export const GlobalShortcutsDescription = {
@@ -32,4 +64,17 @@ export const GlobalShortcutsDescription = {
 	NavigateToExceptions: 'Navigate to Exceptions List',
 	NavigateToMessagingQueues: 'Navigate to Messaging Queues',
 	ToggleSidebar: 'Toggle sidebar visibility',
+	NavigateToTracesFunnel: 'Navigate to Traces Funnel',
+	NavigateToTracesViews: 'Navigate to Traces Views',
+	NavigateToMetricsSummary: 'Navigate to Metrics Summary',
+	NavigateToMetricsExplorer: 'Navigate to Metrics Explorer',
+	NavigateToMetricsViews: 'Navigate to Metrics Views',
+	NavigateToSettings: 'Navigate to Settings',
+	NavigateToSettingsIngestion: 'Navigate to Ingestion Settings',
+	NavigateToSettingsBilling: 'Navigate to Billing Settings',
+	NavigateToSettingsAPIKeys: 'Navigate to API Keys Settings',
+	NavigateToSettingsNotificationChannels:
+		'Navigate to Notification Channels Settings',
+	NavigateToLogsPipelines: 'Navigate to Logs Pipelines',
+	NavigateToLogsViews: 'Navigate to Logs Views',
 };

frontend/src/container/AppLayout/__tests__/sidebar-toggle-shortcut.test.tsx

@@ -10,6 +10,20 @@ import {
 import { QueryClient, QueryClientProvider } from 'react-query';
 
 // Mock dependencies
+jest.mock('providers/cmdKProvider', () => ({
+	useCmdK: (): {
+		open: boolean;
+		setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+		openCmdK: () => void;
+		closeCmdK: () => void;
+	} => ({
+		open: false,
+		setOpen: jest.fn(),
+		openCmdK: jest.fn(),
+		closeCmdK: jest.fn(),
+	}),
+}));
+
 jest.mock('api/common/logEvent', () => jest.fn());
 
 // Mock the AppContext
@@ -63,7 +77,7 @@ describe('Sidebar Toggle Shortcut', () => {
 
 	describe('Global Shortcuts Constants', () => {
 		it('should have the correct shortcut key combination', () => {
-			expect(GlobalShortcuts.ToggleSidebar).toBe('b+shift');
+			expect(GlobalShortcuts.ToggleSidebar).toBe('shift+b');
 		});
 	});
 

frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.tsx

@@ -67,7 +67,6 @@ function WidgetGraphComponent({
 }: WidgetGraphComponentProps): JSX.Element {
 	const { safeNavigate } = useSafeNavigate();
 	const [deleteModal, setDeleteModal] = useState(false);
-	const [hovered, setHovered] = useState(false);
 	const { notifications } = useNotifications();
 	const { pathname, search } = useLocation();
 
@@ -316,18 +315,6 @@ function WidgetGraphComponent({
 			style={{
 				height: '100%',
 			}}
-			onMouseOver={(): void => {
-				setHovered(true);
-			}}
-			onFocus={(): void => {
-				setHovered(true);
-			}}
-			onMouseOut={(): void => {
-				setHovered(false);
-			}}
-			onBlur={(): void => {
-				setHovered(false);
-			}}
 			id={widget.id}
 			className="widget-graph-component-container"
 		>
@@ -377,7 +364,6 @@ function WidgetGraphComponent({
 
 			<div className="drag-handle">
 				<WidgetHeader
-					parentHover={hovered}
 					title={widget?.title}
 					widget={widget}
 					onView={handleOnView}

frontend/src/container/GridCardLayout/GridCardLayout.styles.scss

@@ -99,6 +99,12 @@
 			height: calc(100% - 30px);
 		}
 	}
+
+	&:hover {
+		.widget-header-more-options {
+			visibility: visible;
+		}
+	}
 }
 
 .widget-full-view {

frontend/src/container/GridCardLayout/WidgetHeader/WidgetHeader.styles.scss

@@ -51,10 +51,6 @@
 	visibility: visible;
 }
 
-.widget-header-hover {
-	visibility: visible;
-}
-
 .widget-api-actions {
 	padding-right: 0.25rem;
 }

frontend/src/container/GridCardLayout/WidgetHeader/__tests__/WidgetHeader.test.tsx

@@ -181,7 +181,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -204,7 +203,6 @@ describe('WidgetHeader', () => {
 				title="Empty Widget"
 				widget={emptyWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -227,7 +225,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -255,7 +252,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -298,7 +294,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={errorResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -340,7 +335,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={warningResponse}
 				isWarning
 				isFetchingResponse={false}
@@ -370,7 +364,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={fetchingResponse}
 				isWarning={false}
 				isFetchingResponse
@@ -389,7 +382,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -414,7 +406,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -433,7 +424,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -454,7 +444,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}

frontend/src/container/GridCardLayout/WidgetHeader/index.tsx

@@ -48,7 +48,6 @@ interface IWidgetHeaderProps {
 	onView: VoidFunction;
 	onDelete?: VoidFunction;
 	onClone?: VoidFunction;
-	parentHover: boolean;
 	queryResponse: UseQueryResult<
 		SuccessResponse<MetricRangePayloadProps, unknown> & {
 			warning?: Warning;
@@ -69,7 +68,6 @@ function WidgetHeader({
 	onView,
 	onDelete,
 	onClone,
-	parentHover,
 	queryResponse,
 	threshold,
 	headerMenuList,
@@ -315,8 +313,6 @@ function WidgetHeader({
 								<MoreOutlined
 									data-testid="widget-header-options"
 									className={`widget-header-more-options ${
-										parentHover ? 'widget-header-hover' : ''
-									} ${
 										globalSearchAvailable ? 'widget-header-more-options-visible' : ''
 									}`}
 								/>

frontend/src/container/LogDetailedView/BodyTitleRenderer.tsx

@@ -92,14 +92,14 @@ function BodyTitleRenderer({
 
 			if (isObject) {
 				// For objects/arrays, stringify the entire structure
-				copyText = `"${cleanedKey}": ${JSON.stringify(value, null, 2)}`;
+				copyText = JSON.stringify(value, null, 2);
 			} else if (parentIsArray) {
-				// For array elements, copy just the value
-				copyText = `"${cleanedKey}": ${value}`;
+				// array elements
+				copyText = `${value}`;
 			} else {
-				// For primitive values, format as JSON key-value pair
-				const valueStr = typeof value === 'string' ? `"${value}"` : String(value);
-				copyText = `"${cleanedKey}": ${valueStr}`;
+				// primitive values
+				const valueStr = typeof value === 'string' ? value : String(value);
+				copyText = valueStr;
 			}
 
 			setCopy(copyText);

frontend/src/container/LogDetailedView/TableView/TableViewActions.tsx

@@ -60,7 +60,8 @@ const BodyContent: React.FC<{
 	fieldData: Record<string, string>;
 	record: DataType;
 	bodyHtml: { __html: string };
-}> = React.memo(({ fieldData, record, bodyHtml }) => {
+	textToCopy: string;
+}> = React.memo(({ fieldData, record, bodyHtml, textToCopy }) => {
 	const { isLoading, treeData, error } = useAsyncJSONProcessing(
 		fieldData.value,
 		record.field === 'body',
@@ -92,11 +93,13 @@ const BodyContent: React.FC<{
 
 	if (record.field === 'body') {
 		return (
-			<span
-				style={{ color: Color.BG_SIENNA_400, whiteSpace: 'pre-wrap', tabSize: 4 }}
-			>
-				<span dangerouslySetInnerHTML={bodyHtml} />
-			</span>
+			<CopyClipboardHOC entityKey="body" textToCopy={textToCopy}>
+				<span
+					style={{ color: Color.BG_SIENNA_400, whiteSpace: 'pre-wrap', tabSize: 4 }}
+				>
+					<span dangerouslySetInnerHTML={bodyHtml} />
+				</span>
+			</CopyClipboardHOC>
 		);
 	}
 
@@ -172,7 +175,12 @@ export default function TableViewActions(
 		switch (record.field) {
 			case 'body':
 				return (
-					<BodyContent fieldData={fieldData} record={record} bodyHtml={bodyHtml} />
+					<BodyContent
+						fieldData={fieldData}
+						record={record}
+						bodyHtml={bodyHtml}
+						textToCopy={textToCopy}
+					/>
 				);
 
 			case 'timestamp':
@@ -194,6 +202,7 @@ export default function TableViewActions(
 		record,
 		fieldData,
 		bodyHtml,
+		textToCopy,
 		formatTimezoneAdjustedTimestamp,
 		cleanTimestamp,
 	]);
@@ -202,7 +211,12 @@ export default function TableViewActions(
 	if (record.field === 'body') {
 		return (
 			<div className={cx('value-field', isOpen ? 'open-popover' : '')}>
-				<BodyContent fieldData={fieldData} record={record} bodyHtml={bodyHtml} />
+				<BodyContent
+					fieldData={fieldData}
+					record={record}
+					bodyHtml={bodyHtml}
+					textToCopy={textToCopy}
+				/>
 				{!isListViewPanel && !RESTRICTED_SELECTED_FIELDS.includes(fieldFilterKey) && (
 					<span className="action-btn">
 						<Tooltip title="Filter for value">

frontend/src/container/LogDetailedView/TableView/__test__/TableViewActions.test.tsx

@@ -1,16 +1,54 @@
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
 
 import TableViewActions from '../TableViewActions';
+import useAsyncJSONProcessing from '../useAsyncJSONProcessing';
+
+// Mock data for tests
+let mockCopyToClipboard: jest.Mock;
+let mockNotificationsSuccess: jest.Mock;
 
 // Mock the components and hooks
 jest.mock('components/Logs/CopyClipboardHOC', () => ({
 	__esModule: true,
-	default: ({ children }: { children: React.ReactNode }): JSX.Element => (
-		<div className="CopyClipboardHOC">{children}</div>
+	default: ({
+		children,
+		textToCopy,
+		entityKey,
+	}: {
+		children: React.ReactNode;
+		textToCopy: string;
+		entityKey: string;
+	}): JSX.Element => (
+		// eslint-disable-next-line jsx-a11y/click-events-have-key-events
+		<div
+			className="CopyClipboardHOC"
+			data-testid={`copy-clipboard-${entityKey}`}
+			data-text-to-copy={textToCopy}
+			onClick={(): void => {
+				if (mockCopyToClipboard) {
+					mockCopyToClipboard(textToCopy);
+				}
+				if (mockNotificationsSuccess) {
+					mockNotificationsSuccess({
+						message: `${entityKey} copied to clipboard`,
+						key: `${entityKey} copied to clipboard`,
+					});
+				}
+			}}
+			role="button"
+			tabIndex={0}
+		>
+			{children}
+		</div>
 	),
 }));
 
+jest.mock('../useAsyncJSONProcessing', () => ({
+	__esModule: true,
+	default: jest.fn(),
+}));
+
 jest.mock('providers/Timezone', () => ({
 	useTimezone: (): {
 		formatTimezoneAdjustedTimestamp: (timestamp: string) => string;
@@ -53,6 +91,19 @@ describe('TableViewActions', () => {
 		onGroupByAttribute: jest.fn(),
 	};
 
+	beforeEach(() => {
+		mockCopyToClipboard = jest.fn();
+		mockNotificationsSuccess = jest.fn();
+
+		// Default mock for useAsyncJSONProcessing
+		const mockUseAsyncJSONProcessing = jest.mocked(useAsyncJSONProcessing);
+		mockUseAsyncJSONProcessing.mockReturnValue({
+			isLoading: false,
+			treeData: null,
+			error: null,
+		});
+	});
+
 	it('should render without crashing', () => {
 		render(
 			<TableViewActions
@@ -127,4 +178,60 @@ describe('TableViewActions', () => {
 			container.querySelector(ACTION_BUTTON_TEST_ID),
 		).not.toBeInTheDocument();
 	});
+
+	it('should copy non-JSON body text without quotes when user clicks on body', () => {
+		// Setup: body field with surrounding quotes
+		const bodyValueWithQuotes =
+			'"FeatureFlag \'kafkaQueueProblems\' is enabled, sleeping 1 second"';
+		const expectedCopiedText =
+			"FeatureFlag 'kafkaQueueProblems' is enabled, sleeping 1 second";
+
+		const bodyProps = {
+			fieldData: {
+				field: 'body',
+				value: bodyValueWithQuotes,
+			},
+			record: {
+				key: 'body-key',
+				field: 'body',
+				value: bodyValueWithQuotes,
+			},
+			isListViewPanel: false,
+			isfilterInLoading: false,
+			isfilterOutLoading: false,
+			onClickHandler: jest.fn(),
+			onGroupByAttribute: jest.fn(),
+		};
+
+		// Render component with body field
+		render(
+			<TableViewActions
+				fieldData={bodyProps.fieldData}
+				record={bodyProps.record}
+				isListViewPanel={bodyProps.isListViewPanel}
+				isfilterInLoading={bodyProps.isfilterInLoading}
+				isfilterOutLoading={bodyProps.isfilterOutLoading}
+				onClickHandler={bodyProps.onClickHandler}
+				onGroupByAttribute={bodyProps.onGroupByAttribute}
+			/>,
+		);
+
+		// Find the clickable copy area for body
+		const copyArea = screen.getByTestId('copy-clipboard-body');
+
+		// Verify it has the correct text to copy (without quotes)
+		expect(copyArea).toHaveAttribute('data-text-to-copy', expectedCopiedText);
+
+		// Action: User clicks on body content
+		fireEvent.click(copyArea);
+
+		// Assert: Text was copied without surrounding quotes
+		expect(mockCopyToClipboard).toHaveBeenCalledWith(expectedCopiedText);
+
+		// Assert: Success notification shown
+		expect(mockNotificationsSuccess).toHaveBeenCalledWith({
+			message: 'body copied to clipboard',
+			key: 'body copied to clipboard',
+		});
+	});
 });

frontend/src/container/LogDetailedView/__tests__/BodyTitleRenderer.test.tsx

@@ -51,7 +51,7 @@ describe('BodyTitleRenderer', () => {
 		await user.click(screen.getByText('name'));
 
 		await waitFor(() => {
-			expect(mockSetCopy).toHaveBeenCalledWith('"user.name": "John"');
+			expect(mockSetCopy).toHaveBeenCalledWith('John');
 			expect(mockNotification).toHaveBeenCalledWith(
 				expect.objectContaining({
 					message: expect.stringContaining('user.name'),
@@ -75,7 +75,7 @@ describe('BodyTitleRenderer', () => {
 		await user.click(screen.getByText('0'));
 
 		await waitFor(() => {
-			expect(mockSetCopy).toHaveBeenCalledWith('"items[*].0": arrayElement');
+			expect(mockSetCopy).toHaveBeenCalledWith('arrayElement');
 		});
 	});
 
@@ -96,9 +96,8 @@ describe('BodyTitleRenderer', () => {
 
 		await waitFor(() => {
 			const callArg = mockSetCopy.mock.calls[0][0];
-			expect(callArg).toContain('"user.metadata":');
-			expect(callArg).toContain('"id": 123');
-			expect(callArg).toContain('"active": true');
+			const expectedJson = JSON.stringify(testObject, null, 2);
+			expect(callArg).toBe(expectedJson);
 			expect(mockNotification).toHaveBeenCalledWith(
 				expect.objectContaining({
 					message: expect.stringContaining('object copied'),

frontend/src/container/QueryTable/__test__/mocks.ts

@@ -363,7 +363,6 @@ export const WidgetHeaderProps: any = {
 		title: 'Table - Panel',
 		yAxisUnit: 'none',
 	},
-	parentHover: false,
 	queryResponse: {
 		status: 'success',
 		isLoading: false,

frontend/src/container/SideNav/SideNav.tsx

@@ -679,7 +679,42 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 		registerShortcut(GlobalShortcuts.NavigateToExceptions, () =>
 			onClickHandler(ROUTES.ALL_ERROR, null),
 		);
-
+		registerShortcut(GlobalShortcuts.NavigateToTracesFunnel, () =>
+			onClickHandler(ROUTES.TRACES_FUNNELS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToTracesViews, () =>
+			onClickHandler(ROUTES.TRACES_SAVE_VIEWS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsSummary, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsExplorer, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER_EXPLORER, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsViews, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER_VIEWS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettings, () =>
+			onClickHandler(ROUTES.SETTINGS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsIngestion, () =>
+			onClickHandler(ROUTES.INGESTION_SETTINGS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsBilling, () =>
+			onClickHandler(ROUTES.BILLING, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsAPIKeys, () =>
+			onClickHandler(ROUTES.API_KEYS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsNotificationChannels, () =>
+			onClickHandler(ROUTES.ALL_CHANNELS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToLogsPipelines, () =>
+			onClickHandler(ROUTES.LOGS_PIPELINES, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToLogsViews, () =>
+			onClickHandler(ROUTES.LOGS_SAVE_VIEWS, null),
+		);
 		return (): void => {
 			deregisterShortcut(GlobalShortcuts.NavigateToHome);
 			deregisterShortcut(GlobalShortcuts.NavigateToServices);
@@ -689,6 +724,18 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 			deregisterShortcut(GlobalShortcuts.NavigateToAlerts);
 			deregisterShortcut(GlobalShortcuts.NavigateToExceptions);
 			deregisterShortcut(GlobalShortcuts.NavigateToMessagingQueues);
+			deregisterShortcut(GlobalShortcuts.NavigateToTracesFunnel);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsSummary);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsExplorer);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsViews);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettings);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsIngestion);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsBilling);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsAPIKeys);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsNotificationChannels);
+			deregisterShortcut(GlobalShortcuts.NavigateToLogsPipelines);
+			deregisterShortcut(GlobalShortcuts.NavigateToLogsViews);
+			deregisterShortcut(GlobalShortcuts.NavigateToTracesViews);
 		};
 	}, [deregisterShortcut, onClickHandler, registerShortcut]);
 

frontend/src/container/SpanDetailsDrawer/SpanLogs/spanLogs.styles.scss

@@ -5,16 +5,20 @@
 	&-virtuoso {
 		background: rgba(171, 189, 255, 0.04);
 	}
-	&-list-container .logs-loading-skeleton {
+	&-list-container {
 		height: 100%;
-		border: 1px solid var(--bg-slate-500);
-		border-top: none;
-		color: var(--bg-vanilla-400);
-		display: flex;
-		flex-direction: column;
-		align-items: center;
-		justify-content: center;
-		padding: 8px 0;
+
+		.logs-loading-skeleton {
+			height: 100%;
+			border: 1px solid var(--bg-slate-500);
+			border-top: none;
+			color: var(--bg-vanilla-400);
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+			justify-content: center;
+			padding: 8px 0;
+		}
 	}
 
 	&-empty-content {

frontend/src/hooks/hotkeys/__tests__/useKeyboardHotkeys.test.tsx

@@ -1,11 +1,18 @@
 import { render } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { useEffect } from 'react';
 
 import {
 	KeyboardHotkeysProvider,
 	useKeyboardHotkeys,
 } from '../useKeyboardHotkeys';
 
+jest.mock('../../../providers/cmdKProvider', () => ({
+	useCmdK: (): { open: boolean } => ({
+		open: false,
+	}),
+}));
+
 function TestComponentWithRegister({
 	handleShortcut,
 }: {
@@ -13,14 +20,13 @@ function TestComponentWithRegister({
 }): JSX.Element {
 	const { registerShortcut } = useKeyboardHotkeys();
 
-	registerShortcut('a', handleShortcut);
+	useEffect(() => {
+		registerShortcut('a', handleShortcut);
+	}, [registerShortcut, handleShortcut]);
 
-	return (
-		<div>
-			<span>Test Component</span>
-		</div>
-	);
+	return <span>Test Component</span>;
 }
+
 function TestComponentWithDeRegister({
 	handleShortcut,
 }: {
@@ -28,21 +34,18 @@ function TestComponentWithDeRegister({
 }): JSX.Element {
 	const { registerShortcut, deregisterShortcut } = useKeyboardHotkeys();
 
-	registerShortcut('b', handleShortcut);
+	useEffect(() => {
+		registerShortcut('b', handleShortcut);
+		deregisterShortcut('b');
+	}, [registerShortcut, deregisterShortcut, handleShortcut]);
 
-	// Deregister the shortcut before triggering it
-	deregisterShortcut('b');
-
-	return (
-		<div>
-			<span>Test Component</span>
-		</div>
-	);
+	return <span>Test Component</span>;
 }
 
 describe('KeyboardHotkeysProvider', () => {
 	it('registers and triggers shortcuts correctly', async () => {
 		const handleShortcut = jest.fn();
+		const user = userEvent.setup();
 
 		render(
 			<KeyboardHotkeysProvider>
@@ -50,15 +53,15 @@ describe('KeyboardHotkeysProvider', () => {
 			</KeyboardHotkeysProvider>,
 		);
 
-		// Trigger the registered shortcut
-		await userEvent.keyboard('a');
+		// fires on keyup
+		await user.keyboard('{a}');
 
-		// Assert that the handleShortcut function has been called
-		expect(handleShortcut).toHaveBeenCalled();
+		expect(handleShortcut).toHaveBeenCalledTimes(1);
 	});
 
-	it('deregisters shortcuts correctly', () => {
+	it('does not trigger deregistered shortcuts', async () => {
 		const handleShortcut = jest.fn();
+		const user = userEvent.setup();
 
 		render(
 			<KeyboardHotkeysProvider>
@@ -66,10 +69,8 @@ describe('KeyboardHotkeysProvider', () => {
 			</KeyboardHotkeysProvider>,
 		);
 
-		// Try to trigger the deregistered shortcut
-		userEvent.keyboard('b');
+		await user.keyboard('{b}');
 
-		// Assert that the handleShortcut function has NOT been called
 		expect(handleShortcut).not.toHaveBeenCalled();
 	});
 });

frontend/src/hooks/hotkeys/useKeyboardHotkeys.tsx

@@ -8,20 +8,21 @@ import {
 	useRef,
 } from 'react';
 
+import { useCmdK } from '../../providers/cmdKProvider';
+
 interface KeyboardHotkeysContextReturnValue {
 	/**
-	 * @param keyCombination provide the string for which the subsequent callback should be triggered. Example 'ctrl+a'
+	 * @param keyCombo provide the string for which the subsequent callback should be triggered. Example 'ctrl+a'
 	 * @param callback the callback that should be triggered when the above key combination is being pressed
 	 * @returns void
 	 */
-	registerShortcut: (keyCombination: string, callback: () => void) => void;
-
+	registerShortcut: (keyCombo: string, callback: () => void) => void;
 	/**
 	 *
-	 * @param keyCombination provide the string for which we want to deregister the callback
+	 * @param keyCombo provide the string for which we want to deregister the callback
 	 * @returns void
 	 */
-	deregisterShortcut: (keyCombination: string) => void;
+	deregisterShortcut: (keyCombo: string) => void;
 }
 
 const KeyboardHotkeysContext = createContext<KeyboardHotkeysContextReturnValue>(
@@ -33,7 +34,7 @@ const KeyboardHotkeysContext = createContext<KeyboardHotkeysContextReturnValue>(
 
 const IGNORE_INPUTS = ['input', 'textarea', 'cm-editor']; // Inputs in which hotkey events will be ignored
 
-const useKeyboardHotkeys = (): KeyboardHotkeysContextReturnValue => {
+export function useKeyboardHotkeys(): KeyboardHotkeysContextReturnValue {
 	const context = useContext(KeyboardHotkeysContext);
 	if (!context) {
 		throw new Error(
@@ -42,21 +43,45 @@ const useKeyboardHotkeys = (): KeyboardHotkeysContextReturnValue => {
 	}
 
 	return context;
-};
+}
 
-function KeyboardHotkeysProvider({
+/**
+ * Normalize a set of keys into a stable combo
+ * { shift, m, e } → "e+m+shift"
+ */
+function normalizeChord(keys: Set<string>): string {
+	return Array.from(keys).sort().join('+');
+}
+
+/**
+ * Normalize registration strings
+ * "shift+m+e" → "e+m+shift"
+ */
+function normalizeComboString(combo: string): string {
+	return normalizeChord(new Set(combo.split('+')));
+}
+
+export function KeyboardHotkeysProvider({
 	children,
 }: {
 	children: JSX.Element;
 }): JSX.Element {
+	const { open: cmdKOpen } = useCmdK();
 	const shortcuts = useRef<Record<string, () => void>>({});
+	const pressedKeys = useRef<Set<string>>(new Set());
 
-	const handleKeyPress = (event: KeyboardEvent): void => {
-		const { key, ctrlKey, altKey, shiftKey, metaKey, target } = event;
+	// A detected valid shortcut waiting to fire
+	const pendingCombo = useRef<string | null>(null);
 
+	// Tracks whether user extended the combo
+	const wasExtended = useRef(false);
+
+	const handleKeyDown = (event: KeyboardEvent): void => {
+		if (event.repeat) return;
+
+		const target = event.target as HTMLElement;
 		const isCodeMirrorEditor =
 			(target as HTMLElement).closest('.cm-editor') !== null;
-
 		if (
 			IGNORE_INPUTS.includes((target as HTMLElement).tagName.toLowerCase()) ||
 			isCodeMirrorEditor
@@ -64,61 +89,110 @@ function KeyboardHotkeysProvider({
 			return;
 		}
 
-		// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/metaKey
-		const modifiers = { ctrlKey, altKey, shiftKey, metaKey };
+		const key = event.key?.toLowerCase();
+		if (!key) return; // Skip if key is undefined
 
-		let shortcutKey = `${key.toLowerCase()}`;
+		// If a pending combo exists and a new key is pressed → extension
+		if (pendingCombo.current && !pressedKeys.current.has(key)) {
+			wasExtended.current = true;
+		}
 
-		const isAltKey = `${modifiers.altKey ? '+alt' : ''}`;
-		const isShiftKey = `${modifiers.shiftKey ? '+shift' : ''}`;
+		pressedKeys.current.add(key);
 
-		// ctrl and cmd have the same functionality for mac and windows parity
-		const isMetaKey = `${modifiers.metaKey || modifiers.ctrlKey ? '+meta' : ''}`;
+		if (event.shiftKey) pressedKeys.current.add('shift');
+		if (event.metaKey || event.ctrlKey) pressedKeys.current.add('meta');
+		if (event.altKey) pressedKeys.current.add('alt');
 
-		shortcutKey = shortcutKey + isAltKey + isShiftKey + isMetaKey;
+		const combo = normalizeChord(pressedKeys.current);
 
-		if (shortcuts.current[shortcutKey]) {
+		if (shortcuts.current[combo]) {
 			event.preventDefault();
-			event.stopImmediatePropagation();
-
-			shortcuts.current[shortcutKey]();
+			event.stopPropagation();
+			pendingCombo.current = combo;
+			wasExtended.current = false;
 		}
 	};
 
-	useEffect(() => {
-		document.addEventListener('keydown', handleKeyPress);
+	const handleKeyUp = (event: KeyboardEvent): void => {
+		const key = event.key?.toLowerCase();
+		if (!key) return; // Skip if key is undefined
+
+		pressedKeys.current.delete(key);
+
+		if (!event.shiftKey) pressedKeys.current.delete('shift');
+		if (!event.metaKey && !event.ctrlKey) pressedKeys.current.delete('meta');
+		if (!event.altKey) pressedKeys.current.delete('alt');
+
+		if (!pendingCombo.current) return;
+
+		// Fire only if user did NOT extend the combo
+		if (!wasExtended.current) {
+			event.preventDefault();
+			try {
+				shortcuts.current[pendingCombo.current]?.();
+			} catch (error) {
+				console.error('Error executing hotkey callback:', error);
+			}
+		}
+
+		pendingCombo.current = null;
+		wasExtended.current = false;
+	};
+
+	useEffect((): (() => void) => {
+		document.addEventListener('keydown', handleKeyDown);
+		document.addEventListener('keyup', handleKeyUp);
+
+		const reset = (): void => {
+			pressedKeys.current.clear();
+			pendingCombo.current = null;
+			wasExtended.current = false;
+		};
+
+		window.addEventListener('blur', reset);
+
 		return (): void => {
-			document.removeEventListener('keydown', handleKeyPress);
+			document.removeEventListener('keydown', handleKeyDown);
+			document.removeEventListener('keyup', handleKeyUp);
+			window.removeEventListener('blur', reset);
 		};
 	}, []);
 
+	useEffect(() => {
+		if (!cmdKOpen) {
+			// Reset when palette closes
+			pressedKeys.current.clear();
+			pendingCombo.current = null;
+			wasExtended.current = false;
+		}
+	}, [cmdKOpen]);
+
 	const registerShortcut = useCallback(
-		(keyCombination: string, callback: () => void): void => {
-			if (!shortcuts.current[keyCombination]) {
-				shortcuts.current[keyCombination] = callback;
-			} else if (process.env.NODE_ENV === 'development') {
-				throw new Error(
-					`This shortcut is already present in current scope :- ${keyCombination}`,
-				);
+		(keyCombo: string, callback: () => void): void => {
+			const normalized = normalizeComboString(keyCombo);
+
+			if (!shortcuts.current[normalized]) {
+				shortcuts.current[normalized] = callback;
+				return;
+			}
+
+			const message = `This shortcut is already present in current scope :- ${keyCombo}`;
+
+			if (process.env.NODE_ENV === 'development') {
+				throw new Error(message);
 			} else {
-				console.error(
-					`This shortcut is already present in current scope :- ${keyCombination}`,
-				);
+				console.error(message);
 			}
 		},
-		[shortcuts],
+		[],
 	);
 
-	const deregisterShortcut = useCallback(
-		(keyCombination: string): void => {
-			if (shortcuts.current[keyCombination]) {
-				unset(shortcuts.current, keyCombination);
-			}
-		},
-		[shortcuts],
-	);
+	const deregisterShortcut = useCallback((keyCombo: string) => {
+		const normalized = normalizeComboString(keyCombo);
+		unset(shortcuts.current, normalized);
+	}, []);
 
-	const contextValue = useMemo(
+	const ctxValue = useMemo(
 		() => ({
 			registerShortcut,
 			deregisterShortcut,
@@ -127,10 +201,8 @@ function KeyboardHotkeysProvider({
 	);
 
 	return (
-		<KeyboardHotkeysContext.Provider value={contextValue}>
+		<KeyboardHotkeysContext.Provider value={ctxValue}>
 			{children}
 		</KeyboardHotkeysContext.Provider>
 	);
 }
-
-export { KeyboardHotkeysProvider, useKeyboardHotkeys };

pkg/apiserver/signozapiserver/promote.go

@@ -0,0 +1,43 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addPromoteRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/logs/promote_paths", handler.New(provider.authZ.EditAccess(provider.promoteHandler.HandlePromoteAndIndexPaths), handler.OpenAPIDef{
+		ID:                  "PromotePaths",
+		Tags:                []string{"promoted_paths", "logs", "json_logs"},
+		Summary:             "Promote and index paths",
+		Description:         "This endpoints promotes and indexes paths",
+		Request:             new([]*promotetypes.PromotePath),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusCreated,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/logs/promote_paths", handler.New(provider.authZ.ViewAccess(provider.promoteHandler.ListPromotedAndIndexedPaths), handler.OpenAPIDef{
+		ID:                  "PromotePaths",
+		Tags:                []string{"promoted_paths", "logs", "json_logs"},
+		Summary:             "Promote and index paths",
+		Description:         "This endpoints promotes and indexes paths",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            new([]*promotetypes.PromotePath),
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/apiserver/signozapiserver/provider.go

@@ -12,6 +12,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -30,6 +31,7 @@ type provider struct {
 	authDomainHandler authdomain.Handler
 	preferenceHandler preference.Handler
 	globalHandler     global.Handler
+	promoteHandler    promote.Handler
 }
 
 func NewFactory(
@@ -41,9 +43,10 @@ func NewFactory(
 	authDomainHandler authdomain.Handler,
 	preferenceHandler preference.Handler,
 	globalHandler global.Handler,
+	promoteHandler promote.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
-		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler)
+		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler, promoteHandler)
 	})
 }
 
@@ -59,6 +62,7 @@ func newProvider(
 	authDomainHandler authdomain.Handler,
 	preferenceHandler preference.Handler,
 	globalHandler global.Handler,
+	promoteHandler promote.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -73,6 +77,7 @@ func newProvider(
 		authDomainHandler: authDomainHandler,
 		preferenceHandler: preferenceHandler,
 		globalHandler:     globalHandler,
+		promoteHandler:    promoteHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -113,6 +118,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addPromoteRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/errors/errors.go

@@ -209,6 +209,11 @@ func NewUnexpectedf(code Code, format string, args ...any) *base {
 	return Newf(TypeInvalidInput, code, format, args...)
 }
 
+// NewMethodNotAllowedf is a wrapper around Newf with TypeMethodNotAllowed.
+func NewMethodNotAllowedf(code Code, format string, args ...any) *base {
+	return Newf(TypeMethodNotAllowed, code, format, args...)
+}
+
 // WrapTimeoutf is a wrapper around Wrapf with TypeTimeout.
 func WrapTimeoutf(cause error, code Code, format string, args ...any) *base {
 	return Wrapf(cause, TypeTimeout, code, format, args...)

pkg/modules/promote/implpromote/handler.go

@@ -0,0 +1,60 @@
+package implpromote
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/binding"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+)
+
+type handler struct {
+	module promote.Module
+}
+
+func NewHandler(module promote.Module) promote.Handler {
+	return &handler{module: module}
+}
+
+func (h *handler) HandlePromoteAndIndexPaths(w http.ResponseWriter, r *http.Request) {
+	// TODO(Nitya): Use in multi tenant setup
+	_, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, errors.NewInternalf(errors.CodeInternal, "failed to get org id from context"))
+		return
+	}
+
+	var req []*promotetypes.PromotePath
+	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	err = h.module.PromoteAndIndexPaths(r.Context(), req...)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	render.Success(w, http.StatusCreated, nil)
+}
+
+func (h *handler) ListPromotedAndIndexedPaths(w http.ResponseWriter, r *http.Request) {
+	// TODO(Nitya): Use in multi tenant setup
+	_, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, errors.NewInternalf(errors.CodeInternal, "failed to get org id from context"))
+		return
+	}
+
+	paths, err := h.module.ListPromotedAndIndexedPaths(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	render.Success(w, http.StatusOK, paths)
+}

pkg/modules/promote/implpromote/module.go

@@ -0,0 +1,201 @@
+package implpromote
+
+import (
+	"context"
+	"maps"
+	"slices"
+	"strings"
+
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+var (
+	CodeFailedToCreateIndex        = errors.MustNewCode("failed_to_create_index_promoted_paths")
+	CodeFailedToQueryPromotedPaths = errors.MustNewCode("failed_to_query_promoted_paths")
+)
+
+type module struct {
+	metadataStore  telemetrytypes.MetadataStore
+	telemetryStore telemetrystore.TelemetryStore
+}
+
+func NewModule(metadataStore telemetrytypes.MetadataStore, telemetrystore telemetrystore.TelemetryStore) promote.Module {
+	return &module{metadataStore: metadataStore, telemetryStore: telemetrystore}
+}
+
+func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetypes.PromotePath, error) {
+	logsIndexes, err := m.metadataStore.ListLogsJSONIndexes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	// Flatten the map values (which are slices) into a single slice
+	indexes := slices.Concat(slices.Collect(maps.Values(logsIndexes))...)
+
+	aggr := map[string][]promotetypes.WrappedIndex{}
+	for _, index := range indexes {
+		path, columnType, err := schemamigrator.UnfoldJSONSubColumnIndexExpr(index.Expression)
+		if err != nil {
+			return nil, err
+		}
+
+		// clean backticks from the path
+		path = strings.ReplaceAll(path, "`", "")
+
+		aggr[path] = append(aggr[path], promotetypes.WrappedIndex{
+			ColumnType:  columnType,
+			Type:        index.Type,
+			Granularity: index.Granularity,
+		})
+	}
+	promotedPaths, err := m.listPromotedPaths(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	response := []promotetypes.PromotePath{}
+	for _, path := range promotedPaths {
+		fullPath := telemetrylogs.BodyPromotedColumnPrefix + path
+		path = telemetrylogs.BodyJSONStringSearchPrefix + path
+		item := promotetypes.PromotePath{
+			Path:    path,
+			Promote: true,
+		}
+		indexes, ok := aggr[fullPath]
+		if ok {
+			item.Indexes = indexes
+			delete(aggr, fullPath)
+		}
+		response = append(response, item)
+	}
+
+	// add the paths that are not promoted but have indexes
+	for path, indexes := range aggr {
+		path := strings.TrimPrefix(path, telemetrylogs.BodyJSONColumnPrefix)
+		path = telemetrylogs.BodyJSONStringSearchPrefix + path
+		response = append(response, promotetypes.PromotePath{
+			Path:    path,
+			Indexes: indexes,
+		})
+	}
+	return response, nil
+}
+
+func (m *module) listPromotedPaths(ctx context.Context) ([]string, error) {
+	paths, err := m.metadataStore.ListPromotedPaths(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return slices.Collect(maps.Keys(paths)), nil
+}
+
+// PromotePaths inserts provided JSON paths into the promoted paths table for logs queries.
+func (m *module) PromotePaths(ctx context.Context, paths []string) error {
+	if len(paths) == 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "paths cannot be empty")
+	}
+
+	return m.metadataStore.PromotePaths(ctx, paths...)
+}
+
+// createIndexes creates string ngram + token filter indexes on JSON path subcolumns for LIKE queries.
+func (m *module) createIndexes(ctx context.Context, indexes []schemamigrator.Index) error {
+	if len(indexes) == 0 {
+		return nil
+	}
+
+	for _, index := range indexes {
+		alterStmt := schemamigrator.AlterTableAddIndex{
+			Database: telemetrylogs.DBName,
+			Table:    telemetrylogs.LogsV2LocalTableName,
+			Index:    index,
+		}
+		op := alterStmt.OnCluster(m.telemetryStore.Cluster())
+		if err := m.telemetryStore.ClickhouseDB().Exec(ctx, op.ToSQL()); err != nil {
+			return errors.WrapInternalf(err, CodeFailedToCreateIndex, "failed to create index")
+		}
+	}
+
+	return nil
+}
+
+// PromoteAndIndexPaths handles promoting paths and creating indexes in one call.
+func (m *module) PromoteAndIndexPaths(
+	ctx context.Context,
+	paths ...*promotetypes.PromotePath,
+) error {
+	if len(paths) == 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "paths cannot be empty")
+	}
+
+	pathsStr := []string{}
+	// validate the paths
+	for _, path := range paths {
+		if err := path.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+		pathsStr = append(pathsStr, path.Path)
+	}
+
+	existingPromotedPaths, err := m.metadataStore.ListPromotedPaths(ctx, pathsStr...)
+	if err != nil {
+		return err
+	}
+
+	var toInsert []string
+	indexes := []schemamigrator.Index{}
+	for _, it := range paths {
+		if it.Promote {
+			if _, promoted := existingPromotedPaths[it.Path]; !promoted {
+				toInsert = append(toInsert, it.Path)
+			}
+		}
+		if len(it.Indexes) > 0 {
+			parentColumn := telemetrylogs.LogsV2BodyJSONColumn
+			// if the path is already promoted or is being promoted, add it to the promoted column
+			if _, promoted := existingPromotedPaths[it.Path]; promoted || it.Promote {
+				parentColumn = telemetrylogs.LogsV2BodyPromotedColumn
+			}
+
+			for _, index := range it.Indexes {
+				var typeIndex schemamigrator.IndexType
+				switch {
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeNGramBF)):
+					typeIndex = schemamigrator.IndexTypeNGramBF
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeTokenBF)):
+					typeIndex = schemamigrator.IndexTypeTokenBF
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeMinMax)):
+					typeIndex = schemamigrator.IndexTypeMinMax
+				default:
+					return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid index type: %s", index.Type)
+				}
+				indexes = append(indexes, schemamigrator.Index{
+					Name:        schemamigrator.JSONSubColumnIndexName(parentColumn, it.Path, index.JSONDataType.StringValue(), typeIndex),
+					Expression:  schemamigrator.JSONSubColumnIndexExpr(parentColumn, it.Path, index.JSONDataType.StringValue()),
+					Type:        index.Type,
+					Granularity: index.Granularity,
+				})
+			}
+		}
+	}
+
+	if len(toInsert) > 0 {
+		err := m.PromotePaths(ctx, toInsert)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(indexes) > 0 {
+		if err := m.createIndexes(ctx, indexes); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

pkg/modules/promote/promote.go

@@ -0,0 +1,18 @@
+package promote
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+)
+
+type Module interface {
+	ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetypes.PromotePath, error)
+	PromoteAndIndexPaths(ctx context.Context, paths ...*promotetypes.PromotePath) error
+}
+
+type Handler interface {
+	HandlePromoteAndIndexPaths(w http.ResponseWriter, r *http.Request)
+	ListPromotedAndIndexedPaths(w http.ResponseWriter, r *http.Request)
+}

pkg/querier/signozquerier/provider.go

@@ -100,8 +100,10 @@ func newProvider(
 		traceAggExprRewriter,
 	)
 
+	logsKeyEvolutionMetadata := telemetrylogs.NewKeyEvolutionMetadata(telemetryStore, cache, settings.Logger)
+
 	// Create log statement builder
-	logFieldMapper := telemetrylogs.NewFieldMapper()
+	logFieldMapper := telemetrylogs.NewFieldMapper(logsKeyEvolutionMetadata)
 	logConditionBuilder := telemetrylogs.NewConditionBuilder(logFieldMapper)
 	logResourceFilterStmtBuilder := resourcefilter.NewLogResourceFilterStatementBuilder(
 		settings,

pkg/query-service/app/clickhouseReader/reader.go

@@ -43,6 +43,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/traces/tracedetail"
 	"github.com/SigNoz/signoz/pkg/query-service/common"
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
+
 	chErrors "github.com/SigNoz/signoz/pkg/query-service/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/metrics"
 	"github.com/SigNoz/signoz/pkg/query-service/model"

pkg/query-service/app/http_handler.go

@@ -555,6 +555,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/settings/ttl", am.ViewAccess(aH.getTTL)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v2/settings/ttl", am.AdminAccess(aH.setCustomRetentionTTL)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v2/settings/ttl", am.ViewAccess(aH.getCustomRetentionTTL)).Methods(http.MethodGet)
+
 	router.HandleFunc("/api/v1/settings/apdex", am.AdminAccess(aH.Signoz.Handlers.Apdex.Set)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/settings/apdex", am.ViewAccess(aH.Signoz.Handlers.Apdex.Get)).Methods(http.MethodGet)
 

pkg/query-service/app/logs/v4/query_builder_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_getClickhouseKey(t *testing.T) {
@@ -1210,9 +1211,8 @@ func TestPrepareLogsQuery(t *testing.T) {
 				t.Errorf("PrepareLogsQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if got != tt.want {
-				t.Errorf("PrepareLogsQuery() = %v, want %v", got, tt.want)
-			}
+
+			assert.Equal(t, tt.want, got)
 		})
 	}
 }

pkg/querybuilder/agg_rewrite.go

@@ -51,6 +51,8 @@ func NewAggExprRewriter(
 // and the args if the parametric aggregation function is used.
 func (r *aggExprRewriter) Rewrite(
 	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	expr string,
 	rateInterval uint64,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
@@ -77,7 +79,12 @@ func (r *aggExprRewriter) Rewrite(
 		return "", nil, errors.NewInternalf(errors.CodeInternal, "no SELECT items for %q", expr)
 	}
 
-	visitor := newExprVisitor(r.logger, keys,
+	visitor := newExprVisitor(
+		ctx,
+		startNs,
+		endNs,
+		r.logger,
+		keys,
 		r.fullTextColumn,
 		r.fieldMapper,
 		r.conditionBuilder,
@@ -98,6 +105,8 @@ func (r *aggExprRewriter) Rewrite(
 // RewriteMulti rewrites a slice of expressions.
 func (r *aggExprRewriter) RewriteMulti(
 	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	exprs []string,
 	rateInterval uint64,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
@@ -106,7 +115,7 @@ func (r *aggExprRewriter) RewriteMulti(
 	var errs []error
 	var chArgsList [][]any
 	for i, e := range exprs {
-		w, chArgs, err := r.Rewrite(ctx, e, rateInterval, keys)
+		w, chArgs, err := r.Rewrite(ctx, startNs, endNs, e, rateInterval, keys)
 		if err != nil {
 			errs = append(errs, err)
 			out[i] = e
@@ -123,6 +132,9 @@ func (r *aggExprRewriter) RewriteMulti(
 
 // exprVisitor walks FunctionExpr nodes and applies the mappers.
 type exprVisitor struct {
+	ctx     context.Context
+	startNs uint64
+	endNs   uint64
 	chparser.DefaultASTVisitor
 	logger           *slog.Logger
 	fieldKeys        map[string][]*telemetrytypes.TelemetryFieldKey
@@ -137,6 +149,9 @@ type exprVisitor struct {
 }
 
 func newExprVisitor(
+	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	logger *slog.Logger,
 	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
 	fullTextColumn *telemetrytypes.TelemetryFieldKey,
@@ -146,6 +161,9 @@ func newExprVisitor(
 	jsonKeyToKey qbtypes.JsonKeyToFieldFunc,
 ) *exprVisitor {
 	return &exprVisitor{
+		ctx:              ctx,
+		startNs:          startNs,
+		endNs:            endNs,
 		logger:           logger,
 		fieldKeys:        fieldKeys,
 		fullTextColumn:   fullTextColumn,
@@ -190,7 +208,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 	if aggFunc.FuncCombinator {
 		// Map the predicate (last argument)
 		origPred := args[len(args)-1].String()
-        whereClause, err := PrepareWhereClause(
+		whereClause, err := PrepareWhereClause(
 			origPred,
 			FilterExprVisitorOpts{
 				Logger:           v.logger,
@@ -199,7 +217,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 				ConditionBuilder: v.conditionBuilder,
 				FullTextColumn:   v.fullTextColumn,
 				JsonKeyToKey:     v.jsonKeyToKey,
-            }, 0, 0,
+			}, v.startNs, v.endNs,
 		)
 		if err != nil {
 			return err
@@ -219,7 +237,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 		for i := 0; i < len(args)-1; i++ {
 			origVal := args[i].String()
 			fieldKey := telemetrytypes.GetFieldKeyFromKeyText(origVal)
-			expr, exprArgs, err := CollisionHandledFinalExpr(context.Background(), &fieldKey, v.fieldMapper, v.conditionBuilder, v.fieldKeys, dataType, v.jsonBodyPrefix, v.jsonKeyToKey)
+			expr, exprArgs, err := CollisionHandledFinalExpr(v.ctx, v.startNs, v.endNs, &fieldKey, v.fieldMapper, v.conditionBuilder, v.fieldKeys, dataType, v.jsonBodyPrefix, v.jsonKeyToKey)
 			if err != nil {
 				return errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to get table field name for %q", origVal)
 			}
@@ -237,7 +255,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 		for i, arg := range args {
 			orig := arg.String()
 			fieldKey := telemetrytypes.GetFieldKeyFromKeyText(orig)
-			expr, exprArgs, err := CollisionHandledFinalExpr(context.Background(), &fieldKey, v.fieldMapper, v.conditionBuilder, v.fieldKeys, dataType, v.jsonBodyPrefix, v.jsonKeyToKey)
+			expr, exprArgs, err := CollisionHandledFinalExpr(v.ctx, v.startNs, v.endNs, &fieldKey, v.fieldMapper, v.conditionBuilder, v.fieldKeys, dataType, v.jsonBodyPrefix, v.jsonKeyToKey)
 			if err != nil {
 				return err
 			}

pkg/querybuilder/fallback_expr.go

@@ -19,6 +19,8 @@ import (
 
 func CollisionHandledFinalExpr(
 	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	field *telemetrytypes.TelemetryFieldKey,
 	fm qbtypes.FieldMapper,
 	cb qbtypes.ConditionBuilder,
@@ -45,7 +47,7 @@ func CollisionHandledFinalExpr(
 
 	addCondition := func(key *telemetrytypes.TelemetryFieldKey) error {
 		sb := sqlbuilder.NewSelectBuilder()
-        condition, err := cb.ConditionFor(ctx, key, qbtypes.FilterOperatorExists, nil, sb, 0, 0)
+		condition, err := cb.ConditionFor(ctx, key, qbtypes.FilterOperatorExists, nil, sb, startNs, endNs)
 		if err != nil {
 			return err
 		}
@@ -58,7 +60,7 @@ func CollisionHandledFinalExpr(
 		return nil
 	}
 
-	colName, err := fm.FieldFor(ctx, field)
+	colName, err := fm.FieldFor(ctx, startNs, endNs, field)
 	if errors.Is(err, qbtypes.ErrColumnNotFound) {
 		// the key didn't have the right context to be added to the query
 		// we try to use the context we know of
@@ -93,7 +95,7 @@ func CollisionHandledFinalExpr(
 				if err != nil {
 					return "", nil, err
 				}
-				colName, _ = fm.FieldFor(ctx, key)
+				colName, _ = fm.FieldFor(ctx, startNs, endNs, key)
 				colName, _ = DataTypeCollisionHandledFieldName(key, dummyValue, colName, qbtypes.FilterOperatorUnknown)
 				stmts = append(stmts, colName)
 			}

pkg/querybuilder/resourcefilter/condition_builder.go

@@ -48,8 +48,8 @@ func (b *defaultConditionBuilder) ConditionFor(
 	op qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
-    _ uint64,
-    _ uint64,
+	startNs uint64,
+	endNs uint64,
 ) (string, error) {
 
 	if key.FieldContext != telemetrytypes.FieldContextResource {
@@ -68,7 +68,7 @@ func (b *defaultConditionBuilder) ConditionFor(
 	keyIdxFilter := sb.Like(column.Name, keyIndexFilter(key))
 	valueForIndexFilter := valueForIndexFilter(op, key, value)
 
-	fieldName, err := b.fm.FieldFor(ctx, key)
+	fieldName, err := b.fm.FieldFor(ctx, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}

pkg/querybuilder/resourcefilter/field_mapper.go

@@ -47,6 +47,7 @@ func (m *defaultFieldMapper) ColumnFor(
 
 func (m *defaultFieldMapper) FieldFor(
 	ctx context.Context,
+	tsStart, tsEnd uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 	column, err := m.getColumn(ctx, key)
@@ -61,10 +62,11 @@ func (m *defaultFieldMapper) FieldFor(
 
 func (m *defaultFieldMapper) ColumnExpressionFor(
 	ctx context.Context,
+	tsStart, tsEnd uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 	_ map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
-	colName, err := m.FieldFor(ctx, key)
+	colName, err := m.FieldFor(ctx, tsStart, tsEnd, key)
 	if err != nil {
 		return "", err
 	}

pkg/signoz/module.go

@@ -20,6 +20,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/modules/promote/implpromote"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter/implquickfilter"
 	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
@@ -65,6 +67,7 @@ type Modules struct {
 	Services        services.Module
 	SpanPercentile  spanpercentile.Module
 	MetricsExplorer metricsexplorer.Module
+	Promote         promote.Module
 }
 
 func NewModules(
@@ -108,5 +111,6 @@ func NewModules(
 		SpanPercentile:  implspanpercentile.NewModule(querier, providerSettings),
 		Services:        implservices.NewModule(querier, telemetryStore),
 		MetricsExplorer: implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
+		Promote:         implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 	}
 }

pkg/signoz/openapi.go

@@ -14,6 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
@@ -38,6 +39,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ authdomain.Handler }{},
 		struct{ preference.Handler }{},
 		struct{ global.Handler }{},
+		struct{ promote.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -24,6 +24,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/promote/implpromote"
 	"github.com/SigNoz/signoz/pkg/modules/session/implsession"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
@@ -234,6 +235,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			implauthdomain.NewHandler(modules.AuthDomain),
 			implpreference.NewHandler(modules.Preference),
 			signozglobal.NewHandler(global),
+			implpromote.NewHandler(modules.Promote),
 		),
 	)
 }

pkg/telemetrylogs/condition_builder.go

@@ -25,6 +25,7 @@ func NewConditionBuilder(fm qbtypes.FieldMapper) *conditionBuilder {
 
 func (c *conditionBuilder) conditionFor(
 	ctx context.Context,
+	startNs, endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
@@ -46,7 +47,7 @@ func (c *conditionBuilder) conditionFor(
 		return "", err
 	}
 
-	tblFieldName, err := c.fm.FieldFor(ctx, key)
+	tblFieldName, err := c.fm.FieldFor(ctx, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
@@ -239,10 +240,10 @@ func (c *conditionBuilder) ConditionFor(
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
-	_ uint64,
-	_ uint64,
+	startNs uint64,
+	endNs uint64,
 ) (string, error) {
-	condition, err := c.conditionFor(ctx, key, operator, value, sb)
+	condition, err := c.conditionFor(ctx, startNs, endNs, key, operator, value, sb)
 	if err != nil {
 		return "", err
 	}
@@ -250,12 +251,12 @@ func (c *conditionBuilder) ConditionFor(
 	if operator.AddDefaultExistsFilter() {
 		// skip adding exists filter for intrinsic fields
 		// with an exception for body json search
-		field, _ := c.fm.FieldFor(ctx, key)
+		field, _ := c.fm.FieldFor(ctx, startNs, endNs, key)
 		if slices.Contains(maps.Keys(IntrinsicFields), field) && key.FieldContext != telemetrytypes.FieldContextBody {
 			return condition, nil
 		}
 
-		existsCondition, err := c.conditionFor(ctx, key, qbtypes.FilterOperatorExists, nil, sb)
+		existsCondition, err := c.conditionFor(ctx, startNs, endNs, key, qbtypes.FilterOperatorExists, nil, sb)
 		if err != nil {
 			return "", err
 		}

pkg/telemetrylogs/condition_builder_test.go

@@ -6,6 +6,7 @@ import (
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
 	"github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -372,7 +373,8 @@ func TestConditionFor(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {
@@ -425,7 +427,8 @@ func TestConditionForMultipleKeys(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {
@@ -684,7 +687,8 @@ func TestConditionForJSONBodySearch(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {

pkg/telemetrylogs/field_mapper.go

@@ -4,11 +4,14 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/huandu/go-sqlbuilder"
 
 	"golang.org/x/exp/maps"
@@ -55,10 +58,13 @@ var (
 )
 
 type fieldMapper struct {
+	evolutionMetadataStore telemetrytypes.KeyEvolutionMetadataStore
 }
 
-func NewFieldMapper() qbtypes.FieldMapper {
-	return &fieldMapper{}
+func NewFieldMapper(evolutionMetadataStore telemetrytypes.KeyEvolutionMetadataStore) qbtypes.FieldMapper {
+	return &fieldMapper{
+		evolutionMetadataStore: evolutionMetadataStore,
+	}
 }
 
 func (m *fieldMapper) getColumn(_ context.Context, key *telemetrytypes.TelemetryFieldKey) (*schema.Column, error) {
@@ -100,7 +106,7 @@ func (m *fieldMapper) getColumn(_ context.Context, key *telemetrytypes.Telemetry
 	return nil, qbtypes.ErrColumnNotFound
 }
 
-func (m *fieldMapper) FieldFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (string, error) {
+func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	column, err := m.getColumn(ctx, key)
 	if err != nil {
 		return "", err
@@ -112,17 +118,34 @@ func (m *fieldMapper) FieldFor(ctx context.Context, key *telemetrytypes.Telemetr
 		if key.FieldContext != telemetrytypes.FieldContextResource {
 			return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource context fields are supported for json columns, got %s", key.FieldContext.String)
 		}
-		oldColumn := logsV2Columns["resources_string"]
-		oldKeyName := fmt.Sprintf("%s['%s']", oldColumn.Name, key.Name)
 
-		// have to add ::string as clickHouse throws an error :- data types Variant/Dynamic are not allowed in GROUP BY
-		// once clickHouse dependency is updated, we need to check if we can remove it.
+		baseColumn := logsV2Columns["resources_string"]
+		tsStartTime := time.Unix(0, int64(tsStart))
+
+		// Extract orgId from context
+		var orgID valuer.UUID
+		if claims, err := authtypes.ClaimsFromContext(ctx); err == nil {
+			orgID, err = valuer.NewUUID(claims.OrgID)
+			if err != nil {
+				return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid orgId %s", claims.OrgID)
+			}
+		}
+
+		// get all evolution for the column
+		evolutions := m.evolutionMetadataStore.Get(ctx, orgID, baseColumn.Name)
+
+		// restricting now to just one entry where we know we changed from map to json
+		if len(evolutions) > 0 && evolutions[0].ReleaseTime.Before(tsStartTime) {
+			return fmt.Sprintf("%s.`%s`::String", evolutions[0].NewColumn, key.Name), nil
+		}
+
 		if key.Materialized {
-			oldKeyName = telemetrytypes.FieldKeyToMaterializedColumnName(key)
+			oldKeyName := telemetrytypes.FieldKeyToMaterializedColumnName(key)
 			oldKeyNameExists := telemetrytypes.FieldKeyToMaterializedColumnNameForExists(key)
 			return fmt.Sprintf("multiIf(%s.`%s` IS NOT NULL, %s.`%s`::String, %s==true, %s, NULL)", column.Name, key.Name, column.Name, key.Name, oldKeyNameExists, oldKeyName), nil
 		} else {
-			return fmt.Sprintf("multiIf(%s.`%s` IS NOT NULL, %s.`%s`::String, mapContains(%s, '%s'), %s, NULL)", column.Name, key.Name, column.Name, key.Name, oldColumn.Name, key.Name, oldKeyName), nil
+			attrVal := fmt.Sprintf("%s['%s']", baseColumn.Name, key.Name)
+			return fmt.Sprintf("multiIf(%s.`%s` IS NOT NULL, %s.`%s`::String, mapContains(%s, '%s'), %s, NULL)", column.Name, key.Name, column.Name, key.Name, baseColumn.Name, key.Name, attrVal), nil
 		}
 	case schema.ColumnTypeEnumLowCardinality:
 		switch elementType := column.Type.(schema.LowCardinalityColumnType).ElementType; elementType.GetType() {
@@ -161,11 +184,12 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, key *telemetrytypes.Telemet
 
 func (m *fieldMapper) ColumnExpressionFor(
 	ctx context.Context,
+	tsStart, tsEnd uint64,
 	field *telemetrytypes.TelemetryFieldKey,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 
-	colName, err := m.FieldFor(ctx, field)
+	colName, err := m.FieldFor(ctx, tsStart, tsEnd, field)
 	if errors.Is(err, qbtypes.ErrColumnNotFound) {
 		// the key didn't have the right context to be added to the query
 		// we try to use the context we know of
@@ -175,7 +199,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 			if _, ok := logsV2Columns[field.Name]; ok {
 				// if it is, attach the column name directly
 				field.FieldContext = telemetrytypes.FieldContextLog
-				colName, _ = m.FieldFor(ctx, field)
+				colName, _ = m.FieldFor(ctx, tsStart, tsEnd, field)
 			} else {
 				// - the context is not provided
 				// - there are not keys for the field
@@ -193,12 +217,12 @@ func (m *fieldMapper) ColumnExpressionFor(
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it
-			colName, _ = m.FieldFor(ctx, keysForField[0])
+			colName, _ = m.FieldFor(ctx, tsStart, tsEnd, keysForField[0])
 		} else {
 			// select any non-empty value from the keys
 			args := []string{}
 			for _, key := range keysForField {
-				colName, _ = m.FieldFor(ctx, key)
+				colName, _ = m.FieldFor(ctx, tsStart, tsEnd, key)
 				args = append(args, fmt.Sprintf("toString(%s) != '', toString(%s)", colName, colName))
 			}
 			colName = fmt.Sprintf("multiIf(%s, NULL)", strings.Join(args, ", "))

pkg/telemetrylogs/field_mapper_test.go

@@ -3,10 +3,14 @@ package telemetrylogs
 import (
 	"context"
 	"testing"
+	"time"
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -164,7 +168,8 @@ func TestGetColumn(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	mockStore := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(mockStore)
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -229,7 +234,7 @@ func TestGetFieldKeyName(t *testing.T) {
 			expectedError:  nil,
 		},
 		{
-			name: "Map column type - resource attribute",
+			name: "Map column type - resource attribute - json",
 			key: telemetrytypes.TelemetryFieldKey{
 				Name:         "service.name",
 				FieldContext: telemetrytypes.FieldContextResource,
@@ -238,7 +243,7 @@ func TestGetFieldKeyName(t *testing.T) {
 			expectedError:  nil,
 		},
 		{
-			name: "Map column type - resource attribute - Materialized",
+			name: "Map column type - resource attribute - Materialized - json",
 			key: telemetrytypes.TelemetryFieldKey{
 				Name:          "service.name",
 				FieldContext:  telemetrytypes.FieldContextResource,
@@ -261,8 +266,96 @@ func TestGetFieldKeyName(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			fm := NewFieldMapper()
-			result, err := fm.FieldFor(ctx, &tc.key)
+			mockStore := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+			fm := NewFieldMapper(mockStore)
+			result, err := fm.FieldFor(ctx, 0, 0, &tc.key)
+
+			if tc.expectedError != nil {
+				assert.Equal(t, tc.expectedError, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tc.expectedResult, result)
+			}
+		})
+	}
+}
+
+func TestFieldForWithEvolutionMetadata(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	ctx = authtypes.NewContextWithClaims(ctx, authtypes.Claims{
+		OrgID: orgId.String(),
+	})
+
+	// Create a test release time
+	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+	releaseTimeNano := uint64(releaseTime.UnixNano())
+
+	// Common test key
+	serviceNameKey := telemetrytypes.TelemetryFieldKey{
+		Name:         "service.name",
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+
+	// Common expected results
+	jsonOnlyResult := "resource.`service.name`::String"
+	fallbackResult := "multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL)"
+
+	// Set up stores once
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(mockKeyEvolutionMetadata(ctx, orgId, releaseTime))
+	storeWithoutMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+
+	testCases := []struct {
+		name           string
+		tsStart        uint64
+		tsEnd          uint64
+		key            telemetrytypes.TelemetryFieldKey
+		mockStore      *telemetrytypestest.MockKeyEvolutionMetadataStore
+		expectedResult string
+		expectedError  error
+	}{
+		{
+			name:           "Resource attribute - tsStart before release time (use fallback with multiIf)",
+			tsStart:        releaseTimeNano - uint64(24*time.Hour.Nanoseconds()),
+			tsEnd:          releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			key:            serviceNameKey,
+			mockStore:      storeWithMetadata,
+			expectedResult: fallbackResult,
+			expectedError:  nil,
+		},
+		{
+			name:           "Resource attribute - tsStart after release time (use new json column)",
+			tsStart:        releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			tsEnd:          releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
+			key:            serviceNameKey,
+			mockStore:      storeWithMetadata,
+			expectedResult: jsonOnlyResult,
+			expectedError:  nil,
+		},
+		{
+			name:           "Resource attribute - no evolution metadata (use fallback with multiIf)",
+			tsStart:        releaseTimeNano,
+			tsEnd:          releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			key:            serviceNameKey,
+			mockStore:      storeWithoutMetadata,
+			expectedResult: fallbackResult,
+			expectedError:  nil,
+		},
+		{
+			name:           "Resource attribute - tsStart exactly at release time (use fallback with multiIf)",
+			tsStart:        releaseTimeNano,
+			tsEnd:          releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			key:            serviceNameKey,
+			mockStore:      storeWithMetadata,
+			expectedResult: fallbackResult,
+			expectedError:  nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			fm := NewFieldMapper(tc.mockStore)
+			result, err := fm.FieldFor(ctx, tc.tsStart, tc.tsEnd, &tc.key)
 
 			if tc.expectedError != nil {
 				assert.Equal(t, tc.expectedError, err)

pkg/telemetrylogs/filter_expr_like_warning_test.go

@@ -5,12 +5,14 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
 	"github.com/stretchr/testify/require"
 )
 
 // TestLikeAndILikeWithoutWildcards_Warns Tests that LIKE/ILIKE without wildcards add warnings and include docs URL
 func TestLikeAndILikeWithoutWildcards_Warns(t *testing.T) {
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 
 	keys := buildCompleteFieldKeyMap()
@@ -33,7 +35,7 @@ func TestLikeAndILikeWithoutWildcards_Warns(t *testing.T) {
 
 	for _, expr := range tests {
 		t.Run(expr, func(t *testing.T) {
-            clause, err := querybuilder.PrepareWhereClause(expr, opts, 0, 0)
+			clause, err := querybuilder.PrepareWhereClause(expr, opts, 0, 0)
 			require.NoError(t, err)
 			require.NotNil(t, clause)
 
@@ -46,7 +48,8 @@ func TestLikeAndILikeWithoutWildcards_Warns(t *testing.T) {
 
 // TestLikeAndILikeWithWildcards_NoWarn Tests that LIKE/ILIKE with wildcards do not add warnings
 func TestLikeAndILikeWithWildcards_NoWarn(t *testing.T) {
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 
 	keys := buildCompleteFieldKeyMap()
@@ -69,7 +72,7 @@ func TestLikeAndILikeWithWildcards_NoWarn(t *testing.T) {
 
 	for _, expr := range tests {
 		t.Run(expr, func(t *testing.T) {
-            clause, err := querybuilder.PrepareWhereClause(expr, opts, 0, 0)
+			clause, err := querybuilder.PrepareWhereClause(expr, opts, 0, 0)
 			require.NoError(t, err)
 			require.NotNil(t, clause)
 

pkg/telemetrylogs/filter_expr_logs_body_json_test.go

@@ -7,13 +7,15 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
 	"github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/require"
 )
 
 // TestFilterExprLogsBodyJSON tests a comprehensive set of query patterns for body JSON search
 func TestFilterExprLogsBodyJSON(t *testing.T) {
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 
 	// Define a comprehensive set of field keys to support all test cases

pkg/telemetrylogs/filter_expr_logs_test.go

@@ -9,13 +9,15 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
 	"github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/require"
 )
 
 // TestFilterExprLogs tests a comprehensive set of query patterns for logs search
 func TestFilterExprLogs(t *testing.T) {
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 
 	// Define a comprehensive set of field keys to support all test cases
@@ -2422,7 +2424,8 @@ func TestFilterExprLogs(t *testing.T) {
 
 // TestFilterExprLogs tests a comprehensive set of query patterns for logs search
 func TestFilterExprLogsConflictNegation(t *testing.T) {
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 
 	// Define a comprehensive set of field keys to support all test cases

pkg/telemetrylogs/key_evolution_metadata.go

@@ -0,0 +1,158 @@
+package telemetrylogs
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/cache"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/types/cachetypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+const (
+	// KeyEvolutionMetadataTableName is the table name for key evolution metadata
+	KeyEvolutionMetadataTableName = "distributed_column_key_evolution_metadata"
+	// KeyEvolutionMetadataDBName is the database name for key evolution metadata
+	KeyEvolutionMetadataDBName = "signoz_logs"
+	// KeyEvolutionMetadataCacheKeyPrefix is the prefix for cache keys
+	KeyEvolutionMetadataCacheKeyPrefix = "key_evolution_metadata:"
+
+	base_column      = "base_column"
+	base_column_type = "base_column_type"
+	new_column       = "new_column"
+	new_column_type  = "new_column_type"
+	release_time     = "release_time"
+)
+
+// CachedKeyEvolutionMetadata is a cacheable type for storing key evolution metadata
+type CachedKeyEvolutionMetadata struct {
+	Keys []*telemetrytypes.KeyEvolutionMetadataKey `json:"keys"`
+}
+
+var _ cachetypes.Cacheable = (*CachedKeyEvolutionMetadata)(nil)
+
+func (c *CachedKeyEvolutionMetadata) MarshalBinary() ([]byte, error) {
+	return json.Marshal(c)
+}
+
+func (c *CachedKeyEvolutionMetadata) UnmarshalBinary(data []byte) error {
+	return json.Unmarshal(data, c)
+}
+
+// Each key can have multiple evolution entries, allowing for multiple column transitions over time.
+// The cache is organized by orgId, then by key name.
+type KeyEvolutionMetadata struct {
+	cache          cache.Cache
+	telemetryStore telemetrystore.TelemetryStore
+	logger         *slog.Logger
+}
+
+var _ telemetrytypes.KeyEvolutionMetadataStore = (*KeyEvolutionMetadata)(nil)
+
+func NewKeyEvolutionMetadata(telemetryStore telemetrystore.TelemetryStore, cache cache.Cache, logger *slog.Logger) *KeyEvolutionMetadata {
+	return &KeyEvolutionMetadata{
+		cache:          cache,
+		telemetryStore: telemetryStore,
+		logger:         logger,
+	}
+}
+
+func (k *KeyEvolutionMetadata) fetchFromClickHouse(ctx context.Context, orgID valuer.UUID, key string) []*telemetrytypes.KeyEvolutionMetadataKey {
+	store := k.telemetryStore
+	logger := k.logger
+
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+
+	// Build query to fetch all key evolution metadata
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select(
+		base_column,
+		base_column_type,
+		new_column,
+		new_column_type,
+		release_time,
+	)
+	sb.From(fmt.Sprintf("%s.%s", KeyEvolutionMetadataDBName, KeyEvolutionMetadataTableName))
+	sb.OrderBy(base_column, release_time)
+	sb.Where(sb.E(base_column, key))
+
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := store.ClickhouseDB().Query(ctx, query, args...)
+	if err != nil {
+		logger.WarnContext(ctx, "Failed to fetch key evolution metadata from ClickHouse", "error", err)
+		return nil
+	}
+	defer rows.Close()
+
+	// Group metadata by base_column
+	metadataByKey := make(map[string][]*telemetrytypes.KeyEvolutionMetadataKey)
+
+	for rows.Next() {
+		var (
+			baseColumn     string
+			baseColumnType string
+			newColumn      string
+			newColumnType  string
+			releaseTime    uint64
+		)
+
+		if err := rows.Scan(&baseColumn, &baseColumnType, &newColumn, &newColumnType, &releaseTime); err != nil {
+			logger.WarnContext(ctx, "Failed to scan key evolution metadata row", "error", err)
+			continue
+		}
+
+		key := &telemetrytypes.KeyEvolutionMetadataKey{
+			BaseColumn:     baseColumn,
+			BaseColumnType: baseColumnType,
+			NewColumn:      newColumn,
+			NewColumnType:  newColumnType,
+			ReleaseTime:    time.Unix(0, int64(releaseTime)),
+		}
+
+		metadataByKey[baseColumn] = append(metadataByKey[baseColumn], key)
+	}
+
+	if err := rows.Err(); err != nil {
+		logger.WarnContext(ctx, "Error iterating key evolution metadata rows", "error", err)
+		return nil
+	}
+
+	return metadataByKey[key]
+
+}
+
+// Get retrieves all metadata keys for the given key name and orgId from cache.
+// Returns an empty slice if the key is not found in cache.
+func (k *KeyEvolutionMetadata) Get(ctx context.Context, orgId valuer.UUID, keyName string) []*telemetrytypes.KeyEvolutionMetadataKey {
+
+	cacheKey := KeyEvolutionMetadataCacheKeyPrefix + keyName
+	cachedData := &CachedKeyEvolutionMetadata{}
+	if err := k.cache.Get(ctx, orgId, cacheKey, cachedData); err != nil {
+
+		if !errors.Ast(err, errors.TypeNotFound) {
+			k.logger.ErrorContext(ctx, "Failed to get key evolution metadata from cache", "error", err)
+			return nil
+		}
+
+		// Cache miss - fetch from ClickHouse and try again
+		metadata := k.fetchFromClickHouse(ctx, orgId, keyName)
+
+		if metadata != nil {
+			cacheKey := KeyEvolutionMetadataCacheKeyPrefix + keyName
+			cachedData = &CachedKeyEvolutionMetadata{Keys: metadata}
+			if err := k.cache.Set(ctx, orgId, cacheKey, cachedData, 24*time.Hour); err != nil {
+				k.logger.WarnContext(ctx, "Failed to set key evolution metadata in cache", "key", keyName, "error", err)
+			}
+		}
+	}
+	return cachedData.Keys
+}

pkg/telemetrylogs/key_evolution_metadata_test.go

@@ -0,0 +1,213 @@
+package telemetrylogs
+
+import (
+	"context"
+	"log/slog"
+	"testing"
+	"time"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/SigNoz/signoz/pkg/cache"
+	"github.com/SigNoz/signoz/pkg/cache/cachetest"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	cmock "github.com/srikanthccv/ClickHouse-go-mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	clickHouseQueryPattern = "SELECT.*base_column.*FROM.*distributed_column_key_evolution_metadata.*WHERE.*base_column.*=.*"
+	clickHouseColumns      = []cmock.ColumnType{
+		{Name: base_column, Type: "String"},
+		{Name: base_column_type, Type: "String"},
+		{Name: new_column, Type: "String"},
+		{Name: new_column_type, Type: "String"},
+		{Name: release_time, Type: "UInt64"},
+	}
+)
+
+func newTestCache(t *testing.T) cache.Cache {
+	t.Helper()
+	testCache, err := cachetest.New(cache.Config{
+		Provider: "memory",
+		Memory: cache.Memory{
+			NumCounters: 10 * 1000,
+			MaxCost:     1 << 26,
+		},
+	})
+	require.NoError(t, err)
+	return testCache
+}
+
+func newTestTelemetryStore() *telemetrystoretest.Provider {
+	return telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherRegexp)
+}
+
+func newKeyEvolutionMetadata(telemetryStore telemetrystore.TelemetryStore, cache cache.Cache) *KeyEvolutionMetadata {
+	return NewKeyEvolutionMetadata(telemetryStore, cache, slog.Default())
+}
+
+func createMockRows(values [][]any) *cmock.Rows {
+	return cmock.NewRows(clickHouseColumns, values)
+}
+
+func assertMetadataEqual(t *testing.T, expected, actual *telemetrytypes.KeyEvolutionMetadataKey) {
+	t.Helper()
+	assert.Equal(t, expected.BaseColumn, actual.BaseColumn)
+	assert.Equal(t, expected.BaseColumnType, actual.BaseColumnType)
+	assert.Equal(t, expected.NewColumn, actual.NewColumn)
+	assert.Equal(t, expected.NewColumnType, actual.NewColumnType)
+	assert.Equal(t, expected.ReleaseTime, actual.ReleaseTime)
+}
+
+func TestKeyEvolutionMetadata_Get_CacheHit(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	keyName := "service.name"
+
+	testCache := newTestCache(t)
+	telemetryStore := newTestTelemetryStore()
+	kem := newKeyEvolutionMetadata(telemetryStore, testCache)
+
+	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+	expectedMetadata := []*telemetrytypes.KeyEvolutionMetadataKey{
+		{
+			BaseColumn:     "resources_string",
+			BaseColumnType: "Map(LowCardinality(String), String)",
+			NewColumn:      "resource",
+			NewColumnType:  "JSON(max_dynamic_paths=100)",
+			ReleaseTime:    releaseTime,
+		},
+	}
+
+	cacheKey := KeyEvolutionMetadataCacheKeyPrefix + keyName
+	cachedData := &CachedKeyEvolutionMetadata{Keys: expectedMetadata}
+	err := testCache.Set(ctx, orgId, cacheKey, cachedData, 24*time.Hour)
+	require.NoError(t, err)
+
+	result := kem.Get(ctx, orgId, keyName)
+
+	require.Len(t, result, 1)
+	assertMetadataEqual(t, expectedMetadata[0], result[0])
+}
+
+func TestKeyEvolutionMetadata_Get_CacheMiss_FetchFromClickHouse(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	keyName := "resources_string"
+
+	testCache := newTestCache(t)
+	telemetryStore := newTestTelemetryStore()
+
+	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+	values := [][]any{
+		{
+			"resources_string",
+			"Map(LowCardinality(String), String)",
+			"resource",
+			"JSON(max_dynamic_paths=100)",
+			uint64(releaseTime.UnixNano()),
+		},
+	}
+
+	rows := createMockRows(values)
+	telemetryStore.Mock().ExpectQuery(clickHouseQueryPattern).WithArgs(keyName).WillReturnRows(rows)
+
+	kem := newKeyEvolutionMetadata(telemetryStore, testCache)
+	result := kem.Get(ctx, orgId, keyName)
+
+	require.Len(t, result, 1)
+	assert.Equal(t, "resources_string", result[0].BaseColumn)
+	assert.Equal(t, "Map(LowCardinality(String), String)", result[0].BaseColumnType)
+	assert.Equal(t, "resource", result[0].NewColumn)
+	assert.Equal(t, "JSON(max_dynamic_paths=100)", result[0].NewColumnType)
+	assert.Equal(t, releaseTime.UnixNano(), result[0].ReleaseTime.UnixNano())
+
+	// Verify data was cached
+	var cachedData CachedKeyEvolutionMetadata
+	cacheKey := KeyEvolutionMetadataCacheKeyPrefix + keyName
+	err := testCache.Get(ctx, orgId, cacheKey, &cachedData)
+	require.NoError(t, err)
+	require.Len(t, cachedData.Keys, 1)
+	assert.Equal(t, result[0].BaseColumn, cachedData.Keys[0].BaseColumn)
+}
+
+func TestKeyEvolutionMetadata_Get_MultipleMetadataEntries(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	keyName := "resources_string"
+
+	testCache := newTestCache(t)
+	telemetryStore := newTestTelemetryStore()
+
+	releaseTime1 := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+	releaseTime2 := time.Date(2024, 2, 15, 10, 0, 0, 0, time.UTC)
+
+	values := [][]any{
+		{
+			"resources_string",
+			"Map(LowCardinality(String), String)",
+			"resource",
+			"JSON(max_dynamic_paths=100)",
+			uint64(releaseTime1.UnixNano()),
+		},
+		{
+			"resources_string",
+			"Map(LowCardinality(String), String)",
+			"resource_v2",
+			"JSON(max_dynamic_paths=100, max_dynamic_path_depth=10)",
+			uint64(releaseTime2.UnixNano()),
+		},
+	}
+
+	rows := createMockRows(values)
+	telemetryStore.Mock().ExpectQuery(clickHouseQueryPattern).WithArgs(keyName).WillReturnRows(rows)
+
+	kem := newKeyEvolutionMetadata(telemetryStore, testCache)
+	result := kem.Get(ctx, orgId, keyName)
+
+	require.Len(t, result, 2)
+	assert.Equal(t, "resources_string", result[0].BaseColumn)
+	assert.Equal(t, "resource", result[0].NewColumn)
+	assert.Equal(t, "JSON(max_dynamic_paths=100)", result[0].NewColumnType)
+	assert.Equal(t, releaseTime1.UnixNano(), result[0].ReleaseTime.UnixNano())
+	assert.Equal(t, "resource_v2", result[1].NewColumn)
+	assert.Equal(t, "JSON(max_dynamic_paths=100, max_dynamic_path_depth=10)", result[1].NewColumnType)
+	assert.Equal(t, releaseTime2.UnixNano(), result[1].ReleaseTime.UnixNano())
+}
+
+func TestKeyEvolutionMetadata_Get_EmptyResultFromClickHouse(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	keyName := "resources_string"
+
+	testCache := newTestCache(t)
+	telemetryStore := newTestTelemetryStore()
+
+	rows := createMockRows([][]any{})
+	telemetryStore.Mock().ExpectQuery(clickHouseQueryPattern).WithArgs(keyName).WillReturnRows(rows)
+
+	kem := newKeyEvolutionMetadata(telemetryStore, testCache)
+	result := kem.Get(ctx, orgId, keyName)
+
+	assert.Empty(t, result)
+}
+
+func TestKeyEvolutionMetadata_Get_ClickHouseQueryError(t *testing.T) {
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	keyName := "resources_string"
+
+	testCache := newTestCache(t)
+	telemetryStore := newTestTelemetryStore()
+
+	telemetryStore.Mock().ExpectQuery(clickHouseQueryPattern).WithArgs(keyName).WillReturnError(assert.AnError)
+
+	kem := newKeyEvolutionMetadata(telemetryStore, testCache)
+	result := kem.Get(ctx, orgId, keyName)
+
+	assert.Empty(t, result)
+}

pkg/telemetrylogs/statement_builder.go

@@ -247,7 +247,7 @@ func (b *logQueryStatementBuilder) buildListQuery(
 				continue
 			}
 			// get column expression for the field - use array index directly to avoid pointer to loop variable
-			colExpr, err := b.fm.ColumnExpressionFor(ctx, &query.SelectFields[index], keys)
+			colExpr, err := b.fm.ColumnExpressionFor(ctx, start, end, &query.SelectFields[index], keys)
 			if err != nil {
 				return nil, err
 			}
@@ -267,7 +267,7 @@ func (b *logQueryStatementBuilder) buildListQuery(
 
 	// Add order by
 	for _, orderBy := range query.Order {
-		colExpr, err := b.fm.ColumnExpressionFor(ctx, &orderBy.Key.TelemetryFieldKey, keys)
+		colExpr, err := b.fm.ColumnExpressionFor(ctx, start, end, &orderBy.Key.TelemetryFieldKey, keys)
 		if err != nil {
 			return nil, err
 		}
@@ -333,7 +333,7 @@ func (b *logQueryStatementBuilder) buildTimeSeriesQuery(
 	// Keep original column expressions so we can build the tuple
 	fieldNames := make([]string, 0, len(query.GroupBy))
 	for _, gb := range query.GroupBy {
-		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, b.jsonBodyPrefix, b.jsonKeyToKey)
+		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, start, end, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, b.jsonBodyPrefix, b.jsonKeyToKey)
 		if err != nil {
 			return nil, err
 		}
@@ -347,7 +347,7 @@ func (b *logQueryStatementBuilder) buildTimeSeriesQuery(
 	allAggChArgs := make([]any, 0)
 	for i, agg := range query.Aggregations {
 		rewritten, chArgs, err := b.aggExprRewriter.Rewrite(
-			ctx, agg.Expression,
+			ctx, start, end, agg.Expression,
 			uint64(query.StepInterval.Seconds()),
 			keys,
 		)
@@ -479,7 +479,7 @@ func (b *logQueryStatementBuilder) buildScalarQuery(
 	var allGroupByArgs []any
 
 	for _, gb := range query.GroupBy {
-		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, b.jsonBodyPrefix, b.jsonKeyToKey)
+		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, start, end, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, b.jsonBodyPrefix, b.jsonKeyToKey)
 		if err != nil {
 			return nil, err
 		}
@@ -496,7 +496,7 @@ func (b *logQueryStatementBuilder) buildScalarQuery(
 		for idx := range query.Aggregations {
 			aggExpr := query.Aggregations[idx]
 			rewritten, chArgs, err := b.aggExprRewriter.Rewrite(
-				ctx, aggExpr.Expression,
+				ctx, start, end, aggExpr.Expression,
 				rateInterval,
 				keys,
 			)

pkg/telemetrylogs/stmt_builder_test.go

@@ -8,9 +8,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/querybuilder/resourcefilter"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/stretchr/testify/require"
 )
 
@@ -38,7 +40,14 @@ func resourceFilterStmtBuilder() qbtypes.StatementBuilder[qbtypes.LogAggregation
 }
 
 func TestStatementBuilderTimeSeries(t *testing.T) {
+
+	// Create a test release time
+	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+	releaseTimeNano := uint64(releaseTime.UnixNano())
+
 	cases := []struct {
+		startTs     uint64
+		endTs       uint64
 		name        string
 		requestType qbtypes.RequestType
 		query       qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]
@@ -46,14 +55,16 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 		expectedErr error
 	}{
 		{
-			name:        "Time series with limit",
+			startTs:     releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			endTs:       releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
+			name:        "Time series with limit and count distinct on service.name",
 			requestType: qbtypes.RequestTypeTimeSeries,
 			query: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
 				Signal:       telemetrytypes.SignalLogs,
 				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
 				Aggregations: []qbtypes.LogAggregation{
 					{
-						Expression: "count()",
+						Expression: "count_distinct(service.name)",
 					},
 				},
 				Filter: &qbtypes.Filter{
@@ -69,20 +80,22 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name`",
-				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1747945619), uint64(1747983448), "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448), 10, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448)},
+				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS `service.name`, countDistinct(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS `service.name`, countDistinct(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name`",
+				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1705397400), uint64(1705485600), "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600), 10, "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600)},
 			},
 			expectedErr: nil,
 		},
 		{
-			name:        "Time series with OR b/w resource attr and attribute filter",
+			startTs:     releaseTimeNano - uint64(24*time.Hour.Nanoseconds()),
+			endTs:       releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
+			name:        "Time series with OR b/w resource attr and attribute filter and count distinct on service.name",
 			requestType: qbtypes.RequestTypeTimeSeries,
 			query: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
 				Signal:       telemetrytypes.SignalTraces,
 				StepInterval: qbtypes.Step{Duration: 30 * time.Second},
 				Aggregations: []qbtypes.LogAggregation{
 					{
-						Expression: "count()",
+						Expression: "count_distinct(service.name)",
 					},
 				},
 				Filter: &qbtypes.Filter{
@@ -98,12 +111,14 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE ((simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) OR true) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND ((multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) = ? AND multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL) OR (attributes_string['http.method'] = ? AND mapContains(attributes_string, 'http.method') = ?)) AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND ((multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) = ? AND multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL) OR (attributes_string['http.method'] = ? AND mapContains(attributes_string, 'http.method') = ?)) AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name`",
-				Args:  []any{"redis-manual", "%service.name%", "%service.name\":\"redis-manual%", uint64(1747945619), uint64(1747983448), "redis-manual", "GET", true, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448), 10, "redis-manual", "GET", true, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448)},
+				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE ((simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) OR true) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, countDistinct(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND ((multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) = ? AND multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL) OR (attributes_string['http.method'] = ? AND mapContains(attributes_string, 'http.method') = ?)) AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, countDistinct(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND ((multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) = ? AND multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL) OR (attributes_string['http.method'] = ? AND mapContains(attributes_string, 'http.method') = ?)) AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name`",
+				Args:  []any{"redis-manual", "%service.name%", "%service.name\":\"redis-manual%", uint64(1705224600), uint64(1705485600), "redis-manual", "GET", true, "1705226400000000000", uint64(1705224600), "1705485600000000000", uint64(1705485600), 10, "redis-manual", "GET", true, "1705226400000000000", uint64(1705224600), "1705485600000000000", uint64(1705485600)},
 			},
 			expectedErr: nil,
 		},
 		{
+			startTs:     releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			endTs:       releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
 			name:        "Time series with limit + custom order by",
 			requestType: qbtypes.RequestTypeTimeSeries,
 			query: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
@@ -137,12 +152,14 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 				},
 			},
 			expected: qbtypes.Statement{
-				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY `service.name` desc LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`service.name` IS NOT NULL, resource.`service.name`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name` ORDER BY `service.name` desc, ts desc",
-				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1747945619), uint64(1747983448), "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448), 10, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448)},
+				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `service.name` ORDER BY `service.name` desc LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(resource.`service.name`::String IS NOT NULL, resource.`service.name`::String, NULL)) AS `service.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`service.name`) GLOBAL IN (SELECT `service.name` FROM __limit_cte) GROUP BY ts, `service.name` ORDER BY `service.name` desc, ts desc",
+				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1705397400), uint64(1705485600), "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600), 10, "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600)},
 			},
 			expectedErr: nil,
 		},
 		{
+			startTs:     releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			endTs:       releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
 			name:        "Time series with group by on materialized column",
 			requestType: qbtypes.RequestTypeTimeSeries,
 			query: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
@@ -169,10 +186,12 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 			},
 			expected: qbtypes.Statement{
 				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (simpleJSONExtractString(labels, 'service.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?), __limit_cte AS (SELECT toString(multiIf(`attribute_string_materialized$$key$$name_exists` = ?, `attribute_string_materialized$$key$$name`, NULL)) AS `materialized.key.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY `materialized.key.name` ORDER BY __result_0 DESC LIMIT ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, toString(multiIf(`attribute_string_materialized$$key$$name_exists` = ?, `attribute_string_materialized$$key$$name`, NULL)) AS `materialized.key.name`, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND true AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? AND (`materialized.key.name`) GLOBAL IN (SELECT `materialized.key.name` FROM __limit_cte) GROUP BY ts, `materialized.key.name`",
-				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1747945619), uint64(1747983448), true, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448), 10, true, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448)},
+				Args:  []any{"cartservice", "%service.name%", "%service.name\":\"cartservice%", uint64(1705397400), uint64(1705485600), true, "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600), 10, true, "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600)},
 			},
 		},
 		{
+			startTs:     releaseTimeNano + uint64(24*time.Hour.Nanoseconds()),
+			endTs:       releaseTimeNano + uint64(48*time.Hour.Nanoseconds()),
 			name:        "Time series with materialised column using or with regex operator",
 			requestType: qbtypes.RequestTypeTimeSeries,
 			query: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
@@ -190,13 +209,20 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 			},
 			expected: qbtypes.Statement{
 				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource WHERE (true OR true) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ?) SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 30 SECOND) AS ts, count() AS __result_0 FROM signoz_logs.distributed_logs_v2 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND ((match(`attribute_string_materialized$$key$$name`, ?) AND `attribute_string_materialized$$key$$name_exists` = ?) OR (`attribute_string_materialized$$key$$name` = ? AND `attribute_string_materialized$$key$$name_exists` = ?)) AND timestamp >= ? AND ts_bucket_start >= ? AND timestamp < ? AND ts_bucket_start <= ? GROUP BY ts",
-				Args:  []any{uint64(1747945619), uint64(1747983448), "redis.*", true, "memcached", true, "1747947419000000000", uint64(1747945619), "1747983448000000000", uint64(1747983448)},
+				Args:  []any{uint64(1705397400), uint64(1705485600), "redis.*", true, "memcached", true, "1705399200000000000", uint64(1705397400), "1705485600000000000", uint64(1705485600)},
 			},
 			expectedErr: nil,
 		},
 	}
 
-	fm := NewFieldMapper()
+	ctx := context.Background()
+	orgId := valuer.GenerateUUID()
+	ctx = authtypes.NewContextWithClaims(ctx, authtypes.Claims{
+		OrgID: orgId.String(),
+	})
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(mockKeyEvolutionMetadata(ctx, orgId, releaseTime))
+
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap()
@@ -220,7 +246,7 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 
-			q, err := statementBuilder.Build(context.Background(), 1747947419000, 1747983448000, c.requestType, c.query, nil)
+			q, err := statementBuilder.Build(ctx, c.startTs, c.endTs, c.requestType, c.query, nil)
 
 			if c.expectedErr != nil {
 				require.Error(t, err)
@@ -317,7 +343,8 @@ func TestStatementBuilderListQuery(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap()
@@ -426,7 +453,8 @@ func TestStatementBuilderListQueryResourceTests(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap()
@@ -500,7 +528,8 @@ func TestStatementBuilderTimeSeriesBodyGroupBy(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap()
@@ -596,7 +625,8 @@ func TestStatementBuilderListQueryServiceCollision(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
+	storeWithMetadata := telemetrytypestest.NewMockKeyEvolutionMetadataStore(nil)
+	fm := NewFieldMapper(storeWithMetadata)
 	cb := NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = buildCompleteFieldKeyMapCollision()

pkg/telemetrylogs/test_data.go

@@ -1,9 +1,12 @@
 package telemetrylogs
 
 import (
+	"context"
 	"strings"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // Helper function to limit string length for display
@@ -951,3 +954,23 @@ func buildCompleteFieldKeyMapCollision() map[string][]*telemetrytypes.TelemetryF
 	}
 	return keysMap
 }
+
+// mockKeyEvolutionMetadata builds a mock org-scoped key evolution metadata map for a column evolution.
+func mockKeyEvolutionMetadata(ctx context.Context, orgId valuer.UUID, releaseTime time.Time) map[string]map[string][]*telemetrytypes.KeyEvolutionMetadataKey {
+	metadata := make(map[string]map[string][]*telemetrytypes.KeyEvolutionMetadataKey)
+
+	// Make sure to initialize the inner map before assignment to prevent 'assignment to entry in nil map'
+	orgIdStr := orgId.String()
+	if _, exists := metadata[orgIdStr]; !exists {
+		metadata[orgIdStr] = make(map[string][]*telemetrytypes.KeyEvolutionMetadataKey)
+	}
+	newKeyEvolutionMetadataEntry := telemetrytypes.KeyEvolutionMetadataKey{
+		BaseColumn:     "resources_string",
+		BaseColumnType: "Map(LowCardinality(String), String)",
+		NewColumn:      "resource",
+		NewColumnType:  "JSON(max_dynamic_paths=100)",
+		ReleaseTime:    releaseTime,
+	}
+	metadata[orgIdStr]["resources_string"] = []*telemetrytypes.KeyEvolutionMetadataKey{&newKeyEvolutionMetadataEntry}
+	return metadata
+}

pkg/telemetrymetadata/body_json_metadata.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/ClickHouse/clickhouse-go/v2/lib/chcol"
 	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz-otel-collector/constants"
@@ -15,7 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/huandu/go-sqlbuilder"
 )
@@ -34,6 +32,10 @@ var (
 	CodeFailScanVariant         = errors.MustNewCode("fail_scan_variant")
 	CodeFailBuildJSONPathsQuery = errors.MustNewCode("fail_build_json_paths_query")
 	CodeNoPathsToQueryIndexes   = errors.MustNewCode("no_paths_to_query_indexes_provided")
+
+	CodeFailedToPrepareBatch = errors.MustNewCode("failed_to_prepare_batch_promoted_paths")
+	CodeFailedToSendBatch    = errors.MustNewCode("failed_to_send_batch_promoted_paths")
+	CodeFailedToAppendPath   = errors.MustNewCode("failed_to_append_path_promoted_paths")
 )
 
 // GetBodyJSONPaths extracts body JSON paths from the path_types table
@@ -48,7 +50,7 @@ var (
 // TODO(Piyush): Remove this lint skip
 //
 // nolint:unused
-func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.TelemetryStore,
+func (t *telemetryMetaStore) getBodyJSONPaths(ctx context.Context,
 	fieldKeySelectors []*telemetrytypes.FieldKeySelector) ([]*telemetrytypes.TelemetryFieldKey, bool, error) {
 
 	query, args, limit, err := buildGetBodyJSONPathsQuery(fieldKeySelectors)
@@ -56,7 +58,7 @@ func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.Telemet
 		return nil, false, err
 	}
 
-	rows, err := telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, false, errors.WrapInternalf(err, CodeFailExtractBodyJSONKeys, "failed to extract body JSON keys")
 	}
@@ -96,12 +98,12 @@ func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.Telemet
 		return nil, false, errors.WrapInternalf(rows.Err(), CodeFailIterateBodyJSONKeys, "error iterating body JSON keys")
 	}
 
-	promoted, err := GetPromotedPaths(ctx, telemetryStore.ClickhouseDB(), paths...)
+	promoted, err := t.GetPromotedPaths(ctx, paths...)
 	if err != nil {
 		return nil, false, err
 	}
 
-	indexes, err := getJSONPathIndexes(ctx, telemetryStore, paths...)
+	indexes, err := t.getJSONPathIndexes(ctx, paths...)
 	if err != nil {
 		return nil, false, err
 	}
@@ -163,7 +165,7 @@ func buildGetBodyJSONPathsQuery(fieldKeySelectors []*telemetrytypes.FieldKeySele
 // TODO(Piyush): Remove this lint skip
 //
 // nolint:unused
-func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.TelemetryStore, paths ...string) (map[string][]telemetrytypes.JSONDataTypeIndex, error) {
+func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...string) (map[string][]telemetrytypes.JSONDataTypeIndex, error) {
 	filteredPaths := []string{}
 	for _, path := range paths {
 		if strings.Contains(path, telemetrylogs.ArraySep) || strings.Contains(path, telemetrylogs.ArrayAnyIndex) {
@@ -176,7 +178,7 @@ func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.Telem
 	}
 
 	// list indexes for the paths
-	indexesMap, err := ListLogsJSONIndexes(ctx, telemetryStore, filteredPaths...)
+	indexesMap, err := t.ListLogsJSONIndexes(ctx, filteredPaths...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to list JSON path indexes")
 	}
@@ -215,7 +217,6 @@ func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.Telem
 }
 
 func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, []any) {
-	// This aggregates all types per path and gets the max last_seen, then applies LIMIT
 	sb := sqlbuilder.Select(
 		"name", "type_full", "expr", "granularity",
 	).From(fmt.Sprintf("clusterAllReplicas('%s', %s)", cluster, SkipIndexTableName))
@@ -236,9 +237,9 @@ func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, [
 	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
 }
 
-func ListLogsJSONIndexes(ctx context.Context, telemetryStore telemetrystore.TelemetryStore, filters ...string) (map[string][]schemamigrator.Index, error) {
-	query, args := buildListLogsJSONIndexesQuery(telemetryStore.Cluster(), filters...)
-	rows, err := telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
+	query, args := buildListLogsJSONIndexesQuery(t.telemetrystore.Cluster(), filters...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to load string indexed columns")
 	}
@@ -264,9 +265,16 @@ func ListLogsJSONIndexes(ctx context.Context, telemetryStore telemetrystore.Tele
 	return indexesMap, nil
 }
 
-func ListPromotedPaths(ctx context.Context, conn clickhouse.Conn) (map[string]struct{}, error) {
-	query := fmt.Sprintf("SELECT path FROM %s.%s", DBName, PromotedPathsTableName)
-	rows, err := conn.Query(ctx, query)
+func (t *telemetryMetaStore) ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error) {
+	sb := sqlbuilder.Select("path").From(fmt.Sprintf("%s.%s", DBName, PromotedPathsTableName))
+	pathConditions := []string{}
+	for _, path := range paths {
+		pathConditions = append(pathConditions, sb.Equal("path", path))
+	}
+	sb.Where(sb.Or(pathConditions...))
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadPromotedPaths, "failed to load promoted paths")
 	}
@@ -285,14 +293,14 @@ func ListPromotedPaths(ctx context.Context, conn clickhouse.Conn) (map[string]st
 }
 
 // TODO(Piyush): Remove this if not used in future
-func ListJSONValues(ctx context.Context, conn clickhouse.Conn, path string, limit int) (*telemetrytypes.TelemetryFieldValues, bool, error) {
+func (t *telemetryMetaStore) ListJSONValues(ctx context.Context, path string, limit int) (*telemetrytypes.TelemetryFieldValues, bool, error) {
 	path = CleanPathPrefixes(path)
 
 	if strings.Contains(path, telemetrylogs.ArraySep) || strings.Contains(path, telemetrylogs.ArrayAnyIndex) {
 		return nil, false, errors.NewInvalidInputf(errors.CodeInvalidInput, "array paths are not supported")
 	}
 
-	promoted, err := IsPathPromoted(ctx, conn, path)
+	promoted, err := t.IsPathPromoted(ctx, path)
 	if err != nil {
 		return nil, false, err
 	}
@@ -325,7 +333,7 @@ func ListJSONValues(ctx context.Context, conn clickhouse.Conn, path string, limi
 	contextWithTimeout, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := conn.Query(contextWithTimeout, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(contextWithTimeout, query, args...)
 	if err != nil {
 		if errors.Is(err, context.DeadlineExceeded) {
 			return nil, false, errors.WrapTimeoutf(err, errors.CodeTimeout, "query timed out").WithAdditional("failed to list JSON values")
@@ -447,10 +455,10 @@ func derefValue(v any) any {
 }
 
 // IsPathPromoted checks if a specific path is promoted
-func IsPathPromoted(ctx context.Context, conn clickhouse.Conn, path string) (bool, error) {
+func (t *telemetryMetaStore) IsPathPromoted(ctx context.Context, path string) (bool, error) {
 	split := strings.Split(path, telemetrylogs.ArraySep)
 	query := fmt.Sprintf("SELECT 1 FROM %s.%s WHERE path = ? LIMIT 1", DBName, PromotedPathsTableName)
-	rows, err := conn.Query(ctx, query, split[0])
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, split[0])
 	if err != nil {
 		return false, errors.WrapInternalf(err, CodeFailCheckPathPromoted, "failed to check if path %s is promoted", path)
 	}
@@ -460,7 +468,7 @@ func IsPathPromoted(ctx context.Context, conn clickhouse.Conn, path string) (boo
 }
 
 // GetPromotedPaths checks if a specific path is promoted
-func GetPromotedPaths(ctx context.Context, conn clickhouse.Conn, paths ...string) (*utils.ConcurrentSet[string], error) {
+func (t *telemetryMetaStore) GetPromotedPaths(ctx context.Context, paths ...string) (*utils.ConcurrentSet[string], error) {
 	sb := sqlbuilder.Select("path").From(fmt.Sprintf("%s.%s", DBName, PromotedPathsTableName))
 	pathConditions := []string{}
 	for _, path := range paths {
@@ -469,7 +477,7 @@ func GetPromotedPaths(ctx context.Context, conn clickhouse.Conn, paths ...string
 	sb.Where(sb.Or(pathConditions...))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := conn.Query(ctx, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailCheckPathPromoted, "failed to get promoted paths")
 	}
@@ -494,3 +502,29 @@ func CleanPathPrefixes(path string) string {
 	path = strings.TrimPrefix(path, telemetrylogs.BodyPromotedColumnPrefix)
 	return path
 }
+
+func (t *telemetryMetaStore) PromotePaths(ctx context.Context, paths ...string) error {
+	batch, err := t.telemetrystore.ClickhouseDB().PrepareBatch(ctx,
+		fmt.Sprintf("INSERT INTO %s.%s (path, created_at) VALUES", DBName,
+			PromotedPathsTableName))
+	if err != nil {
+		return errors.WrapInternalf(err, CodeFailedToPrepareBatch, "failed to prepare batch")
+	}
+
+	nowMs := uint64(time.Now().UnixMilli())
+	for _, p := range paths {
+		trimmed := strings.TrimSpace(p)
+		if trimmed == "" {
+			continue
+		}
+		if err := batch.Append(trimmed, nowMs); err != nil {
+			_ = batch.Abort()
+			return errors.WrapInternalf(err, CodeFailedToAppendPath, "failed to append path")
+		}
+	}
+
+	if err := batch.Send(); err != nil {
+		return errors.WrapInternalf(err, CodeFailedToSendBatch, "failed to send batch")
+	}
+	return nil
+}

pkg/telemetrymetadata/condition_builder.go

@@ -25,8 +25,7 @@ func (c *conditionBuilder) ConditionFor(
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
-    _ uint64,
-    _ uint64,
+	tsStart, tsEnd uint64,
 ) (string, error) {
 
 	switch operator {
@@ -45,7 +44,7 @@ func (c *conditionBuilder) ConditionFor(
 		return "", nil
 	}
 
-	tblFieldName, err := c.fm.FieldFor(ctx, key)
+	tblFieldName, err := c.fm.FieldFor(ctx, tsStart, tsEnd, key)
 	if err != nil {
 		// if we don't have a table field name, we can't build a condition for related values
 		return "", nil

pkg/telemetrymetadata/condition_builder_test.go

@@ -53,7 +53,7 @@ func TestConditionFor(t *testing.T) {
 	for _, tc := range testCases {
 		sb := sqlbuilder.NewSelectBuilder()
 		t.Run(tc.name, func(t *testing.T) {
-            cond, err := conditionBuilder.ConditionFor(ctx, &tc.key, tc.operator, tc.value, sb, 0, 0)
+			cond, err := conditionBuilder.ConditionFor(ctx, &tc.key, tc.operator, tc.value, sb, 0, 0)
 			sb.Where(cond)
 
 			if tc.expectedError != nil {

pkg/telemetrymetadata/field_mapper.go

@@ -51,7 +51,7 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, key *telemetrytypes.Telemet
 	return column, nil
 }
 
-func (m *fieldMapper) FieldFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (string, error) {
+func (m *fieldMapper) FieldFor(ctx context.Context, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	column, err := m.getColumn(ctx, key)
 	if err != nil {
 		return "", err
@@ -69,11 +69,12 @@ func (m *fieldMapper) FieldFor(ctx context.Context, key *telemetrytypes.Telemetr
 
 func (m *fieldMapper) ColumnExpressionFor(
 	ctx context.Context,
+	startNs, endNs uint64,
 	field *telemetrytypes.TelemetryFieldKey,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 
-	colName, err := m.FieldFor(ctx, field)
+	colName, err := m.FieldFor(ctx, startNs, endNs, field)
 	if errors.Is(err, qbtypes.ErrColumnNotFound) {
 		// the key didn't have the right context to be added to the query
 		// we try to use the context we know of
@@ -83,7 +84,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 			if _, ok := attributeMetadataColumns[field.Name]; ok {
 				// if it is, attach the column name directly
 				field.FieldContext = telemetrytypes.FieldContextSpan
-				colName, _ = m.FieldFor(ctx, field)
+				colName, _ = m.FieldFor(ctx, startNs, endNs, field)
 			} else {
 				// - the context is not provided
 				// - there are not keys for the field
@@ -101,12 +102,12 @@ func (m *fieldMapper) ColumnExpressionFor(
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it
-			colName, _ = m.FieldFor(ctx, keysForField[0])
+			colName, _ = m.FieldFor(ctx, startNs, endNs, keysForField[0])
 		} else {
 			// select any non-empty value from the keys
 			args := []string{}
 			for _, key := range keysForField {
-				colName, _ = m.FieldFor(ctx, key)
+				colName, _ = m.FieldFor(ctx, startNs, endNs, key)
 				args = append(args, fmt.Sprintf("toString(%s) != '', toString(%s)", colName, colName))
 			}
 			colName = fmt.Sprintf("multiIf(%s, NULL)", strings.Join(args, ", "))

pkg/telemetrymetadata/field_mapper_test.go

@@ -145,6 +145,8 @@ func TestGetFieldKeyName(t *testing.T) {
 
 	testCases := []struct {
 		name           string
+		tsStart        uint64
+		tsEnd          uint64
 		key            telemetrytypes.TelemetryFieldKey
 		expectedResult string
 		expectedError  error
@@ -203,7 +205,7 @@ func TestGetFieldKeyName(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result, err := fm.FieldFor(ctx, &tc.key)
+			result, err := fm.FieldFor(ctx, tc.tsStart, tc.tsEnd, &tc.key)
 
 			if tc.expectedError != nil {
 				assert.Equal(t, tc.expectedError, err)

pkg/telemetrymetadata/metadata.go

@@ -942,18 +942,18 @@ func (t *telemetryMetaStore) getRelatedValues(ctx context.Context, fieldValueSel
 		FieldDataType: fieldValueSelector.FieldDataType,
 	}
 
-	selectColumn, err := t.fm.FieldFor(ctx, key)
+	selectColumn, err := t.fm.FieldFor(ctx, 0, 0, key)
 
 	if err != nil {
 		// we don't have a explicit column to select from the related metadata table
 		// so we will select either from resource_attributes or attributes table
 		// in that order
-		resourceColumn, _ := t.fm.FieldFor(ctx, &telemetrytypes.TelemetryFieldKey{
+		resourceColumn, _ := t.fm.FieldFor(ctx, 0, 0, &telemetrytypes.TelemetryFieldKey{
 			Name:          key.Name,
 			FieldContext:  telemetrytypes.FieldContextResource,
 			FieldDataType: telemetrytypes.FieldDataTypeString,
 		})
-		attributeColumn, _ := t.fm.FieldFor(ctx, &telemetrytypes.TelemetryFieldKey{
+		attributeColumn, _ := t.fm.FieldFor(ctx, 0, 0, &telemetrytypes.TelemetryFieldKey{
 			Name:          key.Name,
 			FieldContext:  telemetrytypes.FieldContextAttribute,
 			FieldDataType: telemetrytypes.FieldDataTypeString,
@@ -978,7 +978,7 @@ func (t *telemetryMetaStore) getRelatedValues(ctx context.Context, fieldValueSel
 			FieldMapper:      t.fm,
 			ConditionBuilder: t.conditionBuilder,
 			FieldKeys:        keys,
-        }, 0, 0)
+		}, 0, 0)
 		if err == nil {
 			sb.AddWhereClause(whereClause.WhereClause)
 		} else {
@@ -1002,20 +1002,20 @@ func (t *telemetryMetaStore) getRelatedValues(ctx context.Context, fieldValueSel
 
 			// search on attributes
 			key.FieldContext = telemetrytypes.FieldContextAttribute
-            cond, err := t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
+			cond, err := t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
 			if err == nil {
 				conds = append(conds, cond)
 			}
 
 			// search on resource
 			key.FieldContext = telemetrytypes.FieldContextResource
-            cond, err = t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
+			cond, err = t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
 			if err == nil {
 				conds = append(conds, cond)
 			}
 			key.FieldContext = origContext
 		} else {
-            cond, err := t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
+			cond, err := t.conditionBuilder.ConditionFor(ctx, key, qbtypes.FilterOperatorContains, fieldValueSelector.Value, sb, 0, 0)
 			if err == nil {
 				conds = append(conds, cond)
 			}

pkg/telemetrymeter/statement_builder.go

@@ -120,7 +120,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 		stepSec,
 	))
 	for _, g := range query.GroupBy {
-		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		col, err := b.fm.ColumnExpressionFor(ctx, start, end, &g.TelemetryFieldKey, keys)
 		if err != nil {
 			return "", []any{}, err
 		}
@@ -148,7 +148,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 			FieldKeys:        keys,
 			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
 			Variables:        variables,
-        }, start, end)
+		}, start, end)
 		if err != nil {
 			return "", []any{}, err
 		}
@@ -200,7 +200,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDelta(
 	))
 
 	for _, g := range query.GroupBy {
-		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		col, err := b.fm.ColumnExpressionFor(ctx, start, end, &g.TelemetryFieldKey, keys)
 		if err != nil {
 			return "", nil, err
 		}
@@ -231,7 +231,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDelta(
 			FieldKeys:        keys,
 			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
 			Variables:        variables,
-        }, start, end)
+		}, start, end)
 		if err != nil {
 			return "", nil, err
 		}
@@ -270,7 +270,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 		stepSec,
 	))
 	for _, g := range query.GroupBy {
-		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		col, err := b.fm.ColumnExpressionFor(ctx, start, end, &g.TelemetryFieldKey, keys)
 		if err != nil {
 			return "", nil, err
 		}
@@ -295,7 +295,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 			FieldKeys:        keys,
 			FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels"},
 			Variables:        variables,
-        }, start, end)
+		}, start, end)
 		if err != nil {
 			return "", nil, err
 		}

pkg/telemetrymetrics/condition_builder.go

@@ -23,6 +23,8 @@ func NewConditionBuilder(fm qbtypes.FieldMapper) *conditionBuilder {
 
 func (c *conditionBuilder) conditionFor(
 	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
@@ -39,7 +41,7 @@ func (c *conditionBuilder) conditionFor(
 		value = querybuilder.FormatValueForContains(value)
 	}
 
-	tblFieldName, err := c.fm.FieldFor(ctx, key)
+	tblFieldName, err := c.fm.FieldFor(ctx, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
@@ -139,10 +141,10 @@ func (c *conditionBuilder) ConditionFor(
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
-	_ uint64,
-	_ uint64,
+	startNs uint64,
+	endNs uint64,
 ) (string, error) {
-	condition, err := c.conditionFor(ctx, key, operator, value, sb)
+	condition, err := c.conditionFor(ctx, startNs, endNs, key, operator, value, sb)
 	if err != nil {
 		return "", err
 	}

pkg/telemetrymetrics/field_mapper.go

@@ -65,7 +65,7 @@ func (m *fieldMapper) getColumn(_ context.Context, key *telemetrytypes.Telemetry
 	return nil, qbtypes.ErrColumnNotFound
 }
 
-func (m *fieldMapper) FieldFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (string, error) {
+func (m *fieldMapper) FieldFor(ctx context.Context, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	column, err := m.getColumn(ctx, key)
 	if err != nil {
 		return "", err
@@ -92,11 +92,12 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, key *telemetrytypes.Telemet
 
 func (m *fieldMapper) ColumnExpressionFor(
 	ctx context.Context,
+	startNs, endNs uint64,
 	field *telemetrytypes.TelemetryFieldKey,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 
-	colName, err := m.FieldFor(ctx, field)
+	colName, err := m.FieldFor(ctx, startNs, endNs, field)
 	if err != nil {
 		return "", err
 	}

pkg/telemetrymetrics/field_mapper_test.go

@@ -207,7 +207,7 @@ func TestGetFieldKeyName(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result, err := fm.FieldFor(ctx, &tc.key)
+			result, err := fm.FieldFor(ctx, 0, 0, &tc.key)
 
 			if tc.expectedError != nil {
 				assert.Equal(t, tc.expectedError, err)

pkg/telemetrymetrics/statement_builder.go

@@ -359,7 +359,7 @@ func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
 
 	sb.Select("fingerprint")
 	for _, g := range query.GroupBy {
-		col, err := b.fm.ColumnExpressionFor(ctx, &g.TelemetryFieldKey, keys)
+		col, err := b.fm.ColumnExpressionFor(ctx, start, end, &g.TelemetryFieldKey, keys)
 		if err != nil {
 			return "", nil, err
 		}

pkg/telemetrytraces/condition_builder.go

@@ -29,6 +29,8 @@ func NewConditionBuilder(fm qbtypes.FieldMapper) *conditionBuilder {
 
 func (c *conditionBuilder) conditionFor(
 	ctx context.Context,
+	startNs uint64,
+	endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
@@ -52,7 +54,7 @@ func (c *conditionBuilder) conditionFor(
 	}
 
 	// then ask the mapper for the actual SQL reference
-	tblFieldName, err := c.fm.FieldFor(ctx, key)
+	tblFieldName, err := c.fm.FieldFor(ctx, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
@@ -239,20 +241,20 @@ func (c *conditionBuilder) ConditionFor(
 	value any,
 	sb *sqlbuilder.SelectBuilder,
 	startNs uint64,
-	_ uint64,
+	endNs uint64,
 ) (string, error) {
 	if c.isSpanScopeField(key.Name) {
 		return c.buildSpanScopeCondition(key, operator, value, startNs)
 	}
 
-	condition, err := c.conditionFor(ctx, key, operator, value, sb)
+	condition, err := c.conditionFor(ctx, startNs, endNs, key, operator, value, sb)
 	if err != nil {
 		return "", err
 	}
 
 	if operator.AddDefaultExistsFilter() {
 		// skip adding exists filter for intrinsic fields
-		field, _ := c.fm.FieldFor(ctx, key)
+		field, _ := c.fm.FieldFor(ctx, startNs, endNs, key)
 		if slices.Contains(maps.Keys(IntrinsicFields), field) ||
 			slices.Contains(maps.Keys(IntrinsicFieldsDeprecated), field) ||
 			slices.Contains(maps.Keys(CalculatedFields), field) ||
@@ -260,7 +262,7 @@ func (c *conditionBuilder) ConditionFor(
 			return condition, nil
 		}
 
-		existsCondition, err := c.conditionFor(ctx, key, qbtypes.FilterOperatorExists, nil, sb)
+		existsCondition, err := c.conditionFor(ctx, startNs, endNs, key, qbtypes.FilterOperatorExists, nil, sb)
 		if err != nil {
 			return "", err
 		}

pkg/telemetrytraces/field_mapper.go

@@ -225,6 +225,7 @@ func (m *defaultFieldMapper) ColumnFor(
 // otherwise it returns qbtypes.ErrColumnNotFound
 func (m *defaultFieldMapper) FieldFor(
 	ctx context.Context,
+	startNs, endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 	// Special handling for span scope fields
@@ -297,11 +298,12 @@ func (m *defaultFieldMapper) FieldFor(
 // if it exists otherwise it returns qbtypes.ErrColumnNotFound
 func (m *defaultFieldMapper) ColumnExpressionFor(
 	ctx context.Context,
+	startNs, endNs uint64,
 	field *telemetrytypes.TelemetryFieldKey,
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 
-	colName, err := m.FieldFor(ctx, field)
+	colName, err := m.FieldFor(ctx, startNs, endNs, field)
 	if errors.Is(err, qbtypes.ErrColumnNotFound) {
 		// the key didn't have the right context to be added to the query
 		// we try to use the context we know of
@@ -311,7 +313,7 @@ func (m *defaultFieldMapper) ColumnExpressionFor(
 			if _, ok := indexV3Columns[field.Name]; ok {
 				// if it is, attach the column name directly
 				field.FieldContext = telemetrytypes.FieldContextSpan
-				colName, _ = m.FieldFor(ctx, field)
+				colName, _ = m.FieldFor(ctx, startNs, endNs, field)
 			} else {
 				// - the context is not provided
 				// - there are not keys for the field
@@ -329,12 +331,12 @@ func (m *defaultFieldMapper) ColumnExpressionFor(
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it
-			colName, _ = m.FieldFor(ctx, keysForField[0])
+			colName, _ = m.FieldFor(ctx, startNs, endNs, keysForField[0])
 		} else {
 			// select any non-empty value from the keys
 			args := []string{}
 			for _, key := range keysForField {
-				colName, _ = m.FieldFor(ctx, key)
+				colName, _ = m.FieldFor(ctx, startNs, endNs, key)
 				args = append(args, fmt.Sprintf("toString(%s) != '', toString(%s)", colName, colName))
 			}
 			colName = fmt.Sprintf("multiIf(%s, NULL)", strings.Join(args, ", "))

pkg/telemetrytraces/field_mapper_test.go

@@ -92,7 +92,7 @@ func TestGetFieldKeyName(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			fm := NewFieldMapper()
-			result, err := fm.FieldFor(ctx, &tc.key)
+			result, err := fm.FieldFor(ctx, 0, 0, &tc.key)
 
 			if tc.expectedError != nil {
 				assert.Equal(t, tc.expectedError, err)

pkg/telemetrytraces/statement_builder.go

@@ -293,7 +293,7 @@ func (b *traceQueryStatementBuilder) buildListQuery(
 
 	// TODO: should we deprecate `SelectFields` and return everything from a span like we do for logs?
 	for _, field := range selectedFields {
-		colExpr, err := b.fm.ColumnExpressionFor(ctx, &field, keys)
+		colExpr, err := b.fm.ColumnExpressionFor(ctx, start, end, &field, keys)
 		if err != nil {
 			return nil, err
 		}
@@ -311,7 +311,7 @@ func (b *traceQueryStatementBuilder) buildListQuery(
 
 	// Add order by
 	for _, orderBy := range query.Order {
-		colExpr, err := b.fm.ColumnExpressionFor(ctx, &orderBy.Key.TelemetryFieldKey, keys)
+		colExpr, err := b.fm.ColumnExpressionFor(ctx, start, end, &orderBy.Key.TelemetryFieldKey, keys)
 		if err != nil {
 			return nil, err
 		}
@@ -495,7 +495,7 @@ func (b *traceQueryStatementBuilder) buildTimeSeriesQuery(
 	// Keep original column expressions so we can build the tuple
 	fieldNames := make([]string, 0, len(query.GroupBy))
 	for _, gb := range query.GroupBy {
-		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, "", nil)
+		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, start, end, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, "", nil)
 		if err != nil {
 			return nil, err
 		}
@@ -509,7 +509,7 @@ func (b *traceQueryStatementBuilder) buildTimeSeriesQuery(
 	allAggChArgs := make([]any, 0)
 	for i, agg := range query.Aggregations {
 		rewritten, chArgs, err := b.aggExprRewriter.Rewrite(
-			ctx, agg.Expression,
+			ctx, start, end, agg.Expression,
 			uint64(query.StepInterval.Seconds()),
 			keys,
 		)
@@ -637,7 +637,7 @@ func (b *traceQueryStatementBuilder) buildScalarQuery(
 
 	var allGroupByArgs []any
 	for _, gb := range query.GroupBy {
-		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, "", nil)
+		expr, args, err := querybuilder.CollisionHandledFinalExpr(ctx, start, end, &gb.TelemetryFieldKey, b.fm, b.cb, keys, telemetrytypes.FieldDataTypeString, "", nil)
 		if err != nil {
 			return nil, err
 		}
@@ -654,7 +654,7 @@ func (b *traceQueryStatementBuilder) buildScalarQuery(
 		for idx := range query.Aggregations {
 			aggExpr := query.Aggregations[idx]
 			rewritten, chArgs, err := b.aggExprRewriter.Rewrite(
-				ctx, aggExpr.Expression,
+				ctx, start, end, aggExpr.Expression,
 				rateInterval,
 				keys,
 			)
@@ -746,7 +746,7 @@ func (b *traceQueryStatementBuilder) addFilterCondition(
 			FieldKeys:          keys,
 			SkipResourceFilter: true,
 			Variables:          variables,
-        }, start, end)
+		}, start, end)
 
 		if err != nil {
 			return nil, err

pkg/telemetrytraces/trace_operator_cte_builder.go

@@ -237,7 +237,7 @@ func (b *traceOperatorCTEBuilder) buildQueryCTE(ctx context.Context, queryName s
 				ConditionBuilder:   b.stmtBuilder.cb,
 				FieldKeys:          keys,
 				SkipResourceFilter: true,
-            }, b.start, b.end,
+			}, b.start, b.end,
 		)
 		if err != nil {
 			b.stmtBuilder.logger.ErrorContext(ctx, "Failed to prepare where clause", "error", err, "filter", query.Filter.Expression)
@@ -450,7 +450,7 @@ func (b *traceOperatorCTEBuilder) buildListQuery(ctx context.Context, selectFrom
 		if selectedFields[field.Name] {
 			continue
 		}
-		colExpr, err := b.stmtBuilder.fm.ColumnExpressionFor(ctx, &field, keys)
+		colExpr, err := b.stmtBuilder.fm.ColumnExpressionFor(ctx, b.start, b.end, &field, keys)
 		if err != nil {
 			b.stmtBuilder.logger.WarnContext(ctx, "failed to map select field",
 				"field", field.Name, "error", err)
@@ -465,7 +465,7 @@ func (b *traceOperatorCTEBuilder) buildListQuery(ctx context.Context, selectFrom
 	// Add order by support using ColumnExpressionFor
 	orderApplied := false
 	for _, orderBy := range b.operator.Order {
-		colExpr, err := b.stmtBuilder.fm.ColumnExpressionFor(ctx, &orderBy.Key.TelemetryFieldKey, keys)
+		colExpr, err := b.stmtBuilder.fm.ColumnExpressionFor(ctx, b.start, b.end, &orderBy.Key.TelemetryFieldKey, keys)
 		if err != nil {
 			return nil, err
 		}
@@ -547,6 +547,8 @@ func (b *traceOperatorCTEBuilder) buildTimeSeriesQuery(ctx context.Context, sele
 	for _, gb := range b.operator.GroupBy {
 		expr, args, err := querybuilder.CollisionHandledFinalExpr(
 			ctx,
+			b.start,
+			b.end,
 			&gb.TelemetryFieldKey,
 			b.stmtBuilder.fm,
 			b.stmtBuilder.cb,
@@ -572,6 +574,8 @@ func (b *traceOperatorCTEBuilder) buildTimeSeriesQuery(ctx context.Context, sele
 	for i, agg := range b.operator.Aggregations {
 		rewritten, chArgs, err := b.stmtBuilder.aggExprRewriter.Rewrite(
 			ctx,
+			b.start,
+			b.end,
 			agg.Expression,
 			uint64(b.operator.StepInterval.Seconds()),
 			keys,
@@ -657,6 +661,8 @@ func (b *traceOperatorCTEBuilder) buildTraceQuery(ctx context.Context, selectFro
 	for _, gb := range b.operator.GroupBy {
 		expr, args, err := querybuilder.CollisionHandledFinalExpr(
 			ctx,
+			b.start,
+			b.end,
 			&gb.TelemetryFieldKey,
 			b.stmtBuilder.fm,
 			b.stmtBuilder.cb,
@@ -684,6 +690,8 @@ func (b *traceOperatorCTEBuilder) buildTraceQuery(ctx context.Context, selectFro
 	for i, agg := range b.operator.Aggregations {
 		rewritten, chArgs, err := b.stmtBuilder.aggExprRewriter.Rewrite(
 			ctx,
+			b.start,
+			b.end,
 			agg.Expression,
 			rateInterval,
 			keys,
@@ -797,6 +805,8 @@ func (b *traceOperatorCTEBuilder) buildScalarQuery(ctx context.Context, selectFr
 	for _, gb := range b.operator.GroupBy {
 		expr, args, err := querybuilder.CollisionHandledFinalExpr(
 			ctx,
+			b.start,
+			b.end,
 			&gb.TelemetryFieldKey,
 			b.stmtBuilder.fm,
 			b.stmtBuilder.cb,
@@ -822,6 +832,8 @@ func (b *traceOperatorCTEBuilder) buildScalarQuery(ctx context.Context, selectFr
 	for i, agg := range b.operator.Aggregations {
 		rewritten, chArgs, err := b.stmtBuilder.aggExprRewriter.Rewrite(
 			ctx,
+			b.start,
+			b.end,
 			agg.Expression,
 			uint64((b.end-b.start)/querybuilder.NsToSeconds),
 			keys,

pkg/types/dashboardtypes/dashboard.go

@@ -349,7 +349,7 @@ func (dashboard *Dashboard) GetWidgetQuery(startTime, endTime uint64, widgetInde
 		return nil, errors.Wrapf(err, errors.TypeInvalidInput, ErrCodeDashboardInvalidData, "invalid dashboard data")
 	}
 
-	if len(data.Widgets) < int(widgetIndex)+1 {
+	if widgetIndex < 0 || int(widgetIndex) >= len(data.Widgets) {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidInput, "widget with index %v doesn't exist", widgetIndex)
 	}
 

pkg/types/promotetypes/types.go

@@ -0,0 +1,76 @@
+package promotetypes
+
+import (
+	"strings"
+
+	"github.com/SigNoz/signoz-otel-collector/constants"
+	"github.com/SigNoz/signoz-otel-collector/pkg/keycheck"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+type WrappedIndex struct {
+	JSONDataType telemetrytypes.JSONDataType `json:"-"`
+	ColumnType   string                      `json:"column_type"`
+	Type         string                      `json:"type"`
+	Granularity  int                         `json:"granularity"`
+}
+
+type PromotePath struct {
+	Path    string `json:"path"`
+	Promote bool   `json:"promote,omitempty"`
+
+	Indexes []WrappedIndex `json:"indexes,omitempty"`
+}
+
+func (i *PromotePath) ValidateAndSetDefaults() error {
+	if i.Path == "" {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path is required")
+	}
+
+	if strings.Contains(i.Path, " ") {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path cannot contain spaces")
+	}
+
+	if strings.Contains(i.Path, telemetrylogs.ArraySep) || strings.Contains(i.Path, telemetrylogs.ArrayAnyIndex) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "array paths can not be promoted or indexed")
+	}
+
+	if strings.HasPrefix(i.Path, constants.BodyJSONColumnPrefix) || strings.HasPrefix(i.Path, constants.BodyPromotedColumnPrefix) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "`%s`, `%s` don't add these prefixes to the path", constants.BodyJSONColumnPrefix, constants.BodyPromotedColumnPrefix)
+	}
+
+	if !strings.HasPrefix(i.Path, telemetrylogs.BodyJSONStringSearchPrefix) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path must start with `body.`")
+	}
+
+	// remove the "body." prefix from the path
+	i.Path = strings.TrimPrefix(i.Path, telemetrylogs.BodyJSONStringSearchPrefix)
+
+	isCardinal := keycheck.IsCardinal(i.Path)
+	if isCardinal {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cardinal paths can not be promoted or indexed")
+	}
+
+	for idx, index := range i.Indexes {
+		if index.Type == "" {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index type is required")
+		}
+		if index.Granularity <= 0 {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index granularity must be greater than 0")
+		}
+
+		jsonDataType, ok := telemetrytypes.MappingStringToJSONDataType[index.ColumnType]
+		if !ok {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid column type: %s", index.ColumnType)
+		}
+		if !jsonDataType.IndexSupported {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index is not supported for column type: %s", index.ColumnType)
+		}
+
+		i.Indexes[idx].JSONDataType = jsonDataType
+	}
+
+	return nil
+}

pkg/types/querybuildertypes/querybuildertypesv5/qb.go

@@ -21,11 +21,11 @@ type JsonKeyToFieldFunc func(context.Context, *telemetrytypes.TelemetryFieldKey,
 // FieldMapper maps the telemetry field key to the table field name.
 type FieldMapper interface {
 	// FieldFor returns the field name for the given key.
-	FieldFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (string, error)
+	FieldFor(ctx context.Context, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error)
 	// ColumnFor returns the column for the given key.
 	ColumnFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (*schema.Column, error)
 	// ColumnExpressionFor returns the column expression for the given key.
-	ColumnExpressionFor(ctx context.Context, key *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemetrytypes.TelemetryFieldKey) (string, error)
+	ColumnExpressionFor(ctx context.Context, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemetrytypes.TelemetryFieldKey) (string, error)
 }
 
 // ConditionBuilder builds the condition for the filter.
@@ -37,8 +37,8 @@ type ConditionBuilder interface {
 
 type AggExprRewriter interface {
 	// Rewrite rewrites the aggregation expression to be used in the query.
-	Rewrite(ctx context.Context, expr string, rateInterval uint64, keys map[string][]*telemetrytypes.TelemetryFieldKey) (string, []any, error)
-	RewriteMulti(ctx context.Context, exprs []string, rateInterval uint64, keys map[string][]*telemetrytypes.TelemetryFieldKey) ([]string, [][]any, error)
+	Rewrite(ctx context.Context, startNs, endNs uint64, expr string, rateInterval uint64, keys map[string][]*telemetrytypes.TelemetryFieldKey) (string, []any, error)
+	RewriteMulti(ctx context.Context, startNs, endNs uint64, exprs []string, rateInterval uint64, keys map[string][]*telemetrytypes.TelemetryFieldKey) ([]string, [][]any, error)
 }
 
 type Statement struct {

pkg/types/telemetrytypes/evolution_metadata.go

@@ -0,0 +1,20 @@
+package telemetrytypes
+
+import (
+	"context"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type KeyEvolutionMetadataKey struct {
+	BaseColumn     string
+	BaseColumnType string
+	NewColumn      string
+	NewColumnType  string
+	ReleaseTime    time.Time
+}
+
+type KeyEvolutionMetadataStore interface {
+	Get(ctx context.Context, orgId valuer.UUID, keyName string) []*KeyEvolutionMetadataKey
+}

pkg/types/telemetrytypes/store.go

@@ -3,6 +3,7 @@ package telemetrytypes
 import (
 	"context"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 )
 
@@ -30,4 +31,13 @@ type MetadataStore interface {
 
 	// FetchTemporalityMulti fetches the temporality for multiple metrics
 	FetchTemporalityMulti(ctx context.Context, metricNames ...string) (map[string]metrictypes.Temporality, error)
+
+	// ListLogsJSONIndexes lists the JSON indexes for the logs table.
+	ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error)
+
+	// ListPromotedPaths lists the promoted paths.
+	ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error)
+
+	// PromotePaths promotes the paths.
+	PromotePaths(ctx context.Context, paths ...string) error
 }

pkg/types/telemetrytypes/telemetrytypestest/key_evolution_metadata.go

@@ -0,0 +1,40 @@
+package telemetrytypestest
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// MockKeyEvolutionMetadataStore implements the KeyEvolutionMetadataStore interface for testing purposes
+type MockKeyEvolutionMetadataStore struct {
+	metadata map[string]map[string][]*telemetrytypes.KeyEvolutionMetadataKey // orgId -> keyName -> metadata
+}
+
+// NewMockKeyEvolutionMetadataStore creates a new instance of MockKeyEvolutionMetadataStore with initialized maps
+func NewMockKeyEvolutionMetadataStore(metadata map[string]map[string][]*telemetrytypes.KeyEvolutionMetadataKey) *MockKeyEvolutionMetadataStore {
+	return &MockKeyEvolutionMetadataStore{
+		metadata: metadata,
+	}
+}
+
+// Get retrieves all metadata keys for the given key name and orgId.
+// Returns an empty slice if the key is not found.
+func (m *MockKeyEvolutionMetadataStore) Get(ctx context.Context, orgId valuer.UUID, keyName string) []*telemetrytypes.KeyEvolutionMetadataKey {
+	if m.metadata == nil {
+		return nil
+	}
+	orgMetadata, orgExists := m.metadata[orgId.String()]
+	if !orgExists {
+		return nil
+	}
+	keys, exists := orgMetadata[keyName]
+	if !exists {
+		return nil
+	}
+	// Return a copy to prevent external modification
+	result := make([]*telemetrytypes.KeyEvolutionMetadataKey, len(keys))
+	copy(result, keys)
+	return result
+}

pkg/types/telemetrytypes/telemetrytypestest/metadata_store.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
@@ -11,19 +12,23 @@ import (
 // MockMetadataStore implements the MetadataStore interface for testing purposes
 type MockMetadataStore struct {
 	// Maps to store test data
-	KeysMap          map[string][]*telemetrytypes.TelemetryFieldKey
-	RelatedValuesMap map[string][]string
-	AllValuesMap     map[string]*telemetrytypes.TelemetryFieldValues
-	TemporalityMap   map[string]metrictypes.Temporality
+	KeysMap            map[string][]*telemetrytypes.TelemetryFieldKey
+	RelatedValuesMap   map[string][]string
+	AllValuesMap       map[string]*telemetrytypes.TelemetryFieldValues
+	TemporalityMap     map[string]metrictypes.Temporality
+	PromotedPathsMap   map[string]struct{}
+	LogsJSONIndexesMap map[string][]schemamigrator.Index
 }
 
 // NewMockMetadataStore creates a new instance of MockMetadataStore with initialized maps
 func NewMockMetadataStore() *MockMetadataStore {
 	return &MockMetadataStore{
-		KeysMap:          make(map[string][]*telemetrytypes.TelemetryFieldKey),
-		RelatedValuesMap: make(map[string][]string),
-		AllValuesMap:     make(map[string]*telemetrytypes.TelemetryFieldValues),
-		TemporalityMap:   make(map[string]metrictypes.Temporality),
+		KeysMap:            make(map[string][]*telemetrytypes.TelemetryFieldKey),
+		RelatedValuesMap:   make(map[string][]string),
+		AllValuesMap:       make(map[string]*telemetrytypes.TelemetryFieldValues),
+		TemporalityMap:     make(map[string]metrictypes.Temporality),
+		PromotedPathsMap:   make(map[string]struct{}),
+		LogsJSONIndexesMap: make(map[string][]schemamigrator.Index),
 	}
 }
 
@@ -284,3 +289,21 @@ func (m *MockMetadataStore) FetchTemporalityMulti(ctx context.Context, metricNam
 func (m *MockMetadataStore) SetTemporality(metricName string, temporality metrictypes.Temporality) {
 	m.TemporalityMap[metricName] = temporality
 }
+
+// PromotePaths promotes the paths.
+func (m *MockMetadataStore) PromotePaths(ctx context.Context, paths ...string) error {
+	for _, path := range paths {
+		m.PromotedPathsMap[path] = struct{}{}
+	}
+	return nil
+}
+
+// ListPromotedPaths lists the promoted paths.
+func (m *MockMetadataStore) ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error) {
+	return m.PromotedPathsMap, nil
+}
+
+// ListLogsJSONIndexes lists the JSON indexes for the logs table.
+func (m *MockMetadataStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
+	return m.LogsJSONIndexesMap, nil
+}

tests/integration/src/dashboard/a_public_dashboard.py

@@ -101,3 +101,145 @@ def test_create_and_get_public_dashboard(
         )
         tuple_row = tuple_result.fetchone()
         assert tuple_row is not None
+
+
+def test_public_dashboard_widget_query_range(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    dashboard_req = {
+        "title": "Test Widget Query Range Dashboard",
+        "description": "For testing widget query range",
+        "version": "v5",
+        "widgets": [
+            {
+                "id": "6990c9d8-57ad-492f-8c63-039081e30d02",
+                "panelTypes": "graph",
+                "query": {
+                    "builder": {
+                        "queryData": [
+                            {
+                                "aggregations": [
+                                    {
+                                        "metricName": "container.cpu.time",
+                                        "reduceTo": "avg",
+                                        "spaceAggregation": "sum",
+                                        "temporality": "",
+                                        "timeAggregation": "rate",
+                                    }
+                                ],
+                                "dataSource": "metrics",
+                                "disabled": False,
+                                "expression": "A",
+                                "filter": {
+                                    "expression": ""
+                                },
+                                "functions": [],
+                                "groupBy": [],
+                                "having": {
+                                    "expression": ""
+                                },
+                                "legend": "",
+                                "limit": 10,
+                                "orderBy": [],
+                                "queryName": "A",
+                                "source": "",
+                                "stepInterval": 10
+                            }
+                        ],
+                        "queryFormulas": [],
+                        "queryTraceOperator": []
+                    },
+                    "clickhouse_sql": [
+                        {
+                            "disabled": False,
+                            "legend": "",
+                            "name": "A",
+                            "query": ""
+                        }
+                    ],
+                    "id": "80f12506-ef72-4013-8282-2713c8114c9e",
+                    "promql": [
+                        {
+                            "disabled": False,
+                            "legend": "",
+                            "name": "A",
+                            "query": ""
+                        }
+                    ],
+                    "queryType": "builder"
+                },
+            }
+        ],
+    }
+    create_response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/dashboards"),
+        json=dashboard_req,
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+    assert create_response.status_code == HTTPStatus.CREATED
+    data = create_response.json()["data"]
+    dashboard_id = data["id"]
+
+
+    # create public dashboard
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(
+            f"/api/v1/dashboards/{dashboard_id}/public"
+        ),
+        json={
+            "timeRangeEnabled": False,
+            "defaultTimeRange": "10s",
+        },
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+
+    assert response.status_code == HTTPStatus.CREATED
+    assert "id" in response.json()["data"]
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(
+            f"/api/v1/dashboards/{dashboard_id}/public"
+        ),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["status"] == "success"
+    public_path = response.json()["data"]["publicPath"]
+    public_dashboard_id = public_path.split("/public/dashboard/")[-1] 
+
+    
+    
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/0/query_range"
+        ),
+        timeout=2,
+    )
+    print(resp.json())
+    assert resp.status_code == HTTPStatus.OK
+    assert resp.json().get("status") == "success"
+
+    
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/-1/query_range"
+        ),
+        timeout=2,
+    )
+    assert resp.status_code == HTTPStatus.BAD_REQUEST
+
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/1/query_range"
+        ),
+        timeout=2,
+    )
+    assert resp.status_code == HTTPStatus.BAD_REQUEST