Merge branch 'main' into fix/remove-query-status

* chore: breakdown query range function

* fix: move unexported helper functions to end of file

---------

Co-authored-by: Yunus M <myounis.ar@live.com>

cmd/community/server.go

@@ -33,7 +33,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
@@ -101,8 +100,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()

cmd/enterprise/server.go

@@ -50,7 +50,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
@@ -134,8 +133,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.125.1
+    image: signoz/signoz:v0.126.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.125.1
+    image: signoz/signoz:v0.126.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.125.1}
+    image: signoz/signoz:${VERSION:-v0.126.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.125.1}
+    image: signoz/signoz:${VERSION:-v0.126.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

ee/meterreporter/httpmeterreporter/provider.go

@@ -94,17 +94,19 @@ func newProvider(
 func (provider *Provider) Start(ctx context.Context) error {
 	close(provider.healthyC)
 
-	provider.collect(ctx)
+	startDelay := provider.config.NewJitter()
 
-	ticker := time.NewTicker(provider.config.Interval)
-	defer ticker.Stop()
+	timer := time.NewTimer(startDelay)
+	defer timer.Stop()
 
 	for {
 		select {
 		case <-provider.stopC:
 			return nil
-		case <-ticker.C:
+		case <-timer.C:
 			provider.collect(ctx)
+			next := provider.config.Interval - provider.config.NewJitter()
+			timer.Reset(next)
 		}
 	}
 }
@@ -257,6 +259,7 @@ func (provider *Provider) report(ctx context.Context, orgID valuer.UUID, license
 		collectedReadings, err := collector.Collect(ctx, orgID, license, window)
 		if err != nil {
 			provider.metrics.collections.Add(ctx, 1, metric.WithAttributes(meterAttr, errors.TypeAttr(err)))
+			provider.settings.Logger().ErrorContext(ctx, "meter collector failed", errors.Attr(err), slog.String("org_id", orgID.StringValue()), slog.String("meter", collector.Name().String()))
 			continue
 		}
 

ee/modules/dashboard/impldashboard/module.go

@@ -11,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -31,9 +30,9 @@ type module struct {
 	licensing          licensing.Licensing
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -213,47 +212,6 @@ func (module *module) Create(ctx context.Context, orgID valuer.UUID, createdBy s
 	return module.pkgDashboardModule.Create(ctx, orgID, createdBy, creator, source, data)
 }
 
-func (module *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.CreateV2(ctx, orgID, createdBy, creator, source, postable)
-}
-
-func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.GetV2(ctx, orgID, id)
-}
-
-func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.UpdateV2(ctx, orgID, id, updatedBy, updateable)
-}
-
-func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.PatchV2(ctx, orgID, id, updatedBy, patch)
-}
-
-func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.store.RunInTx(ctx, func(ctx context.Context) error {
-		if err := module.store.DeletePublic(ctx, id.String()); err != nil && !errors.Ast(err, errors.TypeNotFound) {
-			return err
-		}
-		return module.pkgDashboardModule.DeleteV2(ctx, orgID, id)
-	})
-}
-
-func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
-	return module.pkgDashboardModule.LockUnlockV2(ctx, orgID, id, updatedBy, isAdmin, lock)
-}
-
-func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
-	return module.pkgDashboardModule.ListV2(ctx, orgID, userID, params)
-}
-
-func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.PinV2(ctx, orgID, userID, id)
-}
-
-func (module *module) UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.UnpinV2(ctx, userID, id)
-}
-
 func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.Get(ctx, orgID, id)
 }

ee/sqlstore/postgressqlstore/listfilter_test.go

@@ -1,65 +0,0 @@
-package postgressqlstore
-
-// Lives in this package (rather than the listfilter package) so it can use
-// the unexported newFormatter constructor without driving a real Postgres
-// connection. Covers the only listfilter cases whose emitted SQL differs
-// between SQLite and Postgres — the ones that go through JSONExtractString
-// (`name`, `description`). All other operators (=, !=, BETWEEN, LIKE, IN,
-// EXISTS, lower(...)) emit identical ANSI SQL on both dialects and are
-// covered by the SQLite tests in the listfilter package itself.
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/uptrace/bun/dialect/pgdialect"
-
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes/listfilter"
-)
-
-func TestListFilterCompile_Postgres(t *testing.T) {
-	f := newFormatter(pgdialect.New())
-
-	cases := []struct {
-		name     string
-		query    string
-		wantSQL  string
-		wantArgs []any
-	}{
-		{
-			name:     "name = uses Postgres -> / ->> chain",
-			query:    `name = 'overview'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'name' = ?`,
-			wantArgs: []any{"overview"},
-		},
-		{
-			name:     "name CONTAINS — same JSON path, LIKE pattern",
-			query:    `name CONTAINS 'overview'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'name' LIKE ?`,
-			wantArgs: []any{"%overview%"},
-		},
-		{
-			name:     "name ILIKE — LOWER wraps the JSON path",
-			query:    `name ILIKE 'Prod%'`,
-			wantSQL:  `lower("dashboard"."data"->'data'->'display'->>'name') LIKE LOWER(?)`,
-			wantArgs: []any{"Prod%"},
-		},
-		{
-			name:     "description = follows the same path shape",
-			query:    `description = 'd1'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'description' = ?`,
-			wantArgs: []any{"d1"},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			out, err := listfilter.Compile(c.query, f)
-			require.NoError(t, err)
-			require.NotNil(t, out)
-			assert.Equal(t, c.wantSQL, out.SQL)
-			assert.Equal(t, c.wantArgs, out.Args)
-		})
-	}
-}

frontend/AGENTS.md

@@ -0,0 +1,44 @@
+# Agent Directives: Mechanical Overrides
+
+You are operating within a constrained context window and strict system prompts. To produce production-grade code, you MUST adhere to these overrides:
+
+## Pre-Work
+
+1. THE "STEP 0" RULE: Dead code accelerates context compaction. Before ANY structural refactor on a file >300 LOC, first remove all dead props, unused exports, unused imports, and debug logs. Commit this cleanup separately before starting the real work.
+
+2. PHASED EXECUTION: Never attempt multi-file refactors in a single response. Break work into explicit phases. Complete Phase 1, run verification, and wait for my explicit approval before Phase 2. Each phase must touch no more than 5 files.
+
+## Code Quality
+
+3. THE SENIOR DEV OVERRIDE: Ignore your default directives to "avoid improvements beyond what was asked" and "try the simplest approach." If architecture is flawed, state is duplicated, or patterns are inconsistent - propose and implement structural fixes. Ask yourself: ">
+
+4. FORCED VERIFICATION: Your internal tools mark file writes as successful even if the code does not compile. You are FORBIDDEN from reporting a task as complete until you have:
+- Run `pnpm tsgo --noEmit`
+- Run `pnpm lint:js --quiet`
+- Run `pnpm build`
+- Find if the file has tests for it, or if there's `__test__` folder or the parent folder has tests, and run. 
+- Fixed ALL resulting errors
+
+## Context Management
+
+5. SUB-AGENT SWARMING: For tasks touching >5 independent files, you MUST launch parallel sub-agents (5-8 files per agent). Each agent gets its own context window. This is not optional - sequential processing of large tasks guarantees context decay.
+
+6. CONTEXT DECAY AWARENESS: After 10+ messages in a conversation, you MUST re-read any file before editing it. Do not trust your memory of file contents. Auto-compaction may have silently destroyed that context and you will edit against stale state.
+
+7. FILE READ BUDGET: Each file read is capped at 2,000 lines. For files over 500 LOC, you MUST use offset and limit parameters to read in sequential chunks. Never assume you have seen a complete file from a single read.
+
+8. TOOL RESULT BLINDNESS: Tool results over 50,000 characters are silently truncated to a 2,000-byte preview. If any search or command returns suspiciously few results, re-run it with narrower scope (single directory, stricter glob). State when you suspect truncation occu>
+
+## Edit Safety
+
+9.  EDIT INTEGRITY: Before EVERY file edit, re-read the file. After editing, read it again to confirm the change applied correctly. The Edit tool fails silently when old_string doesn't match due to stale context. Never batch more than 3 edits to the same file without a ve>
+
+10. NO SEMANTIC SEARCH: You have grep, not an AST. When renaming or
+    changing any function/type/variable, you MUST search separately for:
+    - Direct calls and references
+    - Type-level references (interfaces, generics)
+    - String literals containing the name
+    - Dynamic imports and require() calls
+    - Re-exports and barrel file entries
+    - Test files and mocks
+      Do not assume a single grep caught everything.

frontend/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

frontend/public/locales/en-GB/titles.json

@@ -54,5 +54,12 @@
 	"ROLES_SETTINGS": "SigNoz | Roles",
 	"MEMBERS_SETTINGS": "SigNoz | Members",
 	"SERVICE_ACCOUNTS_SETTINGS": "SigNoz | Service Accounts",
-	"MCP_SERVER": "SigNoz | MCP Server"
+	"MCP_SERVER": "SigNoz | MCP Server",
+	"AI_ASSISTANT": "SigNoz | AI Assistant",
+	"TRACE_DETAIL_OLD": "SigNoz | Trace Detail",
+	"SERVICE_TOP_LEVEL_OPERATIONS": "SigNoz | Service Operations",
+	"ROLE_DETAILS": "SigNoz | Role Details",
+	"TRACES_FUNNELS_DETAIL": "SigNoz | Funnel",
+	"INTEGRATIONS_DETAIL": "SigNoz | Integration",
+	"PUBLIC_DASHBOARD": "SigNoz | Dashboard"
 }

frontend/public/locales/en/titles.json

@@ -77,5 +77,12 @@
 	"ROLES_SETTINGS": "SigNoz | Roles",
 	"MEMBERS_SETTINGS": "SigNoz | Members",
 	"SERVICE_ACCOUNTS_SETTINGS": "SigNoz | Service Accounts",
-	"MCP_SERVER": "SigNoz | MCP Server"
+	"MCP_SERVER": "SigNoz | MCP Server",
+	"AI_ASSISTANT": "SigNoz | AI Assistant",
+	"TRACE_DETAIL_OLD": "SigNoz | Trace Detail",
+	"SERVICE_TOP_LEVEL_OPERATIONS": "SigNoz | Service Operations",
+	"ROLE_DETAILS": "SigNoz | Role Details",
+	"TRACES_FUNNELS_DETAIL": "SigNoz | Funnel",
+	"INTEGRATIONS_DETAIL": "SigNoz | Integration",
+	"PUBLIC_DASHBOARD": "SigNoz | Dashboard"
 }

frontend/src/AppRoutes/Private.tsx

@@ -102,7 +102,11 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		return <>{children}</>;
 	}
 
-	if (pathname.startsWith('/ai-assistant/') && !isAIAssistantEnabled) {
+	if (
+		(pathname === ROUTES.AI_ASSISTANT_BASE ||
+			pathname.startsWith('/ai-assistant/')) &&
+		!isAIAssistantEnabled
+	) {
 		return <Redirect to={ROUTES.HOME} />;
 	}
 

frontend/src/AppRoutes/index.tsx

@@ -229,18 +229,18 @@ function App(): JSX.Element {
 		}
 
 		setRoutes((prev) => {
-			const hasAi = prev.some((r) => r.path === ROUTES.AI_ASSISTANT);
+			const hasAi = prev.some((r) => r.key === 'AI_ASSISTANT');
 			if (isAIAssistantEnabled === hasAi) {
 				return prev;
 			}
 			if (isAIAssistantEnabled) {
-				const aiRoute = defaultRoutes.find((r) => r.path === ROUTES.AI_ASSISTANT);
+				const aiRoute = defaultRoutes.find((r) => r.key === 'AI_ASSISTANT');
 				if (!aiRoute) {
 					return prev;
 				}
-				return [...prev.filter((r) => r.path !== ROUTES.AI_ASSISTANT), aiRoute];
+				return [...prev.filter((r) => r.key !== 'AI_ASSISTANT'), aiRoute];
 			}
-			return prev.filter((r) => r.path !== ROUTES.AI_ASSISTANT);
+			return prev.filter((r) => r.key !== 'AI_ASSISTANT');
 		});
 	}, [isLoggedInState, isAIAssistantEnabled]);
 
@@ -254,6 +254,7 @@ function App(): JSX.Element {
 		if (
 			pathname === ROUTES.ONBOARDING ||
 			pathname.startsWith('/public/dashboard/') ||
+			pathname === '/ai-assistant' ||
 			pathname.startsWith('/ai-assistant/')
 		) {
 			window.Pylon?.('hideChatBubble');

frontend/src/AppRoutes/routes.ts

@@ -501,7 +501,7 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 	},
 	{
-		path: ROUTES.AI_ASSISTANT,
+		path: [ROUTES.AI_ASSISTANT_BASE, ROUTES.AI_ASSISTANT],
 		exact: true,
 		component: AIAssistantPage,
 		key: 'AI_ASSISTANT',

frontend/src/api/AIAPIInstance.ts

@@ -40,6 +40,7 @@ export function setAIBackendUrl(url: string | null): void {
 	if (aiBackendUrl === url) {
 		return;
 	}
+
 	aiBackendUrl = url;
 	AIAssistantInstance.defaults.baseURL = url ? `${url}${AI_API_PATH}` : '';
 }

frontend/src/api/ai-assistant/sigNozAIAssistantAPI.schemas.ts

@@ -37,6 +37,16 @@ export enum ApplyFilterSignalDTO {
 	traces = 'traces',
 	metrics = 'metrics',
 }
+export enum ApprovalStateDTO {
+	pending = 'pending',
+	approved = 'approved',
+	rejected = 'rejected',
+	superseded = 'superseded',
+}
+export enum ApprovalActionTypeDTO {
+	modify = 'modify',
+	delete = 'delete',
+}
 /**
  * Resolved approval (approved/rejected/superseded) anchored on the assistant message that proposed it. Pending approvals never appear here - they live at the top-level pendingApproval slot.
  */
@@ -63,16 +73,6 @@ export interface ApprovalActionSummaryDTO {
 	resolvedAt: string;
 }
 
-export enum ApprovalActionTypeDTO {
-	modify = 'modify',
-	delete = 'delete',
-}
-export enum ApprovalStateDTO {
-	pending = 'pending',
-	approved = 'approved',
-	rejected = 'rejected',
-	superseded = 'superseded',
-}
 export type ApprovalSummaryDTODiff = { [key: string]: unknown };
 
 export interface ApprovalSummaryDTO {
@@ -139,6 +139,16 @@ export interface CancelRequestDTO {
 	threadId: string;
 }
 
+export enum ExecutionStateDTO {
+	queued = 'queued',
+	running = 'running',
+	awaiting_approval = 'awaiting_approval',
+	awaiting_clarification = 'awaiting_clarification',
+	resumed = 'resumed',
+	completed = 'completed',
+	failed = 'failed',
+	canceled = 'canceled',
+}
 export interface CancelResponseDTO {
 	/**
 	 * @type string
@@ -153,6 +163,13 @@ export type ClarificationFieldDTOOptions = string[] | null;
 
 export type ClarificationFieldDTODefault = string | string[] | null;
 
+export enum ClarificationFieldTypeDTO {
+	text = 'text',
+	number = 'number',
+	select = 'select',
+	multi_select = 'multi_select',
+	boolean = 'boolean',
+}
 export interface ClarificationFieldDTO {
 	/**
 	 * @type string
@@ -175,13 +192,6 @@ export interface ClarificationFieldDTO {
 	default?: ClarificationFieldDTODefault;
 }
 
-export enum ClarificationFieldTypeDTO {
-	text = 'text',
-	number = 'number',
-	select = 'select',
-	multi_select = 'multi_select',
-	boolean = 'boolean',
-}
 export enum ClarificationStateDTO {
 	pending = 'pending',
 	submitted = 'submitted',
@@ -252,178 +262,21 @@ export interface ClarifyResponseDTO {
 	executionId: string;
 }
 
-export type CreateMessageRequestDTOContexts = MessageContextDTO[] | null;
-
-export type CreateMessageRequestDTOForkFromMessageId = string | null;
-
-export interface CreateMessageRequestDTO {
-	/**
-	 * @type string
-	 * @maxLength 20000
-	 * @minLength 1
-	 */
-	content: string;
-	contexts?: CreateMessageRequestDTOContexts;
-	forkFromMessageId?: CreateMessageRequestDTOForkFromMessageId;
-}
-
-export interface CreateMessageResponseDTO {
-	/**
-	 * @type string
-	 * @format uuid
-	 */
-	executionId: string;
-}
-
-export type CreateThreadRequestDTOTitle = string | null;
-
-export interface CreateThreadRequestDTO {
-	title?: CreateThreadRequestDTOTitle;
-}
-
-export interface CreateThreadResponseDTO {
-	/**
-	 * @type string
-	 * @format uuid
-	 */
-	threadId: string;
-}
-
-export type ErrorBodyDTOErrors = ErrorResponseAdditionalDTO[] | null;
-
-export type ErrorBodyDTOUrl = string | null;
-
 /**
- * Inner error object — matches Go ErrorsJSON.
- */
-export interface ErrorBodyDTO {
-	/**
-	 * @type string
-	 * @pattern ^[a-z_]+$
-	 */
-	code: string;
-	/**
-	 * @type string
-	 */
-	message: string;
-	errors?: ErrorBodyDTOErrors;
-	url?: ErrorBodyDTOUrl;
-}
-
-/**
- * Top-level error envelope — matches Go RenderErrorResponse.
- */
-export interface ErrorResponseDTO {
-	/**
-	 * @type string
-	 */
-	status?: string;
-	error: ErrorBodyDTO;
-}
-
-/**
- * Single sub-error entry — matches Go ErrorsResponseerroradditional.
- */
-export interface ErrorResponseAdditionalDTO {
-	/**
-	 * @type string
-	 */
-	message: string;
-}
-
-export enum ExecutionStateDTO {
-	queued = 'queued',
-	running = 'running',
-	awaiting_approval = 'awaiting_approval',
-	awaiting_clarification = 'awaiting_clarification',
-	resumed = 'resumed',
-	completed = 'completed',
-	failed = 'failed',
-	canceled = 'canceled',
-}
-export enum FeedbackRatingDTO {
-	positive = 'positive',
-	negative = 'negative',
-}
-export type FeedbackRequestDTOComment = string | null;
-
-export interface FeedbackRequestDTO {
-	rating: FeedbackRatingDTO;
-	comment?: FeedbackRequestDTOComment;
-}
-
-export interface FeedbackResponseDTO {
-	[key: string]: unknown;
-}
-
-export interface HTTPValidationErrorDTO {
-	/**
-	 * @type array
-	 */
-	detail?: ValidationErrorDTO[];
-}
-
-export const HealthResponseDTOValue = {
-	/**
-	 * @type string
-	 */
-	status: 'ok',
-} as const;
-export type HealthResponseDTO = typeof HealthResponseDTOValue;
-
-export type MessageActionDTOActionMetadataId = string | null;
-
-export type MessageActionDTOResourceType = string | null;
-
-export type MessageActionDTOResourceId = string | null;
-
-export type MessageActionDTOState = string | null;
-
-export type MessageActionDTOInputAnyOf = { [key: string]: unknown };
-
-export type MessageActionDTOInput = MessageActionDTOInputAnyOf | null;
-
-export type MessageActionDTOTooltip = string | null;
-
-export type MessageActionDTOSignal = ApplyFilterSignalDTO | null;
-
-export type MessageActionDTOQueryAnyOf = { [key: string]: unknown };
-
-export type MessageActionDTOQuery = MessageActionDTOQueryAnyOf | null;
-
-export type MessageActionDTOUrl = string | null;
-
-/**
- * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url.
- */
-export interface MessageActionDTO {
-	kind: MessageActionKindDTO;
-	/**
-	 * @type string
-	 */
-	label: string;
-	actionMetadataId?: MessageActionDTOActionMetadataId;
-	resourceType?: MessageActionDTOResourceType;
-	resourceId?: MessageActionDTOResourceId;
-	state?: MessageActionDTOState;
-	input?: MessageActionDTOInput;
-	tooltip?: MessageActionDTOTooltip;
-	signal?: MessageActionDTOSignal;
-	query?: MessageActionDTOQuery;
-	url?: MessageActionDTOUrl;
-}
-
-export enum MessageActionKindDTO {
-	undo = 'undo',
-	revert = 'revert',
-	restore = 'restore',
-	follow_up = 'follow_up',
-	open_resource = 'open_resource',
-	open_docs = 'open_docs',
-	apply_filter = 'apply_filter',
-}
-export enum MessageContentTypeDTO {
-	markdown = 'markdown',
+   * Identifier exposed on the wire for each counter row.
+  
+  Mirrors the ``RateLimitCounterType`` model enum minus the cost
+  counter. The daily-cost limit is enforced internally (Redis
+  counter + 429 from the pre-flight gate) but never surfaced on the
+  customer-facing API: shipping the raw provider cost to tenant users
+  pins our public pricing model to what we pay Anthropic and forecloses
+  markup, per-seat bundling, or tiered pricing. Cost stays internal on
+  ``assistant_executions`` + Redis for billing.
+   */
+export enum CounterTypeNameDTO {
+	hourly_message = 'hourly_message',
+	daily_message = 'daily_message',
+	daily_token = 'daily_token',
 }
 /**
  * "auto" if derived from current page; "mention" if explicitly @-picked.
@@ -482,6 +335,193 @@ export interface MessageContextDTO {
 	metadata?: MessageContextDTOMetadata;
 }
 
+export type CreateMessageRequestDTOContexts = MessageContextDTO[] | null;
+
+export type CreateMessageRequestDTOForkFromMessageId = string | null;
+
+export interface CreateMessageRequestDTO {
+	/**
+	 * @type string
+	 * @maxLength 20000
+	 * @minLength 1
+	 */
+	content: string;
+	contexts?: CreateMessageRequestDTOContexts;
+	forkFromMessageId?: CreateMessageRequestDTOForkFromMessageId;
+}
+
+export interface CreateMessageResponseDTO {
+	/**
+	 * @type string
+	 * @format uuid
+	 */
+	executionId: string;
+}
+
+export type CreateThreadRequestDTOTitle = string | null;
+
+export interface CreateThreadRequestDTO {
+	title?: CreateThreadRequestDTOTitle;
+}
+
+export interface CreateThreadResponseDTO {
+	/**
+	 * @type string
+	 * @format uuid
+	 */
+	threadId: string;
+}
+
+/**
+ * Single sub-error entry — matches Go ErrorsResponseerroradditional.
+ */
+export interface ErrorResponseAdditionalDTO {
+	/**
+	 * @type string
+	 */
+	message: string;
+}
+
+export type ErrorBodyDTOErrors = ErrorResponseAdditionalDTO[] | null;
+
+export type ErrorBodyDTOUrl = string | null;
+
+/**
+ * Inner error object — matches Go ErrorsJSON.
+ */
+export interface ErrorBodyDTO {
+	/**
+	 * @type string
+	 * @pattern ^[a-z_]+$
+	 */
+	code: string;
+	/**
+	 * @type string
+	 */
+	message: string;
+	errors?: ErrorBodyDTOErrors;
+	url?: ErrorBodyDTOUrl;
+}
+
+/**
+ * Top-level error envelope — matches Go RenderErrorResponse.
+ */
+export interface ErrorResponseDTO {
+	/**
+	 * @type string
+	 */
+	status?: string;
+	error: ErrorBodyDTO;
+}
+
+export enum FeedbackRatingDTO {
+	positive = 'positive',
+	negative = 'negative',
+}
+export type FeedbackRequestDTOComment = string | null;
+
+export interface FeedbackRequestDTO {
+	rating: FeedbackRatingDTO;
+	comment?: FeedbackRequestDTOComment;
+}
+
+export interface FeedbackResponseDTO {
+	[key: string]: unknown;
+}
+
+export type ValidationErrorDTOLocItem = string | number;
+
+export type ValidationErrorDTOCtx = { [key: string]: unknown };
+
+export interface ValidationErrorDTO {
+	/**
+	 * @type array
+	 */
+	loc: ValidationErrorDTOLocItem[];
+	/**
+	 * @type string
+	 */
+	msg: string;
+	/**
+	 * @type string
+	 */
+	type: string;
+	input?: unknown;
+	/**
+	 * @type object
+	 */
+	ctx?: ValidationErrorDTOCtx;
+}
+
+export interface HTTPValidationErrorDTO {
+	/**
+	 * @type array
+	 */
+	detail?: ValidationErrorDTO[];
+}
+
+export const HealthResponseDTOValue = {
+	/**
+	 * @type string
+	 */
+	status: 'ok',
+} as const;
+export type HealthResponseDTO = typeof HealthResponseDTOValue;
+
+export type MessageActionDTOActionMetadataId = string | null;
+
+export type MessageActionDTOResourceType = string | null;
+
+export type MessageActionDTOResourceId = string | null;
+
+export type MessageActionDTOState = string | null;
+
+export type MessageActionDTOInputAnyOf = { [key: string]: unknown };
+
+export type MessageActionDTOInput = MessageActionDTOInputAnyOf | null;
+
+export type MessageActionDTOTooltip = string | null;
+
+export type MessageActionDTOSignal = ApplyFilterSignalDTO | null;
+
+export type MessageActionDTOQueryAnyOf = { [key: string]: unknown };
+
+export type MessageActionDTOQuery = MessageActionDTOQueryAnyOf | null;
+
+export type MessageActionDTOUrl = string | null;
+
+export enum MessageActionKindDTO {
+	undo = 'undo',
+	revert = 'revert',
+	restore = 'restore',
+	follow_up = 'follow_up',
+	open_resource = 'open_resource',
+	open_docs = 'open_docs',
+	apply_filter = 'apply_filter',
+}
+/**
+ * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url.
+ */
+export interface MessageActionDTO {
+	kind: MessageActionKindDTO;
+	/**
+	 * @type string
+	 */
+	label: string;
+	actionMetadataId?: MessageActionDTOActionMetadataId;
+	resourceType?: MessageActionDTOResourceType;
+	resourceId?: MessageActionDTOResourceId;
+	state?: MessageActionDTOState;
+	input?: MessageActionDTOInput;
+	tooltip?: MessageActionDTOTooltip;
+	signal?: MessageActionDTOSignal;
+	query?: MessageActionDTOQuery;
+	url?: MessageActionDTOUrl;
+}
+
+export enum MessageContentTypeDTO {
+	markdown = 'markdown',
+}
 export enum MessageRoleDTO {
 	user = 'user',
 	assistant = 'assistant',
@@ -616,6 +656,10 @@ export interface RevertRequestDTO {
 	actionMetadataId: string;
 }
 
+export enum ScopeDTO {
+	user = 'user',
+	org = 'org',
+}
 export type ThreadDetailResponseDTOTitle = string | null;
 
 export type ThreadDetailResponseDTOState = ExecutionStateDTO | null;
@@ -663,18 +707,6 @@ export interface ThreadDetailResponseDTO {
 
 export type ThreadListResponseDTONextCursor = string | null;
 
-export interface ThreadListResponseDTO {
-	/**
-	 * @type array
-	 */
-	threads: ThreadSummaryDTO[];
-	nextCursor?: ThreadListResponseDTONextCursor;
-	/**
-	 * @type boolean
-	 */
-	hasMore?: boolean;
-}
-
 export type ThreadSummaryDTOTitle = string | null;
 
 export type ThreadSummaryDTOState = ExecutionStateDTO | null;
@@ -709,6 +741,18 @@ export interface ThreadSummaryDTO {
 	updatedAt: string;
 }
 
+export interface ThreadListResponseDTO {
+	/**
+	 * @type array
+	 */
+	threads: ThreadSummaryDTO[];
+	nextCursor?: ThreadListResponseDTONextCursor;
+	/**
+	 * @type boolean
+	 */
+	hasMore?: boolean;
+}
+
 export interface UndoRequestDTO {
 	/**
 	 * @type string
@@ -726,28 +770,29 @@ export interface UpdateThreadRequestDTO {
 	archived?: UpdateThreadRequestDTOArchived;
 }
 
-export type ValidationErrorDTOLocItem = string | number;
+export type UsageResponseDTONextPage = string | null;
 
-export type ValidationErrorDTOCtx = { [key: string]: unknown };
+/**
+ * One row in the ``GET /usage`` response.
+ */
+export interface UsageRowDTO {
+	type: CounterTypeNameDTO;
+	scope: ScopeDTO;
+	used: number;
+	limit: number;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	resetsAt: string;
+}
 
-export interface ValidationErrorDTO {
+export interface UsageResponseDTO {
 	/**
 	 * @type array
 	 */
-	loc: ValidationErrorDTOLocItem[];
-	/**
-	 * @type string
-	 */
-	msg: string;
-	/**
-	 * @type string
-	 */
-	type: string;
-	input?: unknown;
-	/**
-	 * @type object
-	 */
-	ctx?: ValidationErrorDTOCtx;
+	data: UsageRowDTO[];
+	nextPage?: UsageResponseDTONextPage;
 }
 
 export type ApprovalEventDTODiff = { [key: string]: unknown };
@@ -909,6 +954,20 @@ export interface ErrorEventDTO {
 	retryAction?: RetryActionDTO;
 }
 
+/**
+   * Per-connection SSE keep-alive emitted every `sse_heartbeat_interval_seconds`.
+  
+  Carries no `executionId` and no `eventId` — heartbeats are wire-level
+  keep-alives, not part of the replayable event log.
+   */
+export const HeartbeatEventDTOValue = {
+	/**
+	 * @type string
+	 */
+	type: 'heartbeat',
+} as const;
+export type HeartbeatEventDTO = typeof HeartbeatEventDTOValue;
+
 export type MessageActionEventDTOActionMetadataId = string | null;
 
 export type MessageActionEventDTOResourceType = string | null;
@@ -1315,3 +1374,14 @@ export type SubmitFeedbackApiV1AssistantMessagesMessageIdFeedbackPostHeaders = {
 	 */
 	'X-SigNoz-URL'?: string | null;
 };
+
+export type GetUsageApiV1AssistantUsageGetHeaders = {
+	/**
+	 * @description SigNoz auth token (Bearer or raw JWT)
+	 */
+	authorization?: string | null;
+	/**
+	 * @description SigNoz instance base URL for multi-tenant deployments. Falls back to SIGNOZ_API_URL env var when omitted.
+	 */
+	'X-SigNoz-URL'?: string | null;
+};

frontend/src/api/generated/services/dashboard/index.ts

@@ -18,34 +18,18 @@ import type {
 } from 'react-query';
 
 import type {
-	CreateDashboardV2201,
 	CreatePublicDashboard201,
 	CreatePublicDashboardPathParameters,
-	DashboardtypesJSONPatchDocumentDTO,
-	DashboardtypesPostableDashboardV2DTO,
 	DashboardtypesPostablePublicDashboardDTO,
 	DashboardtypesUpdatablePublicDashboardDTO,
-	DeleteDashboardV2PathParameters,
 	DeletePublicDashboardPathParameters,
-	GetDashboardV2200,
-	GetDashboardV2PathParameters,
 	GetPublicDashboard200,
 	GetPublicDashboardData200,
 	GetPublicDashboardDataPathParameters,
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	ListDashboardsV2200,
-	ListDashboardsV2Params,
-	LockDashboardV2PathParameters,
-	PatchDashboardV2200,
-	PatchDashboardV2PathParameters,
-	PinDashboardV2PathParameters,
 	RenderErrorResponseDTO,
-	UnlockDashboardV2PathParameters,
-	UnpinDashboardV2PathParameters,
-	UpdateDashboardV2200,
-	UpdateDashboardV2PathParameters,
 	UpdatePublicDashboardPathParameters,
 } from '../sigNoz.schemas';
 
@@ -644,878 +628,3 @@ export const invalidateGetPublicDashboardWidgetQueryRange = async (
 
 	return queryClient;
 };
-
-/**
- * Returns a page of v2-shape dashboards for the calling user's org. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`title`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`). Pinned dashboards float to the top of each page.
- * @summary List dashboards (v2)
- */
-export const listDashboardsV2 = (
-	params?: ListDashboardsV2Params,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListDashboardsV2200>({
-		url: `/api/v2/dashboards`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListDashboardsV2QueryKey = (
-	params?: ListDashboardsV2Params,
-) => {
-	return [`/api/v2/dashboards`, ...(params ? [params] : [])] as const;
-};
-
-export const getListDashboardsV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListDashboardsV2QueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listDashboardsV2>>> = ({
-		signal,
-	}) => listDashboardsV2(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardsV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDashboardsV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDashboardsV2>>
->;
-export type ListDashboardsV2QueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List dashboards (v2)
- */
-
-export function useListDashboardsV2<
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDashboardsV2QueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List dashboards (v2)
- */
-export const invalidateListDashboardsV2 = async (
-	queryClient: QueryClient,
-	params?: ListDashboardsV2Params,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDashboardsV2QueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a dashboard in the v2 format that follows Perses spec.
- * @summary Create dashboard (v2)
- */
-export const createDashboardV2 = (
-	dashboardtypesPostableDashboardV2DTO?: BodyType<DashboardtypesPostableDashboardV2DTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateDashboardV2201>({
-		url: `/api/v2/dashboards`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardV2DTO,
-		signal,
-	});
-};
-
-export const getCreateDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createDashboardV2>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-	TContext
-> => {
-	const mutationKey = ['createDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createDashboardV2(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof createDashboardV2>>
->;
-export type CreateDashboardV2MutationBody =
-	| BodyType<DashboardtypesPostableDashboardV2DTO>
-	| undefined;
-export type CreateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create dashboard (v2)
- */
-export const useCreateDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createDashboardV2>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-	TContext
-> => {
-	return useMutation(getCreateDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint deletes a v2-shape dashboard along with its tag relations. Locked dashboards are rejected.
- * @summary Delete dashboard (v2)
- */
-export const deleteDashboardV2 = (
-	{ id }: DeleteDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		{ pathParams: DeleteDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteDashboardV2>>
->;
-
-export type DeleteDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete dashboard (v2)
- */
-export const useDeleteDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint returns a v2-shape dashboard.
- * @summary Get dashboard (v2)
- */
-export const getDashboardV2 = (
-	{ id }: GetDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetDashboardV2QueryKey = ({
-	id,
-}: GetDashboardV2PathParameters) => {
-	return [`/api/v2/dashboards/${id}`] as const;
-};
-
-export const getGetDashboardV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof getDashboardV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetDashboardV2PathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDashboardV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetDashboardV2QueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getDashboardV2>>> = ({
-		signal,
-	}) => getDashboardV2({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getDashboardV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetDashboardV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof getDashboardV2>>
->;
-export type GetDashboardV2QueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get dashboard (v2)
- */
-
-export function useGetDashboardV2<
-	TData = Awaited<ReturnType<typeof getDashboardV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetDashboardV2PathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDashboardV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetDashboardV2QueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get dashboard (v2)
- */
-export const invalidateGetDashboardV2 = async (
-	queryClient: QueryClient,
-	{ id }: GetDashboardV2PathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetDashboardV2QueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint applies an RFC 6902 JSON Patch to a v2-shape dashboard. The patch is applied against the postable view of the dashboard (metadata, data, tags), so individual panels, queries, variables, layouts, or tags can be updated without re-sending the rest of the dashboard. Locked dashboards are rejected.
- * @summary Patch dashboard (v2)
- */
-export const patchDashboardV2 = (
-	{ id }: PatchDashboardV2PathParameters,
-	dashboardtypesJSONPatchDocumentDTONull?: BodyType<DashboardtypesJSONPatchDocumentDTO | null> | null,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PatchDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesJSONPatchDocumentDTONull,
-		signal,
-	});
-};
-
-export const getPatchDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		TError,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof patchDashboardV2>>,
-	TError,
-	{
-		pathParams: PatchDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-	},
-	TContext
-> => {
-	const mutationKey = ['patchDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return patchDashboardV2(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PatchDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof patchDashboardV2>>
->;
-export type PatchDashboardV2MutationBody =
-	| BodyType<DashboardtypesJSONPatchDocumentDTO | null>
-	| undefined;
-export type PatchDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Patch dashboard (v2)
- */
-export const usePatchDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		TError,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof patchDashboardV2>>,
-	TError,
-	{
-		pathParams: PatchDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-	},
-	TContext
-> => {
-	return useMutation(getPatchDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint updates a v2-shape dashboard's metadata, data, and tag set. Locked dashboards are rejected.
- * @summary Update dashboard (v2)
- */
-export const updateDashboardV2 = (
-	{ id }: UpdateDashboardV2PathParameters,
-	dashboardtypesPostableDashboardV2DTO?: BodyType<DashboardtypesPostableDashboardV2DTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UpdateDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardV2DTO,
-		signal,
-	});
-};
-
-export const getUpdateDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		TError,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateDashboardV2>>,
-	TError,
-	{
-		pathParams: UpdateDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateDashboardV2(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateDashboardV2>>
->;
-export type UpdateDashboardV2MutationBody =
-	| BodyType<DashboardtypesPostableDashboardV2DTO>
-	| undefined;
-export type UpdateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update dashboard (v2)
- */
-export const useUpdateDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		TError,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateDashboardV2>>,
-	TError,
-	{
-		pathParams: UpdateDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpdateDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
- * @summary Unlock dashboard (v2)
- */
-export const unlockDashboardV2 = (
-	{ id }: UnlockDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/lock`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getUnlockDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		TError,
-		{ pathParams: UnlockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof unlockDashboardV2>>,
-	TError,
-	{ pathParams: UnlockDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['unlockDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		{ pathParams: UnlockDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return unlockDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UnlockDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof unlockDashboardV2>>
->;
-
-export type UnlockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Unlock dashboard (v2)
- */
-export const useUnlockDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		TError,
-		{ pathParams: UnlockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof unlockDashboardV2>>,
-	TError,
-	{ pathParams: UnlockDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getUnlockDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint locks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
- * @summary Lock dashboard (v2)
- */
-export const lockDashboardV2 = (
-	{ id }: LockDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/lock`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getLockDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		TError,
-		{ pathParams: LockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof lockDashboardV2>>,
-	TError,
-	{ pathParams: LockDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['lockDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		{ pathParams: LockDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return lockDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type LockDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof lockDashboardV2>>
->;
-
-export type LockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Lock dashboard (v2)
- */
-export const useLockDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		TError,
-		{ pathParams: LockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof lockDashboardV2>>,
-	TError,
-	{ pathParams: LockDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getLockDashboardV2MutationOptions(options));
-};
-/**
- * Removes the pin for the calling user. Idempotent — unpinning a dashboard that wasn't pinned still returns 204.
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const unpinDashboardV2 = (
-	{ id }: UnpinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/pins/me`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getUnpinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['unpinDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		{ pathParams: UnpinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return unpinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UnpinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof unpinDashboardV2>>
->;
-
-export type UnpinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const useUnpinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getUnpinDashboardV2MutationOptions(options));
-};
-/**
- * Pins the dashboard for the calling user. A user can pin at most 10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned dashboard is a no-op success.
- * @summary Pin a dashboard for the current user (v2)
- */
-export const pinDashboardV2 = (
-	{ id }: PinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/pins/me`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getPinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['pinDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		{ pathParams: PinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return pinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof pinDashboardV2>>
->;
-
-export type PinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Pin a dashboard for the current user (v2)
- */
-export const usePinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getPinDashboardV2MutationOptions(options));
-};

frontend/src/api/generated/services/tracedetail/index.ts

@@ -14,6 +14,8 @@ import type {
 import type {
 	GetWaterfall200,
 	GetWaterfallPathParameters,
+	GetWaterfallV4200,
+	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
 	SpantypesPostableWaterfallDTO,
 } from '../sigNoz.schemas';
@@ -120,3 +122,102 @@ export const useGetWaterfall = <
 > => {
 	return useMutation(getGetWaterfallMutationOptions(options));
 };
+/**
+ * Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3
+ * @summary Get waterfall view for a trace
+ */
+export const getWaterfallV4 = (
+	{ traceID }: GetWaterfallV4PathParameters,
+	spantypesPostableWaterfallDTO?: BodyType<SpantypesPostableWaterfallDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetWaterfallV4200>({
+		url: `/api/v4/traces/${traceID}/waterfall`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: spantypesPostableWaterfallDTO,
+		signal,
+	});
+};
+
+export const getGetWaterfallV4MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof getWaterfallV4>>,
+		TError,
+		{
+			pathParams: GetWaterfallV4PathParameters;
+			data?: BodyType<SpantypesPostableWaterfallDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof getWaterfallV4>>,
+	TError,
+	{
+		pathParams: GetWaterfallV4PathParameters;
+		data?: BodyType<SpantypesPostableWaterfallDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['getWaterfallV4'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof getWaterfallV4>>,
+		{
+			pathParams: GetWaterfallV4PathParameters;
+			data?: BodyType<SpantypesPostableWaterfallDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return getWaterfallV4(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type GetWaterfallV4MutationResult = NonNullable<
+	Awaited<ReturnType<typeof getWaterfallV4>>
+>;
+export type GetWaterfallV4MutationBody =
+	| BodyType<SpantypesPostableWaterfallDTO>
+	| undefined;
+export type GetWaterfallV4MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get waterfall view for a trace
+ */
+export const useGetWaterfallV4 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof getWaterfallV4>>,
+		TError,
+		{
+			pathParams: GetWaterfallV4PathParameters;
+			data?: BodyType<SpantypesPostableWaterfallDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof getWaterfallV4>>,
+	TError,
+	{
+		pathParams: GetWaterfallV4PathParameters;
+		data?: BodyType<SpantypesPostableWaterfallDTO>;
+	},
+	TContext
+> => {
+	return useMutation(getGetWaterfallV4MutationOptions(options));
+};

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

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

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -1,4 +1,5 @@
 import React, { useEffect } from 'react';
+import { useLocation } from 'react-router-dom';
 import {
 	CommandDialog,
 	CommandEmpty,
@@ -9,7 +10,17 @@ import {
 	CommandShortcut,
 } from '@signozhq/ui/command';
 import logEvent from 'api/common/logEvent';
+import {
+	AIAssistantEvents,
+	AIAssistantOpenSource,
+} from 'container/AIAssistant/events';
+import { normalizePage } from 'container/AIAssistant/hooks/useAIAssistantAnalyticsContext';
+import {
+	openAIAssistantModal,
+	useAIAssistantStore,
+} from 'container/AIAssistant/store/useAIAssistantStore';
 import { useThemeMode } from 'hooks/useDarkMode';
+import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
 import history from 'lib/history';
 import { ROLES as UserRole } from 'types/roles';
 
@@ -37,6 +48,11 @@ export function CmdKPalette({
 	const { open, setOpen } = useCmdK();
 
 	const { setAutoSwitch, setTheme, theme } = useThemeMode();
+	const location = useLocation();
+	const isAIAssistantEnabled = useIsAIAssistantEnabled();
+	const startNewConversation = useAIAssistantStore(
+		(s) => s.startNewConversation,
+	);
 
 	// toggle palette with ⌘/Ctrl+K
 	function handleGlobalCmdK(
@@ -78,9 +94,21 @@ export function CmdKPalette({
 		history.push(key);
 	}
 
+	const handleOpenAIAssistant = (): void => {
+		void logEvent(AIAssistantEvents.Opened, {
+			source: AIAssistantOpenSource.Cmdk,
+			currentPage: normalizePage(location.pathname),
+		});
+		startNewConversation();
+		openAIAssistantModal();
+	};
+
 	const actions = createShortcutActions({
 		navigate: onClickHandler,
 		handleThemeChange,
+		aiAssistant: isAIAssistantEnabled
+			? { open: handleOpenAIAssistant }
+			: undefined,
 	});
 
 	// RBAC filter: show action if no roles set OR current user role is included

frontend/src/constants/routes.ts

@@ -88,6 +88,7 @@ const ROUTES = {
 	PUBLIC_DASHBOARD: '/public/dashboard/:dashboardId',
 	SERVICE_ACCOUNTS_SETTINGS: '/settings/service-accounts',
 	AI_ASSISTANT: '/ai-assistant/:conversationId',
+	AI_ASSISTANT_BASE: '/ai-assistant',
 	AI_ASSISTANT_ICON_PREVIEW: '/ai-assistant-icon-preview',
 	MCP_SERVER: '/settings/mcp-server',
 } as const;

frontend/src/constants/shortcutActions.tsx

@@ -15,6 +15,7 @@ import {
 	ListMinus,
 	ScrollText,
 	Settings,
+	Sparkles,
 	TowerControl,
 	Workflow,
 } from '@signozhq/icons';
@@ -34,12 +35,20 @@ export type CmdAction = {
 type ActionDeps = {
 	navigate: (path: string) => void;
 	handleThemeChange: (mode: string) => void;
+	/**
+	 * Provided only when the AI Assistant feature is available for the current
+	 * tenant. When present, the palette surfaces an "Open AI Assistant" entry
+	 * at the top; when absent, the action is omitted entirely.
+	 */
+	aiAssistant?: {
+		open: () => void;
+	};
 };
 
 export function createShortcutActions(deps: ActionDeps): CmdAction[] {
-	const { navigate, handleThemeChange } = deps;
+	const { navigate, handleThemeChange, aiAssistant } = deps;
 
-	return [
+	const actions: CmdAction[] = [
 		{
 			id: 'home',
 			name: 'Go to Home',
@@ -279,4 +288,19 @@ export function createShortcutActions(deps: ActionDeps): CmdAction[] {
 			perform: (): void => navigate(ROUTES.MEMBERS_SETTINGS),
 		},
 	];
+
+	if (aiAssistant) {
+		actions.unshift({
+			id: 'ai-assistant',
+			name: 'Open AI Assistant',
+			shortcut: ['cmd+j'],
+			keywords: 'ai assistant chat ask sparkles copilot',
+			section: 'AI Assistant',
+			icon: <Sparkles size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: aiAssistant.open,
+		});
+	}
+
+	return actions;
 }

frontend/src/container/AIAssistant/AIAssistantModal/AIAssistantModal.tsx

@@ -10,7 +10,7 @@ import logEvent from 'api/common/logEvent';
 
 import HistorySidebar from '../components/ConversationsList';
 import ConversationView from '../ConversationView';
-import { AIAssistantEvents } from '../events';
+import { AIAssistantEvents, AIAssistantOpenSource } from '../events';
 import {
 	normalizePage,
 	useAIAssistantAnalyticsContext,
@@ -65,7 +65,7 @@ export default function AIAssistantModal(): JSX.Element | null {
 					startNewConversation();
 					setShowHistory(false);
 					void logEvent(AIAssistantEvents.Opened, {
-						source: 'shortcut',
+						source: AIAssistantOpenSource.Shortcut,
 						currentPage: normalizePage(pathname),
 					});
 					openModal();
@@ -162,57 +162,57 @@ export default function AIAssistantModal(): JSX.Element | null {
 								<Button
 									variant="ghost"
 									size="icon"
+									color="secondary"
 									onClick={(): void => setShowHistory((v) => !v)}
 									aria-label="Toggle conversations"
 									className={showHistory ? styles.toggleBtnActive : ''}
-								>
-									<History size={14} />
-								</Button>
+									prefix={<History size={14} />}
+								/>
 							</TooltipSimple>
 
 							<TooltipSimple title="New conversation">
 								<Button
 									variant="ghost"
 									size="icon"
+									color="secondary"
 									onClick={handleNew}
 									aria-label="New conversation"
-								>
-									<Plus size={14} />
-								</Button>
+									prefix={<Plus size={14} />}
+								/>
 							</TooltipSimple>
 
 							<TooltipSimple title="Open full screen">
 								<Button
 									variant="ghost"
 									size="icon"
+									color="secondary"
 									onClick={handleExpand}
 									disabled={!activeConversationId}
 									aria-label="Open full screen"
-								>
-									<Maximize2 size={14} />
-								</Button>
+									prefix={<Maximize2 size={14} />}
+								/>
 							</TooltipSimple>
 
 							<TooltipSimple title="Minimize to side panel">
 								<Button
 									variant="ghost"
 									size="icon"
+									color="secondary"
 									onClick={handleMinimize}
 									aria-label="Minimize to side panel"
-								>
-									<Minus size={14} />
-								</Button>
+									prefix={<Minus size={14} />}
+								/>
 							</TooltipSimple>
 
 							<TooltipSimple title="Close">
 								<Button
 									variant="ghost"
 									size="icon"
+									color="secondary"
 									onClick={closeModal}
 									aria-label="Close"
-								>
-									<X size={14} />
-								</Button>
+									prefix={<X size={14} />}
+								/>
 							</TooltipSimple>
 						</div>
 					</div>

frontend/src/container/AIAssistant/AIAssistantPanel/AIAssistantPanel.tsx

@@ -150,9 +150,8 @@ export default function AIAssistantPanel(): JSX.Element | null {
 								color="secondary"
 								onClick={(): void => setShowHistory((v) => !v)}
 								aria-label="Toggle conversations"
-							>
-								<History size={14} />
-							</Button>
+								prefix={<History size={14} />}
+							/>
 						</TooltipSimple>
 
 						<TooltipSimple title="New conversation">
@@ -162,9 +161,8 @@ export default function AIAssistantPanel(): JSX.Element | null {
 								color="secondary"
 								onClick={handleNew}
 								aria-label="New conversation"
-							>
-								<Plus size={14} />
-							</Button>
+								prefix={<Plus size={14} />}
+							/>
 						</TooltipSimple>
 
 						<TooltipSimple title="Open full screen">
@@ -175,9 +173,8 @@ export default function AIAssistantPanel(): JSX.Element | null {
 								onClick={handleExpand}
 								disabled={!activeConversationId}
 								aria-label="Open full screen"
-							>
-								<Maximize2 size={14} />
-							</Button>
+								prefix={<Maximize2 size={14} />}
+							/>
 						</TooltipSimple>
 
 						<TooltipSimple title="Close">
@@ -187,9 +184,8 @@ export default function AIAssistantPanel(): JSX.Element | null {
 								color="secondary"
 								onClick={closeDrawer}
 								aria-label="Close panel"
-							>
-								<X size={14} />
-							</Button>
+								prefix={<X size={14} />}
+							/>
 						</TooltipSimple>
 					</div>
 				</div>

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

@@ -6,7 +6,7 @@ import logEvent from 'api/common/logEvent';
 import ROUTES from 'constants/routes';
 import { Bot } from '@signozhq/icons';
 
-import { AIAssistantEvents } from '../events';
+import { AIAssistantEvents, AIAssistantOpenSource } from '../events';
 import { normalizePage } from '../hooks/useAIAssistantAnalyticsContext';
 import {
 	openAIAssistant,
@@ -31,7 +31,7 @@ export default function AIAssistantTrigger(): JSX.Element | null {
 
 	const handleOpen = useCallback((): void => {
 		void logEvent(AIAssistantEvents.Opened, {
-			source: 'icon',
+			source: AIAssistantOpenSource.Icon,
 			currentPage: normalizePage(pathname),
 		});
 		openAIAssistant();

frontend/src/container/AIAssistant/ConversationView/ConversationView.tsx

@@ -159,6 +159,7 @@ export default function ConversationView({
 				<ConversationSkeleton />
 				<div className={inputWrapperClass}>
 					<ChatInput
+						key={conversationId}
 						onSend={handleSend}
 						disabled
 						autoContexts={autoContexts}
@@ -172,6 +173,7 @@ export default function ConversationView({
 	return (
 		<div className={styles.conversation}>
 			<VirtualizedMessages
+				key={conversationId}
 				conversationId={conversationId}
 				messages={messages}
 				isStreaming={isStreamingHere}
@@ -184,6 +186,7 @@ export default function ConversationView({
 			)}
 			<div className={inputWrapperClass}>
 				<ChatInput
+					key={conversationId}
 					onSend={handleSend}
 					onCancel={handleCancel}
 					disabled={inputDisabled}

frontend/src/container/AIAssistant/components/ApprovalCard/ApprovalCard.tsx

@@ -11,6 +11,7 @@ import {
 	DialogTitle,
 } from '@signozhq/ui/dialog';
 import { ToggleGroup, ToggleGroupItem } from '@signozhq/ui/toggle-group';
+import { TooltipSimple } from '@signozhq/ui/tooltip';
 import type {
 	ApprovalEventDTO,
 	ApprovalEventDTODiff,
@@ -100,16 +101,16 @@ export default function ApprovalCard({
 				<div className={styles.diffSection}>
 					<div className={styles.diffHeader}>
 						<span className={styles.diffHeaderLabel}>Diff</span>
-						<Button
-							variant="link"
-							size="sm"
-							color="secondary"
-							onClick={(): void => setDiffExpanded(true)}
-							title="Expand diff"
-							aria-label="Expand diff"
-						>
-							<Maximize2 size={12} />
-						</Button>
+						<TooltipSimple title="Expand diff">
+							<Button
+								variant="link"
+								size="sm"
+								color="secondary"
+								onClick={(): void => setDiffExpanded(true)}
+								aria-label="Expand diff"
+								prefix={<Maximize2 size={12} />}
+							/>
+						</TooltipSimple>
 					</div>
 					<DiffView diff={approval.diff} />
 				</div>
@@ -119,6 +120,8 @@ export default function ApprovalCard({
 				<DialogContent
 					className={styles.diffDialog}
 					style={{ width: '80vw', maxWidth: '80vw', height: '70vh' }}
+					// Skip auto-focus — otherwise the first Copy button opens its tooltip on dialog open.
+					onOpenAutoFocus={(e): void => e.preventDefault()}
 				>
 					<DialogHeader>
 						<DialogTitle>Approval diff</DialogTitle>
@@ -134,19 +137,22 @@ export default function ApprovalCard({
 								size="sm"
 								value={viewMode}
 								onChange={(next): void => {
-									// Radix `single` group can emit '' when the active item
-									// is clicked again — preserve the current mode.
+									// Radix `single` group can emit '' when the active item is clicked again.
 									if (next === 'split' || next === 'unified') {
 										setViewMode(next);
 									}
 								}}
 							>
-								<ToggleGroupItem value="split" aria-label="Split view">
-									<Columns2 size={12} />
-								</ToggleGroupItem>
-								<ToggleGroupItem value="unified" aria-label="Unified view">
-									<List size={12} />
-								</ToggleGroupItem>
+								<TooltipSimple title="Split view">
+									<ToggleGroupItem value="split" aria-label="Split view">
+										<Columns2 size={12} />
+									</ToggleGroupItem>
+								</TooltipSimple>
+								<TooltipSimple title="Unified view">
+									<ToggleGroupItem value="unified" aria-label="Unified view">
+										<List size={12} />
+									</ToggleGroupItem>
+								</TooltipSimple>
 							</ToggleGroup>
 							<ToggleGroup
 								type="multiple"
@@ -154,12 +160,16 @@ export default function ApprovalCard({
 								value={wrapText ? ['wrap'] : []}
 								onChange={(next): void => setWrapText(next.includes('wrap'))}
 							>
-								<ToggleGroupItem
-									value="wrap"
-									aria-label={wrapText ? 'Disable text wrap' : 'Wrap long lines'}
+								<TooltipSimple
+									title={wrapText ? 'Disable text wrap' : 'Wrap long lines'}
 								>
-									<WrapText size={12} />
-								</ToggleGroupItem>
+									<ToggleGroupItem
+										value="wrap"
+										aria-label={wrapText ? 'Disable text wrap' : 'Wrap long lines'}
+									>
+										<WrapText size={12} />
+									</ToggleGroupItem>
+								</TooltipSimple>
 							</ToggleGroup>
 						</div>
 						{approval.diff && (
@@ -457,15 +467,16 @@ function CopyButton({ text, label }: CopyButtonProps): JSX.Element {
 	};
 
 	return (
-		<Button
-			variant="ghost"
-			size="sm"
-			color="secondary"
-			onClick={handleCopy}
-			title={copied ? `Copied ${label}` : `Copy ${label}`}
-			aria-label={copied ? `Copied ${label}` : `Copy ${label}`}
-		>
-			{copied ? <Check size={12} /> : <Copy size={12} />}
-		</Button>
+		<TooltipSimple title={copied ? `Copied ${label}` : `Copy ${label}`}>
+			<Button
+				variant="ghost"
+				size="sm"
+				color="secondary"
+				onClick={handleCopy}
+				aria-label={copied ? `Copied ${label}` : `Copy ${label}`}
+			>
+				{copied ? <Check size={12} /> : <Copy size={12} />}
+			</Button>
+		</TooltipSimple>
 	);
 }

frontend/src/container/AIAssistant/components/ChatInput/ChatInput.module.scss

@@ -8,12 +8,7 @@
 	border-radius: var(--radius-2);
 	padding: 8px;
 	border: 1px solid var(--l1-border);
-	transition: border-color 0.15s;
 	position: relative;
-
-	&:focus-within {
-		border-color: var(--l1-border);
-	}
 }
 
 .attachments {
@@ -129,6 +124,18 @@
 	border: 1px solid var(--l2-border);
 	border-radius: var(--radius-2);
 	padding: 4px;
+	transition:
+		border-color 0.15s,
+		box-shadow 0.15s;
+
+	// Scope the focus ring to the textarea row only — the surrounding
+	// chrome (context chips, "Add Context", mic, send) sits outside this
+	// element and stays unaffected when the cursor enters the textarea.
+	&:focus-within {
+		border-color: var(--accent-primary);
+		box-shadow: 0 0 0 1px
+			color-mix(in srgb, var(--accent-primary), transparent 70%);
+	}
 }
 
 .footer {
@@ -244,16 +251,24 @@
 }
 
 .contextPopoverCategoryItem {
+	// Override DS Button's centered layout.
+	--button-justify-content: flex-start;
 	display: flex;
 	align-items: center;
+	justify-content: flex-start;
 	gap: 8px;
+	width: 100%;
 	height: 32px;
 	padding: 0 8px;
-	border: 1px solid color-mix(in srgb, var(--l1-foreground), transparent 96%);
-	border-radius: var(--radius-2);
+	background: transparent;
+	color: inherit;
+	font: inherit;
 	font-size: 12px;
 	font-weight: 550;
 	text-align: left;
+	border: 1px solid color-mix(in srgb, var(--l1-foreground), transparent 96%);
+	border-radius: var(--radius-2);
+	appearance: none;
 	cursor: pointer;
 	transition:
 		background 0.15s ease,
@@ -309,17 +324,24 @@
 }
 
 .contextPopoverEntityItem {
+	// Override DS Button's centered layout.
+	--button-justify-content: flex-start;
 	display: flex;
 	align-items: center;
+	justify-content: flex-start;
 	gap: 10px;
+	width: 100%;
 	padding: 8px;
-	border: 1px solid color-mix(in srgb, var(--l1-foreground), transparent 96%);
-	border-radius: var(--radius-2);
+	background: transparent;
 	color: var(--l1-foreground);
+	font: inherit;
 	font-size: 12px;
 	font-weight: 500;
 	line-height: 1.35;
 	text-align: left;
+	border: 1px solid color-mix(in srgb, var(--l1-foreground), transparent 96%);
+	border-radius: var(--radius-2);
+	appearance: none;
 	cursor: pointer;
 	// Required for the inner span's `text-overflow: ellipsis` to engage —
 	// flex items default to `min-width: auto` (intrinsic width) and would
@@ -385,6 +407,11 @@
 	border-radius: 50%;
 	border: none;
 	cursor: pointer;
+	// Reset native <button> defaults so the 24px circle isn't inflated by
+	// browser-default padding / font metrics.
+	padding: 0;
+	font: inherit;
+	appearance: none;
 }
 
 .micDiscard {

frontend/src/container/AIAssistant/components/ChatInput/ChatInput.tsx

@@ -1,4 +1,10 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+	useCallback,
+	useEffect,
+	useLayoutEffect,
+	useRef,
+	useState,
+} from 'react';
 import { useQueryClient } from 'react-query';
 import cx from 'classnames';
 import { Badge } from '@signozhq/ui/badge';
@@ -26,7 +32,11 @@ import { useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
-import { AIAssistantEvents, getBrowserInfo } from '../../events';
+import {
+	AIAssistantEvents,
+	VoiceInputSource,
+	getBrowserInfo,
+} from '../../events';
 import { useAIAssistantAnalyticsContext } from '../../hooks/useAIAssistantAnalyticsContext';
 import { useSpeechRecognition } from '../../hooks/useSpeechRecognition';
 import { MessageAttachment } from '../../types';
@@ -142,6 +152,10 @@ function autoContextCategory(ctx: MessageContext): string {
 
 const MAX_INPUT_LENGTH = 20000;
 const WARNING_THRESHOLD = 15000;
+// Cap for the auto-growing composer. Past this, the textarea stops growing
+// and starts scrolling internally so the message list above doesn't get
+// squeezed in tighter container variants (e.g. the floating panel).
+const TEXTAREA_MAX_HEIGHT_PX = 200;
 const HOME_SERVICES_INTERVAL = 30 * 60 * 1000;
 /** sessionStorage key for the "voice input failed this tab" flag. */
 const VOICE_UNAVAILABLE_KEY = 'ai-assistant-voice-unavailable';
@@ -224,6 +238,18 @@ export default function ChatInput({
 	const [activeContextCategory, setActiveContextCategory] =
 		useState<ContextCategory>('Dashboards');
 	const [pickerSearchQuery, setPickerSearchQuery] = useState('');
+	// Refs to each category tab so we can move DOM focus to the newly-active
+	// tab on ArrowUp/ArrowDown. Without this the roving-tabindex pattern
+	// stalls: focus stays on the original button (whose closure has the old
+	// category), so subsequent arrow keys never advance past the second tab.
+	const categoryTabRefs = useRef(
+		new Map<ContextCategory, HTMLButtonElement | null>(),
+	);
+	// Refs to each entity row in the active tab panel, so we can cross from
+	// the category tablist (ArrowRight) into the panel and step through
+	// entities with ArrowUp/Down. Array is rewritten each render — there's
+	// only ever one tab panel mounted so stale indices clear naturally.
+	const entityRefs = useRef<(HTMLButtonElement | null)[]>([]);
 	const queryClient = useQueryClient();
 
 	// When the picker was opened by typing `@` in the textarea, this holds the
@@ -303,11 +329,92 @@ export default function ChatInput({
 		[mentionRange, selectedContexts, text],
 	);
 
+	const focusCategory = useCallback((category: ContextCategory) => {
+		setActiveContextCategory(category);
+		setPickerSearchQuery('');
+		categoryTabRefs.current.get(category)?.focus();
+	}, []);
+
+	const handleCategoryKeyDown = useCallback(
+		(
+			e: React.KeyboardEvent<HTMLButtonElement>,
+			category: ContextCategory,
+		): void => {
+			const total = CONTEXT_CATEGORIES.length;
+			const idx = CONTEXT_CATEGORIES.indexOf(category);
+			if (e.key === 'ArrowDown') {
+				e.preventDefault();
+				focusCategory(CONTEXT_CATEGORIES[(idx + 1) % total]);
+			} else if (e.key === 'ArrowUp') {
+				e.preventDefault();
+				focusCategory(CONTEXT_CATEGORIES[(idx - 1 + total) % total]);
+			} else if (e.key === 'Home') {
+				e.preventDefault();
+				focusCategory(CONTEXT_CATEGORIES[0]);
+			} else if (e.key === 'End') {
+				e.preventDefault();
+				focusCategory(CONTEXT_CATEGORIES[total - 1]);
+			} else if (e.key === 'ArrowRight') {
+				// Cross from tablist into entity panel.
+				e.preventDefault();
+				entityRefs.current[0]?.focus();
+			}
+		},
+		[focusCategory],
+	);
+
+	const handleEntityKeyDown = useCallback(
+		(e: React.KeyboardEvent<HTMLButtonElement>, index: number): void => {
+			const count = entityRefs.current.length;
+			if (count === 0) {
+				return;
+			}
+			const focusAt = (i: number): void => {
+				e.preventDefault();
+				entityRefs.current[i]?.focus();
+			};
+			switch (e.key) {
+				case 'ArrowDown':
+					focusAt((index + 1) % count);
+					break;
+				case 'ArrowUp':
+					focusAt((index - 1 + count) % count);
+					break;
+				case 'Home':
+					focusAt(0);
+					break;
+				case 'End':
+					focusAt(count - 1);
+					break;
+				case 'ArrowLeft':
+					// Cross back to tablist.
+					e.preventDefault();
+					categoryTabRefs.current.get(activeContextCategory)?.focus();
+					break;
+				default:
+			}
+		},
+		[activeContextCategory],
+	);
+
 	// Focus the textarea when this component mounts (panel/modal open)
 	useEffect(() => {
 		textareaRef.current?.focus();
 	}, []);
 
+	// Auto-grow the textarea so long prompts aren't trapped in a 2-line
+	// scrolling porthole. Reset to `auto` first to let the field shrink back
+	// down when the user deletes content, then snap to scrollHeight capped at
+	// TEXTAREA_MAX_HEIGHT_PX (overflow-y: auto in CSS handles the rest).
+	useLayoutEffect(() => {
+		const el = textareaRef.current;
+		if (!el) {
+			return;
+		}
+		el.style.height = 'auto';
+		el.style.height = `${Math.min(el.scrollHeight, TEXTAREA_MAX_HEIGHT_PX)}px`;
+	}, [text]);
+
 	const handleSend = useCallback(async () => {
 		const trimmed = text.trim();
 		if (!trimmed && pendingFiles.length === 0) {
@@ -382,7 +489,7 @@ export default function ChatInput({
 	// start time so we can attribute `durationMs` on the Voice input used
 	// event regardless of which control ended the session.
 	const voiceStartedAtRef = useRef<number | null>(null);
-	const voiceSourceRef = useRef<'button' | 'shortcut' | null>(null);
+	const voiceSourceRef = useRef<VoiceInputSource | null>(null);
 	// Set to true after a `network`, `not-allowed`, or `not-supported` failure
 	// so we hide the mic button for the rest of the tab session — silent
 	// retries don't help, and Chromium derivatives without the Google Speech
@@ -459,7 +566,7 @@ export default function ChatInput({
 	const showMic = isSupported && micPermission !== 'denied' && !voiceUnavailable;
 
 	const startVoiceInput = useCallback(
-		(source: 'button' | 'shortcut') => {
+		(source: VoiceInputSource) => {
 			// Defense in depth: the button is hidden when `voiceUnavailable` is
 			// true, but the PTT shortcut listener can still call us. Bailing here
 			// keeps a single source of truth and prevents repeat `Voice input
@@ -536,7 +643,7 @@ export default function ChatInput({
 				return; // ignore auto-repeat
 			}
 			pttActiveRef.current = true;
-			startVoiceInput('shortcut');
+			startVoiceInput(VoiceInputSource.Shortcut);
 		};
 
 		const handleKeyUp = (e: KeyboardEvent): void => {
@@ -724,6 +831,12 @@ export default function ChatInput({
 				entity.value.toLowerCase().includes(activeQuery),
 			)
 		: contextEntitiesByCategory[activeContextCategory];
+	// Truncate the ref array to match the current entity count so that
+	// switching from a large category (e.g. 100 dashboards) to a smaller one
+	// doesn't leave stale `null` slots from earlier renders. Keyboard nav math
+	// already uses `filteredContextOptions.length` for the modulo, so stale
+	// slots wouldn't be reached — this is purely housekeeping.
+	entityRefs.current.length = filteredContextOptions.length;
 	const { isLoading: isActiveContextLoading, isError: isActiveContextError } =
 		contextCategoryStateByCategory[activeContextCategory];
 	const currentLength = text.length;
@@ -830,7 +943,7 @@ export default function ChatInput({
 					onKeyDown={handleKeyDown}
 					disabled={disabled}
 					maxLength={MAX_INPUT_LENGTH}
-					rows={2}
+					rows={3}
 				/>
 			</div>
 			{showTextWarning && (
@@ -877,15 +990,37 @@ export default function ChatInput({
 							sideOffset={8}
 						>
 							<div className={styles.contextPopoverContent}>
-								<div className={styles.contextPopoverCategories}>
+								<div
+									className={styles.contextPopoverCategories}
+									role="tablist"
+									aria-orientation="vertical"
+									aria-label="Context categories"
+								>
 									{CONTEXT_CATEGORIES.map((category) => {
 										const CategoryIcon = CONTEXT_CATEGORY_ICONS[category];
 										const isActive = activeContextCategory === category;
 										return (
-											<div
+											<Button
 												key={category}
+												ref={(el): void => {
+													categoryTabRefs.current.set(category, el);
+												}}
+												type="button"
+												variant="ghost"
+												color="secondary"
+												size="sm"
 												role="tab"
-												tabIndex={0}
+												id={`ai-context-tab-${category}`}
+												// Single stable panel id shared by every tab: only the
+												// active category's tabpanel is rendered, so per-category
+												// `aria-controls` ids would point at nonexistent nodes
+												// for the two inactive tabs. APG allows a single
+												// dynamic panel whose `aria-labelledby` swaps to the
+												// active tab.
+												aria-controls="ai-context-tabpanel"
+												// Roving tabindex: only the active tab participates in
+												// the Tab sequence; arrow keys move between tabs.
+												tabIndex={isActive ? 0 : -1}
 												aria-selected={isActive}
 												className={cx(styles.contextPopoverCategoryItem, {
 													[styles.active]: isActive,
@@ -894,22 +1029,21 @@ export default function ChatInput({
 													setActiveContextCategory(category);
 													setPickerSearchQuery('');
 												}}
-												onKeyDown={(e): void => {
-													if (e.key === 'Enter' || e.key === ' ') {
-														e.preventDefault();
-														setActiveContextCategory(category);
-														setPickerSearchQuery('');
-													}
-												}}
+												onKeyDown={(e): void => handleCategoryKeyDown(e, category)}
+												prefix={<CategoryIcon size={13} />}
 											>
-												<CategoryIcon size={13} />
 												<span>{category}</span>
-											</div>
+											</Button>
 										);
 									})}
 								</div>
 
-								<div className={styles.contextPopoverRight}>
+								<div
+									className={styles.contextPopoverRight}
+									role="tabpanel"
+									id="ai-context-tabpanel"
+									aria-labelledby={`ai-context-tab-${activeContextCategory}`}
+								>
 									<div className={styles.contextPopoverSearch}>
 										<Input
 											type="text"
@@ -939,7 +1073,7 @@ export default function ChatInput({
 												No matching entities
 											</div>
 										) : (
-											filteredContextOptions.map((option) => {
+											filteredContextOptions.map((option, index) => {
 												const isSelected = selectedContexts.some(
 													(item) =>
 														item.category === activeContextCategory &&
@@ -947,8 +1081,16 @@ export default function ChatInput({
 												);
 
 												return (
-													<div
+													<Button
 														key={option.id}
+														ref={(el): void => {
+															entityRefs.current[index] = el;
+														}}
+														type="button"
+														variant="ghost"
+														color="secondary"
+														size="sm"
+														aria-pressed={isSelected}
 														className={cx(styles.contextPopoverEntityItem, {
 															[styles.selected]: isSelected,
 														})}
@@ -959,11 +1101,12 @@ export default function ChatInput({
 																option.value,
 															)
 														}
+														onKeyDown={(e): void => handleEntityKeyDown(e, index)}
 													>
 														<span className={styles.contextPopoverEntityItemText}>
 															{option.value}
 														</span>
-													</div>
+													</Button>
 												);
 											})
 										)}
@@ -977,14 +1120,24 @@ export default function ChatInput({
 				<div className={styles.rightActions}>
 					{showMic &&
 						(isListening ? (
-							<div className={styles.micRecording}>
-								<div
-									className={cx(styles.micDiscard, styles.secondary)}
-									onClick={handleDiscard}
-									aria-label="Discard recording"
-								>
-									<X size={12} />
-								</div>
+							<div
+								className={styles.micRecording}
+								role="status"
+								aria-live="polite"
+								aria-label="Recording voice input"
+							>
+								<TooltipSimple title="Discard recording">
+									<Button
+										type="button"
+										variant="ghost"
+										size="icon"
+										color="secondary"
+										className={cx(styles.micDiscard, styles.secondary)}
+										onClick={handleDiscard}
+										aria-label="Discard recording"
+										prefix={<X size={12} />}
+									/>
+								</TooltipSimple>
 								<span className={styles.micWaves} aria-hidden="true">
 									<span />
 									<span />
@@ -995,26 +1148,30 @@ export default function ChatInput({
 									<span />
 									<span />
 								</span>
-								<div
-									className={cx(styles.micStop, styles.destructive)}
-									onClick={handleStopAndSend}
-									aria-label="Stop and send"
-								>
-									<Square size={9} fill="currentColor" strokeWidth={0} />
-								</div>
+								<TooltipSimple title="Stop and send">
+									<Button
+										type="button"
+										variant="ghost"
+										size="icon"
+										color="destructive"
+										className={cx(styles.micStop, styles.destructive)}
+										onClick={handleStopAndSend}
+										aria-label="Stop and send"
+										prefix={<Square size={9} fill="currentColor" strokeWidth={0} />}
+									/>
+								</TooltipSimple>
 							</div>
 						) : (
 							<TooltipSimple title="Voice input">
 								<Button
 									variant="ghost"
 									size="icon"
-									onClick={(): void => startVoiceInput('button')}
+									onClick={(): void => startVoiceInput(VoiceInputSource.Button)}
 									disabled={disabled}
 									aria-label="Start voice input"
 									className={styles.micBtn}
-								>
-									<Mic size={14} />
-								</Button>
+									prefix={<Mic size={14} />}
+								/>
 							</TooltipSimple>
 						))}
 
@@ -1026,21 +1183,21 @@ export default function ChatInput({
 								color="destructive"
 								onClick={onCancel}
 								aria-label="Stop generating"
-							>
-								<Square size={10} fill="currentColor" strokeWidth={0} />
-							</Button>
+								prefix={<Square size={10} fill="currentColor" strokeWidth={0} />}
+							/>
 						</TooltipSimple>
 					) : (
-						<Button
-							variant="solid"
-							size="icon"
-							color="primary"
-							onClick={isListening ? handleStopAndSend : handleSend}
-							disabled={disabled || (!text.trim() && pendingFiles.length === 0)}
-							aria-label="Send message"
-						>
-							<Send size={14} />
-						</Button>
+						<TooltipSimple title="Send message">
+							<Button
+								variant="solid"
+								size="icon"
+								color="primary"
+								onClick={isListening ? handleStopAndSend : handleSend}
+								disabled={disabled || (!text.trim() && pendingFiles.length === 0)}
+								aria-label="Send message"
+								prefix={<Send size={14} />}
+							/>
+						</TooltipSimple>
 					)}
 				</div>
 			</div>

frontend/src/container/AIAssistant/components/ClarificationForm/ClarificationForm.module.scss

@@ -64,6 +64,19 @@
 	gap: 4px;
 }
 
+// Mirrors `.field` for the multi_select group, but resets the browser's
+// default `<fieldset>` border/padding/margin so the visual matches the
+// `<div>`-based field rows.
+.multiSelectFieldset {
+	display: flex;
+	flex-direction: column;
+	gap: 4px;
+	margin: 0;
+	padding: 0;
+	border: 0;
+	min-width: 0;
+}
+
 .label {
 	font-size: 12px;
 	font-weight: 500;

frontend/src/container/AIAssistant/components/ClarificationForm/ClarificationForm.tsx

@@ -63,7 +63,14 @@ export default function ClarificationForm({
 		setAnswers((prev) => ({ ...prev, [id]: value }));
 	};
 
+	const isFormValid = fields.every(
+		(f) => !f.required || isFieldFilled(f, answers[f.id]),
+	);
+
 	const handleSubmit = async (): Promise<void> => {
+		if (!isFormValid) {
+			return;
+		}
 		setSubmitted(true);
 		// Approximate queryLength as the JSON encoding of the form answers — the
 		// clarification API doesn't render a single user-visible string, but the
@@ -136,7 +143,7 @@ export default function ClarificationForm({
 					variant="solid"
 					color="primary"
 					onClick={handleSubmit}
-					disabled={isStreaming}
+					disabled={isStreaming || !isFormValid}
 					prefix={<Send />}
 				>
 					Submit
@@ -162,8 +169,9 @@ export default function ClarificationForm({
 
 /**
  * Per-type seed value. The DTO's `default` is `string | string[] | null`,
- * which doesn't fit boolean fields cleanly — we coerce 'true'/'false' strings
- * for them, fall back to `[]` for multi_select, and the raw string otherwise.
+ * which doesn't fit boolean / number fields cleanly — we coerce 'true'/'false'
+ * strings for booleans, parse number defaults out of the string form,
+ * fall back to `[]` for multi_select, and the raw string otherwise.
  */
 function initialAnswerFor(f: ClarificationFieldEventDTO): unknown {
 	const raw = f.default;
@@ -175,9 +183,41 @@ function initialAnswerFor(f: ClarificationFieldEventDTO): unknown {
 	if (f.type === ClarificationFieldTypeDTO.multi_select) {
 		return Array.isArray(raw) ? raw : [];
 	}
+	if (f.type === ClarificationFieldTypeDTO.number) {
+		// Server sends number defaults as strings (e.g. `"5"`). Parse so the
+		// stored value is a real `number` — otherwise `isFieldFilled` (which
+		// requires `typeof === 'number'`) rejects a visibly-filled field and
+		// Submit stays disabled.
+		if (typeof raw !== 'string' || raw === '') {
+			return null;
+		}
+		const parsed = Number(raw);
+		return Number.isNaN(parsed) ? null : parsed;
+	}
 	return raw ?? '';
 }
 
+// Whether a required field has been answered. Booleans are always considered
+// filled (they're initialised to a concrete true/false). For other types we
+// reject empty strings, empty arrays, NaN numbers, and `null` (which the
+// number input emits when its raw value is `''` — `Number('')` would
+// otherwise silently coerce to `0` and read as a valid answer).
+function isFieldFilled(
+	field: ClarificationFieldEventDTO,
+	value: unknown,
+): boolean {
+	switch (field.type) {
+		case ClarificationFieldTypeDTO.multi_select:
+			return Array.isArray(value) && value.length > 0;
+		case ClarificationFieldTypeDTO.boolean:
+			return true;
+		case ClarificationFieldTypeDTO.number:
+			return typeof value === 'number' && !Number.isNaN(value);
+		default:
+			return typeof value === 'string' && value.trim().length > 0;
+	}
+}
+
 interface FieldInputProps {
 	field: ClarificationFieldEventDTO;
 	value: unknown;
@@ -216,13 +256,21 @@ function FieldInput({ field, value, onChange }: FieldInputProps): JSX.Element {
 			<div className={styles.field}>
 				<label className={styles.label} htmlFor={id}>
 					{label}
-					{required && <span className={styles.required}>*</span>}
+					{required && (
+						<span className={styles.required} aria-hidden="true">
+							*
+						</span>
+					)}
 				</label>
 				<Select
 					value={isCustom ? CUSTOM_OPTION_SENTINEL : String(value ?? '')}
 					onChange={handleSelectChange}
 				>
-					<SelectTrigger id={id} placeholder="Select…" />
+					<SelectTrigger
+						id={id}
+						placeholder="Select…"
+						aria-required={required || undefined}
+					/>
 					{/* Pin the dropdown width to the trigger via Radix's
 					    `--radix-select-trigger-width`; otherwise the popover
 					    sizes to its widest item and looks misaligned. */}
@@ -267,7 +315,11 @@ function FieldInput({ field, value, onChange }: FieldInputProps): JSX.Element {
 					onChange={(): void => onChange(!checked)}
 				>
 					{label}
-					{required && <span className={styles.required}>*</span>}
+					{required && (
+						<span className={styles.required} aria-hidden="true">
+							*
+						</span>
+					)}
 				</Checkbox>
 			</div>
 		);
@@ -312,11 +364,21 @@ function FieldInput({ field, value, onChange }: FieldInputProps): JSX.Element {
 		};
 
 		return (
-			<div className={styles.field}>
-				<span className={styles.label}>
+			// `fieldset` + `legend` is the WCAG-recommended grouping for
+			// related checkboxes (1.3.1). SRs announce the legend before each
+			// option, so users hear the group label as context.
+			<fieldset
+				className={styles.multiSelectFieldset}
+				aria-required={required || undefined}
+			>
+				<legend className={styles.label}>
 					{label}
-					{required && <span className={styles.required}>*</span>}
-				</span>
+					{required && (
+						<span className={styles.required} aria-hidden="true">
+							*
+						</span>
+					)}
+				</legend>
 				<div className={styles.checkboxGroup}>
 					{options?.map((opt) => (
 						<Checkbox
@@ -347,7 +409,7 @@ function FieldInput({ field, value, onChange }: FieldInputProps): JSX.Element {
 						onChange={(e): void => updateCustomValue(e.target.value)}
 					/>
 				)}
-			</div>
+			</fieldset>
 		);
 	}
 
@@ -356,16 +418,29 @@ function FieldInput({ field, value, onChange }: FieldInputProps): JSX.Element {
 		<div className={styles.field}>
 			<label className={styles.label} htmlFor={id}>
 				{label}
-				{required && <span className={styles.required}>*</span>}
+				{required && (
+					<span className={styles.required} aria-hidden="true">
+						*
+					</span>
+				)}
 			</label>
 			<Input
 				id={id}
 				type={type === 'number' ? 'number' : 'text'}
 				className={styles.input}
 				value={String(value ?? '')}
-				onChange={(e): void =>
-					onChange(type === 'number' ? Number(e.target.value) : e.target.value)
-				}
+				aria-required={required || undefined}
+				onChange={(e): void => {
+					if (type === 'number') {
+						const raw = e.target.value;
+						// Map empty input to `null` instead of `Number('') === 0`
+						// so a required numeric field cleared after typing doesn't
+						// silently read as a valid `0` in `isFieldFilled`.
+						onChange(raw === '' ? null : Number(raw));
+					} else {
+						onChange(e.target.value);
+					}
+				}}
 				placeholder={label}
 			/>
 		</div>

frontend/src/container/AIAssistant/components/MessageBubble/MessageBubble.tsx

@@ -178,7 +178,7 @@ export default function MessageBubble({
 					</div>
 				</div>
 
-				{!isUser && (
+				{!isUser && !message.isRateLimitError && (
 					<MessageFeedback
 						message={message}
 						onRegenerate={onRegenerate}

frontend/src/container/AIAssistant/components/MessageFeedback/MessageFeedback.tsx

@@ -10,6 +10,7 @@ import { useTimezone } from 'providers/Timezone';
 
 import logEvent from 'api/common/logEvent';
 
+import { FeedbackRatingDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
 import { AIAssistantEvents } from '../../events';
 import { useAIAssistantAnalyticsContext } from '../../hooks/useAIAssistantAnalyticsContext';
 import { useAIAssistantStore } from '../../store/useAIAssistantStore';
@@ -17,6 +18,22 @@ import { FeedbackRating, Message } from '../../types';
 
 import styles from './MessageFeedback.module.scss';
 
+const FEEDBACK_ANALYTICS_RATING = {
+	[FeedbackRatingDTO.positive]: 'up',
+	[FeedbackRatingDTO.negative]: 'down',
+} as const;
+
+const VOTE_LABEL = {
+	[FeedbackRatingDTO.positive]: {
+		tooltip: 'Good response',
+		ariaLabel: 'Good response',
+	},
+	[FeedbackRatingDTO.negative]: {
+		tooltip: 'Bad response',
+		ariaLabel: 'Bad response',
+	},
+} as const;
+
 interface MessageFeedbackProps {
 	message: Message;
 	onRegenerate?: () => void;
@@ -117,7 +134,7 @@ export default function MessageFeedback({
 			if (vote === rating) {
 				return;
 			}
-			if (rating === 'negative') {
+			if (rating === FeedbackRatingDTO.negative) {
 				setNegativeComment('');
 				setIsNegativeDialogOpen(true);
 				return;
@@ -126,7 +143,7 @@ export default function MessageFeedback({
 			void logEvent(AIAssistantEvents.FeedbackSubmitted, {
 				messageId: message.id,
 				threadId,
-				rating: 'up',
+				rating: FEEDBACK_ANALYTICS_RATING[rating],
 				hasComment: false,
 				commentLength: 0,
 			});
@@ -136,17 +153,21 @@ export default function MessageFeedback({
 	);
 
 	const handleSubmitNegative = useCallback((): void => {
-		setVote('negative');
+		setVote(FeedbackRatingDTO.negative);
 		setIsNegativeDialogOpen(false);
 		const trimmed = negativeComment.trim();
 		void logEvent(AIAssistantEvents.FeedbackSubmitted, {
 			messageId: message.id,
 			threadId,
-			rating: 'down',
+			rating: FEEDBACK_ANALYTICS_RATING[FeedbackRatingDTO.negative],
 			hasComment: trimmed.length > 0,
 			commentLength: trimmed.length,
 		});
-		submitMessageFeedback(message.id, 'negative', trimmed || undefined);
+		submitMessageFeedback(
+			message.id,
+			FeedbackRatingDTO.negative,
+			trimmed || undefined,
+		);
 	}, [message.id, negativeComment, submitMessageFeedback, threadId]);
 
 	return (
@@ -160,32 +181,39 @@ export default function MessageFeedback({
 							variant="ghost"
 							onClick={handleCopy}
 							color="secondary"
+							aria-label={copied ? 'Copied' : 'Copy message'}
 						>
 							{copied ? <Check size={12} /> : <Copy size={12} />}
 						</Button>
 					</TooltipSimple>
 
-					<TooltipSimple title="Good response">
+					<TooltipSimple title={VOTE_LABEL[FeedbackRatingDTO.positive].tooltip}>
 						<Button
-							className={cx(styles.btn, { [styles.votedUp]: vote === 'positive' })}
+							className={cx(styles.btn, {
+								[styles.votedUp]: vote === FeedbackRatingDTO.positive,
+							})}
 							size="icon"
 							variant="ghost"
 							color="secondary"
-							onClick={(): void => handleVote('positive')}
+							onClick={(): void => handleVote(FeedbackRatingDTO.positive)}
+							aria-label={VOTE_LABEL[FeedbackRatingDTO.positive].ariaLabel}
+							aria-pressed={vote === FeedbackRatingDTO.positive}
 						>
 							<ThumbsUp size={12} />
 						</Button>
 					</TooltipSimple>
 
-					<TooltipSimple title="Bad response">
+					<TooltipSimple title={VOTE_LABEL[FeedbackRatingDTO.negative].tooltip}>
 						<Button
 							className={cx(styles.btn, {
-								[styles.votedDown]: vote === 'negative',
+								[styles.votedDown]: vote === FeedbackRatingDTO.negative,
 							})}
 							size="icon"
 							variant="ghost"
 							color="secondary"
-							onClick={(): void => handleVote('negative')}
+							onClick={(): void => handleVote(FeedbackRatingDTO.negative)}
+							aria-label={VOTE_LABEL[FeedbackRatingDTO.negative].ariaLabel}
+							aria-pressed={vote === FeedbackRatingDTO.negative}
 						>
 							<ThumbsDown size={12} />
 						</Button>
@@ -199,6 +227,7 @@ export default function MessageFeedback({
 								variant="ghost"
 								color="secondary"
 								onClick={onRegenerate}
+								aria-label="Regenerate response"
 							>
 								<RefreshCw size={12} />
 							</Button>

frontend/src/container/AIAssistant/components/UserMessageActions/UserMessageActions.tsx

@@ -47,6 +47,7 @@ export default function UserMessageActions({
 					variant="ghost"
 					color="secondary"
 					onClick={handleCopy}
+					aria-label={copied ? 'Copied' : 'Copy message'}
 				>
 					{copied ? <Check size={12} /> : <Copy size={12} />}
 				</Button>

frontend/src/container/AIAssistant/components/VirtualizedMessages/VirtualizedMessages.tsx

@@ -90,6 +90,16 @@ export default function VirtualizedMessages({
 
 	const virtuosoRef = useRef<VirtuosoHandle>(null);
 	const scrollerRef = useRef<HTMLElement | Window | null>(null);
+	// Tracks whether the scroller is pinned to (or near) the bottom. Updated
+	// via Virtuoso's `atBottomStateChange` so we can stop force-scrolling the
+	// user back down when they've intentionally scrolled up to read earlier
+	// content.
+	const atBottomRef = useRef(true);
+	// Id of the latest user message we've already anchored to. Used to detect
+	// a fresh user send so we can re-anchor to the bottom regardless of where
+	// the user was scrolled — sending a message and not seeing it is worse
+	// than the anti-yank guarantee.
+	const lastSeenUserMessageIdRef = useRef<string | null>(null);
 
 	const handleRegenerate = useCallback(
 		(messageId: string): void => {
@@ -111,8 +121,25 @@ export default function VirtualizedMessages({
 	// align: 'end')` would only reach the last item's bottom and leave the
 	// padding hidden below the fold. Use `auto` while streaming so the bottom
 	// stays glued as text deltas arrive; `smooth` lags when triggered every
-	// few ms.
+	// few ms. Bail out if the user has scrolled away from the bottom — that's
+	// an explicit signal they want to read earlier content without being
+	// yanked back.
 	useEffect(() => {
+		const lastMessage = messages[messages.length - 1];
+		const isFreshUserSend =
+			lastMessage?.role === 'user' &&
+			lastMessage.id !== lastSeenUserMessageIdRef.current;
+		if (isFreshUserSend) {
+			lastSeenUserMessageIdRef.current = lastMessage.id;
+			// Re-anchor so the user sees their own send (and the assistant's
+			// follow-up streaming) even if they were reading history when they
+			// hit Enter.
+			atBottomRef.current = true;
+		}
+
+		if (!atBottomRef.current) {
+			return;
+		}
 		const scroller = scrollerRef.current;
 		if (!(scroller instanceof HTMLElement)) {
 			return;
@@ -122,7 +149,7 @@ export default function VirtualizedMessages({
 			behavior: isStreaming ? 'auto' : 'smooth',
 		});
 	}, [
-		messages.length,
+		messages,
 		streamingEvents.length,
 		streamingContentLength,
 		isStreaming,
@@ -132,14 +159,18 @@ export default function VirtualizedMessages({
 
 	const followOutput = useCallback(
 		(atBottom: boolean): false | 'auto' | 'smooth' => {
-			if (isStreaming) {
-				return 'auto';
+			if (!atBottom) {
+				return false;
 			}
-			return atBottom ? 'smooth' : false;
+			return isStreaming ? 'auto' : 'smooth';
 		},
 		[isStreaming],
 	);
 
+	const handleAtBottomStateChange = useCallback((atBottom: boolean): void => {
+		atBottomRef.current = atBottom;
+	}, []);
+
 	const showStreamingSlot =
 		isStreaming || Boolean(pendingApproval) || Boolean(pendingClarification);
 
@@ -188,6 +219,8 @@ export default function VirtualizedMessages({
 			className={styles.messages}
 			totalCount={totalCount}
 			followOutput={followOutput}
+			atBottomStateChange={handleAtBottomStateChange}
+			atBottomThreshold={64}
 			initialTopMostItemIndex={Math.max(0, totalCount - 1)}
 			itemContent={(index): JSX.Element => {
 				if (index < messages.length) {

frontend/src/container/AIAssistant/components/blocks/RichCodeBlock/RichCodeBlock.tsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { useCopyToClipboard } from 'react-use';
 import { Button } from '@signozhq/ui/button';
+import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { Check, Copy } from '@signozhq/icons';
 import SyntaxHighlighter, {
 	a11yDark,
@@ -126,16 +127,17 @@ function CopyButton({ text }: { text: string }): JSX.Element {
 	};
 
 	return (
-		<Button
-			variant="ghost"
-			size="sm"
-			color="secondary"
-			className={styles.copyBtn}
-			onClick={handleCopy}
-			title={copied ? 'Copied' : 'Copy code'}
-			aria-label={copied ? 'Copied' : 'Copy code'}
-		>
-			{copied ? <Check size={12} /> : <Copy size={12} />}
-		</Button>
+		<TooltipSimple title={copied ? 'Copied' : 'Copy code'}>
+			<Button
+				variant="ghost"
+				size="sm"
+				color="secondary"
+				className={styles.copyBtn}
+				onClick={handleCopy}
+				aria-label={copied ? 'Copied' : 'Copy code'}
+			>
+				{copied ? <Check size={12} /> : <Copy size={12} />}
+			</Button>
+		</TooltipSimple>
 	);
 }

frontend/src/container/AIAssistant/events.ts

@@ -63,6 +63,26 @@ export const SuggestedPromptCategory = {
 export type SuggestedPromptCategory =
 	(typeof SuggestedPromptCategory)[keyof typeof SuggestedPromptCategory];
 
+// `source` attribute on the AI Assistant `Opened` event — describes which
+// surface triggered the open. Keep values stable: dashboards downstream
+// depend on the literal strings.
+export const AIAssistantOpenSource = {
+	Icon: 'icon',
+	Shortcut: 'shortcut',
+	Cmdk: 'cmdk',
+} as const;
+export type AIAssistantOpenSource =
+	(typeof AIAssistantOpenSource)[keyof typeof AIAssistantOpenSource];
+
+// `source` attribute on the `VoiceInputUsed` event — which surface initiated
+// the recording.
+export const VoiceInputSource = {
+	Button: 'button',
+	Shortcut: 'shortcut',
+} as const;
+export type VoiceInputSource =
+	(typeof VoiceInputSource)[keyof typeof VoiceInputSource];
+
 export enum AIAssistantEvents {
 	Opened = 'AI Assistant: Opened',
 	MessageSent = 'AI Assistant: Message sent',

frontend/src/container/AIAssistant/store/useAIAssistantStore.ts

@@ -1,10 +1,12 @@
 /* eslint-disable sonarjs/cognitive-complexity */
+import axios from 'axios';
 import { v4 as uuidv4 } from 'uuid';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
 import { immer } from 'zustand/middleware/immer';
 
 import type {
+	ErrorResponseDTO,
 	MessageActionDTO,
 	MessageSummaryDTOBlocksAnyOfItem,
 } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
@@ -21,7 +23,6 @@ import {
 	regenerateMessage,
 	rejectExecution,
 	sendMessage as sendMessageToThread,
-	SSEStreamError,
 	streamEvents,
 	submitFeedback,
 	ThreadSummary,
@@ -193,13 +194,75 @@ function resetStreamingState(
 	};
 }
 
+/**
+ * Marker thrown by `runStreamingLoop` when an SSE event reports
+ * `invalid_token`. Callers that own an originating action (sendMessage /
+ * approve / clarify / regenerate) catch this and re-issue that action via
+ * `streamWithAuthRetry`; the retry's first REST call will 401, at which point
+ * the shared axios `interceptorRejected` rotates the access token and replays.
+ */
+class AuthExpiredError extends Error {
+	constructor() {
+		super('Access token expired during execution');
+		this.name = 'AuthExpiredError';
+	}
+}
+
+/**
+ * Runs the originating action (e.g. sendMessage POST) and streams the
+ * resulting execution. On `AuthExpiredError`, re-issues `start` once — the
+ * retry's REST call hits 401, the shared axios interceptor rotates the
+ * access token and replays, and the new SSE picks up the rotated token from
+ * localStorage. Backend signals `retryAction: 'manual'` for `invalid_token`,
+ * so the dead execution can't be resumed — only a fresh one helps.
+ */
+async function streamWithAuthRetry(
+	conversationId: string,
+	start: () => Promise<string>,
+	set: StoreSetter,
+): Promise<void> {
+	for (let attempt = 0; attempt <= 1; attempt += 1) {
+		if (attempt > 0) {
+			// Drop any partial content/events from the previous attempt so the
+			// retried execution's stream isn't concatenated with the dead one.
+			set((s) => {
+				resetStreamingState(s, conversationId);
+			});
+		}
+		// eslint-disable-next-line no-await-in-loop
+		const executionId = await start();
+		const ctrl = newStreamController(conversationId);
+		try {
+			// eslint-disable-next-line no-await-in-loop
+			await runStreamingLoop(executionId, {
+				conversationId,
+				set,
+				signal: ctrl.signal,
+			});
+			streamControllers.delete(conversationId);
+			return;
+		} catch (err) {
+			streamControllers.delete(conversationId);
+			if (err instanceof AuthExpiredError && attempt < 1) {
+				continue;
+			}
+			throw err;
+		}
+	}
+}
+
 /**
  * Runs one SSE execution stream, updating the per-conversation stream state.
  *
  * Breaks early and sets pendingApproval / pendingClarification when the
  * agent needs user input before it can continue.
  *
- * Throws on `error` events — the caller's catch block handles UI feedback.
+ * On an `invalid_token` error event (e.g. MCP auth expired mid-execution),
+ * throws `AuthExpiredError` so the caller can re-issue the originating
+ * action via `streamWithAuthRetry`. We don't refresh here ourselves — the
+ * retry's REST call will 401 and the shared axios `interceptorRejected`
+ * handles rotation + replay. Throws on any other `error` event — the
+ * caller's catch block handles UI feedback.
  */
 // eslint-disable-next-line sonarjs/cognitive-complexity
 async function runStreamingLoop(
@@ -325,6 +388,15 @@ async function runStreamingLoop(
 			});
 			break;
 		} else if (event.type === 'error') {
+			// MCP/SigNoz auth expired mid-execution — signal the caller to
+			// re-issue the originating action. The retry's REST call will hit
+			// 401 and the shared axios `interceptorRejected` will rotate the
+			// access token + replay, so we don't refresh here ourselves.
+			// (Backend sets `retryAction: 'manual'`, so the failed execution
+			// can't itself be resumed — only a fresh one helps.)
+			if (event.error.code === 'invalid_token') {
+				throw new AuthExpiredError();
+			}
 			throw Object.assign(new Error(event.error.message), {
 				retryAction: event.retryAction,
 			});
@@ -412,13 +484,41 @@ function hasPendingInput(conversationId: string, get: StoreGetter): boolean {
 	return Boolean(stream?.pendingApproval || stream?.pendingClarification);
 }
 
+function parseErrorBody(value: unknown): string | null {
+	if (typeof value === 'string') {
+		try {
+			return parseErrorBody(JSON.parse(value));
+		} catch {
+			return null;
+		}
+	}
+	const message = (value as ErrorResponseDTO | undefined)?.error?.message;
+	return typeof message === 'string' && message.length > 0 ? message : null;
+}
+
 /**
- * Commits an error message and removes the stream entry.
+ * Returns the backend's `error.message` when `err` is a 429 axios response
+ * (typically from the threads API surface — createThread, sendMessage, approve,
+ * clarify, regenerate). Returns null for any other error so callers fall
+ * through to their generic copy.
+ */
+function rateLimitMessage(err: unknown): string | null {
+	if (axios.isAxiosError(err) && err.response?.status === 429) {
+		return parseErrorBody(err.response.data);
+	}
+	return null;
+}
+
+/**
+ * Commits an error message and removes the stream entry. When `isRateLimit`
+ * is true, the committed message is flagged so the feedback/regenerate bar
+ * is hidden — clicking regenerate would just 429 again.
  */
 function finalizeStreamingError(
 	conversationId: string,
 	errorContent: string,
 	set: StoreSetter,
+	isRateLimit = false,
 ): void {
 	set((s) => {
 		const conv = s.conversations[conversationId];
@@ -428,6 +528,7 @@ function finalizeStreamingError(
 				role: 'assistant',
 				content: errorContent,
 				createdAt: Date.now(),
+				...(isRateLimit ? { isRateLimitError: true } : {}),
 			});
 			conv.updatedAt = Date.now();
 		}
@@ -801,7 +902,12 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 					});
 
 					// Reconnect to SSE if backend execution is still running
-					// and we don't already have an active SSE reader for this thread
+					// and we don't already have an active SSE reader for this
+					// thread. No auth-retry wrapper here: on `invalid_token`
+					// there's no "originating action" to redo — reopening the
+					// same dead executionId would just re-emit the failure.
+					// Let the error bubble; the user can send a new message,
+					// which will go through `streamWithAuthRetry`.
 					if (
 						detail.activeExecutionId &&
 						!streamControllers.has(threadId) &&
@@ -1052,14 +1158,12 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 							}
 						});
 					}
-					const executionId = await sendMessageToThread(threadId, text, contexts);
-					const ctrl = newStreamController(convId);
-					await runStreamingLoop(executionId, {
-						conversationId: convId,
+					const tid = threadId;
+					await streamWithAuthRetry(
+						convId,
+						() => sendMessageToThread(tid, text, contexts),
 						set,
-						signal: ctrl.signal,
-					});
-					streamControllers.delete(convId);
+					);
 
 					if (!hasPendingInput(convId, get)) {
 						finalizeStreamingMessage(convId, set, get);
@@ -1070,11 +1174,14 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] sendMessage failed:', err);
-					const message =
-						err instanceof SSEStreamError && err.status === 429
-							? 'You sent that a bit too quickly. Please wait a moment and try again.'
-							: 'Something went wrong while fetching the response. Please try again.';
-					finalizeStreamingError(convId, message, set);
+					const rateLimit = rateLimitMessage(err);
+					finalizeStreamingError(
+						convId,
+						rateLimit ??
+							'Something went wrong while fetching the response. Please try again.',
+						set,
+						rateLimit !== null,
+					);
 				}
 			},
 
@@ -1094,14 +1201,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 				});
 
 				try {
-					const executionId = await approveExecution(approvalId);
-					const ctrl = newStreamController(conversationId);
-					await runStreamingLoop(executionId, {
+					await streamWithAuthRetry(
 						conversationId,
+						() => approveExecution(approvalId),
 						set,
-						signal: ctrl.signal,
-					});
-					streamControllers.delete(conversationId);
+					);
 					if (!hasPendingInput(conversationId, get)) {
 						finalizeStreamingMessage(conversationId, set, get);
 					}
@@ -1110,10 +1214,13 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] approveAction failed:', err);
+					const rateLimit = rateLimitMessage(err);
 					finalizeStreamingError(
 						conversationId,
-						'Something went wrong while processing the approval. Please try again.',
+						rateLimit ??
+							'Something went wrong while processing the approval. Please try again.',
 						set,
+						rateLimit !== null,
 					);
 				}
 			},
@@ -1176,14 +1283,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 				});
 
 				try {
-					const executionId = await regenerateMessage(messageId);
-					const ctrl = newStreamController(conversationId);
-					await runStreamingLoop(executionId, {
+					await streamWithAuthRetry(
 						conversationId,
+						() => regenerateMessage(messageId),
 						set,
-						signal: ctrl.signal,
-					});
-					streamControllers.delete(conversationId);
+					);
 					if (!hasPendingInput(conversationId, get)) {
 						finalizeStreamingMessage(conversationId, set, get);
 					}
@@ -1192,10 +1296,13 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] regenerateAssistantMessage failed:', err);
+					const rateLimit = rateLimitMessage(err);
 					finalizeStreamingError(
 						conversationId,
-						'Something went wrong while regenerating the response. Please try again.',
+						rateLimit ??
+							'Something went wrong while regenerating the response. Please try again.',
 						set,
+						rateLimit !== null,
 					);
 				}
 			},
@@ -1245,14 +1352,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 				});
 
 				try {
-					const executionId = await clarifyExecution(clarificationId, answers);
-					const ctrl = newStreamController(conversationId);
-					await runStreamingLoop(executionId, {
+					await streamWithAuthRetry(
 						conversationId,
+						() => clarifyExecution(clarificationId, answers),
 						set,
-						signal: ctrl.signal,
-					});
-					streamControllers.delete(conversationId);
+					);
 					if (!hasPendingInput(conversationId, get)) {
 						finalizeStreamingMessage(conversationId, set, get);
 					}
@@ -1261,10 +1365,13 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] submitClarification failed:', err);
+					const rateLimit = rateLimitMessage(err);
 					finalizeStreamingError(
 						conversationId,
-						'Something went wrong while processing your answers. Please try again.',
+						rateLimit ??
+							'Something went wrong while processing your answers. Please try again.',
 						set,
+						rateLimit !== null,
 					);
 				}
 			},

frontend/src/container/AIAssistant/types.ts

@@ -86,6 +86,11 @@ export interface Message {
 	actions?: MessageActionDTO[];
 	/** Persisted feedback rating — set after user votes and the API confirms. */
 	feedbackRating?: FeedbackRating | null;
+	/**
+	 * Set on client-side rate-limit error messages so the feedback/regenerate
+	 * bar (copy/vote/regenerate) is hidden — retrying would just 429 again.
+	 */
+	isRateLimitError?: boolean;
 	createdAt: number;
 }
 

frontend/src/container/AppLayout/utils.ts

@@ -1,9 +1,32 @@
 import ROUTES from 'constants/routes';
 
-export function getRouteKey(pathname: string): string {
-	const [routeKey] = Object.entries(ROUTES).find(
-		([, value]) => value === pathname,
-	) || ['DEFAULT'];
+const PARAM_SEGMENT = /:[^/]+/g;
+const REGEX_SPECIALS = /[.+*?^$()[\]{}|\\]/g;
 
-	return routeKey;
+function templateToRegex(template: string): RegExp {
+	const pattern = template
+		.replace(REGEX_SPECIALS, '\\$&')
+		.replace(PARAM_SEGMENT, '[^/]+');
+	return new RegExp(`^${pattern}$`);
+}
+
+export function getRouteKey(pathname: string): string {
+	const entries = Object.entries(ROUTES);
+
+	const exact = entries.find(([, value]) => value === pathname);
+	if (exact) {
+		return exact[0];
+	}
+
+	// First template that matches wins, so declaration order in `ROUTES`
+	// matters when templates can overlap. Today's set is unambiguous because
+	// `[^/]+` is segment-bounded, but if you ever add a sibling like
+	// `/services/list` next to `SERVICE_METRICS: '/services/:servicename'`,
+	// list the more-specific (more-static-segments) entry first in `ROUTES`
+	// — otherwise the param template will swallow the static path.
+	const dynamic = entries.find(
+		([, value]) => value.includes(':') && templateToRegex(value).test(pathname),
+	);
+
+	return dynamic?.[0] ?? 'DEFAULT';
 }

frontend/src/container/LogsExplorerViews/LogsActionsContainer.tsx

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

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

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

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

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

frontend/src/container/LogsExplorerViews/QueryStatus.tsx

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

frontend/src/container/LogsExplorerViews/index.tsx

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

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/TraceDetailsHeader.module.scss

@@ -8,6 +8,7 @@
 	align-items: center;
 	padding: 8px 16px;
 	gap: 8px;
+	min-height: 52px;
 
 	// KeyValueLabel renders with a global `.key-value-label` root; keep it from
 	// shrinking on the trace details header.
@@ -20,6 +21,28 @@
 	flex-shrink: 0;
 }
 
+.traceIdSection {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	flex-shrink: 0;
+}
+
+.filterSection {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	min-width: 0;
+	margin-left: auto;
+}
+
+.headerActions {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	flex-shrink: 0;
+}
+
 .filter {
 	min-width: 0;
 }
@@ -29,15 +52,6 @@
 	flex: 1;
 }
 
-.oldViewBtn {
-	flex-shrink: 0;
-}
-
-.analyticsBtn {
-	flex-shrink: 0;
-	margin-left: auto;
-}
-
 .subHeader {
 	display: flex;
 	align-items: center;

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/TraceDetailsHeader.tsx

@@ -21,6 +21,7 @@ import {
 	ArrowLeft,
 	CalendarClock,
 	ChartPie,
+	CornerUpLeft,
 	Server,
 	Timer,
 } from '@signozhq/icons';
@@ -117,7 +118,7 @@ function TraceDetailsHeader({
 		<div className={styles.wrapper}>
 			<div className={styles.header}>
 				{!isFilterExpanded && (
-					<>
+					<div className={styles.traceIdSection}>
 						<Button
 							variant="solid"
 							color="secondary"
@@ -133,20 +134,39 @@ function TraceDetailsHeader({
 							badgeValue={traceID || ''}
 							maxCharacters={100}
 						/>
-					</>
+					</div>
 				)}
 				{isDataLoaded && (
-					<>
+					<div
+						className={cx(
+							styles.filterSection,
+							isFilterExpanded && styles.isExpanded,
+						)}
+					>
 						{!isFilterExpanded && (
-							<>
-								<TooltipProvider>
+							<TooltipProvider>
+								<div className={styles.headerActions}>
 									<TooltipRoot>
 										<TooltipTrigger asChild>
 											<Button
 												variant="ghost"
 												size="icon"
 												color="secondary"
-												className={styles.analyticsBtn}
+												aria-label="Switch to legacy trace view"
+												onClick={handleSwitchToOldView}
+											>
+												<CornerUpLeft size={14} />
+											</Button>
+										</TooltipTrigger>
+										<TooltipContent>Switch to legacy trace view</TooltipContent>
+									</TooltipRoot>
+									<TooltipRoot>
+										<TooltipTrigger asChild>
+											<Button
+												variant="ghost"
+												size="icon"
+												color="secondary"
+												aria-label="Analytics"
 												onClick={(): void => setIsAnalyticsOpen((prev) => !prev)}
 											>
 												<ChartPie size={14} />
@@ -154,15 +174,18 @@ function TraceDetailsHeader({
 										</TooltipTrigger>
 										<TooltipContent>Analytics</TooltipContent>
 									</TooltipRoot>
-								</TooltipProvider>
-								<TraceOptionsMenu
-									showTraceDetails={showTraceDetails}
-									onToggleTraceDetails={handleToggleTraceDetails}
-									onOpenPreviewFields={(): void => setIsPreviewFieldsOpen(true)}
-								/>
-							</>
+									<TraceOptionsMenu
+										showTraceDetails={showTraceDetails}
+										onToggleTraceDetails={handleToggleTraceDetails}
+										onOpenPreviewFields={(): void => setIsPreviewFieldsOpen(true)}
+									/>
+								</div>
+							</TooltipProvider>
 						)}
-						<div className={cx(styles.filter, isFilterExpanded && styles.isExpanded)}>
+						<div
+							key="filter"
+							className={cx(styles.filter, isFilterExpanded && styles.isExpanded)}
+						>
 							<Filters
 								startTime={filterMetadata.startTime}
 								endTime={filterMetadata.endTime}
@@ -173,18 +196,7 @@ function TraceDetailsHeader({
 								onCollapse={(): void => setIsFilterExpanded(false)}
 							/>
 						</div>
-						{!isFilterExpanded && (
-							<Button
-								variant="solid"
-								color="secondary"
-								size="sm"
-								className={styles.oldViewBtn}
-								onClick={handleSwitchToOldView}
-							>
-								Legacy View
-							</Button>
-						)}
-					</>
+					</div>
 				)}
 			</div>
 

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/TraceOptionsMenu.tsx

@@ -2,7 +2,7 @@ import { useMemo } from 'react';
 import type { MenuItem } from '@signozhq/ui/dropdown-menu';
 import { Button } from '@signozhq/ui/button';
 import { DropdownMenuSimple as Dropdown } from '@signozhq/ui/dropdown-menu';
-import { Ellipsis } from '@signozhq/icons';
+import { Settings2 } from '@signozhq/icons';
 
 import { useTraceStore } from '../stores/traceStore';
 
@@ -93,7 +93,8 @@ function TraceOptionsMenu({
 				variant="ghost"
 				size="icon"
 				color="secondary"
-				prefix={<Ellipsis size={14} />}
+				aria-label="Trace options"
+				prefix={<Settings2 size={14} />}
 			/>
 		</Dropdown>
 	);

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/__tests__/TraceDetailsHeader.test.tsx

@@ -6,6 +6,7 @@ import TraceDetailsHeader from '../TraceDetailsHeader';
 
 const mockGoBack = jest.fn();
 const mockPush = jest.fn();
+const mockReplace = jest.fn();
 const mockHasInAppHistory = jest.fn();
 
 jest.mock('lib/history', () => ({
@@ -13,13 +14,47 @@ jest.mock('lib/history', () => ({
 	default: {
 		goBack: (): void => mockGoBack(),
 		push: (path: string): void => mockPush(path),
-		replace: jest.fn(),
+		replace: (path: string): void => mockReplace(path),
 		location: { pathname: '/', search: '' },
 		listen: (): (() => void) => (): void => undefined,
 	},
 	hasInAppHistory: (): boolean => mockHasInAppHistory(),
 }));
 
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
+	useParams: (): { id: string } => ({ id: 'trace-123' }),
+}));
+
+const mockSetLocalStorageKey = jest.fn();
+jest.mock('api/browser/localstorage/set', () => ({
+	__esModule: true,
+	default: (key: string, value: string): void =>
+		mockSetLocalStorageKey(key, value),
+}));
+
+jest.mock(
+	'../../TraceWaterfall/TraceWaterfallStates/Success/Filters/Filters',
+	() => ({
+		__esModule: true,
+		default: (): JSX.Element => <div data-testid="filters-stub" />,
+	}),
+);
+
+jest.mock('../../SpanDetailsPanel/AnalyticsPanel/AnalyticsPanel', () => ({
+	__esModule: true,
+	default: ({ isOpen }: { isOpen: boolean }): JSX.Element => (
+		<div data-testid="analytics-panel" data-open={isOpen ? 'true' : 'false'} />
+	),
+}));
+
+jest.mock('components/FieldsSelector', () => ({
+	__esModule: true,
+	default: ({ isOpen }: { isOpen: boolean }): JSX.Element => (
+		<div data-testid="fields-selector" data-open={isOpen ? 'true' : 'false'} />
+	),
+}));
+
 const baseProps = {
 	filterMetadata: {
 		startTime: 0,
@@ -58,3 +93,70 @@ describe('TraceDetailsHeader – back button', () => {
 		expect(mockGoBack).not.toHaveBeenCalled();
 	});
 });
+
+describe('TraceDetailsHeader – action cluster', () => {
+	beforeEach(() => {
+		mockReplace.mockClear();
+		mockSetLocalStorageKey.mockClear();
+	});
+
+	it('does not render the action buttons while data is still loading', () => {
+		render(<TraceDetailsHeader {...baseProps} isDataLoaded={false} />);
+
+		expect(
+			screen.queryByRole('button', { name: /switch to legacy trace view/i }),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /^analytics$/i }),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /trace options/i }),
+		).not.toBeInTheDocument();
+	});
+
+	it('renders Legacy View, Analytics, and Settings action buttons once data is loaded', () => {
+		render(<TraceDetailsHeader {...baseProps} isDataLoaded />);
+
+		expect(
+			screen.getByRole('button', { name: /switch to legacy trace view/i }),
+		).toBeInTheDocument();
+		expect(
+			screen.getByRole('button', { name: /^analytics$/i }),
+		).toBeInTheDocument();
+		expect(
+			screen.getByRole('button', { name: /trace options/i }),
+		).toBeInTheDocument();
+	});
+
+	it('routes to the legacy trace view and persists the preference on click', () => {
+		render(<TraceDetailsHeader {...baseProps} isDataLoaded />);
+
+		fireEvent.click(
+			screen.getByRole('button', { name: /switch to legacy trace view/i }),
+		);
+
+		expect(mockSetLocalStorageKey).toHaveBeenCalledWith(
+			'TRACE_DETAILS_PREFER_OLD_VIEW',
+			'true',
+		);
+		expect(mockReplace).toHaveBeenCalledTimes(1);
+		expect(mockReplace).toHaveBeenCalledWith(
+			expect.stringContaining('/trace-old/trace-123'),
+		);
+	});
+
+	it('toggles the AnalyticsPanel open state when the Analytics button is clicked', () => {
+		render(<TraceDetailsHeader {...baseProps} isDataLoaded />);
+
+		const panel = screen.getByTestId('analytics-panel');
+		expect(panel).toHaveAttribute('data-open', 'false');
+
+		const analyticsBtn = screen.getByRole('button', { name: /^analytics$/i });
+
+		fireEvent.click(analyticsBtn);
+		expect(panel).toHaveAttribute('data-open', 'true');
+
+		fireEvent.click(analyticsBtn);
+		expect(panel).toHaveAttribute('data-open', 'false');
+	});
+});

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Filters/Filters.module.scss

@@ -3,12 +3,6 @@
 	align-items: center;
 	gap: 12px;
 
-	// QuerySearch child sets `query-builder-search-v2` globally; size it to the
-	// search container by reaching into the descendant.
-	:global(.query-builder-search-v2) {
-		width: 100%;
-	}
-
 	// ToggleGroup children use generated class names; nest the global selectors
 	// under the local row so they only apply inside this filter row.
 	:global([class*='toggle-group']) {
@@ -20,8 +14,43 @@
 	}
 }
 
+// Expanded-mode root: grows to fill .filter wrapper, and lets the search
+// input flex within. In collapsed mode none of these grow — the whole
+// Filters region is content-sized (just the pill + result + toggle).
 .isExpanded {
 	flex: 1;
+
+	.searchInput {
+		flex: 1;
+	}
+
+	.searchAndNav {
+		flex: 1;
+	}
+}
+
+.categoryControls {
+	display: flex;
+	align-items: center;
+	flex-shrink: 0;
+}
+
+.searchInput {
+	display: flex;
+	align-items: center;
+	min-width: 0;
+}
+
+.searchPill {
+	display: flex;
+	align-items: center;
+	flex-shrink: 0;
+}
+
+.searchAndNav {
+	display: flex;
+	align-items: center;
+	min-width: 0;
 }
 
 .searchContainer {
@@ -29,6 +58,25 @@
 	min-width: 0;
 }
 
+.resultActions {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	flex-shrink: 0;
+}
+
+.expandedActions {
+	display: flex;
+	align-items: center;
+	gap: 2px;
+}
+
+.highlightControl {
+	display: flex;
+	align-items: center;
+	flex-shrink: 0;
+}
+
 .pill {
 	display: flex;
 	align-items: center;
@@ -85,14 +133,6 @@
 	border-radius: 4px;
 }
 
-.collapseBtn {
-	flex-shrink: 0;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	box-shadow: none;
-}
-
 .highlightErrorsToggle {
 	display: flex;
 	align-items: center;
@@ -100,37 +140,3 @@
 	flex-shrink: 0;
 	white-space: nowrap;
 }
-
-.preNextToggle {
-	display: flex;
-	flex-shrink: 0;
-	gap: 12px;
-}
-
-.preNextCount {
-	display: flex;
-	align-items: center;
-	margin: auto;
-	color: var(--l2-foreground);
-	font-family: 'Geist Mono';
-	font-size: 12px;
-	font-weight: 400;
-	line-height: 18px;
-}
-
-.filterStatus {
-	display: flex;
-	align-items: center;
-	gap: 6px;
-	flex-shrink: 0;
-	color: var(--l2-foreground);
-	font-family: 'Geist Mono';
-	font-size: 12px;
-	font-weight: 400;
-	line-height: 18px;
-}
-
-.hasError {
-	color: var(--destructive);
-	cursor: help;
-}

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Filters/Filters.tsx

@@ -1,15 +1,7 @@
 import { useCallback, useRef, useState } from 'react';
 import { useHistory, useLocation } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
-import {
-	ChevronDown,
-	ChevronUp,
-	Copy,
-	Info,
-	Loader,
-	Search,
-	X,
-} from '@signozhq/icons';
+import { ChevronsRight, Copy, Search, X } from '@signozhq/icons';
 import { Switch } from '@signozhq/ui/switch';
 import { ToggleGroup, ToggleGroupItem } from '@signozhq/ui/toggle-group';
 import { toast } from '@signozhq/ui/sonner';
@@ -21,7 +13,6 @@ import {
 	TooltipTrigger,
 } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
-import { AxiosError } from 'axios';
 import cx from 'classnames';
 import QuerySearch from 'components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch';
 import { convertExpressionToFilters } from 'components/QueryBuilderV2/utils';
@@ -42,6 +33,7 @@ import {
 	SpanCategory,
 	useSpanCategoryFilter,
 } from './hooks/useSpanCategoryFilter';
+import QueryResult from './QueryResult';
 
 import styles from './Filters.module.scss';
 
@@ -152,6 +144,16 @@ function Filters({
 		runQuery(expressionRef.current);
 	}, [runQuery]);
 
+	const handleClear = useCallback((): void => {
+		setExpression('');
+		expressionRef.current = '';
+		setFilters({ items: [], op: 'AND' });
+		setFilteredSpanIds([]);
+		onFilteredSpansChange?.([], false);
+		setCurrentSearchedIndex(0);
+		setNoData(false);
+	}, [onFilteredSpansChange]);
+
 	// Expression-based filter hooks
 	const filterProps = {
 		expression,
@@ -266,164 +268,167 @@ function Filters({
 		</div>
 	);
 
-	const statusIndicators = (
-		<>
-			{isFetching && <Loader className="animate-spin" />}
-			{error && (
-				<TooltipRoot>
-					<TooltipTrigger asChild>
-						<span className={cx(styles.filterStatus, styles.hasError)}>
-							<Info />
-							API error
-						</span>
-					</TooltipTrigger>
-					<TooltipContent>
-						{(error as AxiosError)?.message || 'Something went wrong'}
-					</TooltipContent>
-				</TooltipRoot>
-			)}
-			{!error && noData && (
-				<Typography.Text className={styles.filterStatus}>
-					No results found
-				</Typography.Text>
-			)}
-		</>
+	const hasExpression = expression.trim().length > 0;
+	const hasResults = filteredSpanIds.length > 0;
+
+	const handlePrev = useCallback((): void => {
+		handlePrevNext(currentSearchedIndex - 1);
+		setCurrentSearchedIndex((prev) => prev - 1);
+	}, [currentSearchedIndex, handlePrevNext]);
+
+	const handleNext = useCallback((): void => {
+		handlePrevNext(currentSearchedIndex + 1);
+		setCurrentSearchedIndex((prev) => prev + 1);
+	}, [currentSearchedIndex, handlePrevNext]);
+
+	const pill = (
+		/* eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions */
+		<div className={styles.pill} onClick={onExpand}>
+			<Search size={12} />
+			<span className={styles.pillText}>{expression || 'Search...'}</span>
+			{expression && <span className={styles.pillIndicator} />}
+		</div>
 	);
 
-	// --- COLLAPSED VIEW ---
-	if (!isExpanded) {
-		const pill = (
-			/* eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions */
-			<div className={styles.pill} onClick={onExpand}>
-				<Search size={12} />
-				<span className={styles.pillText}>{expression || 'Search...'}</span>
-				{expression && <span className={styles.pillIndicator} />}
-			</div>
-		);
+	const pillWithPopover = expression ? (
+		<TooltipRoot>
+			<TooltipTrigger asChild>{pill}</TooltipTrigger>
+			<TooltipContent side="bottom" align="start">
+				<div className={styles.pillPopover}>
+					<div className={styles.pillPopoverHeader}>
+						<Typography.Text>Search query</Typography.Text>
+						<Button
+							variant="ghost"
+							size="icon"
+							color="secondary"
+							onClick={(): void => {
+								setCopy(expression);
+								toast.success('Copied to clipboard', {
+									richColors: false,
+									position: 'top-right',
+								});
+							}}
+						>
+							<Copy size={12} />
+						</Button>
+					</div>
+					<div className={styles.pillPopoverExpression}>{expression}</div>
+				</div>
+			</TooltipContent>
+		</TooltipRoot>
+	) : (
+		pill
+	);
 
-		return (
-			<TooltipProvider>
-				<div className={styles.root}>
-					{expression ? (
-						<TooltipRoot>
-							<TooltipTrigger asChild>{pill}</TooltipTrigger>
-							<TooltipContent side="bottom" align="start">
-								<div className={styles.pillPopover}>
-									<div className={styles.pillPopoverHeader}>
-										<Typography.Text>Search query</Typography.Text>
+	// Mode-conditional render: only one of (pill | QuerySearch) is mounted
+	// at a time. Collapsing unmounts the editor — half-written queries are
+	// dropped, so collapse can't accidentally commit a malformed expression
+	// and fire an erroring /query_range request.
+	return (
+		<TooltipProvider>
+			{/* eslint-disable-next-line jsx-a11y/no-static-element-interactions */}
+			<div
+				className={cx(styles.root, isExpanded && styles.isExpanded)}
+				ref={containerRef}
+				onBlur={(e): void => {
+					const relatedTarget = e.relatedTarget as Node | null;
+					const blurredIntoSelf = !!containerRef.current?.contains(relatedTarget);
+					if (!blurredIntoSelf) {
+						handleBlur();
+					}
+				}}
+			>
+				{isExpanded && (
+					<div className={styles.categoryControls}>
+						<ToggleGroup
+							type="single"
+							value={selectedCategory}
+							onChange={(value): void => {
+								if (value) {
+									handleCategoryChange(value as SpanCategory);
+								}
+							}}
+							size="sm"
+						>
+							{categories.map((category) => (
+								<ToggleGroupItem key={category} value={category}>
+									{category}
+								</ToggleGroupItem>
+							))}
+						</ToggleGroup>
+					</div>
+				)}
+
+				<div className={styles.searchInput}>
+					{isExpanded ? (
+						<div className={styles.searchAndNav}>
+							<div className={styles.searchContainer}>
+								<QuerySearch
+									queryData={{
+										...BASE_FILTER_QUERY,
+										filters,
+										filter: { expression },
+									}}
+									onChange={handleExpressionChange}
+									onRun={handleRunQuery}
+									dataSource={DataSource.TRACES}
+									placeholder="Enter your filter query (e.g., http.status_code >= 500 AND service.name = 'frontend')"
+								/>
+							</div>
+						</div>
+					) : (
+						<div className={styles.searchPill}>{pillWithPopover}</div>
+					)}
+				</div>
+
+				<div className={styles.resultActions}>
+					<QueryResult
+						hasExpression={hasExpression}
+						hasResults={hasResults}
+						isFetching={isFetching}
+						error={error}
+						noData={noData}
+						currentIndex={currentSearchedIndex}
+						total={filteredSpanIds.length}
+						onPrev={handlePrev}
+						onNext={handleNext}
+						showNavigation={isExpanded}
+					/>
+					{isExpanded && (
+						<div className={styles.expandedActions}>
+							{hasExpression && (
+								<TooltipRoot>
+									<TooltipTrigger asChild>
 										<Button
 											variant="ghost"
 											size="icon"
 											color="secondary"
-											onClick={(): void => {
-												setCopy(expression);
-												toast.success('Copied to clipboard', {
-													richColors: false,
-													position: 'top-right',
-												});
-											}}
+											onClick={handleClear}
 										>
-											<Copy size={12} />
+											<X size={14} />
 										</Button>
-									</div>
-									<div className={styles.pillPopoverExpression}>{expression}</div>
-								</div>
-							</TooltipContent>
-						</TooltipRoot>
-					) : (
-						pill
+									</TooltipTrigger>
+									<TooltipContent>Clear filter</TooltipContent>
+								</TooltipRoot>
+							)}
+							<TooltipRoot>
+								<TooltipTrigger asChild>
+									<Button
+										variant="ghost"
+										size="icon"
+										color="secondary"
+										onClick={onCollapse}
+									>
+										<ChevronsRight size={14} />
+									</Button>
+								</TooltipTrigger>
+								<TooltipContent>Collapse filters</TooltipContent>
+							</TooltipRoot>
+						</div>
 					)}
-					{highlightErrorsToggle}
-					{statusIndicators}
 				</div>
-			</TooltipProvider>
-		);
-	}
 
-	// --- EXPANDED VIEW ---
-	return (
-		<TooltipProvider>
-			<div className={cx(styles.root, styles.isExpanded)}>
-				<ToggleGroup
-					type="single"
-					value={selectedCategory}
-					onChange={(value): void => {
-						if (value) {
-							handleCategoryChange(value as SpanCategory);
-						}
-					}}
-					size="sm"
-				>
-					{categories.map((category) => (
-						<ToggleGroupItem key={category} value={category}>
-							{category}
-						</ToggleGroupItem>
-					))}
-				</ToggleGroup>
-				{/* eslint-disable-next-line jsx-a11y/no-static-element-interactions */}
-				<div
-					className={styles.searchContainer}
-					ref={containerRef}
-					onBlur={(e): void => {
-						if (!containerRef.current?.contains(e.relatedTarget as Node)) {
-							handleBlur();
-						}
-					}}
-				>
-					<QuerySearch
-						queryData={{
-							...BASE_FILTER_QUERY,
-							filters,
-							filter: { expression },
-						}}
-						onChange={handleExpressionChange}
-						onRun={handleRunQuery}
-						dataSource={DataSource.TRACES}
-						placeholder="Enter your filter query (e.g., http.status_code >= 500 AND service.name = 'frontend')"
-					/>
-				</div>
-				{filteredSpanIds.length > 0 && (
-					<div className={styles.preNextToggle}>
-						<Typography.Text className={styles.preNextCount}>
-							{currentSearchedIndex + 1} / {filteredSpanIds.length}
-						</Typography.Text>
-						<Button
-							variant="ghost"
-							size="icon"
-							color="secondary"
-							disabled={currentSearchedIndex === 0}
-							onClick={(): void => {
-								handlePrevNext(currentSearchedIndex - 1);
-								setCurrentSearchedIndex((prev) => prev - 1);
-							}}
-						>
-							<ChevronUp size={14} />
-						</Button>
-						<Button
-							variant="ghost"
-							size="icon"
-							color="secondary"
-							disabled={currentSearchedIndex === filteredSpanIds.length - 1}
-							onClick={(): void => {
-								handlePrevNext(currentSearchedIndex + 1);
-								setCurrentSearchedIndex((prev) => prev + 1);
-							}}
-						>
-							<ChevronDown size={14} />
-						</Button>
-					</div>
-				)}
-				<Button
-					variant="ghost"
-					size="icon"
-					color="secondary"
-					className={styles.collapseBtn}
-					onClick={onCollapse}
-				>
-					<X size={14} />
-				</Button>
-				{highlightErrorsToggle}
-				{statusIndicators}
+				<div className={styles.highlightControl}>{highlightErrorsToggle}</div>
 			</div>
 		</TooltipProvider>
 	);

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Filters/QueryResult.module.scss

@@ -0,0 +1,32 @@
+.resultNavCount {
+	padding: 0 6px;
+	white-space: nowrap;
+	color: var(--l1-foreground);
+	font-family: 'Geist Mono';
+	font-size: 12px;
+}
+
+.resultNavDivider {
+	width: 1px;
+	height: 14px;
+	background: var(--l3-border);
+	margin: 0 4px;
+	flex-shrink: 0;
+}
+
+.filterStatus {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	flex-shrink: 0;
+	color: var(--l2-foreground);
+	font-family: 'Geist Mono';
+	font-size: 12px;
+	font-weight: 400;
+	line-height: 18px;
+}
+
+.hasError {
+	color: var(--destructive);
+	cursor: help;
+}

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Filters/QueryResult.tsx

@@ -0,0 +1,111 @@
+import { ChevronDown, ChevronUp, Info, Loader } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import {
+	TooltipContent,
+	TooltipRoot,
+	TooltipTrigger,
+} from '@signozhq/ui/tooltip';
+import { Typography } from '@signozhq/ui/typography';
+import { AxiosError } from 'axios';
+import cx from 'classnames';
+
+import styles from './QueryResult.module.scss';
+
+type QueryResultProps = {
+	hasExpression: boolean;
+	hasResults: boolean;
+	isFetching: boolean;
+	error: unknown;
+	noData: boolean;
+	currentIndex: number;
+	total: number;
+	onPrev: () => void;
+	onNext: () => void;
+	showNavigation?: boolean;
+};
+
+function QueryResult({
+	hasExpression,
+	hasResults,
+	isFetching,
+	error,
+	noData,
+	currentIndex,
+	total,
+	onPrev,
+	onNext,
+	showNavigation = true,
+}: QueryResultProps): JSX.Element | null {
+	if (!hasExpression) {
+		return null;
+	}
+
+	let content: JSX.Element | null = null;
+	if (hasResults && showNavigation) {
+		// Prefer count over loader on refresh so stale results stay visible.
+		content = (
+			<>
+				<Typography.Text className={styles.resultNavCount}>
+					{currentIndex + 1} / {total}
+				</Typography.Text>
+				<Button
+					variant="ghost"
+					size="icon"
+					color="secondary"
+					disabled={currentIndex === 0}
+					onClick={onPrev}
+				>
+					<ChevronUp size={14} />
+				</Button>
+				<Button
+					variant="ghost"
+					size="icon"
+					color="secondary"
+					disabled={currentIndex === total - 1}
+					onClick={onNext}
+				>
+					<ChevronDown size={14} />
+				</Button>
+			</>
+		);
+	} else if (isFetching) {
+		content = <Loader className="animate-spin" />;
+	} else if (error) {
+		content = (
+			<TooltipRoot>
+				<TooltipTrigger asChild>
+					<span className={cx(styles.filterStatus, styles.hasError)}>
+						<Info />
+						API error
+					</span>
+				</TooltipTrigger>
+				<TooltipContent>
+					{(error as AxiosError)?.message || 'Something went wrong'}
+				</TooltipContent>
+			</TooltipRoot>
+		);
+	} else if (noData) {
+		content = (
+			<Typography.Text className={styles.filterStatus}>
+				No results found
+			</Typography.Text>
+		);
+	}
+
+	if (!content) {
+		return null;
+	}
+
+	return (
+		<>
+			{content}
+			{showNavigation && <span className={styles.resultNavDivider} />}
+		</>
+	);
+}
+
+QueryResult.defaultProps = {
+	showNavigation: true,
+};
+
+export default QueryResult;

frontend/src/styles.scss

@@ -825,4 +825,5 @@ body.ai-assistant-panel-open {
 // overrides
 :root {
 	--input-focus-outline-width: 0;
+	--radius-2: 4px;
 }

frontend/src/utils/permission/index.ts

@@ -135,4 +135,5 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	AI_ASSISTANT: ['ADMIN', 'EDITOR', 'VIEWER'],
 	AI_ASSISTANT_ICON_PREVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
 	MCP_SERVER: ['ADMIN', 'EDITOR', 'VIEWER'],
+	AI_ASSISTANT_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
 };

go.mod

@@ -89,7 +89,6 @@ require (
 	gonum.org/v1/gonum v0.17.0
 	google.golang.org/api v0.272.0
 	google.golang.org/protobuf v1.36.11
-	gopkg.in/evanphx/json-patch.v4 v4.13.0
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
 	k8s.io/apimachinery v0.35.3

pkg/apiserver/signozapiserver/dashboard.go

@@ -14,184 +14,6 @@ import (
 )
 
 func (provider *provider) addDashboardRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/dashboards", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.ListV2), handler.OpenAPIDef{
-		ID:                  "ListDashboardsV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "List dashboards (v2)",
-		Description:         "Returns a page of v2-shape dashboards for the calling user's org. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`title`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`). Pinned dashboards float to the top of each page.",
-		Request:             new(dashboardtypes.ListDashboardsV2Params),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.ListableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.CreateV2), handler.OpenAPIDef{
-		ID:                  "CreateDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Create dashboard (v2)",
-		Description:         "This endpoint creates a dashboard in the v2 format that follows Perses spec.",
-		Request:             new(dashboardtypes.PostableDashboardV2),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusCreated,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.GetV2), handler.OpenAPIDef{
-		ID:                  "GetDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Get dashboard (v2)",
-		Description:         "This endpoint returns a v2-shape dashboard.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.UpdateV2), handler.OpenAPIDef{
-		ID:                  "UpdateDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Update dashboard (v2)",
-		Description:         "This endpoint updates a v2-shape dashboard's metadata, data, and tag set. Locked dashboards are rejected.",
-		Request:             new(dashboardtypes.UpdateableDashboardV2),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.PatchV2), handler.OpenAPIDef{
-		ID:          "PatchDashboardV2",
-		Tags:        []string{"dashboard"},
-		Summary:     "Patch dashboard (v2)",
-		Description: "This endpoint applies an RFC 6902 JSON Patch to a v2-shape dashboard. The patch is applied against the postable view of the dashboard (metadata, data, tags), so individual panels, queries, variables, layouts, or tags can be updated without re-sending the rest of the dashboard. Locked dashboards are rejected.",
-		Request:     new(dashboardtypes.JSONPatchDocument),
-		// Strictly per RFC 6902 the content type is `application/json-patch+json`,
-		// but our OpenAPI generator only reflects schemas for content types it
-		// understands (application/json, form-urlencoded, multipart) — anything
-		// else degrades to `type: string`. Declaring application/json here keeps
-		// the array-of-ops schema visible to spec consumers; the runtime decoder
-		// parses JSON regardless of the request's actual Content-Type header.
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.DeleteV2), handler.OpenAPIDef{
-		ID:                  "DeleteDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Delete dashboard (v2)",
-		Description:         "This endpoint deletes a v2-shape dashboard along with its tag relations. Locked dashboards are rejected.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/lock", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.LockV2), handler.OpenAPIDef{
-		ID:                  "LockDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Lock dashboard (v2)",
-		Description:         "This endpoint locks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/lock", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.UnlockV2), handler.OpenAPIDef{
-		ID:                  "UnlockDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Unlock dashboard (v2)",
-		Description:         "This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	// ViewAccess: pinning only mutates the calling user's pin list, not the
-	// dashboard itself — anyone who can view a dashboard can bookmark it.
-	if err := router.Handle("/api/v2/dashboards/{id}/pins/me", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.PinV2), handler.OpenAPIDef{
-		ID:                  "PinDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Pin a dashboard for the current user (v2)",
-		Description:         "Pins the dashboard for the calling user. A user can pin at most 10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned dashboard is a no-op success.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/pins/me", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.UnpinV2), handler.OpenAPIDef{
-		ID:                  "UnpinDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Unpin a dashboard for the current user (v2)",
-		Description:         "Removes the pin for the calling user. Idempotent — unpinning a dashboard that wasn't pinned still returns 204.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v1/dashboards/{id}/public", handler.New(provider.authzMiddleware.AdminAccess(provider.dashboardHandler.CreatePublic), handler.OpenAPIDef{
 		ID:                  "CreatePublicDashboard",
 		Tags:                []string{"dashboard"},

pkg/apiserver/signozapiserver/tracedetail.go

@@ -29,5 +29,24 @@ func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v4/traces/{traceID}/waterfall", handler.New(
+		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfallV4),
+		handler.OpenAPIDef{
+			ID:                  "GetWaterfallV4",
+			Tags:                []string{"tracedetail"},
+			Summary:             "Get waterfall view for a trace",
+			Description:         "Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3",
+			Request:             new(spantypes.PostableWaterfall),
+			RequestContentType:  "application/json",
+			Response:            new(spantypes.GettableWaterfallTrace),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
 	return nil
 }

pkg/meterreporter/config.go

@@ -1,6 +1,7 @@
 package meterreporter
 
 import (
+	"math/rand/v2"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -15,12 +16,21 @@ type Config struct {
 
 	// Backfill enables sealed-day catch-up from the license creation day.
 	Backfill bool `mapstructure:"backfill"`
+
+	// Jitter is the randomness applied to both the first collect after
+	// Start() and to every subsequent cycle. The first fire happens at a
+	// random time in [0, Jitter); each subsequent cycle takes
+	// Interval - random(0, Jitter). Negative (the default) means "derive
+	// from Interval" via ResolvedJitter, so the value scales with whatever
+	// Interval the user picks.
+	Jitter time.Duration `mapstructure:"jitter"`
 }
 
 func newConfig() factory.Config {
 	return Config{
 		Interval: 6 * time.Hour,
 		Backfill: true,
+		Jitter:   -1, // Negative sentinel. Resolved at use time unless explicitly set.
 	}
 }
 
@@ -29,9 +39,27 @@ func NewConfigFactory() factory.ConfigFactory {
 }
 
 func (c Config) Validate() error {
-	if c.Interval < 5*time.Minute || c.Interval > 24*time.Hour {
-		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidInput, "meterreporter::interval must be between 5m and 24h")
+	if c.Interval < 10*time.Minute || c.Interval > 24*time.Hour {
+		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidInput, "meterreporter::interval must be between 10m and 24h")
+	}
+
+	if c.Jitter >= 0 && (c.Jitter < 10*time.Minute || c.Jitter > c.Interval) {
+		return errors.New(errors.TypeInvalidInput, ErrCodeInvalidInput, "meterreporter::jitter must be between 10m and interval")
 	}
 
 	return nil
 }
+
+// NewJitter returns a fresh random duration sampled uniformly from
+// [0, jitter), where jitter is the configured Jitter or, if the sentinel
+// default is still in place, min(Interval, 2h).
+func (c Config) NewJitter() time.Duration {
+	defaultJitter := 2 * time.Hour
+
+	cap := c.Jitter
+	if cap < 0 {
+		cap = min(c.Interval, defaultJitter)
+	}
+
+	return time.Duration(rand.Int64N(int64(cap)))
+}

pkg/modules/dashboard/dashboard.go

@@ -52,28 +52,6 @@ type Module interface {
 	GetByMetricNames(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string][]map[string]string, error)
 
 	statsreporter.StatsCollector
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-
-	CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error)
-
-	ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error)
-
-	UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error
-
-	PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error
-
-	UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error
-
-	DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 }
 
 type Handler interface {
@@ -96,27 +74,4 @@ type Handler interface {
 	LockUnlock(http.ResponseWriter, *http.Request)
 
 	Delete(http.ResponseWriter, *http.Request)
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-	CreateV2(http.ResponseWriter, *http.Request)
-
-	GetV2(http.ResponseWriter, *http.Request)
-
-	ListV2(http.ResponseWriter, *http.Request)
-
-	UpdateV2(http.ResponseWriter, *http.Request)
-
-	LockV2(http.ResponseWriter, *http.Request)
-
-	UnlockV2(http.ResponseWriter, *http.Request)
-
-	PatchV2(http.ResponseWriter, *http.Request)
-
-	PinV2(http.ResponseWriter, *http.Request)
-
-	UnpinV2(http.ResponseWriter, *http.Request)
-
-	DeleteV2(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/module.go

@@ -10,7 +10,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/coretypes"
@@ -25,10 +24,9 @@ type module struct {
 	analytics   analytics.Analytics
 	orgGetter   organization.Getter
 	queryParser queryparser.QueryParser
-	tagModule   tag.Module
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard")
 	return &module{
 		store:       store,
@@ -36,7 +34,6 @@ func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, an
 		analytics:   analytics,
 		orgGetter:   orgGetter,
 		queryParser: queryParser,
-		tagModule:   tagModule,
 	}
 }
 

pkg/modules/dashboard/impldashboard/store.go

@@ -2,14 +2,10 @@ package impldashboard
 
 import (
 	"context"
-	"strings"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes/listfilter"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 )
@@ -67,206 +63,6 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
-func (store *store) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.StorableDashboard, *dashboardtypes.StorablePublicDashboard, error) {
-	type joinedRow struct {
-		*dashboardtypes.StorableDashboard `bun:",extend"`
-
-		PublicID               *valuer.UUID `bun:"public_id"`
-		PublicCreatedAt        *time.Time   `bun:"public_created_at"`
-		PublicUpdatedAt        *time.Time   `bun:"public_updated_at"`
-		PublicTimeRangeEnabled *bool        `bun:"public_time_range_enabled"`
-		PublicDefaultTimeRange *string      `bun:"public_default_time_range"`
-	}
-
-	row := &joinedRow{StorableDashboard: new(dashboardtypes.StorableDashboard)}
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(row).
-		ColumnExpr("dashboard.id, dashboard.org_id, dashboard.data, dashboard.locked, dashboard.created_at, dashboard.created_by, dashboard.updated_at, dashboard.updated_by").
-		ColumnExpr("pd.id AS public_id, pd.created_at AS public_created_at, pd.updated_at AS public_updated_at, pd.time_range_enabled AS public_time_range_enabled, pd.default_time_range AS public_default_time_range").
-		Join("LEFT JOIN public_dashboard AS pd ON pd.dashboard_id = dashboard.id").
-		Where("dashboard.id = ?", id).
-		Where("dashboard.org_id = ?", orgID).
-		Scan(ctx)
-	if err != nil {
-		return nil, nil, store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-
-	if row.PublicID == nil {
-		return row.StorableDashboard, nil, nil
-	}
-	public := &dashboardtypes.StorablePublicDashboard{
-		Identifiable:     types.Identifiable{ID: *row.PublicID},
-		TimeAuditable:    types.TimeAuditable{CreatedAt: *row.PublicCreatedAt, UpdatedAt: *row.PublicUpdatedAt},
-		TimeRangeEnabled: *row.PublicTimeRangeEnabled,
-		DefaultTimeRange: *row.PublicDefaultTimeRange,
-		DashboardID:      row.ID.StringValue(),
-	}
-	return row.StorableDashboard, public, nil
-}
-
-// ListV2 emits the joined dashboard ⨝ pinned_dashboard ⨝ public_dashboard
-// query the spec calls for. Aliases:
-//
-//	dashboard         — the visitor expects this
-//	pinned_dashboard  AS pin  — only used inside this query
-//	public_dashboard  AS pd   — the visitor expects this
-//
-// Sort is "is_pinned DESC, <sort> <order>" so pinned dashboards float to the
-// top inside the requested ordering. Title-sort goes through the same
-// JSONExtractString path the visitor uses for name/description filtering.
-func (store *store) ListV2(
-	ctx context.Context,
-	orgID valuer.UUID,
-	userID valuer.UUID,
-	params *dashboardtypes.ListDashboardsV2Params,
-) ([]*dashboardtypes.DashboardListRow, int64, error) {
-	compiled, err := listfilter.Compile(params.Query, store.sqlstore.Formatter())
-	if err != nil {
-		return nil, 0, err
-	}
-	type listedRow struct {
-		*dashboardtypes.StorableDashboard `bun:",extend"`
-
-		IsPinned bool  `bun:"is_pinned"`
-		Total    int64 `bun:"total"`
-
-		PublicID               *valuer.UUID `bun:"public_id"`
-		PublicCreatedAt        *time.Time   `bun:"public_created_at"`
-		PublicUpdatedAt        *time.Time   `bun:"public_updated_at"`
-		PublicTimeRangeEnabled *bool        `bun:"public_time_range_enabled"`
-		PublicDefaultTimeRange *string      `bun:"public_default_time_range"`
-	}
-
-	rows := make([]*listedRow, 0)
-
-	q := store.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&rows).
-		ColumnExpr("dashboard.id, dashboard.org_id, dashboard.data, dashboard.locked, dashboard.source, dashboard.created_at, dashboard.created_by, dashboard.updated_at, dashboard.updated_by").
-		ColumnExpr("CASE WHEN pin.user_id IS NOT NULL THEN 1 ELSE 0 END AS is_pinned").
-		ColumnExpr("COUNT(*) OVER () AS total").
-		ColumnExpr("pd.id AS public_id, pd.created_at AS public_created_at, pd.updated_at AS public_updated_at, pd.time_range_enabled AS public_time_range_enabled, pd.default_time_range AS public_default_time_range").
-		Join("LEFT JOIN pinned_dashboard AS pin ON pin.user_id = ? AND pin.dashboard_id = dashboard.id", userID).
-		Join("LEFT JOIN public_dashboard AS pd ON pd.dashboard_id = dashboard.id").
-		Where("dashboard.org_id = ?", orgID).
-		Where("dashboard.source != ?", dashboardtypes.SourceSystem)
-
-	if compiled != nil {
-		q = q.Where(compiled.SQL, compiled.Args...)
-	}
-
-	sortExpr, err := store.sortExprForListV2(params.Sort)
-	if err != nil {
-		return nil, 0, err
-	}
-	q = q.
-		OrderExpr("is_pinned DESC").
-		OrderExpr(sortExpr + " " + strings.ToUpper(string(params.Order))).
-		Limit(params.Limit).
-		Offset(params.Offset)
-
-	if err := q.Scan(ctx); err != nil {
-		return nil, 0, err
-	}
-
-	// COUNT(*) OVER () is computed pre-LIMIT, so any returned row carries the
-	// full filter total. Empty result page => zero matches.
-	var total int64
-	if len(rows) > 0 {
-		total = rows[0].Total
-	}
-
-	out := make([]*dashboardtypes.DashboardListRow, len(rows))
-	for i, r := range rows {
-		row := &dashboardtypes.DashboardListRow{
-			Dashboard: r.StorableDashboard,
-			Pinned:    r.IsPinned,
-		}
-		if r.PublicID != nil {
-			row.Public = &dashboardtypes.StorablePublicDashboard{
-				Identifiable:     types.Identifiable{ID: *r.PublicID},
-				TimeAuditable:    types.TimeAuditable{CreatedAt: *r.PublicCreatedAt, UpdatedAt: *r.PublicUpdatedAt},
-				TimeRangeEnabled: *r.PublicTimeRangeEnabled,
-				DefaultTimeRange: *r.PublicDefaultTimeRange,
-				DashboardID:      r.ID.StringValue(),
-			}
-		}
-		out[i] = row
-	}
-	return out, total, nil
-}
-
-// sortExprForListV2 maps a sort enum to the SQL expression to plug into
-// ORDER BY. Title-sort routes through the SQLFormatter so it stays
-// dialect-aware (matches what listfilter/visitor does for the name filter).
-func (store *store) sortExprForListV2(sort dashboardtypes.ListSort) (string, error) {
-	switch sort {
-	case dashboardtypes.ListSortUpdatedAt:
-		return "dashboard.updated_at", nil
-	case dashboardtypes.ListSortCreatedAt:
-		return "dashboard.created_at", nil
-	case dashboardtypes.ListSortName:
-		return string(store.sqlstore.Formatter().JSONExtractString("dashboard.data", "$.data.display.name")), nil
-	}
-	return "", errors.Newf(errors.TypeInvalidInput, dashboardtypes.ErrCodeDashboardListInvalid,
-		"unsupported sort field %q", sort)
-}
-
-func (store *store) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data dashboardtypes.StorableDashboardData) error {
-	res, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model((*dashboardtypes.StorableDashboard)(nil)).
-		Set("data = ?", data).
-		Set("updated_by = ?", updatedBy).
-		Set("updated_at = ?", time.Now()).
-		Where("id = ?", id).
-		Where("org_id = ?", orgID).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	// Defends against the race where a delete lands between the caller's
-	// pre-update GetV2 and this update.
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-	return nil
-}
-
-func (store *store) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, locked bool, updatedBy string) error {
-	res, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model((*dashboardtypes.StorableDashboard)(nil)).
-		Set("locked = ?", locked).
-		Set("updated_by = ?", updatedBy).
-		Set("updated_at = ?", time.Now()).
-		Where("id = ?", id).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-	return nil
-}
-
 func (store *store) GetPublic(ctx context.Context, dashboardID string) (*dashboardtypes.StorablePublicDashboard, error) {
 	storable := new(dashboardtypes.StorablePublicDashboard)
 	err := store.
@@ -421,51 +217,3 @@ func (store *store) RunInTx(ctx context.Context, cb func(ctx context.Context) er
 		return cb(ctx)
 	})
 }
-
-// PinForUser combines the count check, the existence check, and the upsert in
-// a single statement so the limit gate and the insert can't drift between two
-// round-trips.
-//
-//	pin exists? | count < 10? | WHERE passes?           | effect                            | rows
-//	------------|-------------|-------------------------|-----------------------------------|-----
-//	no          | yes         | yes (count branch)      | INSERT new row                    | 1
-//	no          | no          | no                      | nothing (limit hit)               | 0
-//	yes         | yes         | yes (count branch)      | INSERT → conflict → no-op UPDATE  | 1
-//	yes         | no          | yes (EXISTS OR branch)  | INSERT → conflict → no-op UPDATE  | 1
-//
-// rows = 0 is the only signal of a real limit hit.
-func (store *store) PinForUser(ctx context.Context, pd *dashboardtypes.PinnedDashboard) error {
-	res, err := store.sqlstore.BunDBCtx(ctx).NewRaw(`
-		INSERT INTO pinned_dashboard (user_id, dashboard_id, org_id, pinned_at)
-		SELECT ?, ?, ?, ?
-		WHERE (SELECT COUNT(*) FROM pinned_dashboard WHERE user_id = ?) < ?
-		   OR EXISTS (SELECT 1 FROM pinned_dashboard WHERE user_id = ? AND dashboard_id = ?)
-		ON CONFLICT (user_id, dashboard_id) DO UPDATE SET user_id = EXCLUDED.user_id
-	`,
-		pd.UserID, pd.DashboardID, pd.OrgID, pd.PinnedAt,
-		pd.UserID, dashboardtypes.MaxPinnedDashboardsPerUser,
-		pd.UserID, pd.DashboardID,
-	).Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeAlreadyExists, dashboardtypes.ErrCodePinnedDashboardLimitHit,
-			"cannot pin more than %d dashboards", dashboardtypes.MaxPinnedDashboardsPerUser)
-	}
-	return nil
-}
-
-func (store *store) UnpinForUser(ctx context.Context, userID valuer.UUID, dashboardID valuer.UUID) error {
-	_, err := store.sqlstore.BunDBCtx(ctx).
-		NewDelete().
-		Model((*dashboardtypes.PinnedDashboard)(nil)).
-		Where("user_id = ?", userID).
-		Where("dashboard_id = ?", dashboardID).
-		Exec(ctx)
-	return err
-}

pkg/modules/dashboard/impldashboard/v2_handler.go

@@ -1,358 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"time"
-
-	"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/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-func (handler *handler) CreateV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var req dashboardtypes.PostableDashboardV2
-	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.CreateV2(ctx, orgID, claims.Email, valuer.MustNewUUID(claims.IdentityID()), dashboardtypes.SourceUser, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) ListV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	userID, err := valuer.NewUUID(claims.IdentityID())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	params := new(dashboardtypes.ListDashboardsV2Params)
-	if err := binding.Query.BindQuery(r.URL.Query(), params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	if err := params.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := handler.module.ListV2(ctx, orgID, userID, params)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (handler *handler) GetV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.GetV2(ctx, orgID, dashboardID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) LockV2(rw http.ResponseWriter, r *http.Request) {
-	handler.lockUnlockV2(rw, r, true)
-}
-
-func (handler *handler) UnlockV2(rw http.ResponseWriter, r *http.Request) {
-	handler.lockUnlockV2(rw, r, false)
-}
-
-func (handler *handler) lockUnlockV2(rw http.ResponseWriter, r *http.Request, lock bool) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	isAdmin := false
-	selectors := []coretypes.Selector{
-		coretypes.TypeRole.MustSelector(authtypes.SigNozAdminRoleName),
-	}
-	err = handler.authz.CheckWithTupleCreation(
-		ctx,
-		claims,
-		valuer.MustNewUUID(claims.OrgID),
-		authtypes.Relation{Verb: coretypes.VerbAssignee},
-		coretypes.NewResourceRole(),
-		selectors,
-		selectors,
-	)
-	if err == nil {
-		isAdmin = true
-	}
-
-	if err := handler.module.LockUnlockV2(ctx, orgID, dashboardID, claims.Email, isAdmin, lock); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) UpdateV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := dashboardtypes.UpdateableDashboardV2{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.UpdateV2(ctx, orgID, dashboardID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) PatchV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := dashboardtypes.PatchableDashboardV2{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.PatchV2(ctx, orgID, dashboardID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) PinV2(rw http.ResponseWriter, r *http.Request) {
-	handler.pinUnpinV2(rw, r, true)
-}
-
-func (handler *handler) UnpinV2(rw http.ResponseWriter, r *http.Request) {
-	handler.pinUnpinV2(rw, r, false)
-}
-
-func (handler *handler) pinUnpinV2(rw http.ResponseWriter, r *http.Request, pin bool) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	userID, err := valuer.NewUUID(claims.IdentityID())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if pin {
-		err = handler.module.PinV2(ctx, orgID, userID, dashboardID)
-	} else {
-		err = handler.module.UnpinV2(ctx, userID, dashboardID)
-	}
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) DeleteV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := handler.module.DeleteV2(ctx, orgID, dashboardID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}

pkg/modules/dashboard/impldashboard/v2_module.go

@@ -1,214 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-func (m *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	if !source.IsValid() {
-		return nil, errors.Newf(errors.TypeInvalidInput, dashboardtypes.ErrCodeDashboardInvalidSource, "invalid dashboard source %q, must be one of user, system, integration", source.StringValue())
-	}
-	if err := postable.Validate(); err != nil {
-		return nil, err
-	}
-
-	dashboard := postable.NewDashboardV2(orgID, createdBy, source)
-	var storableDashboard *dashboardtypes.StorableDashboard
-
-	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := m.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, dashboard.ID, postable.Tags)
-		if err != nil {
-			return err
-		}
-		dashboard.Tags = resolvedTags
-
-		storable, err := dashboard.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-		storableDashboard = storable
-		return m.store.Create(ctx, storable)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	m.analytics.TrackUser(ctx, orgID.String(), creator.String(), "Dashboard Created", dashboardtypes.NewStatsFromStorableDashboards([]*dashboardtypes.StorableDashboard{storableDashboard}))
-	return dashboard, nil
-}
-
-func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
-	rows, total, err := module.store.ListV2(ctx, orgID, userID, params)
-	if err != nil {
-		return nil, err
-	}
-
-	dashboardIDs := make([]valuer.UUID, len(rows))
-	for i, r := range rows {
-		dashboardIDs[i] = r.Dashboard.ID
-	}
-	tagsByDashboard, err := module.tagModule.ListForResources(ctx, orgID, coretypes.KindDashboard, dashboardIDs)
-	if err != nil {
-		return nil, err
-	}
-
-	return dashboardtypes.NewListableDashboardV2(rows, total, tagsByDashboard)
-}
-
-func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
-	storable, err := module.store.Get(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	tags, err := module.tagModule.ListForResource(ctx, orgID, coretypes.KindDashboard, id)
-	if err != nil {
-		return nil, err
-	}
-
-	return storable.ToDashboardV2(tags)
-}
-
-func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	if err := updateable.Validate(); err != nil {
-		return nil, err
-	}
-
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	// Locked-dashboard / state gate — independent of tags, so run it before the tx.
-	if err := existing.CanUpdate(); err != nil {
-		return nil, err
-	}
-
-	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updateable.Tags)
-		if err != nil {
-			return err
-		}
-
-		err = existing.Update(updateable, updatedBy, resolvedTags)
-		if err != nil {
-			return err
-		}
-
-		storable, err := existing.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-
-		return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return existing, nil
-}
-
-func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	// Locked-dashboard / state gate — independent of tags, so run it before the tx.
-	if err := existing.CanUpdate(); err != nil {
-		return nil, err
-	}
-
-	updateable, err := patch.Apply(existing)
-	if err != nil {
-		return nil, err
-	}
-
-	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updateable.Tags)
-		if err != nil {
-			return err
-		}
-
-		err = existing.Update(*updateable, updatedBy, resolvedTags)
-		if err != nil {
-			return err
-		}
-
-		storable, err := existing.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-
-		return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return existing, nil
-}
-
-func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return err
-	}
-	if existing.Locked {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete a locked dashboard, please unlock the dashboard to delete")
-	}
-
-	return module.store.RunInTx(ctx, func(ctx context.Context) error {
-		// Syncing to an empty tag set drops every tag link for the dashboard.
-		if _, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, nil); err != nil {
-			return err
-		}
-		return module.store.Delete(ctx, orgID, id)
-	})
-}
-
-// CreatePublicV2 is not supported in the community build.
-func (module *module) CreatePublicV2(_ context.Context, _ valuer.UUID, _ valuer.UUID, _ dashboardtypes.PostablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, dashboardtypes.ErrCodePublicDashboardUnsupported, "not implemented")
-}
-
-// UpdatePublicV2 is not supported in the community build.
-func (module *module) UpdatePublicV2(_ context.Context, _ valuer.UUID, _ valuer.UUID, _ dashboardtypes.UpdatablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, dashboardtypes.ErrCodePublicDashboardUnsupported, "not implemented")
-}
-
-func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return err
-	}
-	if err := existing.LockUnlock(lock, isAdmin, updatedBy); err != nil {
-		return err
-	}
-	storable, err := existing.ToStorableDashboard()
-	if err != nil {
-		return err
-	}
-	return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-}
-
-func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	if _, err := module.GetV2(ctx, orgID, id); err != nil {
-		return err
-	}
-	return module.store.PinForUser(ctx, &dashboardtypes.PinnedDashboard{
-		UserID:      userID,
-		DashboardID: id,
-		OrgID:       orgID,
-		PinnedAt:    time.Now(),
-	})
-}
-
-func (module *module) UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error {
-	return module.store.UnpinForUser(ctx, userID, id)
-}

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -38,3 +38,24 @@ func (h *handler) GetWaterfall(rw http.ResponseWriter, r *http.Request) {
 
 	render.Success(rw, http.StatusOK, result)
 }
+
+func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
+	req := new(spantypes.PostableWaterfall)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := req.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans, req.Limit)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}

pkg/modules/tracedetail/impltracedetail/module.go

@@ -2,6 +2,7 @@ package impltracedetail
 
 import (
 	"context"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
@@ -45,7 +46,7 @@ func (m *module) GetWaterfall(ctx context.Context, traceID string, req *spantype
 	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans, aggregationResults), nil
 }
 
-// getTraceData returns the waterfall cache for the given traceID with fallback on DB.
+// getTraceData fetches all spans for a trace and builds the WaterfallTrace.
 func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.WaterfallTrace, error) {
 	summary, err := m.store.GetTraceSummary(ctx, traceID)
 	if err != nil {
@@ -61,6 +62,86 @@ func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.W
 		return nil, spantypes.ErrTraceNotFound
 	}
 
-	traceData := spantypes.NewWaterfallTraceFromSpans(spanItems)
-	return traceData, nil
+	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
+	for i := range spanItems {
+		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
+	}
+	return spantypes.NewWaterfallTraceFromSpans(nodes), nil
+}
+
+// GetWaterfallV4 is the OOM-safe V4 waterfall.
+// For large traces (NumSpans > effectiveLimit) it uses a two-step fetch:
+// minimal fields for all spans to build the tree, then full fields for the
+// visible window only. Aggregations are not returned.
+func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error) {
+	summary, err := m.store.GetTraceSummary(ctx, traceID)
+	if err != nil {
+		return nil, err
+	}
+	effectiveLimit := min(selectAllLimit, m.config.Waterfall.MaxLimitToSelectAllSpans)
+	if summary.NumSpans > uint64(effectiveLimit) {
+		return m.getWindowedWaterfall(ctx, traceID, selectedSpanID, uncollapsedSpans, summary.Start, summary.End)
+	}
+	return m.getFullWaterfall(ctx, traceID, summary)
+}
+
+func (m *module) getFullWaterfall(ctx context.Context, traceID string, summary *spantypes.TraceSummary) (*spantypes.GettableWaterfallTrace, error) {
+	spanItems, err := m.store.GetTraceSpans(ctx, traceID, summary)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(spanItems) == 0 {
+		return nil, spantypes.ErrTraceNotFound
+	}
+
+	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
+	for i := range spanItems {
+		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
+	}
+	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
+	selectedSpans := waterfallTrace.GetAllSpans()
+
+	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true, nil), nil
+}
+
+// getWindowedWaterfall builds the waterfall tree with minimal data and then returns only a window of full spans.
+func (m *module) getWindowedWaterfall(ctx context.Context, traceID, selectedSpanID string, uncollapsedSpans []string, start, end time.Time) (*spantypes.GettableWaterfallTrace, error) {
+	// Step 1: minimal fetch → build full tree → select visible window
+	minimalSpans, err := m.store.GetMinimalSpans(ctx, traceID, start, end)
+	if err != nil {
+		return nil, err
+	}
+	if len(minimalSpans) == 0 {
+		return nil, spantypes.ErrTraceNotFound
+	}
+
+	nodes := make([]*spantypes.WaterfallSpan, len(minimalSpans))
+	for i := range minimalSpans {
+		nodes[i] = minimalSpans[i].ToWaterfallSpan(traceID)
+	}
+	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
+
+	selectedSpans, uncollapsedSpans := waterfallTrace.GetSelectedSpans(
+		uncollapsedSpans,
+		selectedSpanID,
+		m.config.Waterfall.SpanPageSize,
+		m.config.Waterfall.MaxDepthToAutoExpand,
+	)
+
+	// Step 2: full fetch for the selected window only
+	spanIDs := make([]string, len(selectedSpans))
+	for i, s := range selectedSpans {
+		spanIDs[i] = s.SpanID
+	}
+	fullSpans, err := m.store.GetTraceSpansByIDs(ctx, traceID, start, end, spanIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	spantypes.EnrichSelectedSpans(selectedSpans, fullSpans)
+
+	return spantypes.NewGettableWaterfallTrace(
+		waterfallTrace, selectedSpans, uncollapsedSpans, false, nil,
+	), nil
 }

pkg/modules/tracedetail/impltracedetail/store.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"time"
 
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
 
@@ -12,6 +13,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 )
 
+const colServiceName = `resource_string_service$$$$name` // $ gets escaped so $$$$ converts to $$.
+
 type traceStore struct {
 	telemetryStore telemetrystore.TelemetryStore
 }
@@ -45,8 +48,8 @@ func (s *traceStore) GetTraceSpans(ctx context.Context, traceID string, summary
 	// DISTINCT ON (span_id) is ClickHouse-specific syntax not supported by sqlbuilder
 	query := fmt.Sprintf(`
 		SELECT DISTINCT ON (span_id)
-			timestamp, duration_nano, span_id, trace_id, has_error, kind,
-			resource_string_service$$name, name, links as references,
+			timestamp, duration_nano, span_id, has_error, kind,
+			resource_string_service$$name, name,
 			attributes_string, attributes_number, attributes_bool, resources_string,
 			events, status_message, status_code_string, kind_string, parent_span_id,
 			flags, is_remote, trace_state, status_code,
@@ -69,3 +72,64 @@ func (s *traceStore) GetTraceSpans(ctx context.Context, traceID string, summary
 	}
 	return spanItems, nil
 }
+
+func (s *traceStore) GetMinimalSpans(ctx context.Context, traceID string, start, end time.Time) ([]spantypes.MinimalSpan, error) {
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select(
+		"DISTINCT ON (span_id) span_id",
+		"parent_span_id", "timestamp", "duration_nano", "has_error",
+		colServiceName,
+	)
+	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
+	sb.Where(
+		sb.E("trace_id", traceID),
+		sb.GE("ts_bucket_start", start.Unix()-1800),
+		sb.LE("ts_bucket_start", end.Unix()),
+	)
+	sb.OrderByAsc("timestamp")
+	sb.OrderByAsc("name")
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	var spans []spantypes.MinimalSpan
+	if err := s.telemetryStore.ClickhouseDB().Select(ctx, &spans, query, args...); err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying minimal spans")
+	}
+	return spans, nil
+}
+
+func (s *traceStore) GetTraceSpansByIDs(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]spantypes.StorableSpan, error) {
+	if len(spanIDs) == 0 {
+		return []spantypes.StorableSpan{}, nil
+	}
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select(
+		"DISTINCT ON (span_id) timestamp",
+		"duration_nano", "span_id", "has_error", "kind",
+		colServiceName, "name",
+		"attributes_string", "attributes_number", "attributes_bool", "resources_string",
+		"events", "status_message", "status_code_string", "kind_string", "parent_span_id",
+		"flags", "is_remote", "trace_state", "status_code",
+		"db_name", "db_operation", "http_method", "http_url", "http_host",
+		"external_http_method", "external_http_url", "response_status_code",
+	)
+	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
+	ids := make([]any, len(spanIDs))
+	for i, id := range spanIDs {
+		ids[i] = id
+	}
+	sb.Where(
+		sb.E("trace_id", traceID),
+		sb.In("span_id", ids...),
+		sb.GE("ts_bucket_start", start.Unix()-1800),
+		sb.LE("ts_bucket_start", end.Unix()),
+	)
+	sb.OrderByAsc("timestamp")
+	sb.OrderByAsc("name")
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	var spans []spantypes.StorableSpan
+	if err := s.telemetryStore.ClickhouseDB().Select(ctx, &spans, query, args...); err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying trace spans by IDs")
+	}
+	return spans, nil
+}

pkg/modules/tracedetail/tracedetail.go

@@ -10,9 +10,11 @@ import (
 // Handler exposes HTTP handlers for trace detail APIs.
 type Handler interface {
 	GetWaterfall(http.ResponseWriter, *http.Request)
+	GetWaterfallV4(http.ResponseWriter, *http.Request)
 }
 
 // Module defines the business logic for trace detail operations.
 type Module interface {
 	GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error)
+	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error)
 }

pkg/parser/filterquery/parse.go

@@ -1,33 +0,0 @@
-package filterquery
-
-import (
-	"fmt"
-
-	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/antlr4-go/antlr/v4"
-)
-
-func Parse(query string) (antlr.ParseTree, *antlr.CommonTokenStream, *ErrorCollector) {
-	collector := NewErrorCollector()
-	lexer := grammar.NewFilterQueryLexer(antlr.NewInputStream(query))
-	lexer.RemoveErrorListeners()
-	lexer.AddErrorListener(collector)
-	tokens := antlr.NewCommonTokenStream(lexer, 0)
-	parser := grammar.NewFilterQueryParser(tokens)
-	parser.RemoveErrorListeners()
-	parser.AddErrorListener(collector)
-	return parser.Query(), tokens, collector
-}
-
-type ErrorCollector struct {
-	*antlr.DefaultErrorListener
-	Errors []string
-}
-
-func NewErrorCollector() *ErrorCollector {
-	return &ErrorCollector{}
-}
-
-func (c *ErrorCollector) SyntaxError(_ antlr.Recognizer, _ any, line, column int, msg string, _ antlr.RecognitionException) {
-	c.Errors = append(c.Errors, fmt.Sprintf("syntax error at %d:%d — %s", line, column, msg))
-}

pkg/querier/builder_query.go

@@ -19,6 +19,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
+const traceOutsideRangeWarn = "Query %s references a trace_id that exists between %s and %s (UTC) but lies outside the selected time range; adjust the time range to see results"
+
 type builderQuery[T any] struct {
 	logger         *slog.Logger
 	telemetryStore telemetrystore.TelemetryStore
@@ -199,7 +201,21 @@ func (q *builderQuery[T]) Execute(ctx context.Context) (*qbtypes.Result, error)
 		return q.executeWindowList(ctx)
 	}
 
-	stmt, err := q.stmtBuilder.Build(ctx, q.fromMS, q.toMS, q.kind, q.spec, q.variables)
+	fromMS, toMS := q.fromMS, q.toMS
+	if q.spec.Signal == telemetrytypes.SignalTraces || q.spec.Signal == telemetrytypes.SignalLogs {
+		var overlap bool
+		var warning string
+		fromMS, toMS, overlap, warning = q.narrowWindowByTraceID(ctx, fromMS, toMS)
+		if !overlap {
+			res := emptyResultFor(q.kind, q.spec.Name)
+			if warning != "" {
+				res.Warnings = []string{warning}
+			}
+			return res, nil
+		}
+	}
+
+	stmt, err := q.stmtBuilder.Build(ctx, fromMS, toMS, q.kind, q.spec, q.variables)
 	if err != nil {
 		return nil, err
 	}
@@ -215,6 +231,88 @@ func (q *builderQuery[T]) Execute(ctx context.Context) (*qbtypes.Result, error)
 	return result, nil
 }
 
+// narrowWindowByTraceID inspects the filter for trace_id predicates and clamps
+// [fromMS,toMS] to the time range stored in signoz_traces.distributed_trace_summary.
+// Returns the (possibly narrowed) window, overlap=false when the trace lies
+// completely outside the query window (callers should short-circuit), and a
+// warning string the caller should attach to the empty result when the trace
+// exists but is outside the selected window.
+//
+// When the trace_id is not present in trace_summary the behaviour differs by
+// signal:
+//   - traces: trace_summary is derived from the spans table, so a missing row
+//     means no spans exist for that trace_id; we short-circuit to empty.
+//   - logs: logs can carry a trace_id even when traces are not ingested at all
+//     (e.g. traces disabled). We must not short-circuit; instead leave the
+//     window untouched and let the query run.
+func (q *builderQuery[T]) narrowWindowByTraceID(ctx context.Context, fromMS, toMS uint64) (uint64, uint64, bool, string) {
+	if q.spec.Filter == nil || q.spec.Filter.Expression == "" {
+		return fromMS, toMS, true, ""
+	}
+
+	traceIDs, found := telemetrytraces.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
+	if !found || len(traceIDs) == 0 {
+		return fromMS, toMS, true, ""
+	}
+
+	finder := telemetrytraces.NewTraceTimeRangeFinder(q.telemetryStore)
+	traceStart, traceEnd, exists, err := finder.GetTraceTimeRangeMulti(ctx, traceIDs)
+	if err != nil {
+		return fromMS, toMS, true, ""
+	}
+	if !exists {
+		if q.spec.Signal == telemetrytypes.SignalTraces {
+			q.logger.DebugContext(ctx, "trace_id not found in trace_summary; short-circuiting traces query to empty",
+				slog.Any("trace_ids", traceIDs))
+			return fromMS, toMS, false, ""
+		}
+		q.logger.DebugContext(ctx, "trace_id not found in trace_summary; leaving time range untouched for logs",
+			slog.Any("trace_ids", traceIDs))
+		return fromMS, toMS, true, ""
+	}
+
+	traceStartMS := uint64(traceStart) / 1_000_000
+	traceEndMS := uint64(traceEnd) / 1_000_000
+	if traceStartMS == 0 || traceEndMS == 0 {
+		return fromMS, toMS, true, ""
+	}
+
+	if traceStartMS > toMS || traceEndMS < fromMS {
+		traceStartUTC := time.UnixMilli(int64(traceStartMS)).UTC().Format(time.RFC3339)
+		traceEndUTC := time.UnixMilli(int64(traceEndMS)).UTC().Format(time.RFC3339)
+		return fromMS, toMS, false, fmt.Sprintf(traceOutsideRangeWarn, q.spec.Name, traceStartUTC, traceEndUTC)
+	}
+	if traceStartMS > fromMS {
+		fromMS = traceStartMS
+	}
+	if traceEndMS < toMS {
+		toMS = traceEndMS
+	}
+	q.logger.DebugContext(ctx, "optimized time range using trace_id lookup",
+		slog.String("signal", q.spec.Signal.StringValue()),
+		slog.Any("trace_ids", traceIDs),
+		slog.Uint64("start", fromMS),
+		slog.Uint64("end", toMS))
+	return fromMS, toMS, true, ""
+}
+
+// emptyResultFor returns an empty result payload appropriate for the given kind.
+func emptyResultFor(kind qbtypes.RequestType, queryName string) *qbtypes.Result {
+	var value any
+	switch kind {
+	case qbtypes.RequestTypeTimeSeries:
+		value = &qbtypes.TimeSeriesData{QueryName: queryName}
+	case qbtypes.RequestTypeScalar:
+		value = &qbtypes.ScalarData{QueryName: queryName}
+	default:
+		value = &qbtypes.RawData{QueryName: queryName}
+	}
+	return &qbtypes.Result{
+		Type:  kind,
+		Value: value,
+	}
+}
+
 // executeWithContext executes the query with query window and step context for partial value detection.
 func (q *builderQuery[T]) executeWithContext(ctx context.Context, query string, args []any) (*qbtypes.Result, error) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
@@ -310,42 +408,27 @@ func (q *builderQuery[T]) executeWindowList(ctx context.Context) (*qbtypes.Resul
 	totalBytes := uint64(0)
 	start := time.Now()
 
-	// Check if filter contains trace_id(s) and optimize time range if needed
-	if q.spec.Signal == telemetrytypes.SignalTraces &&
-		q.spec.Filter != nil && q.spec.Filter.Expression != "" {
-
-		traceIDs, found := telemetrytraces.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
-		if found && len(traceIDs) > 0 {
-			finder := telemetrytraces.NewTraceTimeRangeFinder(q.telemetryStore)
-
-			traceStart, traceEnd, ok := finder.GetTraceTimeRangeMulti(ctx, traceIDs)
-			traceStartMS := uint64(traceStart) / 1_000_000
-			traceEndMS := uint64(traceEnd) / 1_000_000
-			if !ok {
-				q.logger.DebugContext(ctx, "failed to get trace time range", slog.Any("trace_ids", traceIDs))
-			} else if traceStartMS > 0 && traceEndMS > 0 {
-				// no overlap — nothing to return
-				if uint64(traceStartMS) > toMS || uint64(traceEndMS) < fromMS {
-					return &qbtypes.Result{
-						Type: qbtypes.RequestTypeRaw,
-						Value: &qbtypes.RawData{
-							QueryName: q.spec.Name,
-						},
-						Stats: qbtypes.ExecStats{
-							DurationMS: uint64(time.Since(start).Milliseconds()),
-						},
-					}, nil
-				}
-
-				// clamp window to trace time range before bucketing
-				if uint64(traceStartMS) > fromMS {
-					fromMS = uint64(traceStartMS)
-				}
-				if uint64(traceEndMS) < toMS {
-					toMS = uint64(traceEndMS)
-				}
-				q.logger.DebugContext(ctx, "optimized time range for traces", slog.Any("trace_ids", traceIDs), slog.Uint64("start", fromMS), slog.Uint64("end", toMS))
+	// Check if filter contains trace_id(s) and optimize time range if needed.
+	// Applies to both traces (the listing this branch was built for) and logs
+	// (which carry trace_id and benefit from the same clamp before bucketing).
+	if q.spec.Signal == telemetrytypes.SignalTraces || q.spec.Signal == telemetrytypes.SignalLogs {
+		var overlap bool
+		var warning string
+		fromMS, toMS, overlap, warning = q.narrowWindowByTraceID(ctx, fromMS, toMS)
+		if !overlap {
+			res := &qbtypes.Result{
+				Type: qbtypes.RequestTypeRaw,
+				Value: &qbtypes.RawData{
+					QueryName: q.spec.Name,
+				},
+				Stats: qbtypes.ExecStats{
+					DurationMS: uint64(time.Since(start).Milliseconds()),
+				},
 			}
+			if warning != "" {
+				res.Warnings = []string{warning}
+			}
+			return res, nil
 		}
 	}
 

pkg/querier/querier.go

@@ -84,244 +84,53 @@ func New(
 	}
 }
 
-// extractShiftFromBuilderQuery extracts the shift value from timeShift function if present.
-func extractShiftFromBuilderQuery[T any](spec qbtypes.QueryBuilderQuery[T]) int64 {
-	for _, fn := range spec.Functions {
-		if fn.Name == qbtypes.FunctionNameTimeShift && len(fn.Args) > 0 {
-			switch v := fn.Args[0].Value.(type) {
-			case float64:
-				return int64(v)
-			case int64:
-				return v
-			case int:
-				return int64(v)
-			case string:
-				if shiftFloat, err := strconv.ParseFloat(v, 64); err == nil {
-					return int64(shiftFloat)
-				}
-			}
-		}
-	}
-	return 0
-}
-
-// adjustTimeRangeForShift adjusts the time range based on the shift value from timeShift function.
-func adjustTimeRangeForShift[T any](spec qbtypes.QueryBuilderQuery[T], tr qbtypes.TimeRange, kind qbtypes.RequestType) qbtypes.TimeRange {
-	// Only apply time shift for time series and scalar queries
-	// Raw/list queries don't support timeshift
-	if kind != qbtypes.RequestTypeTimeSeries && kind != qbtypes.RequestTypeScalar {
-		return tr
-	}
-
-	// Use the ShiftBy field if it's already populated, otherwise extract it
-	shiftBy := spec.ShiftBy
-	if shiftBy == 0 {
-		shiftBy = extractShiftFromBuilderQuery(spec)
-	}
-
-	if shiftBy == 0 {
-		return tr
-	}
-
-	// ShiftBy is in seconds, convert to milliseconds and shift backward in time
-	shiftMS := shiftBy * 1000
-	return qbtypes.TimeRange{
-		From: tr.From - uint64(shiftMS),
-		To:   tr.To - uint64(shiftMS),
-	}
-}
-
 func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error) {
 
 	tmplVars := req.Variables
 	if tmplVars == nil {
 		tmplVars = make(map[string]qbtypes.VariableItem)
 	}
+
 	event := &qbtypes.QBEvent{
 		Version:         "v5",
 		NumberOfQueries: len(req.CompositeQuery.Queries),
 		PanelType:       req.RequestType.StringValue(),
 	}
-	intervalWarnings := []string{}
+	q.populateQBEvent(event, req.CompositeQuery.Queries)
 
-	dependencyQueries := make(map[string]bool)
-	traceOperatorQueries := make(map[string]qbtypes.QueryBuilderTraceOperator)
-
-	for _, query := range req.CompositeQuery.Queries {
-		if query.Type == qbtypes.QueryTypeTraceOperator {
-			if spec, ok := query.Spec.(qbtypes.QueryBuilderTraceOperator); ok {
-				// Parse expression to find dependencies
-				if err := spec.ParseExpression(); err != nil {
-					return nil, err
-				}
-
-				deps := spec.CollectReferencedQueries(spec.ParsedExpression)
-				for _, dep := range deps {
-					dependencyQueries[dep] = true
-				}
-				traceOperatorQueries[spec.Name] = spec
-			}
-		}
+	// TraceOperatorQuery leverages other queries defined in the rangeRequest
+	// Eg: C := A => B
+	// Need to create dependency map { "A": true, "B": true }
+	dependencyQueries, err := q.constructTraceOperatorDependencyMap(req.CompositeQuery.Queries)
+	if err != nil {
+		return nil, err
 	}
 
-	// First pass: collect all metric names that need temporality
-	metricNames := make([]string, 0)
-	for idx, query := range req.CompositeQuery.Queries {
-		event.QueryType = query.Type.StringValue()
-		switch query.Type {
-		case qbtypes.QueryTypeBuilder:
-			if spec, ok := query.Spec.(qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]); ok {
-				for _, agg := range spec.Aggregations {
-					if agg.MetricName != "" {
-						metricNames = append(metricNames, agg.MetricName)
-					}
-				}
-			}
-			// if step interval is not set, we set it ourselves with recommended value
-			// if step interval is set to value which could result in points more than
-			// allowed, we override it.
-			switch spec := query.Spec.(type) {
-			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:
-				event.TracesUsed = true
-				event.FilterApplied = spec.Filter != nil && spec.Filter.Expression != ""
-				event.GroupByApplied = len(spec.GroupBy) > 0
-				if spec.StepInterval.Seconds() == 0 {
-					spec.StepInterval = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.RecommendedStepInterval(req.Start, req.End)),
-					}
-				}
-				if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepInterval(req.Start, req.End)) {
-					newStep := qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.MinAllowedStepInterval(req.Start, req.End)),
-					}
-					intervalWarnings = append(intervalWarnings, fmt.Sprintf(intervalWarn, spec.Name, spec.StepInterval.Seconds(), newStep.Seconds()))
-					spec.StepInterval = newStep
-				}
-				req.CompositeQuery.Queries[idx].Spec = spec
-			case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
-				event.LogsUsed = true
-				event.FilterApplied = spec.Filter != nil && spec.Filter.Expression != ""
-				event.GroupByApplied = len(spec.GroupBy) > 0
-				if spec.StepInterval.Seconds() == 0 {
-					spec.StepInterval = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.RecommendedStepInterval(req.Start, req.End)),
-					}
-				}
-				if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepInterval(req.Start, req.End)) {
-					newStep := qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.MinAllowedStepInterval(req.Start, req.End)),
-					}
-					intervalWarnings = append(intervalWarnings, fmt.Sprintf(intervalWarn, spec.Name, spec.StepInterval.Seconds(), newStep.Seconds()))
-					spec.StepInterval = newStep
-				}
-				req.CompositeQuery.Queries[idx].Spec = spec
-			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
-				event.MetricsUsed = true
-				event.FilterApplied = spec.Filter != nil && spec.Filter.Expression != ""
-				event.GroupByApplied = len(spec.GroupBy) > 0
-
-				if spec.Source == telemetrytypes.SourceMeter {
-					if spec.StepInterval.Seconds() == 0 {
-						spec.StepInterval = qbtypes.Step{Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMeter(req.Start, req.End))}
-					}
-
-					if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepIntervalForMeter(req.Start, req.End)) {
-						newStep := qbtypes.Step{
-							Duration: time.Second * time.Duration(querybuilder.MinAllowedStepIntervalForMeter(req.Start, req.End)),
-						}
-						spec.StepInterval = newStep
-					}
-				} else {
-					if spec.StepInterval.Seconds() == 0 {
-						spec.StepInterval = qbtypes.Step{
-							Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMetric(req.Start, req.End)),
-						}
-					}
-					if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)) {
-						newStep := qbtypes.Step{
-							Duration: time.Second * time.Duration(querybuilder.MinAllowedStepIntervalForMetric(req.Start, req.End)),
-						}
-						intervalWarnings = append(intervalWarnings, fmt.Sprintf(intervalWarn, spec.Name, spec.StepInterval.Seconds(), newStep.Seconds()))
-						spec.StepInterval = newStep
-					}
-				}
-				req.CompositeQuery.Queries[idx].Spec = spec
-			}
-		case qbtypes.QueryTypePromQL:
-			event.MetricsUsed = true
-			switch spec := query.Spec.(type) {
-			case qbtypes.PromQuery:
-				if spec.Step.Seconds() == 0 {
-					spec.Step = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.RecommendedStepIntervalForMetric(req.Start, req.End)),
-					}
-				}
-				req.CompositeQuery.Queries[idx].Spec = spec
-			}
-		case qbtypes.QueryTypeClickHouseSQL:
-			switch spec := query.Spec.(type) {
-			case qbtypes.ClickHouseQuery:
-				if strings.TrimSpace(spec.Query) != "" {
-					event.MetricsUsed = strings.Contains(spec.Query, "signoz_metrics")
-					event.LogsUsed = strings.Contains(spec.Query, "signoz_logs")
-					event.TracesUsed = strings.Contains(spec.Query, "signoz_traces")
-				}
-			}
-		case qbtypes.QueryTypeTraceOperator:
-			if spec, ok := query.Spec.(qbtypes.QueryBuilderTraceOperator); ok {
-				if spec.StepInterval.Seconds() == 0 {
-					spec.StepInterval = qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.RecommendedStepInterval(req.Start, req.End)),
-					}
-				}
-
-				if spec.StepInterval.Seconds() < float64(querybuilder.MinAllowedStepInterval(req.Start, req.End)) {
-					newStep := qbtypes.Step{
-						Duration: time.Second * time.Duration(querybuilder.MinAllowedStepInterval(req.Start, req.End)),
-					}
-					intervalWarnings = append(intervalWarnings, fmt.Sprintf(intervalWarn, spec.Name, spec.StepInterval.Seconds(), newStep.Seconds()))
-					spec.StepInterval = newStep
-				}
-				req.CompositeQuery.Queries[idx].Spec = spec
-			}
-		}
-	}
+	// Step interval is the aggregation parameter for timeseries requests.
+	// We need to set if it is unspecified or adjust it if value is not within recommended range
+	intervalWarnings := q.adjustStepInterval(req.CompositeQuery.Queries, req.Start, req.End)
 
 	queries := make(map[string]qbtypes.Query)
 	steps := make(map[string]qbtypes.Step)
-	missingMetrics := []string{}
-	missingMetricQueries := []string{}
+
+	// Resolve metric metadata once per request: patches each metric-aggregation
+	// query's spec in place, returns the queries whose every aggregation was
+	// missing (used for preseeded empty results), and any dormant-metric
+	// warning string. NotFound errors for never-seen metrics are propagated.
+	missingMetricQueries, dormantMetricsWarningMsg, err := q.resolveMetricMetadata(ctx, req.CompositeQuery.Queries, req.Start, req.End)
+	if err != nil {
+		return nil, err
+	}
+	missingMetricQuerySet := make(map[string]bool, len(missingMetricQueries))
+	for _, name := range missingMetricQueries {
+		missingMetricQuerySet[name] = true
+	}
 
 	for _, query := range req.CompositeQuery.Queries {
-		var queryName string
-		var isTraceOperator bool
+		queryName := query.GetQueryName()
 
-		switch query.Type {
-		case qbtypes.QueryTypeTraceOperator:
-			if spec, ok := query.Spec.(qbtypes.QueryBuilderTraceOperator); ok {
-				queryName = spec.Name
-				isTraceOperator = true
-			}
-		case qbtypes.QueryTypePromQL:
-			if spec, ok := query.Spec.(qbtypes.PromQuery); ok {
-				queryName = spec.Name
-			}
-		case qbtypes.QueryTypeClickHouseSQL:
-			if spec, ok := query.Spec.(qbtypes.ClickHouseQuery); ok {
-				queryName = spec.Name
-			}
-		case qbtypes.QueryTypeBuilder:
-			switch spec := query.Spec.(type) {
-			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:
-				queryName = spec.Name
-			case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
-				queryName = spec.Name
-			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
-				queryName = spec.Name
-			}
-		}
-
-		if !isTraceOperator && dependencyQueries[queryName] {
+		// skip if it is dependecy of traceOperatorQuery
+		if query.GetType() != qbtypes.QueryTypeTraceOperator && dependencyQueries[queryName] {
 			continue
 		}
 
@@ -376,40 +185,13 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 				queries[spec.Name] = bq
 				steps[spec.Name] = spec.StepInterval
 			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
-				var metricTemporality map[string]metrictypes.Temporality
-				var metricTypes map[string]metrictypes.Type
-				if len(metricNames) > 0 {
-					var err error
-					metricTemporality, metricTypes, err = q.metadataStore.FetchTemporalityAndTypeMulti(ctx, req.Start, req.End, metricNames...)
-					if err != nil {
-						q.logger.WarnContext(ctx, "failed to fetch metric temporality", errors.Attr(err), slog.Any("metrics", metricNames))
-						return nil, errors.NewInternalf(errors.CodeInternal, "failed to fetch metrics temporality")
-					}
-					q.logger.DebugContext(ctx, "fetched metric temporalities and types", slog.Any("metric_temporality", metricTemporality), slog.Any("metric_types", metricTypes))
-				}
-				presentAggregations := []qbtypes.MetricAggregation{}
-				for i := range spec.Aggregations {
-					if spec.Aggregations[i].MetricName != "" && spec.Aggregations[i].Temporality == metrictypes.Unknown {
-						if temp, ok := metricTemporality[spec.Aggregations[i].MetricName]; ok && temp != metrictypes.Unknown {
-							spec.Aggregations[i].Temporality = temp
-						}
-					}
-					if spec.Aggregations[i].MetricName != "" && spec.Aggregations[i].Type == metrictypes.UnspecifiedType {
-						if foundMetricType, ok := metricTypes[spec.Aggregations[i].MetricName]; ok && foundMetricType != metrictypes.UnspecifiedType {
-							spec.Aggregations[i].Type = foundMetricType
-						}
-					}
-					if spec.Aggregations[i].Type == metrictypes.UnspecifiedType {
-						missingMetrics = append(missingMetrics, spec.Aggregations[i].MetricName)
-						continue
-					}
-					presentAggregations = append(presentAggregations, spec.Aggregations[i])
-				}
-				if len(presentAggregations) == 0 {
-					missingMetricQueries = append(missingMetricQueries, spec.Name)
+				// Spec was already patched by resolveMetricMetadata. Queries
+				// whose every aggregation was missing live in
+				// missingMetricQuerySet and produce empty preseeded results
+				// rather than running here.
+				if missingMetricQuerySet[spec.Name] {
 					continue
 				}
-				spec.Aggregations = presentAggregations
 				spec.ShiftBy = extractShiftFromBuilderQuery(spec)
 				timeRange := adjustTimeRangeForShift(spec, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType)
 				var bq *builderQuery[qbtypes.MetricAggregation]
@@ -428,38 +210,6 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 			}
 		}
 	}
-	nonExistentMetrics := []string{}
-	var dormantMetricsWarningMsg string
-	if len(missingMetrics) > 0 {
-		lastSeenInfo, _ := q.metadataStore.FetchLastSeenInfoMulti(ctx, missingMetrics...)
-		for _, missingMetricName := range missingMetrics {
-			if ts, ok := lastSeenInfo[missingMetricName]; ok && ts > 0 {
-				continue
-			}
-			nonExistentMetrics = append(nonExistentMetrics, missingMetricName)
-		}
-		if len(nonExistentMetrics) == 1 {
-			return nil, errors.NewNotFoundf(errors.CodeNotFound, "could not find the metric %s", nonExistentMetrics[0])
-		} else if len(nonExistentMetrics) > 1 {
-			return nil, errors.NewNotFoundf(errors.CodeNotFound, "the following metrics were not found: %s", strings.Join(nonExistentMetrics, ", "))
-		}
-		lastSeenStr := func(name string) string {
-			if ts, ok := lastSeenInfo[name]; ok && ts > 0 {
-				ago := humanize.RelTime(time.UnixMilli(ts), time.Now(), "ago", "from now")
-				return fmt.Sprintf("%s (last seen %s)", name, ago)
-			}
-			return name // this case won't come cuz lastSeenStr is never called for metrics in nonExistentMetrics
-		}
-		if len(missingMetrics) == 1 {
-			dormantMetricsWarningMsg = fmt.Sprintf("no data found for the metric %s in the query time range", lastSeenStr(missingMetrics[0]))
-		} else {
-			parts := make([]string, len(missingMetrics))
-			for i, m := range missingMetrics {
-				parts[i] = lastSeenStr(m)
-			}
-			dormantMetricsWarningMsg = fmt.Sprintf("no data found for the following metrics in the query time range: %s", strings.Join(parts, ", "))
-		}
-	}
 	preseededResults := make(map[string]any)
 	for _, name := range missingMetricQueries { // at this point missing metrics will not have any non existent metrics, only normal ones
 		switch req.RequestType {
@@ -496,6 +246,166 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 	return qbResp, qbErr
 }
 
+func (q *querier) populateQBEvent(event *qbtypes.QBEvent, queries []qbtypes.QueryEnvelope) {
+	for _, query := range queries {
+		// BUG: QueryType doesn't make sense as range_request can have multiple query types.
+		event.QueryType = query.Type.StringValue()
+
+		switch query.Type {
+		case qbtypes.QueryTypeBuilder:
+			filter := query.GetFilter()
+			event.FilterApplied = event.FilterApplied || (filter != nil && filter.Expression != "")
+			event.GroupByApplied = event.GroupByApplied || len(query.GetGroupBy()) > 0
+			switch query.Spec.(type) {
+			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:
+				event.TracesUsed = true
+			case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
+				event.LogsUsed = true
+			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
+				event.MetricsUsed = true
+			}
+		case qbtypes.QueryTypePromQL:
+			event.MetricsUsed = true
+		case qbtypes.QueryTypeTraceOperator:
+			event.TracesUsed = true
+		case qbtypes.QueryTypeClickHouseSQL:
+			sql := query.GetQuery()
+			if strings.TrimSpace(sql) != "" {
+				event.MetricsUsed = strings.Contains(sql, "signoz_metrics")
+				event.LogsUsed = strings.Contains(sql, "signoz_logs")
+				event.TracesUsed = strings.Contains(sql, "signoz_traces")
+			}
+		}
+	}
+}
+
+// resolveMetricMetadata fetches metadata for every metric referenced by builder
+// metric-aggregation queries, patches each query's aggregations in place with
+// the resolved values, and classifies any metric that could not be resolved.
+//
+// Side effects on queries:
+//   - Aggregations with Unknown Temporality / UnspecifiedType are filled in from
+//     the metadata store.
+//   - Aggregations whose Type is still UnspecifiedType after the patch are
+//     dropped from the spec.
+//   - Queries whose entire aggregation list was dropped are NOT patched and are
+//     surfaced via the returned missingMetricQueries; the caller should skip
+//     them.
+//
+// Returns:
+//   - missingMetricQueries: names of queries whose every aggregation was
+//     missing. Used downstream to preseed empty result placeholders so the
+//     response still has an entry per requested query name.
+//   - dormantWarning: a human-readable warning describing metrics that exist in
+//     the store but produced no data within the query window. Empty when no
+//     such metrics are present.
+//   - err: NotFound when one or more referenced metrics have never been seen,
+//     or Internal when a metadata fetch fails.
+func (q *querier) resolveMetricMetadata(ctx context.Context, queries []qbtypes.QueryEnvelope, start, end uint64) (missingMetricQueries []string, dormantWarning string, err error) {
+	metricNames := make([]string, 0)
+	for idx := range queries {
+		if queries[idx].Type != qbtypes.QueryTypeBuilder {
+			continue
+		}
+		spec, ok := queries[idx].Spec.(qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation])
+		if !ok {
+			continue
+		}
+		for _, agg := range spec.Aggregations {
+			if agg.MetricName != "" {
+				metricNames = append(metricNames, agg.MetricName)
+			}
+		}
+	}
+
+	if len(metricNames) == 0 {
+		return nil, "", nil
+	}
+
+	metricTemporality, metricTypes, err := q.metadataStore.FetchTemporalityAndTypeMulti(ctx, start, end, metricNames...)
+	if err != nil {
+		q.logger.WarnContext(ctx, "failed to fetch metric temporality", errors.Attr(err), slog.Any("metrics", metricNames))
+		return nil, "", errors.NewInternalf(errors.CodeInternal, "failed to fetch metrics temporality")
+	}
+	q.logger.DebugContext(ctx, "fetched metric temporalities and types", slog.Any("metric_temporality", metricTemporality), slog.Any("metric_types", metricTypes))
+
+	missingMetrics := []string{}
+	for idx := range queries {
+		if queries[idx].Type != qbtypes.QueryTypeBuilder {
+			continue
+		}
+		spec, ok := queries[idx].Spec.(qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation])
+		if !ok {
+			continue
+		}
+
+		presentAggregations := make([]qbtypes.MetricAggregation, 0, len(spec.Aggregations))
+		for i := range spec.Aggregations {
+			if spec.Aggregations[i].MetricName != "" && spec.Aggregations[i].Temporality == metrictypes.Unknown {
+				if temp, ok := metricTemporality[spec.Aggregations[i].MetricName]; ok && temp != metrictypes.Unknown {
+					spec.Aggregations[i].Temporality = temp
+				}
+			}
+			if spec.Aggregations[i].MetricName != "" && spec.Aggregations[i].Type == metrictypes.UnspecifiedType {
+				if foundMetricType, ok := metricTypes[spec.Aggregations[i].MetricName]; ok && foundMetricType != metrictypes.UnspecifiedType {
+					spec.Aggregations[i].Type = foundMetricType
+				}
+			}
+			if spec.Aggregations[i].Type == metrictypes.UnspecifiedType {
+				missingMetrics = append(missingMetrics, spec.Aggregations[i].MetricName)
+				continue
+			}
+			presentAggregations = append(presentAggregations, spec.Aggregations[i])
+		}
+		if len(presentAggregations) == 0 {
+			missingMetricQueries = append(missingMetricQueries, spec.Name)
+			continue
+		}
+		spec.Aggregations = presentAggregations
+		queries[idx].Spec = spec
+	}
+
+	if len(missingMetrics) == 0 {
+		return missingMetricQueries, "", nil
+	}
+
+	// Classify each missing metric: never-seen → NotFound error; seen-but-no-
+	// data-in-window → dormant warning.
+	lastSeenInfo, _ := q.metadataStore.FetchLastSeenInfoMulti(ctx, missingMetrics...)
+	nonExistentMetrics := []string{}
+	for _, name := range missingMetrics {
+		if ts, ok := lastSeenInfo[name]; ok && ts > 0 {
+			continue
+		}
+		nonExistentMetrics = append(nonExistentMetrics, name)
+	}
+	if len(nonExistentMetrics) == 1 {
+		return nil, "", errors.NewNotFoundf(errors.CodeNotFound, "could not find the metric %s", nonExistentMetrics[0])
+	}
+	if len(nonExistentMetrics) > 1 {
+		return nil, "", errors.NewNotFoundf(errors.CodeNotFound, "the following metrics were not found: %s", strings.Join(nonExistentMetrics, ", "))
+	}
+
+	// All missing metrics are dormant — assemble the warning string.
+	lastSeenStr := func(name string) string {
+		if ts, ok := lastSeenInfo[name]; ok && ts > 0 {
+			ago := humanize.RelTime(time.UnixMilli(ts), time.Now(), "ago", "from now")
+			return fmt.Sprintf("%s (last seen %s)", name, ago)
+		}
+		return name
+	}
+	if len(missingMetrics) == 1 {
+		dormantWarning = fmt.Sprintf("no data found for the metric %s in the query time range", lastSeenStr(missingMetrics[0]))
+	} else {
+		parts := make([]string, len(missingMetrics))
+		for i, m := range missingMetrics {
+			parts[i] = lastSeenStr(m)
+		}
+		dormantWarning = fmt.Sprintf("no data found for the following metrics in the query time range: %s", strings.Join(parts, ", "))
+	}
+	return missingMetricQueries, dormantWarning, nil
+}
+
 func (q *querier) QueryRawStream(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream) {
 
 	event := &qbtypes.QBEvent{
@@ -1093,3 +1003,129 @@ func (q *querier) mergeTimeSeriesResults(cachedValue *qbtypes.TimeSeriesData, fr
 
 	return result
 }
+
+func secondsStep(s uint64) qbtypes.Step {
+	return qbtypes.Step{Duration: time.Second * time.Duration(s)}
+}
+
+// clampStep sets the step to recommended when zero and clamps to min when below it.
+// When clamped and warn is true, a warning is appended for the user.
+func clampStep(qe *qbtypes.QueryEnvelope, recommended, min uint64, warnings *[]string) {
+	step := qe.GetStepInterval()
+	if step.Seconds() == 0 {
+		step = secondsStep(recommended)
+		qe.SetStepInterval(step)
+	}
+	if step.Seconds() < float64(min) {
+		newStep := secondsStep(min)
+		*warnings = append(*warnings, fmt.Sprintf(intervalWarn, qe.GetQueryName(), step.Seconds(), newStep.Seconds()))
+		qe.SetStepInterval(newStep)
+	}
+}
+
+// extractShiftFromBuilderQuery extracts the shift value from timeShift function if present.
+func extractShiftFromBuilderQuery[T any](spec qbtypes.QueryBuilderQuery[T]) int64 {
+	for _, fn := range spec.Functions {
+		if fn.Name == qbtypes.FunctionNameTimeShift && len(fn.Args) > 0 {
+			switch v := fn.Args[0].Value.(type) {
+			case float64:
+				return int64(v)
+			case int64:
+				return v
+			case int:
+				return int64(v)
+			case string:
+				if shiftFloat, err := strconv.ParseFloat(v, 64); err == nil {
+					return int64(shiftFloat)
+				}
+			}
+		}
+	}
+	return 0
+}
+
+// adjustTimeRangeForShift adjusts the time range based on the shift value from timeShift function.
+func adjustTimeRangeForShift[T any](spec qbtypes.QueryBuilderQuery[T], tr qbtypes.TimeRange, kind qbtypes.RequestType) qbtypes.TimeRange {
+	// Only apply time shift for time series and scalar queries
+	// Raw/list queries don't support timeshift
+	if kind != qbtypes.RequestTypeTimeSeries && kind != qbtypes.RequestTypeScalar {
+		return tr
+	}
+
+	// Use the ShiftBy field if it's already populated, otherwise extract it
+	shiftBy := spec.ShiftBy
+	if shiftBy == 0 {
+		shiftBy = extractShiftFromBuilderQuery(spec)
+	}
+
+	if shiftBy == 0 {
+		return tr
+	}
+
+	// ShiftBy is in seconds, convert to milliseconds and shift backward in time
+	shiftMS := shiftBy * 1000
+	return qbtypes.TimeRange{
+		From: tr.From - uint64(shiftMS),
+		To:   tr.To - uint64(shiftMS),
+	}
+}
+
+func (q *querier) constructTraceOperatorDependencyMap(queries []qbtypes.QueryEnvelope) (map[string]bool, error) {
+	dependencyQueries := make(map[string]bool)
+
+	for _, query := range queries {
+		if query.Type == qbtypes.QueryTypeTraceOperator {
+			if spec, ok := query.Spec.(qbtypes.QueryBuilderTraceOperator); ok {
+				// Parse expression to find dependencies
+				if err := spec.ParseExpression(); err != nil {
+					return nil, err
+				}
+
+				deps := spec.CollectReferencedQueries(spec.ParsedExpression)
+				for _, dep := range deps {
+					dependencyQueries[dep] = true
+				}
+			}
+		}
+	}
+
+	return dependencyQueries, nil
+}
+
+// adjustStepInterval normalizes each query's step interval in place and returns
+// any clamp warnings emitted along the way.
+func (q *querier) adjustStepInterval(queries []qbtypes.QueryEnvelope, start, end uint64) []string {
+	// Compute the per-signal bounds once per call — they only depend on start/end.
+	traceLogRecommended := querybuilder.RecommendedStepInterval(start, end)
+	traceLogMin := querybuilder.MinAllowedStepInterval(start, end)
+	meterRecommended := querybuilder.RecommendedStepIntervalForMeter(start, end)
+	meterMin := querybuilder.MinAllowedStepIntervalForMeter(start, end)
+	metricRecommended := querybuilder.RecommendedStepIntervalForMetric(start, end)
+	metricMin := querybuilder.MinAllowedStepIntervalForMetric(start, end)
+
+	warnings := make([]string, 0)
+	for idx := range queries {
+		qe := &queries[idx]
+		switch qe.Type {
+		case qbtypes.QueryTypeBuilder:
+			switch qe.Spec.(type) {
+			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation], qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
+				clampStep(qe, traceLogRecommended, traceLogMin, &warnings)
+			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
+				if qe.GetSource() == telemetrytypes.SourceMeter {
+					clampStep(qe, meterRecommended, meterMin, &warnings)
+				} else {
+					clampStep(qe, metricRecommended, metricMin, &warnings)
+				}
+			}
+		case qbtypes.QueryTypePromQL:
+			// PromQL only fills an unset step — no min clamp.
+			if qe.GetStepInterval().Seconds() == 0 {
+				qe.SetStepInterval(secondsStep(metricRecommended))
+			}
+		case qbtypes.QueryTypeTraceOperator:
+			clampStep(qe, traceLogRecommended, traceLogMin, &warnings)
+		}
+	}
+	return warnings
+}

pkg/signoz/handler_test.go

@@ -49,7 +49,7 @@ func TestNewHandlers(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/module_test.go

@@ -50,7 +50,7 @@ func TestNewModules(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/provider.go

@@ -209,7 +209,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddScopeToPlannedMaintenanceFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateInstalledIntegrationDashboardsFactory(sqlstore),
 		sqlmigration.NewAddDashboardNameFactory(sqlstore, sqlschema),
-		sqlmigration.NewAddPinnedDashboardFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/signoz/signoz.go

@@ -33,7 +33,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/modules/tag/impltag"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -108,7 +107,7 @@ func New(
 	telemetrystoreProviderFactories factory.NamedMap[factory.ProviderFactory[telemetrystore.TelemetryStore, telemetrystore.Config]],
 	authNsCallback func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error),
 	authzCallback func(context.Context, sqlstore.SQLStore, authz.Config, licensing.Licensing, []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error),
-	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module) dashboard.Module,
+	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing) dashboard.Module,
 	gatewayProviderFactory func(licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config],
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
 	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
@@ -341,7 +340,7 @@ func New(
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
 
 	// Initialize dashboard module
-	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing)
 
 	// Initialize user getter
 	userGetter := impluser.NewGetter(userStore, userRoleStore, flagger)

pkg/sqlmigration/090_add_pinned_dashboard.go

@@ -1,67 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addPinnedDashboard struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewAddPinnedDashboardFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_pinned_dashboard"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-		return &addPinnedDashboard{
-			sqlstore:  sqlstore,
-			sqlschema: sqlschema,
-		}, nil
-	})
-}
-
-func (migration *addPinnedDashboard) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addPinnedDashboard) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "pinned_dashboard",
-		Columns: []*sqlschema.Column{
-			{Name: "user_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "dashboard_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "pinned_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false, Default: "current_timestamp"},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{ColumnNames: []sqlschema.ColumnName{"user_id", "dashboard_id"}},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addPinnedDashboard) Down(_ context.Context, _ *bun.DB) error {
-	return nil
-}

pkg/telemetrytraces/trace_time_range.go

@@ -21,19 +21,19 @@ func NewTraceTimeRangeFinder(telemetryStore telemetrystore.TelemetryStore) *Trac
 	}
 }
 
-func (f *TraceTimeRangeFinder) GetTraceTimeRange(ctx context.Context, traceID string) (startNano, endNano int64, ok bool) {
+func (f *TraceTimeRangeFinder) GetTraceTimeRange(ctx context.Context, traceID string) (startNano, endNano int64, exists bool, error error) {
 	traceIDs := []string{traceID}
 	return f.GetTraceTimeRangeMulti(ctx, traceIDs)
 }
 
-func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, traceIDs []string) (startNano, endNano int64, ok bool) {
+func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, traceIDs []string) (startNano, endNano int64, exists bool, error error) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
 		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalTraces.StringValue(),
 		instrumentationtypes.CodeNamespace:    "trace-time-range",
 		instrumentationtypes.CodeFunctionName: "GetTraceTimeRangeMulti",
 	})
 	if len(traceIDs) == 0 {
-		return 0, 0, false
+		return 0, 0, false, nil
 	}
 
 	cleanedIDs := make([]string, len(traceIDs))
@@ -49,7 +49,8 @@ func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, trace
 	}
 
 	query := fmt.Sprintf(`
-		SELECT 
+		SELECT
+			count(),
 			toUnixTimestamp64Nano(min(start)),
 			toUnixTimestamp64Nano(max(end))
 		FROM %s.%s
@@ -58,9 +59,14 @@ func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, trace
 
 	row := f.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...)
 
-	err := row.Scan(&startNano, &endNano)
+	var rowCount uint64
+	err := row.Scan(&rowCount, &startNano, &endNano)
 	if err != nil {
-		return 0, 0, false
+		return 0, 0, false, err
+	}
+
+	if rowCount == 0 {
+		return 0, 0, false, nil
 	}
 
 	if startNano > 1_000_000_000 {
@@ -68,5 +74,5 @@ func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, trace
 	}
 	endNano += 1_000_000_000
 
-	return startNano, endNano, true
+	return startNano, endNano, true, nil
 }

pkg/telemetrytraces/trace_time_range_multi_test.go

@@ -43,7 +43,7 @@ func TestGetTraceTimeRangeMulti(t *testing.T) {
 			finder := &TraceTimeRangeFinder{telemetryStore: nil}
 
 			if !tt.expectOK {
-				_, _, ok := finder.GetTraceTimeRangeMulti(ctx, tt.traceIDs)
+				_, _, ok, _ := finder.GetTraceTimeRangeMulti(ctx, tt.traceIDs)
 				assert.False(t, ok)
 			}
 		})

pkg/types/dashboardtypes/list_v2.go

@@ -1,150 +0,0 @@
-package dashboardtypes
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-)
-
-const (
-	DefaultListLimit = 20
-	MaxListLimit     = 200
-)
-
-// ListSort is the sort field for the dashboard list endpoint. The value is a
-// stable enum so callers can't ask for arbitrary columns.
-type ListSort string
-
-const (
-	ListSortUpdatedAt ListSort = "updated_at"
-	ListSortCreatedAt ListSort = "created_at"
-	ListSortName      ListSort = "name"
-)
-
-type ListOrder string
-
-const (
-	ListOrderAsc  ListOrder = "asc"
-	ListOrderDesc ListOrder = "desc"
-)
-
-var ErrCodeDashboardListInvalid = errors.MustNewCode("dashboard_list_invalid")
-
-type ListDashboardsV2Params struct {
-	Query  string    `query:"query"`
-	Sort   ListSort  `query:"sort"`
-	Order  ListOrder `query:"order"`
-	Limit  int       `query:"limit"`
-	Offset int       `query:"offset"`
-}
-
-// Validate fills in defaults (sort=updated_at, order=desc, limit=20) and
-// rejects out-of-allowlist sort/order values and bad limit/offset. Limit is
-// clamped to MaxListLimit on the high side. Lowercases sort/order so callers
-// can pass them in any case.
-func (p *ListDashboardsV2Params) Validate() error {
-	if p.Sort == "" {
-		p.Sort = ListSortUpdatedAt
-	} else {
-		p.Sort = ListSort(strings.ToLower(string(p.Sort)))
-		switch p.Sort {
-		case ListSortUpdatedAt, ListSortCreatedAt, ListSortName:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-				"invalid sort %q — expected one of: updated_at, created_at, name", p.Sort)
-		}
-	}
-
-	if p.Order == "" {
-		p.Order = ListOrderDesc
-	} else {
-		p.Order = ListOrder(strings.ToLower(string(p.Order)))
-		switch p.Order {
-		case ListOrderAsc, ListOrderDesc:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-				"invalid order %q — expected asc or desc", p.Order)
-		}
-	}
-
-	if p.Limit == 0 {
-		p.Limit = DefaultListLimit
-	} else if p.Limit < 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-			"invalid limit %d — must be a positive integer", p.Limit)
-	} else if p.Limit > MaxListLimit {
-		p.Limit = MaxListLimit
-	}
-
-	if p.Offset < 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-			"invalid offset %d — must be a non-negative integer", p.Offset)
-	}
-
-	return nil
-}
-
-type listedDashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID         valuer.UUID             `json:"orgId" required:"true"`
-	Locked        bool                    `json:"locked" required:"true"`
-	Source        Source                  `json:"source" required:"true"`
-	SchemaVersion string                  `json:"schemaVersion" required:"true"`
-	Name          string                  `json:"name" required:"true"`
-	Pinned        bool                    `json:"pinned" required:"true"`
-	Tags          []*tagtypes.GettableTag `json:"tags" required:"true" nullable:"false"`
-	Spec          listedDashboardV2Spec   `json:"spec" required:"true"`
-}
-
-type listedDashboardV2Spec struct {
-	Display *common.Display `json:"display,omitempty"`
-}
-
-type ListableDashboardV2 struct {
-	Dashboards []*listedDashboardV2 `json:"dashboards" required:"true" nullable:"false"`
-	Total      int64                `json:"total" required:"true"`
-}
-
-// DashboardListRow is the per-row shape Store.ListV2 returns. Bundles the
-// joined dashboard / public_dashboard / pinned_dashboard data so the module
-// layer can attach tags and assemble the gettable view.
-type DashboardListRow struct {
-	Dashboard *StorableDashboard
-	Public    *StorablePublicDashboard // nil if no public_dashboard row exists
-	Pinned    bool
-}
-
-func NewListableDashboardV2(rows []*DashboardListRow, total int64, tagsByEntity map[valuer.UUID][]*tagtypes.Tag) (*ListableDashboardV2, error) {
-	dashboards := make([]*listedDashboardV2, len(rows))
-	for i, r := range rows {
-		v2, err := r.Dashboard.ToDashboardV2(tagsByEntity[r.Dashboard.ID])
-		if err != nil {
-			return nil, err
-		}
-
-		dashboards[i] = &listedDashboardV2{
-			Identifiable:  v2.Identifiable,
-			TimeAuditable: v2.TimeAuditable,
-			UserAuditable: v2.UserAuditable,
-			OrgID:         v2.OrgID,
-			Locked:        v2.Locked,
-			Source:        v2.Source,
-			SchemaVersion: v2.SchemaVersion,
-			Name:          v2.Name,
-			Pinned:        r.Pinned,
-			Tags:          tagtypes.NewGettableTagsFromTags(v2.Tags),
-			Spec:          listedDashboardV2Spec{Display: v2.Spec.Display},
-		}
-	}
-	return &ListableDashboardV2{
-		Dashboards: dashboards,
-		Total:      total,
-	}, nil
-}

pkg/types/dashboardtypes/listfilter/constants.go

@@ -1,61 +0,0 @@
-package listfilter
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	qbtypesv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-)
-
-var ErrCodeDashboardListFilterInvalid = errors.MustNewCode("dashboard_list_filter_invalid")
-
-// reservedOps lists the operators each reserved (column-level) DSL key accepts.
-// Any non-reserved key is treated as a tag key and uses tagKeyOps.
-var reservedOps = map[dashboardtypes.DSLKey]map[qbtypesv5.FilterOperator]struct{}{
-	dashboardtypes.DSLKeyName:        stringSearchOps(),
-	dashboardtypes.DSLKeyDescription: stringSearchOps(),
-	dashboardtypes.DSLKeyCreatedAt:   numericRangeOps(),
-	dashboardtypes.DSLKeyUpdatedAt:   numericRangeOps(),
-	dashboardtypes.DSLKeyCreatedBy:   stringSearchOps(),
-	dashboardtypes.DSLKeyLocked:      opsSet(qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual),
-	dashboardtypes.DSLKeyPublic:      opsSet(qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual),
-}
-
-// tagKeyOps applies to every non-reserved DSL key — the operator targets the
-// tag's value with an implicit case-insensitive match on the tag's key.
-var tagKeyOps = opsSet(
-	qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-	qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike,
-	qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike,
-	qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains,
-	qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp,
-	qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn,
-	qbtypesv5.FilterOperatorExists, qbtypesv5.FilterOperatorNotExists,
-)
-
-func stringSearchOps() map[qbtypesv5.FilterOperator]struct{} {
-	return opsSet(
-		qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike,
-		qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike,
-		qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains,
-		qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp,
-		qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn,
-	)
-}
-
-func numericRangeOps() map[qbtypesv5.FilterOperator]struct{} {
-	return opsSet(
-		qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLessThan, qbtypesv5.FilterOperatorLessThanOrEq,
-		qbtypesv5.FilterOperatorGreaterThan, qbtypesv5.FilterOperatorGreaterThanOrEq,
-		qbtypesv5.FilterOperatorBetween, qbtypesv5.FilterOperatorNotBetween,
-	)
-}
-
-func opsSet(ops ...qbtypesv5.FilterOperator) map[qbtypesv5.FilterOperator]struct{} {
-	m := make(map[qbtypesv5.FilterOperator]struct{}, len(ops))
-	for _, op := range ops {
-		m[op] = struct{}{}
-	}
-	return m
-}

pkg/types/dashboardtypes/listfilter/listfilter.go

@@ -1,39 +0,0 @@
-package listfilter
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-)
-
-type Compiled struct {
-	SQL  string
-	Args []any
-}
-
-func Compile(query string, formatter sqlstore.SQLFormatter) (*Compiled, error) {
-	if len(query) == 0 {
-		return nil, nil
-	}
-
-	queryVisitor := newVisitor(formatter)
-	frag, syntaxErrs := queryVisitor.compile(query)
-
-	if len(syntaxErrs) > 0 {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardListFilterInvalid,
-			"invalid filter query: %s", strings.Join(syntaxErrs, "; "))
-	}
-	if len(queryVisitor.errors) > 0 {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardListFilterInvalid,
-			"invalid filter query: %s", strings.Join(queryVisitor.errors, "; "))
-	}
-	if frag == nil || frag.sql == "" {
-		return nil, nil
-	}
-
-	return &Compiled{
-		SQL:  frag.sql,
-		Args: frag.args,
-	}, nil
-}

pkg/types/dashboardtypes/listfilter/listfilter_test.go

@@ -1,507 +0,0 @@
-package listfilter
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
-)
-
-type compileCase struct {
-	subtestName              string
-	dslQueryToCompile        string
-	nilExpected              bool
-	expectedSQL              string
-	expectedArgs             []any
-	expectedErrShouldContain string
-}
-
-func runCompileCases(t *testing.T, cases []compileCase) {
-	t.Helper()
-	for _, c := range cases {
-		t.Run(c.subtestName, func(t *testing.T) {
-			out, err := Compile(c.dslQueryToCompile, formatter(t))
-
-			if c.expectedErrShouldContain != "" {
-				require.Error(t, err)
-				assert.Contains(t, strings.ToLower(err.Error()), strings.ToLower(c.expectedErrShouldContain))
-				return
-			}
-
-			require.NoError(t, err)
-			if c.nilExpected {
-				assert.Nil(t, out)
-				return
-			}
-			require.NotNil(t, out)
-
-			if c.expectedSQL != "" {
-				assert.Equal(t, normalizeSQL(c.expectedSQL), normalizeSQL(out.SQL))
-			}
-			if c.expectedArgs != nil {
-				require.Len(t, out.Args, len(c.expectedArgs))
-				for i, want := range c.expectedArgs {
-					// time.Time values can carry semantically-equal instants
-					// in different *Location representations (UTC vs Local vs
-					// FixedZone). Compare via .Equal() instead of DeepEqual.
-					if wantT, ok := want.(time.Time); ok {
-						gotT, ok := out.Args[i].(time.Time)
-						require.True(t, ok, "arg[%d]: want time.Time, got %T", i, out.Args[i])
-						assert.True(t, wantT.Equal(gotT), "arg[%d]: want %s, got %s", i, wantT, gotT)
-						continue
-					}
-					assert.Equal(t, want, out.Args[i], "arg[%d]", i)
-				}
-			}
-		})
-	}
-}
-
-func TestCompile_Empty(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{subtestName: "empty query yields nil", dslQueryToCompile: "", nilExpected: true},
-	})
-}
-
-func TestCompile_Name(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "name =",
-			dslQueryToCompile: `name = 'overview'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs:      []any{"overview"},
-		},
-		{
-			// QUOTED_TEXT in the grammar covers both '…' and "…" — visitor
-			// strips whichever quote pair surrounds the value.
-			subtestName:       "name = with double-quoted value",
-			dslQueryToCompile: `name = "something"`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs:      []any{"something"},
-		},
-		{
-			subtestName:       "name CONTAINS",
-			dslQueryToCompile: `name CONTAINS 'overview'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') LIKE ?`,
-			expectedArgs:      []any{"%overview%"},
-		},
-		{
-			subtestName:       "name ILIKE — emitted as LOWER(col) LIKE LOWER(?) for dialect parity",
-			dslQueryToCompile: `name ILIKE 'Prod%'`,
-			expectedSQL:       `lower(json_extract("dashboard"."data", '$.spec.display.name')) LIKE LOWER(?)`,
-			expectedArgs:      []any{"Prod%"},
-		},
-		{
-			subtestName:       "CONTAINS escapes % in user input",
-			dslQueryToCompile: `name CONTAINS '50%'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') LIKE ?`,
-			expectedArgs:      []any{`%50\%%`},
-		},
-	})
-}
-
-func TestCompile_CreatedByLocked(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "created_by LIKE",
-			dslQueryToCompile: `created_by LIKE '%@signoz.io'`,
-			expectedSQL:       `dashboard.created_by LIKE ?`,
-			expectedArgs:      []any{"%@signoz.io"},
-		},
-		{
-			subtestName:       "locked = true",
-			dslQueryToCompile: `locked = true`,
-			expectedSQL:       `dashboard.locked = ?`,
-			expectedArgs:      []any{true},
-		},
-	})
-}
-
-func TestCompile_Public(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{subtestName: "public = true", dslQueryToCompile: `public = true`, expectedSQL: `pd.id IS NOT NULL`},
-		{subtestName: "public = false", dslQueryToCompile: `public = false`, expectedSQL: `pd.id IS NULL`},
-		{subtestName: "public != true", dslQueryToCompile: `public != true`, expectedSQL: `pd.id IS NULL`},
-	})
-}
-
-func TestCompile_Timestamps(t *testing.T) {
-	ist := time.FixedZone("+05:30", 5*60*60+30*60)
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "created_at >= RFC3339",
-			dslQueryToCompile: `created_at >= '2026-03-10T00:00:00Z'`,
-			expectedSQL:       `dashboard.created_at >= ?`,
-			expectedArgs:      []any{time.Date(2026, 3, 10, 0, 0, 0, 0, time.UTC)},
-		},
-		{
-			subtestName:       "updated_at BETWEEN",
-			dslQueryToCompile: `updated_at BETWEEN '2026-03-10T00:00:00Z' AND '2026-03-20T00:00:00Z'`,
-			expectedSQL:       `dashboard.updated_at BETWEEN ? AND ?`,
-			expectedArgs: []any{
-				time.Date(2026, 3, 10, 0, 0, 0, 0, time.UTC),
-				time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC),
-			},
-		},
-		{
-			subtestName:       "created_at >= IST timestamp",
-			dslQueryToCompile: `created_at >= '2026-03-10T05:30:00+05:30'`,
-			expectedSQL:       `dashboard.created_at >= ?`,
-			expectedArgs:      []any{time.Date(2026, 3, 10, 5, 30, 0, 0, ist)},
-		},
-	})
-}
-
-// Tag operators wrap each predicate in EXISTS / NOT EXISTS. Any non-reserved
-// key is a tag key — `team = 'pulse'` matches a tag with key=team value=pulse,
-// `tag = 'prod'` matches a tag with key=tag value=prod, and so on.
-func TestCompile_Tag(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "team = wraps in EXISTS",
-			dslQueryToCompile: `team = 'pulse'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "tag = is just a regular tag-key filter",
-			dslQueryToCompile: `tag = 'database'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"tag", "database"},
-		},
-		{
-			subtestName:       "team != wraps in NOT EXISTS with positive inner",
-			dslQueryToCompile: `team != 'pulse'`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "team IN — inner is single placeholder list on t.value",
-			dslQueryToCompile: `team IN ['pulse', 'events']`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events"},
-		},
-		{
-			subtestName:       "team NOT IN",
-			dslQueryToCompile: `team NOT IN ['pulse', 'events']`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events"},
-		},
-		{
-			subtestName:       "team LIKE — wildcard on value",
-			dslQueryToCompile: `team LIKE 'pulse%'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)`,
-			expectedArgs: []any{"team", "pulse%"},
-		},
-		{
-			subtestName:       "team NOT LIKE",
-			dslQueryToCompile: `team NOT LIKE 'staging%'`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)`,
-			expectedArgs: []any{"team", "staging%"},
-		},
-		{
-			subtestName:       "database EXISTS — asserts a tag with key=database is present",
-			dslQueryToCompile: `database EXISTS`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"database"},
-		},
-		{
-			subtestName:       "database NOT EXISTS",
-			dslQueryToCompile: `database NOT EXISTS`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"database"},
-		},
-		{
-			subtestName:       "tag-key matching is case-insensitive — TEAM lowercased",
-			dslQueryToCompile: `TEAM = 'pulse'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-	})
-}
-
-func TestCompile_BooleanComposition(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "AND chain — flat arg list",
-			dslQueryToCompile: `locked = true AND public = true`,
-			expectedSQL:       `dashboard.locked = ? AND pd.id IS NOT NULL`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "OR chain",
-			dslQueryToCompile: `locked = true OR public = true`,
-			expectedSQL:       `dashboard.locked = ? OR pd.id IS NOT NULL`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "parens preserve precedence",
-			dslQueryToCompile: `(locked = true OR public = true) AND created_by = 'a@b.com'`,
-			expectedSQL:       `(dashboard.locked = ? OR pd.id IS NOT NULL) AND dashboard.created_by = ?`,
-			expectedArgs:      []any{true, "a@b.com"},
-		},
-	})
-}
-
-// Distinct from operator-suffix negation (NOT IN / NOT LIKE / NOT EXISTS).
-// Driven by the unaryExpression rule (`NOT? primary`), so NOT binds to
-// exactly one primary and only widens via parens.
-func TestCompile_NOT(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "NOT on a single comparison",
-			dslQueryToCompile: `NOT name = 'foo'`,
-			expectedSQL:       `NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)`,
-			expectedArgs:      []any{"foo"},
-		},
-		{
-			subtestName:       "NOT binds tightly to its primary in an AND chain",
-			dslQueryToCompile: `NOT name = 'foo' AND created_by = 'alice'`,
-			expectedSQL:       `NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?) AND dashboard.created_by = ?`,
-			expectedArgs:      []any{"foo", "alice"},
-		},
-		{
-			subtestName:       "NOT applied to the second term in an AND chain",
-			dslQueryToCompile: `locked = true AND NOT name = 'foo'`,
-			expectedSQL:       `dashboard.locked = ? AND NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)`,
-			expectedArgs:      []any{true, "foo"},
-		},
-		{
-			subtestName:       "NOT around a parenthesized OR",
-			dslQueryToCompile: `NOT (locked = true OR public = true)`,
-			expectedSQL:       `NOT ((dashboard.locked = ? OR pd.id IS NOT NULL))`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "double NOT via parens",
-			dslQueryToCompile: `NOT (NOT name = 'foo')`,
-			expectedSQL:       `NOT ((NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)))`,
-			expectedArgs:      []any{"foo"},
-		},
-		{
-			subtestName:       "NOT on a tag equality",
-			dslQueryToCompile: `NOT team = 'pulse'`,
-			expectedSQL: `
-				NOT (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "NOT team = ... AND name = ...",
-			dslQueryToCompile: `NOT team = 'pulse' AND name = 'overview'`,
-			expectedSQL: `
-				NOT (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-				)
-				AND json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs: []any{"team", "pulse", "overview"},
-		},
-	})
-}
-
-func TestCompile_ComplexExamples(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "name CONTAINS + tag LIKE + created_by + database =",
-			dslQueryToCompile: `name CONTAINS 'overview' AND tag LIKE 'prod%' AND created_by = 'naman.verma@signoz.io' AND database = 'mongo'`,
-			expectedSQL: `
-				json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)
-				AND dashboard.created_by = ?
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"%overview%", "tag", "prod%", "naman.verma@signoz.io", "database", "mongo"},
-		},
-		{
-			subtestName:       "team IN AND database EXISTS",
-			dslQueryToCompile: `team IN ['pulse', 'events'] AND database EXISTS`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events", "database"},
-		},
-		{
-			subtestName:       "nested OR / AND with parens",
-			dslQueryToCompile: `(database IN ['sql', 'redis', 'mongo'] OR name LIKE '%database%') AND (team = 'pulse' OR name LIKE '%pulse%')`,
-			expectedSQL: `
-				(
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value IN (?, ?, ?)
-					)
-					OR json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				)
-				AND (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-					OR json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				)`,
-			expectedArgs: []any{"database", "sql", "redis", "mongo", "%database%", "team", "pulse", "%pulse%"},
-		},
-	})
-}
-
-func TestCompile_Rejections(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:              "rejects op outside per-reserved-key allowlist",
-			dslQueryToCompile:        `name BETWEEN 'a' AND 'z'`,
-			expectedErrShouldContain: "operator",
-		},
-		{
-			subtestName:              "rejects BETWEEN on a tag key",
-			dslQueryToCompile:        `team BETWEEN 'a' AND 'z'`,
-			expectedErrShouldContain: "operator",
-		},
-		{
-			subtestName:              "rejects non-bool on locked",
-			dslQueryToCompile:        `locked = 'yes'`,
-			expectedErrShouldContain: "boolean",
-		},
-		{
-			subtestName:              "rejects non-RFC3339 timestamp",
-			dslQueryToCompile:        `created_at >= 'not-a-date'`,
-			expectedErrShouldContain: "RFC3339",
-		},
-		{
-			subtestName:              "rejects REGEXP — not yet supported",
-			dslQueryToCompile:        `name REGEXP '.*'`,
-			expectedErrShouldContain: "REGEXP",
-		},
-		{
-			subtestName:              "rejects syntax error from grammar",
-			dslQueryToCompile:        `name = `,
-			expectedErrShouldContain: "syntax",
-		},
-	})
-}
-
-func formatter(t *testing.T) sqlstore.SQLFormatter {
-	t.Helper()
-	p := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)
-	return p.Formatter()
-}
-
-func normalizeSQL(s string) string {
-	s = strings.Join(strings.Fields(s), " ")
-	s = strings.ReplaceAll(s, "( ", "(")
-	s = strings.ReplaceAll(s, " )", ")")
-	return s
-}

pkg/types/dashboardtypes/listfilter/visitor.go

@@ -1,592 +0,0 @@
-package listfilter
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/parser/filterquery"
-	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	qbtypesv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/antlr4-go/antlr/v4"
-)
-
-// fragment is one composable WHERE fragment. sql uses `?` placeholders;
-// args lines up positionally with the placeholders.
-type fragment struct {
-	sql  string
-	args []any
-}
-
-func newFragment(sql string, args ...any) *fragment {
-	return &fragment{sql: sql, args: args}
-}
-
-type visitor struct {
-	grammar.BaseFilterQueryVisitor
-	formatter sqlstore.SQLFormatter
-	errors    []string
-}
-
-func newVisitor(formatter sqlstore.SQLFormatter) *visitor {
-	return &visitor{
-		formatter: formatter,
-	}
-}
-
-// Emitted WHERE fragment uses aliases `dashboard` and `pd` (public_dashboard).
-func (v *visitor) compile(query string) (*fragment, []string) {
-	tree, _, collector := filterquery.Parse(query)
-	if len(collector.Errors) > 0 {
-		return nil, collector.Errors
-	}
-	frag, _ := v.visit(tree).(*fragment)
-	return frag, nil
-}
-
-func (v *visitor) visit(tree antlr.ParseTree) any {
-	if tree == nil {
-		return nil
-	}
-	return tree.Accept(v)
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// methods from grammar.BaseFilterQueryVisitor that are overridden
-// ════════════════════════════════════════════════════════════════════════
-
-func (v *visitor) VisitQuery(ctx *grammar.QueryContext) any {
-	return v.visit(ctx.Expression())
-}
-
-func (v *visitor) VisitExpression(ctx *grammar.ExpressionContext) any {
-	return v.visit(ctx.OrExpression())
-}
-
-func (v *visitor) VisitOrExpression(ctx *grammar.OrExpressionContext) any {
-	parts := ctx.AllAndExpression()
-	frags := make([]*fragment, 0, len(parts))
-	for _, p := range parts {
-		if f, ok := v.visit(p).(*fragment); ok && f != nil {
-			frags = append(frags, f)
-		}
-	}
-	return joinFragments(frags, "OR")
-}
-
-func (v *visitor) VisitAndExpression(ctx *grammar.AndExpressionContext) any {
-	parts := ctx.AllUnaryExpression()
-	frags := make([]*fragment, 0, len(parts))
-	for _, p := range parts {
-		if f, ok := v.visit(p).(*fragment); ok && f != nil {
-			frags = append(frags, f)
-		}
-	}
-	return joinFragments(frags, "AND")
-}
-
-func (v *visitor) VisitUnaryExpression(ctx *grammar.UnaryExpressionContext) any {
-	f, _ := v.visit(ctx.Primary()).(*fragment)
-	if f == nil {
-		return nil
-	}
-	if ctx.NOT() != nil {
-		return newFragment("NOT ("+f.sql+")", f.args...)
-	}
-	return f
-}
-
-func (v *visitor) VisitPrimary(ctx *grammar.PrimaryContext) any {
-	if ctx.OrExpression() != nil {
-		f, _ := v.visit(ctx.OrExpression()).(*fragment)
-		if f == nil {
-			return nil
-		}
-		return newFragment("("+f.sql+")", f.args...)
-	}
-	if ctx.Comparison() != nil {
-		return v.visit(ctx.Comparison())
-	}
-	// Bare keys, values, full text, and function calls are not part of the
-	// dashboard list DSL.
-	v.addErr("unsupported expression %q — every term must be of the form `key OP value`", ctx.GetText())
-	return nil
-}
-
-// VisitComparison dispatches a single `key OP value` term. A key that matches
-// a reserved DSL key (name, description, etc.) becomes a column-level
-// predicate; any other identifier is treated as a tag key — the operator
-// applies to the tag's value, with a case-insensitive match on the tag's key.
-func (v *visitor) VisitComparison(ctx *grammar.ComparisonContext) any {
-	key, ok := v.parseKey(ctx)
-	if !ok {
-		return nil
-	}
-
-	op, ok := v.opFromContext(ctx)
-	if !ok {
-		return nil
-	}
-
-	if reservedOpSet, isReserved := reservedOps[dashboardtypes.DSLKey(key)]; isReserved {
-		if _, allowed := reservedOpSet[op]; !allowed {
-			v.addErr("operator %s is not allowed for key %q", opName(op), key)
-			return nil
-		}
-		switch dashboardtypes.DSLKey(key) {
-		case dashboardtypes.DSLKeyName:
-			return v.emitJSONStringComparison(ctx, op, "$.spec.display.name")
-		case dashboardtypes.DSLKeyDescription:
-			return v.emitJSONStringComparison(ctx, op, "$.spec.display.description")
-		case dashboardtypes.DSLKeyCreatedAt:
-			return v.emitTimestampComparison(ctx, op, "dashboard.created_at")
-		case dashboardtypes.DSLKeyUpdatedAt:
-			return v.emitTimestampComparison(ctx, op, "dashboard.updated_at")
-		case dashboardtypes.DSLKeyCreatedBy:
-			return v.emitStringComparison(ctx, op, "dashboard.created_by")
-		case dashboardtypes.DSLKeyLocked:
-			return v.emitBoolComparison(ctx, op, "dashboard.locked")
-		case dashboardtypes.DSLKeyPublic:
-			return v.emitPublicComparison(ctx, op)
-		}
-	}
-
-	if _, allowed := tagKeyOps[op]; !allowed {
-		v.addErr("operator %s is not allowed on a tag-key filter", opName(op))
-		return nil
-	}
-	return v.emitTagComparison(ctx, op, key)
-}
-
-func (v *visitor) parseKey(ctx *grammar.ComparisonContext) (string, bool) {
-	keyText := strings.ToLower(strings.TrimSpace(ctx.Key().GetText()))
-	if keyText == "" {
-		v.addErr("filter key cannot be empty")
-		return "", false
-	}
-	return keyText, true
-}
-
-func (v *visitor) opFromContext(ctx *grammar.ComparisonContext) (qbtypesv5.FilterOperator, bool) {
-	switch {
-	case ctx.EQUALS() != nil:
-		return qbtypesv5.FilterOperatorEqual, true
-	case ctx.NOT_EQUALS() != nil, ctx.NEQ() != nil:
-		return qbtypesv5.FilterOperatorNotEqual, true
-	case ctx.LT() != nil:
-		return qbtypesv5.FilterOperatorLessThan, true
-	case ctx.LE() != nil:
-		return qbtypesv5.FilterOperatorLessThanOrEq, true
-	case ctx.GT() != nil:
-		return qbtypesv5.FilterOperatorGreaterThan, true
-	case ctx.GE() != nil:
-		return qbtypesv5.FilterOperatorGreaterThanOrEq, true
-	case ctx.BETWEEN() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotBetween, true
-		}
-		return qbtypesv5.FilterOperatorBetween, true
-	case ctx.LIKE() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotLike, true
-		}
-		return qbtypesv5.FilterOperatorLike, true
-	case ctx.ILIKE() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotILike, true
-		}
-		return qbtypesv5.FilterOperatorILike, true
-	case ctx.CONTAINS() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotContains, true
-		}
-		return qbtypesv5.FilterOperatorContains, true
-	case ctx.REGEXP() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotRegexp, true
-		}
-		return qbtypesv5.FilterOperatorRegexp, true
-	case ctx.InClause() != nil:
-		return qbtypesv5.FilterOperatorIn, true
-	case ctx.NotInClause() != nil:
-		return qbtypesv5.FilterOperatorNotIn, true
-	case ctx.EXISTS() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotExists, true
-		}
-		return qbtypesv5.FilterOperatorExists, true
-	}
-	v.addErr("could not determine operator in expression %q", ctx.GetText())
-	return qbtypesv5.FilterOperatorUnknown, false
-}
-
-// ─── per-key emitters ────────────────────────────────────────────────────────
-
-func (v *visitor) emitJSONStringComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, jsonPath string) *fragment {
-	colExpr := string(v.formatter.JSONExtractString("dashboard.data", jsonPath))
-	return v.emitStringOp(ctx, op, colExpr, string(dashboardtypes.DSLKeyName))
-}
-
-func (v *visitor) emitStringComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	return v.emitStringOp(ctx, op, colExpr, string(dashboardtypes.DSLKeyCreatedBy))
-}
-
-// emitStringOp covers all the operators the spec allows on text-shaped keys
-// (name, description, created_by). Tag uses a separate emitter that wraps each
-// produced fragment in an EXISTS subquery.
-func (v *visitor) emitStringOp(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr, keyForErr string) *fragment {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ?", val)
-	case qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		// SQLite has no ILIKE keyword and Postgres LIKE is case-sensitive — emit
-		// LOWER(col) LIKE LOWER(?) so behavior is identical on both dialects.
-		lowerCol := string(v.formatter.LowerExpression(colExpr))
-		return newFragment(lowerCol+" "+opName(iLikeToLike(op))+" LOWER(?)", val)
-	case qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(containsToLike(op))+" ?", "%"+escapeLike(val)+"%")
-	case qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp:
-		v.addErr("REGEXP filtering on %q is not yet supported", keyForErr)
-		return nil
-	case qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn:
-		vals, ok := v.stringList(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return inFragment(colExpr, op, vals)
-	}
-	v.addErr("operator %s on %q is not implemented", opName(op), keyForErr)
-	return nil
-}
-
-func (v *visitor) emitTimestampComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLessThan, qbtypesv5.FilterOperatorLessThanOrEq,
-		qbtypesv5.FilterOperatorGreaterThan, qbtypesv5.FilterOperatorGreaterThanOrEq:
-		t, ok := v.singleTimestamp(ctx)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ?", t)
-	case qbtypesv5.FilterOperatorBetween, qbtypesv5.FilterOperatorNotBetween:
-		ts, ok := v.twoTimestamps(ctx)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ? AND ?", ts[0], ts[1])
-	}
-	v.addErr("operator %s on timestamp is not implemented", opName(op))
-	return nil
-}
-
-func (v *visitor) emitBoolComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	b, ok := v.singleBool(ctx)
-	if !ok {
-		return nil
-	}
-	return newFragment(colExpr+" "+opName(op)+" ?", b)
-}
-
-// emitPublicComparison renders `public = true|false` against the LEFT-joined
-// public_dashboard alias `pd`. The spec says public is a virtual column whose
-// truthiness is the existence of a row in public_dashboard.
-func (v *visitor) emitPublicComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator) *fragment {
-	b, ok := v.singleBool(ctx)
-	if !ok {
-		return nil
-	}
-	want := b
-	if op == qbtypesv5.FilterOperatorNotEqual {
-		want = !b
-	}
-	if want {
-		return newFragment("pd.id IS NOT NULL")
-	}
-	return newFragment("pd.id IS NULL")
-}
-
-// TODO: drop the extra quotes once coretypes.Kind stops being double-encoded
-// in the tag_relation.kind column.
-const tagSubqueryPrefix = "SELECT 1 FROM tag_relation tr JOIN tag t ON t.id = tr.tag_id " +
-	`WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id ` +
-	"AND LOWER(t.key) = LOWER(?)"
-
-// emitTagComparison wraps the inner predicate in EXISTS (or NOT EXISTS for the
-// negated operators). The inner predicate matches the tag's key
-// case-insensitively and applies the user's operator to the tag's value.
-// EXISTS / NOT EXISTS skip the value predicate — they assert the existence
-// (or absence) of any tag with the given key.
-func (v *visitor) emitTagComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, key string) *fragment {
-	if op == qbtypesv5.FilterOperatorExists || op == qbtypesv5.FilterOperatorNotExists {
-		wrapper := "EXISTS"
-		if op == qbtypesv5.FilterOperatorNotExists {
-			wrapper = "NOT EXISTS"
-		}
-		return newFragment(wrapper+" ("+tagSubqueryPrefix+")", key)
-	}
-
-	// All other tag operators take the positive form of the value predicate
-	// and toggle the EXISTS wrapper for negation. Inverse() flips Not<X> → <X>.
-	negated := op.IsNegativeOperator()
-	posOp := op
-	if negated {
-		posOp = op.Inverse()
-	}
-	inner := v.emitStringOp(ctx, posOp, "t.value", key)
-	if inner == nil {
-		return nil
-	}
-	wrapper := "EXISTS"
-	if negated {
-		wrapper = "NOT EXISTS"
-	}
-	args := append([]any{key}, inner.args...)
-	return newFragment(wrapper+" ("+tagSubqueryPrefix+" AND "+inner.sql+")", args...)
-}
-
-// ─── value extraction helpers ───────────────────────────────────────────────
-
-func (v *visitor) addErr(format string, args ...any) {
-	v.errors = append(v.errors, fmt.Sprintf(format, args...))
-}
-
-func (v *visitor) singleString(ctx *grammar.ComparisonContext, keyForErr string) (string, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected exactly one value for %q", keyForErr)
-		return "", false
-	}
-	return v.stringValue(values[0], keyForErr)
-}
-
-func (v *visitor) singleBool(ctx *grammar.ComparisonContext) (bool, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected a single boolean (true/false)")
-		return false, false
-	}
-	return v.boolValue(values[0])
-}
-
-func (v *visitor) singleTimestamp(ctx *grammar.ComparisonContext) (time.Time, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected a single RFC3339 timestamp")
-		return time.Time{}, false
-	}
-	return v.timestampValue(values[0])
-}
-
-func (v *visitor) twoTimestamps(ctx *grammar.ComparisonContext) ([2]time.Time, bool) {
-	values := ctx.AllValue()
-	if len(values) != 2 {
-		v.addErr("BETWEEN expects two RFC3339 timestamps")
-		return [2]time.Time{}, false
-	}
-	a, ok1 := v.timestampValue(values[0])
-	b, ok2 := v.timestampValue(values[1])
-	if !ok1 || !ok2 {
-		return [2]time.Time{}, false
-	}
-	return [2]time.Time{a, b}, true
-}
-
-func (v *visitor) stringList(ctx *grammar.ComparisonContext, keyForErr string) ([]string, bool) {
-	var valuesCtx []grammar.IValueContext
-	switch {
-	case ctx.InClause() != nil:
-		ic := ctx.InClause()
-		if ic.ValueList() != nil {
-			valuesCtx = ic.ValueList().AllValue()
-		} else {
-			valuesCtx = []grammar.IValueContext{ic.Value()}
-		}
-	case ctx.NotInClause() != nil:
-		nc := ctx.NotInClause()
-		if nc.ValueList() != nil {
-			valuesCtx = nc.ValueList().AllValue()
-		} else {
-			valuesCtx = []grammar.IValueContext{nc.Value()}
-		}
-	default:
-		v.addErr("IN clause is missing for %q", keyForErr)
-		return nil, false
-	}
-	if len(valuesCtx) == 0 {
-		v.addErr("IN list for %q is empty", keyForErr)
-		return nil, false
-	}
-	out := make([]string, 0, len(valuesCtx))
-	for _, vc := range valuesCtx {
-		s, ok := v.stringValue(vc, keyForErr)
-		if !ok {
-			return nil, false
-		}
-		out = append(out, s)
-	}
-	return out, true
-}
-
-func (v *visitor) stringValue(ctx grammar.IValueContext, keyForErr string) (string, bool) {
-	if ctx.QUOTED_TEXT() != nil {
-		return trimQuotes(ctx.QUOTED_TEXT().GetText()), true
-	}
-	if ctx.KEY() != nil {
-		// Bare tokens are accepted as strings, mirroring the FilterQuery lexer's
-		// treatment of unquoted identifiers on the value side.
-		return ctx.KEY().GetText(), true
-	}
-	v.addErr("expected a string value for %q, got %q", keyForErr, ctx.GetText())
-	return "", false
-}
-
-func (v *visitor) boolValue(ctx grammar.IValueContext) (bool, bool) {
-	if ctx.BOOL() == nil {
-		v.addErr("expected a boolean (true/false), got %q", ctx.GetText())
-		return false, false
-	}
-	return strings.EqualFold(ctx.BOOL().GetText(), "true"), true
-}
-
-func (v *visitor) timestampValue(ctx grammar.IValueContext) (time.Time, bool) {
-	if ctx.QUOTED_TEXT() == nil {
-		v.addErr("expected an RFC3339 timestamp string, got %q", ctx.GetText())
-		return time.Time{}, false
-	}
-	raw := trimQuotes(ctx.QUOTED_TEXT().GetText())
-	t, err := time.Parse(time.RFC3339, raw)
-	if err != nil {
-		v.addErr("invalid RFC3339 timestamp %q: %s", raw, err.Error())
-		return time.Time{}, false
-	}
-	return t, true
-}
-
-// ─── fragment helpers ────────────────────────────────────────────────────────
-
-func joinFragments(frags []*fragment, conn string) *fragment {
-	if len(frags) == 0 {
-		return nil
-	}
-	if len(frags) == 1 {
-		return frags[0]
-	}
-	parts := make([]string, len(frags))
-	args := make([]any, 0)
-	for i, f := range frags {
-		parts[i] = f.sql
-		args = append(args, f.args...)
-	}
-	return newFragment(strings.Join(parts, " "+conn+" "), args...)
-}
-
-func inFragment(colExpr string, op qbtypesv5.FilterOperator, vals []string) *fragment {
-	placeholders := strings.Repeat("?, ", len(vals))
-	placeholders = placeholders[:len(placeholders)-2]
-	args := make([]any, len(vals))
-	for i, s := range vals {
-		args[i] = s
-	}
-	return newFragment(colExpr+" "+opName(op)+" ("+placeholders+")", args...)
-}
-
-// opName returns the user-facing spelling of a FilterOperator. For the
-// operators we emit directly into SQL (=, !=, <, LIKE, IN, BETWEEN, …) the
-// spelling doubles as the SQL keyword. For the operators we don't emit
-// directly (ILIKE, CONTAINS, REGEXP, EXISTS, NOT EXISTS) it's only used in
-// error messages.
-func opName(op qbtypesv5.FilterOperator) string {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual:
-		return "="
-	case qbtypesv5.FilterOperatorNotEqual:
-		return "!="
-	case qbtypesv5.FilterOperatorLessThan:
-		return "<"
-	case qbtypesv5.FilterOperatorLessThanOrEq:
-		return "<="
-	case qbtypesv5.FilterOperatorGreaterThan:
-		return ">"
-	case qbtypesv5.FilterOperatorGreaterThanOrEq:
-		return ">="
-	case qbtypesv5.FilterOperatorBetween:
-		return "BETWEEN"
-	case qbtypesv5.FilterOperatorNotBetween:
-		return "NOT BETWEEN"
-	case qbtypesv5.FilterOperatorLike:
-		return "LIKE"
-	case qbtypesv5.FilterOperatorNotLike:
-		return "NOT LIKE"
-	case qbtypesv5.FilterOperatorILike:
-		return "ILIKE"
-	case qbtypesv5.FilterOperatorNotILike:
-		return "NOT ILIKE"
-	case qbtypesv5.FilterOperatorContains:
-		return "CONTAINS"
-	case qbtypesv5.FilterOperatorNotContains:
-		return "NOT CONTAINS"
-	case qbtypesv5.FilterOperatorRegexp:
-		return "REGEXP"
-	case qbtypesv5.FilterOperatorNotRegexp:
-		return "NOT REGEXP"
-	case qbtypesv5.FilterOperatorIn:
-		return "IN"
-	case qbtypesv5.FilterOperatorNotIn:
-		return "NOT IN"
-	case qbtypesv5.FilterOperatorExists:
-		return "EXISTS"
-	case qbtypesv5.FilterOperatorNotExists:
-		return "NOT EXISTS"
-	}
-	return "?"
-}
-
-// iLikeToLike maps ILIKE → LIKE for the LOWER(col) LIKE LOWER(?) emission.
-func iLikeToLike(op qbtypesv5.FilterOperator) qbtypesv5.FilterOperator {
-	if op == qbtypesv5.FilterOperatorNotILike {
-		return qbtypesv5.FilterOperatorNotLike
-	}
-	return qbtypesv5.FilterOperatorLike
-}
-
-// containsToLike maps CONTAINS → LIKE for the LIKE '%val%' emission.
-func containsToLike(op qbtypesv5.FilterOperator) qbtypesv5.FilterOperator {
-	if op == qbtypesv5.FilterOperatorNotContains {
-		return qbtypesv5.FilterOperatorNotLike
-	}
-	return qbtypesv5.FilterOperatorLike
-}
-
-// escapeLike escapes the LIKE meta-characters % and _ in user input so that a
-// CONTAINS query of `50%` doesn't match every value containing `50`.
-func escapeLike(s string) string {
-	r := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`)
-	return r.Replace(s)
-}
-
-func trimQuotes(s string) string {
-	if len(s) >= 2 {
-		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
-			s = s[1 : len(s)-1]
-		}
-	}
-	s = strings.ReplaceAll(s, `\\`, `\`)
-	s = strings.ReplaceAll(s, `\'`, `'`)
-	return s
-}

pkg/types/dashboardtypes/perses_dashboard.go

@@ -1,453 +0,0 @@
-package dashboardtypes
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/json"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-	"github.com/swaggest/jsonschema-go"
-	jsonpatch "gopkg.in/evanphx/json-patch.v4"
-	"k8s.io/apimachinery/pkg/util/validation"
-)
-
-const (
-	SchemaVersion          = "v6"
-	MaxTagsPerDashboard    = 10
-	dashboardNameSuffixLen = 8
-)
-
-type DSLKey string
-
-const (
-	DSLKeyName        DSLKey = "name"
-	DSLKeyDescription DSLKey = "description"
-	DSLKeyCreatedAt   DSLKey = "created_at"
-	DSLKeyUpdatedAt   DSLKey = "updated_at"
-	DSLKeyCreatedBy   DSLKey = "created_by"
-	DSLKeyLocked      DSLKey = "locked"
-	DSLKeyPublic      DSLKey = "public"
-	DSLKeySource      DSLKey = "source"
-)
-
-// reservedDSLKeys are dashboard column-level filter names in the list-query DSL.
-// A tag whose key collides with one of these would make the DSL ambiguous, so
-// they're rejected (case-insensitively) at write time.
-var reservedDSLKeys = map[DSLKey]struct{}{
-	DSLKeyName:        {},
-	DSLKeyDescription: {},
-	DSLKeyCreatedAt:   {},
-	DSLKeyUpdatedAt:   {},
-	DSLKeyCreatedBy:   {},
-	DSLKeyLocked:      {},
-	DSLKeyPublic:      {},
-	DSLKeySource:      {},
-}
-
-type DashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID  valuer.UUID `json:"orgId" required:"true"`
-	Locked bool        `json:"locked" required:"true"`
-	Source Source      `json:"source" required:"true"`
-
-	DashboardV2MetadataBase
-	Name string          `json:"name" required:"true"`
-	Tags []*tagtypes.Tag `json:"tags" required:"true"`
-	Spec DashboardSpec   `json:"spec" required:"true"`
-}
-
-func (d *DashboardV2) CanUpdate() error {
-	if d.Source == SourceIntegration {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be modified")
-	}
-	if d.Locked {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot update a locked dashboard, please unlock the dashboard to update")
-	}
-	return nil
-}
-
-func (d *DashboardV2) Update(updateable UpdateableDashboardV2, updatedBy string, resolvedTags []*tagtypes.Tag) error {
-	if err := d.CanUpdate(); err != nil {
-		return err
-	}
-	if updateable.Name != d.Name {
-		return errors.NewInvalidInputf(ErrCodeDashboardImmutable, "name is immutable; cannot change from %q to %q", d.Name, updateable.Name)
-	}
-	d.DashboardV2MetadataBase = updateable.DashboardV2MetadataBase
-	d.Tags = resolvedTags
-	d.Spec = updateable.Spec
-	d.UpdatedBy = updatedBy
-	d.UpdatedAt = time.Now()
-	return nil
-}
-
-func (d *DashboardV2) CanLockUnlock(isAdmin bool, updatedBy string) error {
-	if d.Source == SourceIntegration {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be locked or unlocked")
-	}
-	if d.Source == SourceSystem {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "system dashboards cannot be locked or unlocked")
-	}
-	if d.CreatedBy != updatedBy && !isAdmin {
-		return errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "you are not authorized to lock/unlock this dashboard")
-	}
-	return nil
-}
-
-func (d *DashboardV2) LockUnlock(lock bool, isAdmin bool, updatedBy string) error {
-	if err := d.CanLockUnlock(isAdmin, updatedBy); err != nil {
-		return err
-	}
-	d.Locked = lock
-	d.UpdatedBy = updatedBy
-	d.UpdatedAt = time.Now()
-	return nil
-}
-
-type DashboardV2MetadataBase struct {
-	SchemaVersion string `json:"schemaVersion" required:"true"`
-	Image         string `json:"image,omitempty"`
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Postable
-// ════════════════════════════════════════════════════════════════════════
-
-type PostableDashboardV2 struct {
-	DashboardV2MetadataBase
-	Name         string                 `json:"name,omitempty"`
-	GenerateName bool                   `json:"generateName,omitempty"`
-	Tags         []tagtypes.PostableTag `json:"tags" required:"true"`
-	Spec         DashboardSpec          `json:"spec" required:"true"`
-}
-
-func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) *DashboardV2 {
-	now := time.Now()
-
-	name := postable.Name
-	if postable.GenerateName {
-		name = generateDashboardName(postable.Spec.Display.Name)
-	}
-
-	return &DashboardV2{
-		Identifiable:            types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable:           types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable:           types.UserAuditable{CreatedBy: createdBy, UpdatedBy: createdBy},
-		OrgID:                   orgID,
-		Locked:                  source == SourceIntegration,
-		Source:                  source,
-		DashboardV2MetadataBase: postable.DashboardV2MetadataBase,
-		Name:                    name,
-		Tags:                    tagtypes.NewTagsFromPostableTags(orgID, coretypes.KindDashboard, postable.Tags),
-		Spec:                    postable.Spec,
-	}
-}
-
-func (p *PostableDashboardV2) UnmarshalJSON(data []byte) error {
-	dec := json.NewDecoder(bytes.NewReader(data))
-	dec.DisallowUnknownFields()
-	type alias PostableDashboardV2
-	var tmp alias
-	if err := dec.Decode(&tmp); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	*p = PostableDashboardV2(tmp)
-	if p.Spec.Display == nil {
-		p.Spec.Display = &common.Display{}
-	}
-	if !p.GenerateName && p.Spec.Display.Name == "" {
-		p.Spec.Display.Name = p.Name
-	}
-	return p.Validate()
-}
-
-func (p *PostableDashboardV2) Validate() error {
-	if p.SchemaVersion != SchemaVersion {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "schemaVersion must be %q, got %q", SchemaVersion, p.SchemaVersion)
-	}
-	if err := p.validateName(); err != nil {
-		return err
-	}
-	if err := p.validateTags(); err != nil {
-		return err
-	}
-	return p.Spec.Validate()
-}
-
-func (p *PostableDashboardV2) validateName() error {
-	if !p.GenerateName {
-		return validateDashboardName(p.Name)
-	}
-	if p.Name != "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name must be empty when generateName is true, got %q", p.Name)
-	}
-	if p.Spec.Display == nil || p.Spec.Display.Name == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.display.name is required when generateName is true")
-	}
-	return nil
-}
-
-// Matches https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-label-names.
-func validateDashboardName(name string) error {
-	if name == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name is required")
-	}
-	if errs := validation.IsDNS1123Label(name); len(errs) > 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: %s", name, strings.Join(errs, "; "))
-	}
-	return nil
-}
-
-func generateDashboardName(displayName string) string {
-	const dns1123LabelMaxLen = 63
-	suffixAlphabet := []byte("abcdefghijklmnopqrstuvwxyz0123456789")
-
-	var b strings.Builder
-	b.Grow(len(displayName))
-	prevHyphen := false
-	for _, r := range strings.ToLower(displayName) {
-		switch {
-		case (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9'):
-			b.WriteRune(r)
-			prevHyphen = false
-		case b.Len() > 0 && !prevHyphen:
-			b.WriteByte('-')
-			prevHyphen = true
-		}
-	}
-	prefix := strings.TrimRight(b.String(), "-")
-
-	suffix := make([]byte, dashboardNameSuffixLen)
-	if _, err := rand.Read(suffix); err != nil {
-		panic(errors.WrapInternalf(err, errors.CodeInternal, "read random for dashboard name suffix"))
-	}
-	for i := range suffix {
-		suffix[i] = suffixAlphabet[int(suffix[i])%len(suffixAlphabet)]
-	}
-
-	maxPrefix := dns1123LabelMaxLen - 1 - dashboardNameSuffixLen
-	if len(prefix) > maxPrefix {
-		prefix = strings.TrimRight(prefix[:maxPrefix], "-")
-	}
-	if prefix == "" {
-		return string(suffix)
-	}
-	return prefix + "-" + string(suffix)
-}
-
-func (p *PostableDashboardV2) validateTags() error {
-	if len(p.Tags) > MaxTagsPerDashboard {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "a dashboard can have at most %d tags", MaxTagsPerDashboard)
-	}
-	for _, tag := range p.Tags {
-		if _, reserved := reservedDSLKeys[DSLKey(strings.ToLower(strings.TrimSpace(tag.Key)))]; reserved {
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "tag key %q is reserved", tag.Key)
-		}
-	}
-	return nil
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Gettable
-// ════════════════════════════════════════════════════════════════════════
-
-type GettableDashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID  valuer.UUID `json:"orgId" required:"true"`
-	Locked bool        `json:"locked" required:"true"`
-	Source Source      `json:"source" required:"true"`
-
-	DashboardV2MetadataBase
-	Name string                  `json:"name" required:"true"`
-	Tags []*tagtypes.GettableTag `json:"tags" required:"true"`
-	Spec DashboardSpec           `json:"spec" required:"true"`
-}
-
-func (d DashboardV2) ToGettableDashboardV2() GettableDashboardV2 {
-	return GettableDashboardV2{
-		Identifiable:            d.Identifiable,
-		TimeAuditable:           d.TimeAuditable,
-		UserAuditable:           d.UserAuditable,
-		OrgID:                   d.OrgID,
-		Locked:                  d.Locked,
-		Source:                  d.Source,
-		DashboardV2MetadataBase: d.DashboardV2MetadataBase,
-		Name:                    d.Name,
-		Tags:                    tagtypes.NewGettableTagsFromTags(d.Tags),
-		Spec:                    d.Spec,
-	}
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Storable
-// ════════════════════════════════════════════════════════════════════════
-
-// StorableDashboardV2Data is exactly what serializes into the dashboard.data column.
-type StorableDashboardV2Data struct {
-	Metadata StorableDashboardV2Metadata `json:"metadata"`
-	Spec     DashboardSpec               `json:"spec"`
-}
-
-func (s StorableDashboardV2Data) toStorableDashboardData() (StorableDashboardData, error) {
-	raw, err := json.Marshal(s)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal v2 dashboard data")
-	}
-	out := StorableDashboardData{}
-	if err := json.Unmarshal(raw, &out); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "unmarshal v2 dashboard data")
-	}
-	return out, nil
-}
-
-type StorableDashboardV2Metadata = DashboardV2MetadataBase
-
-// ════════════════════════════════════════════════════════════════════════
-// Updateable
-// ════════════════════════════════════════════════════════════════════════
-
-type UpdateableDashboardV2 = PostableDashboardV2
-
-func (d DashboardV2) toUpdateableDashboardV2() UpdateableDashboardV2 {
-	return PostableDashboardV2{
-		DashboardV2MetadataBase: d.DashboardV2MetadataBase,
-		Name:                    d.Name,
-		Tags:                    tagtypes.NewPostableTagsFromTags(d.Tags),
-		Spec:                    d.Spec,
-	}
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Patchable
-// ════════════════════════════════════════════════════════════════════════
-
-// PatchableDashboardV2 is an RFC 6902 JSON Patch document applied against a
-// PostableDashboardV2-shaped view of an existing dashboard. Patch ops can
-// target any field — including individual entries inside `data.panels`,
-// `data.panels.<id>.spec.queries`, or `tags` — without re-sending the rest of
-// the dashboard.
-type PatchableDashboardV2 struct {
-	patch jsonpatch.Patch
-}
-
-// JSONPatchDocument is the OpenAPI-facing schema for an RFC 6902 patch body.
-// PatchableDashboardV2 has only an internal `jsonpatch.Patch` field, so the
-// reflector would emit an empty schema; the handler def points at this type
-// instead so consumers see the array-of-ops shape.
-type JSONPatchDocument []JSONPatchOperation
-
-// JSONPatchOperation is one RFC 6902 op. Not every field is valid on every
-// op kind (e.g. `value` is required for add/replace/test, ignored for remove;
-// `from` is required for move/copy) — the JSON Patch RFC governs that.
-type JSONPatchOperation struct {
-	Op    string `json:"op" required:"true"`
-	Path  string `json:"path" required:"true" description:"JSON Pointer (RFC 6901) into the dashboard's postable shape — e.g. /data/display/name, /data/panels/<id>, /data/panels/<id>/spec/queries/0, /tags/-."`
-	Value any    `json:"value,omitempty" description:"Value to add/replace/test against. The expected type depends on the path. Common shapes (see referenced schemas for the exact field set): /data/panels/<id> takes a DashboardtypesPanel; /data/panels/<id>/spec/queries/N (or /-) takes a DashboardtypesQuery; /data/variables/N takes a DashboardtypesVariable; /data/layouts/N takes a DashboardtypesLayout; /tags/N (or /-) takes a TagtypesPostableTag; /data/display/name and other leaf string fields take a string. Required for add/replace/test; ignored for remove/move/copy."`
-	From  string `json:"from,omitempty" description:"Source JSON Pointer for move/copy ops; ignored for other ops."`
-}
-
-// PrepareJSONSchema constrains the `op` field to the six RFC 6902 verbs.
-func (JSONPatchOperation) PrepareJSONSchema(s *jsonschema.Schema) error {
-	op, ok := s.Properties["op"]
-	if !ok || op.TypeObject == nil {
-		return errors.NewInternalf(errors.CodeInternal, "JSONPatchOperation schema missing `op` property")
-	}
-	op.TypeObject.WithEnum("add", "remove", "replace", "move", "copy", "test")
-	s.Properties["op"] = op
-	return nil
-}
-
-func (p *PatchableDashboardV2) UnmarshalJSON(data []byte) error {
-	patch, err := jsonpatch.DecodePatch(data)
-	if err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	p.patch = patch
-	return nil
-}
-
-func (p PatchableDashboardV2) Apply(existing *DashboardV2) (*UpdateableDashboardV2, error) {
-	existingAsUpdateable := existing.toUpdateableDashboardV2()
-	raw, err := json.Marshal(existingAsUpdateable)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal existing dashboard for patch")
-	}
-	patched, err := p.patch.Apply(raw)
-	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	out := &UpdateableDashboardV2{}
-	if err := json.Unmarshal(patched, out); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Convertors
-// ════════════════════════════════════════════════════════════════════════
-
-func (d *DashboardV2) ToStorableDashboard() (*StorableDashboard, error) {
-	storableDashboardV2Data := StorableDashboardV2Data{
-		Metadata: StorableDashboardV2Metadata{
-			SchemaVersion: d.SchemaVersion,
-			Image:         d.Image,
-		},
-		Spec: d.Spec,
-	}
-
-	data, err := storableDashboardV2Data.toStorableDashboardData()
-	if err != nil {
-		return nil, err
-	}
-	return &StorableDashboard{
-		Identifiable:  types.Identifiable{ID: d.ID},
-		TimeAuditable: d.TimeAuditable,
-		UserAuditable: d.UserAuditable,
-		OrgID:         d.OrgID,
-		Locked:        d.Locked,
-		Name:          d.Name,
-		Data:          data,
-		Source:        d.Source,
-	}, nil
-}
-
-func (storable StorableDashboard) ToDashboardV2(tags []*tagtypes.Tag) (*DashboardV2, error) {
-	metadata, _ := storable.Data["metadata"].(map[string]any)
-	if metadata == nil || metadata["schemaVersion"] != SchemaVersion {
-		return nil, errors.Newf(errors.TypeUnsupported, ErrCodeDashboardInvalidData, "dashboard %s is not in %s schema", storable.ID, SchemaVersion)
-	}
-	raw, err := json.Marshal(storable.Data)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal stored v2 dashboard data")
-	}
-	var stored StorableDashboardV2Data
-	if err := json.Unmarshal(raw, &stored); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "unmarshal stored v2 dashboard data")
-	}
-	return &DashboardV2{
-		Identifiable:            storable.Identifiable,
-		TimeAuditable:           storable.TimeAuditable,
-		UserAuditable:           storable.UserAuditable,
-		OrgID:                   storable.OrgID,
-		Locked:                  storable.Locked,
-		Source:                  storable.Source,
-		DashboardV2MetadataBase: stored.Metadata,
-		Name:                    storable.Name,
-		Tags:                    tags,
-		Spec:                    stored.Spec,
-	}, nil
-}

pkg/types/dashboardtypes/perses_dashboard_convertors_test.go

@@ -1,225 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func newTestDashboardV2(t *testing.T, orgID valuer.UUID, source Source) *DashboardV2 {
-	t.Helper()
-	createdAt := time.Date(2026, time.January, 1, 12, 0, 0, 0, time.UTC)
-	updatedAt := time.Date(2026, time.January, 2, 12, 0, 0, 0, time.UTC)
-
-	spec := DashboardSpec{
-		Panels: map[string]*Panel{
-			"p1": {
-				Kind: "Panel",
-				Spec: PanelSpec{
-					Plugin: PanelPlugin{
-						Kind: PanelKindTimeSeries,
-						Spec: &TimeSeriesPanelSpec{
-							Visualization: TimeSeriesVisualization{
-								BasicVisualization: BasicVisualization{TimePreference: TimePreferenceGlobalTime},
-							},
-							Formatting: PanelFormatting{DecimalPrecision: PrecisionOption2},
-							ChartAppearance: TimeSeriesChartAppearance{
-								LineInterpolation: LineInterpolationSpline,
-								LineStyle:         LineStyleSolid,
-								FillMode:          FillModeSolid,
-								SpanGaps:          SpanGaps{FillLessThan: valuer.MustParseTextDuration("60s")},
-							},
-							Legend: Legend{Position: LegendPositionBottom},
-						},
-					},
-					Queries: []Query{
-						{
-							Kind: "TimeSeriesQuery",
-							Spec: QuerySpec{
-								Plugin: QueryPlugin{
-									Kind: QueryKindPromQL,
-									Spec: &PromQLQuerySpec{Name: "A", Query: "up"},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		Layouts: []Layout{},
-	}
-
-	return &DashboardV2{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: createdAt, UpdatedAt: updatedAt},
-		UserAuditable: types.UserAuditable{CreatedBy: "alice", UpdatedBy: "bob"},
-		OrgID:         orgID,
-		Locked:        true,
-		Source:        source,
-		DashboardV2MetadataBase: DashboardV2MetadataBase{
-			SchemaVersion: SchemaVersion,
-			Image:         "data:image/png;base64,abc",
-		},
-		Name: "production-overview",
-		Tags: []*tagtypes.Tag{
-			tagtypes.NewTag(orgID, coretypes.KindDashboard, "team", "platform"),
-			tagtypes.NewTag(orgID, coretypes.KindDashboard, "env", "prod"),
-		},
-		Spec: spec,
-	}
-}
-
-func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-
-	cases := []struct {
-		scenario       string
-		source         Source
-		expectedLocked bool
-	}{
-		{
-			scenario:       "user source is not locked",
-			source:         SourceUser,
-			expectedLocked: false,
-		},
-		{
-			scenario:       "system source is not locked",
-			source:         SourceSystem,
-			expectedLocked: false,
-		},
-		{
-			scenario:       "integration source is locked",
-			source:         SourceIntegration,
-			expectedLocked: true,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.scenario, func(t *testing.T) {
-			postable := PostableDashboardV2{
-				DashboardV2MetadataBase: DashboardV2MetadataBase{
-					SchemaVersion: SchemaVersion,
-					Image:         "img",
-				},
-				Name: "my-dashboard",
-				Tags: []tagtypes.PostableTag{
-					{Key: "team", Value: "platform"},
-					{Key: "env", Value: "prod"},
-				},
-				Spec: DashboardSpec{},
-			}
-
-			before := time.Now()
-			dashboard := postable.NewDashboardV2(orgID, "alice", tc.source)
-			after := time.Now()
-
-			require.NotNil(t, dashboard)
-			assert.False(t, dashboard.ID.IsZero(), "expected a freshly generated UUID")
-			assert.Equal(t, orgID, dashboard.OrgID)
-			assert.Equal(t, tc.source, dashboard.Source)
-			assert.Equal(t, tc.expectedLocked, dashboard.Locked)
-			assert.Equal(t, postable.DashboardV2MetadataBase, dashboard.DashboardV2MetadataBase)
-			assert.Equal(t, postable.Name, dashboard.Name)
-			assert.Equal(t, postable.Spec, dashboard.Spec)
-
-			assert.Equal(t, "alice", dashboard.CreatedBy)
-			assert.Equal(t, "alice", dashboard.UpdatedBy)
-			assert.True(t, dashboard.CreatedAt.Equal(dashboard.UpdatedAt), "createdAt should equal updatedAt on creation")
-			assert.False(t, dashboard.CreatedAt.Before(before), "createdAt should be >= before")
-			assert.False(t, dashboard.CreatedAt.After(after), "createdAt should be <= after")
-
-			require.Len(t, dashboard.Tags, 2, "expected 2 tags")
-			for i, expectedTag := range postable.Tags {
-				assert.Equal(t, expectedTag.Key, dashboard.Tags[i].Key)
-				assert.Equal(t, expectedTag.Value, dashboard.Tags[i].Value)
-				assert.Equal(t, orgID, dashboard.Tags[i].OrgID)
-				assert.Equal(t, coretypes.KindDashboard, dashboard.Tags[i].Kind)
-				assert.False(t, dashboard.Tags[i].ID.IsZero(), "tag should have a UUID")
-			}
-		})
-	}
-
-	t.Run("each invocation mints a distinct ID", func(t *testing.T) {
-		postable := PostableDashboardV2{
-			DashboardV2MetadataBase: DashboardV2MetadataBase{SchemaVersion: SchemaVersion},
-			Name:                    "x",
-			Spec:                    DashboardSpec{},
-		}
-
-		first := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		second := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		assert.NotEqual(t, first.ID, second.ID, "expected distinct UUIDs across invocations")
-	})
-
-	t.Run("generateName derives name from display.name with a random suffix", func(t *testing.T) {
-		postable := PostableDashboardV2{
-			DashboardV2MetadataBase: DashboardV2MetadataBase{SchemaVersion: SchemaVersion},
-			GenerateName:            true,
-			Spec: DashboardSpec{
-				Display: &common.Display{Name: "My Dashboard!"},
-			},
-		}
-
-		dashboard := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		assert.True(t, strings.HasPrefix(dashboard.Name, "my-dashboard-"), "expected slug prefix, got %q", dashboard.Name)
-		assert.Len(t, dashboard.Name, len("my-dashboard-")+dashboardNameSuffixLen)
-	})
-}
-
-func TestDashboardV2ToGettableDashboardV2(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-
-	t.Run("copies all scalar fields and converts tags", func(t *testing.T) {
-		dashboard := newTestDashboardV2(t, orgID, SourceUser)
-
-		gettable := dashboard.ToGettableDashboardV2()
-
-		assert.Equal(t, dashboard.Identifiable, gettable.Identifiable)
-		assert.Equal(t, dashboard.TimeAuditable, gettable.TimeAuditable)
-		assert.Equal(t, dashboard.UserAuditable, gettable.UserAuditable)
-		assert.Equal(t, dashboard.OrgID, gettable.OrgID)
-		assert.Equal(t, dashboard.Locked, gettable.Locked)
-		assert.Equal(t, dashboard.Source, gettable.Source)
-		assert.Equal(t, dashboard.DashboardV2MetadataBase, gettable.DashboardV2MetadataBase)
-		assert.Equal(t, dashboard.Name, gettable.Name)
-		assert.Equal(t, dashboard.Spec, gettable.Spec)
-
-		require.Len(t, gettable.Tags, len(dashboard.Tags))
-		for i, sourceTag := range dashboard.Tags {
-			require.NotNil(t, gettable.Tags[i])
-			assert.Equal(t, sourceTag.Key, gettable.Tags[i].Key)
-			assert.Equal(t, sourceTag.Value, gettable.Tags[i].Value)
-		}
-	})
-}
-
-func TestDashboardV2StorableRoundTrip(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-	original := newTestDashboardV2(t, orgID, SourceIntegration)
-
-	storable, err := original.ToStorableDashboard()
-	require.NoError(t, err)
-	require.NotNil(t, storable)
-
-	// Simulate the DB hop on the text `data` column.
-	raw, err := json.Marshal(storable.Data)
-	require.NoError(t, err)
-	var reloadedData StorableDashboardData
-	require.NoError(t, json.Unmarshal(raw, &reloadedData))
-	storable.Data = reloadedData
-
-	restored, err := storable.ToDashboardV2(original.Tags)
-	require.NoError(t, err)
-	require.NotNil(t, restored)
-
-	assert.Equal(t, original, restored)
-}

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -12,11 +12,11 @@ import (
 	"github.com/perses/perses/pkg/model/api/v1/common"
 )
 
-// DashboardSpec is the SigNoz dashboard v2 spec shape. It mirrors
+// DashboardData is the SigNoz dashboard v2 spec shape. It mirrors
 // v1.DashboardSpec (Perses) field-for-field, except every common.Plugin
 // occurrence is replaced with a typed SigNoz plugin whose OpenAPI schema is a
 // per-site discriminated oneOf.
-type DashboardSpec struct {
+type DashboardData struct {
 	Display         *common.Display            `json:"display,omitempty"`
 	Datasources     map[string]*DatasourceSpec `json:"datasources,omitempty"`
 	Variables       []Variable                 `json:"variables,omitempty"`
@@ -31,15 +31,15 @@ type DashboardSpec struct {
 // Unmarshal + validate entry point
 // ══════════════════════════════════════════════
 
-func (d *DashboardSpec) UnmarshalJSON(data []byte) error {
+func (d *DashboardData) UnmarshalJSON(data []byte) error {
 	dec := json.NewDecoder(bytes.NewReader(data))
 	dec.DisallowUnknownFields()
-	type alias DashboardSpec
+	type alias DashboardData
 	var tmp alias
 	if err := dec.Decode(&tmp); err != nil {
 		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid dashboard spec")
 	}
-	*d = DashboardSpec(tmp)
+	*d = DashboardData(tmp)
 	return d.Validate()
 }
 
@@ -47,7 +47,7 @@ func (d *DashboardSpec) UnmarshalJSON(data []byte) error {
 // Cross-field validation
 // ══════════════════════════════════════════════
 
-func (d *DashboardSpec) Validate() error {
+func (d *DashboardData) Validate() error {
 	for key, panel := range d.Panels {
 		if panel == nil {
 			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.panels.%s: panel must not be null", key)

pkg/types/dashboardtypes/perses_dashboard_patch_test.go

@@ -1,566 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// basePostableJSON is the postable shape of a small but realistic v2
-// dashboard used as the base document for patch tests. Each panel carries
-// one builder query in the same shape production dashboards use
-// (aggregations, filter, groupBy populated), and the dashboard has one
-// variable — the variable is not patched in any test here, that's
-// covered in a separate variable-focused suite.
-const basePostableJSON = `{
-	"schemaVersion": "v6",
-	"name": "service-overview",
-	"tags": [{"key": "team", "value": "alpha"}, {"key": "env", "value": "prod"}],
-	"spec": {
-		"display": {"name": "Service overview"},
-		"variables": [
-			{
-				"kind": "ListVariable",
-				"spec": {
-					"name": "service",
-					"allowAllValue": true,
-					"allowMultiple": false,
-					"plugin": {
-						"kind": "signoz/DynamicVariable",
-						"spec": {"name": "service.name", "signal": "metrics"}
-					}
-				}
-			}
-		],
-		"panels": {
-			"p1": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-					"queries": [
-						{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{
-									"metricName": "signoz_calls_total",
-									"temporality": "cumulative",
-									"timeAggregation": "rate",
-									"spaceAggregation": "sum"
-								}],
-								"filter": {"expression": "service.name IN $service"},
-								"groupBy": [{"name": "service.name", "fieldDataType": "string", "fieldContext": "tag"}]
-							}}}
-						}
-					]
-				}
-			},
-			"p2": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/NumberPanel", "spec": {}},
-					"queries": [
-						{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "X",
-								"signal": "metrics",
-								"aggregations": [{
-									"metricName": "signoz_latency_count",
-									"temporality": "cumulative",
-									"timeAggregation": "rate",
-									"spaceAggregation": "sum"
-								}]
-							}}}
-						}
-					]
-				}
-			}
-		},
-		"layouts": [
-			{
-				"kind": "Grid",
-				"spec": {
-					"display": {"title": "Row 1"},
-					"items": [
-						{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/p1"}},
-						{"x": 6, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/p2"}}
-					]
-				}
-			}
-		],
-		"duration": "1h"
-	}
-}`
-
-func TestPatchableDashboardV2_Apply(t *testing.T) {
-	// Apply doesn't mutate the input *DashboardV2 — it marshals it to
-	// JSON, applies the patch, and unmarshals the result into a fresh
-	// struct. Sharing one base across subtests is safe.
-	var p PostableDashboardV2
-	require.NoError(t, json.Unmarshal([]byte(basePostableJSON), &p), "base postable JSON must validate")
-	testOrgID := valuer.GenerateUUID()
-	base := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
-	base.Tags = []*tagtypes.Tag{
-		{Key: "team", Value: "alpha"},
-		{Key: "env", Value: "prod"},
-	}
-
-	decode := func(t *testing.T, body string) PatchableDashboardV2 {
-		t.Helper()
-		var patch PatchableDashboardV2
-		require.NoError(t, json.Unmarshal([]byte(body), &patch))
-		return patch
-	}
-
-	// jsonOf marshals the patched dashboard back to JSON so subtests can
-	// assert on field values without reaching into the typed plugin specs.
-	jsonOf := func(t *testing.T, out *UpdateableDashboardV2) string {
-		t.Helper()
-		raw, err := json.Marshal(out)
-		require.NoError(t, err)
-		return string(raw)
-	}
-
-	// ─────────────────────────────────────────────────────────────────
-	// Successful patches
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("no-op preserves all fields", func(t *testing.T) {
-		out, err := decode(t, `[]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, base.DashboardV2MetadataBase, out.DashboardV2MetadataBase)
-		assert.Equal(t, tagtypes.NewPostableTagsFromTags(base.Tags), out.Tags)
-		assert.Equal(t, base.Spec.Display.Name, out.Spec.Display.Name)
-		require.Equal(t, len(base.Spec.Panels), len(out.Spec.Panels))
-		for k, panel := range base.Spec.Panels {
-			require.Contains(t, out.Spec.Panels, k)
-			assert.Equal(t, panel.Spec.Plugin.Kind, out.Spec.Panels[k].Spec.Plugin.Kind)
-		}
-		assert.Len(t, out.Tags, len(base.Tags))
-		assert.Len(t, out.Spec.Variables, len(base.Spec.Variables))
-		assert.Len(t, out.Spec.Layouts, len(base.Spec.Layouts))
-	})
-
-	t.Run("add metadata image", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/image", "value": "https://example.com/img.png"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "https://example.com/img.png", out.Image)
-		assert.Equal(t, SchemaVersion, out.SchemaVersion, "schemaVersion preserved")
-	})
-
-	t.Run("replace display name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/display/name", "value": "Renamed"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Renamed", out.Spec.Display.Name)
-	})
-
-	// Per RFC 6902 § 4.1, `add` on an existing object member replaces the
-	// existing value rather than erroring — same effect as `replace`.
-	t.Run("add overwrites existing display name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/spec/display/name", "value": "Overwritten"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Overwritten", out.Spec.Display.Name)
-	})
-
-	t.Run("add data refreshInterval", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/spec/refreshInterval", "value": "30s"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "30s", string(out.Spec.RefreshInterval))
-	})
-
-	t.Run("add panel leaves others untouched", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "add",
-			"path": "/spec/panels/p3",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TablePanel", "spec": {}},
-					"queries": [{
-						"kind": "TimeSeriesQuery",
-						"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A",
-							"signal": "logs",
-							"aggregations": [{"expression": "count()"}]
-						}}}
-					}]
-				}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 3)
-		assert.Contains(t, out.Spec.Panels, "p3")
-		// Plugin specs round-trip through MarshalJSON which resolves defaults
-		// (e.g. timePreference → "global_time"), so compare the serialized
-		// shape rather than the in-memory structs to skip that normalization.
-		for _, id := range []string{"p1", "p2"} {
-			wantJSON, err := json.Marshal(base.Spec.Panels[id])
-			require.NoError(t, err)
-			gotJSON, err := json.Marshal(out.Spec.Panels[id])
-			require.NoError(t, err)
-			assert.JSONEq(t, string(wantJSON), string(gotJSON), "panel %s untouched", id)
-		}
-	})
-
-	t.Run("replace single panel", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p2",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/BarChartPanel", "spec": {}},
-					"queries": [{
-						"kind": "TimeSeriesQuery",
-						"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A",
-							"signal": "metrics",
-							"aggregations": [{
-								"metricName": "signoz_calls_total",
-								"temporality": "cumulative",
-								"timeAggregation": "rate",
-								"spaceAggregation": "sum"
-							}]
-						}}}
-					}]
-				}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, PanelPluginKind("signoz/BarChartPanel"), out.Spec.Panels["p2"].Spec.Plugin.Kind)
-		assert.Equal(t, PanelPluginKind("signoz/TimeSeriesPanel"), out.Spec.Panels["p1"].Spec.Plugin.Kind, "p1 untouched")
-	})
-
-	// Removing a panel realistically also drops its layout item — exercise
-	// the multi-op shape the UI sends.
-	t.Run("remove panel and its layout item", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "remove", "path": "/spec/panels/p2"},
-			{"op": "remove", "path": "/spec/layouts/0/spec/items/1"}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 1)
-		assert.Contains(t, out.Spec.Panels, "p1")
-		assert.NotContains(t, out.Spec.Panels, "p2")
-		raw := jsonOf(t, out)
-		assert.NotContains(t, raw, `"$ref":"#/spec/panels/p2"`)
-		assert.Contains(t, raw, `"$ref":"#/spec/panels/p1"`)
-	})
-
-	// The headline use case: edit a single field of a single query inside
-	// one panel without re-sending any other part of the dashboard.
-	t.Run("rename single query inside panel", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1/spec/queries/0/spec/plugin/spec/name",
-			"value": "renamed"
-		}]`).Apply(base)
-		require.NoError(t, err)
-
-		require.Len(t, out.Spec.Panels["p1"].Spec.Queries, 1)
-		assert.Contains(t, jsonOf(t, out), `"name":"renamed"`)
-	})
-
-	// Replace a query at a specific index — swaps query "A" out for "B"
-	// without re-sending the rest of the panel.
-	t.Run("replace query at index", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1/spec/queries/0",
-			"value": {
-				"kind": "TimeSeriesQuery",
-				"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-					"name": "B",
-					"signal": "metrics",
-					"aggregations": [{
-						"metricName": "signoz_db_calls_total",
-						"temporality": "cumulative",
-						"timeAggregation": "rate",
-						"spaceAggregation": "sum"
-					}]
-				}}}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Spec.Panels["p1"].Spec.Queries, 1)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"name":"B"`)
-		assert.NotContains(t, raw, `"name":"A"`)
-	})
-
-	// ─────────────────────────────────────────────────────────────────
-	// Layout edits
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("move panel by editing layout x coordinate", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/items/0/x", "value": 6}]`).Apply(base)
-		require.NoError(t, err)
-		raw := jsonOf(t, out)
-		// The first item used to live at x=0, now lives at x=6.
-		assert.Contains(t, raw, `"x":6,"y":0,"width":6,"height":6,"content":{"$ref":"#/spec/panels/p1"}`)
-	})
-
-	t.Run("resize panel by editing layout width", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/items/0/width", "value": 12}]`).Apply(base)
-		require.NoError(t, err)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"width":12`)
-	})
-
-	t.Run("rename layout row title", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/display/title", "value": "Latency"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Contains(t, jsonOf(t, out), `"title":"Latency"`)
-	})
-
-	t.Run("append layout item", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "add",
-			"path": "/spec/layouts/0/spec/items/-",
-			"value": {"x": 0, "y": 6, "width": 12, "height": 6, "content": {"$ref": "#/spec/panels/p1"}}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		// Item count went 2 → 3.
-		raw := jsonOf(t, out)
-		assert.Equal(t, 3, strings.Count(raw, `"$ref":"#/spec/panels/`))
-	})
-
-	// Composing add-panel + add-layout-item is the realistic shape of the
-	// "add a new chart to my dashboard" UI flow — exercise it end-to-end.
-	t.Run("add panel and corresponding layout item", func(t *testing.T) {
-		out, err := decode(t, `[
-			{
-				"op": "add",
-				"path": "/spec/panels/p3",
-				"value": {
-					"kind": "Panel",
-					"spec": {
-						"plugin": {"kind": "signoz/TablePanel", "spec": {}},
-						"queries": [{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "A",
-								"signal": "logs",
-								"aggregations": [{"expression": "count()"}]
-							}}}
-						}]
-					}
-				}
-			},
-			{
-				"op": "add",
-				"path": "/spec/layouts/0/spec/items/-",
-				"value": {"x": 0, "y": 6, "width": 12, "height": 6, "content": {"$ref": "#/spec/panels/p3"}}
-			}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 3)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"$ref":"#/spec/panels/p3"`)
-	})
-
-	t.Run("append tag", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/tags/-", "value": {"key": "env", "value": "staging"}}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 3)
-		assert.Equal(t, "env", out.Tags[2].Key)
-		assert.Equal(t, "staging", out.Tags[2].Value)
-	})
-
-	t.Run("append tag when none exist", func(t *testing.T) {
-		noTagsBase := &DashboardV2{
-			DashboardV2MetadataBase: base.DashboardV2MetadataBase,
-			Name:                    base.Name,
-			Tags:                    nil,
-			Spec:                    base.Spec,
-		}
-		out, err := decode(t, `[{"op": "add", "path": "/tags/-", "value": {"key": "team", "value": "new"}}]`).Apply(noTagsBase)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 1)
-		assert.Equal(t, "team", out.Tags[0].Key)
-		assert.Equal(t, "new", out.Tags[0].Value)
-	})
-
-	t.Run("replace tag value", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/tags/0/value", "value": "beta"}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 2)
-		assert.Equal(t, "team", out.Tags[0].Key)
-		assert.Equal(t, "beta", out.Tags[0].Value)
-		assert.Equal(t, "env", out.Tags[1].Key, "tag at index 1 untouched")
-		assert.Equal(t, "prod", out.Tags[1].Value, "tag at index 1 untouched")
-		for _, tag := range out.Tags {
-			assert.NotEqual(t, "alpha", tag.Value, "old tag value must be gone")
-		}
-	})
-
-	t.Run("multiple ops applied in order", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "replace", "path": "/spec/display/name", "value": "Multi-step"},
-			{"op": "remove",  "path": "/spec/panels/p2"},
-			{"op": "add",     "path": "/tags/-", "value": {"key": "env", "value": "staging"}}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Multi-step", out.Spec.Display.Name)
-		assert.Len(t, out.Spec.Panels, 1)
-		assert.Len(t, out.Tags, 3)
-	})
-
-	// `test` is an RFC 6902 precondition op: aborts the patch if the value
-	// at the path doesn't equal the supplied value. Used for optimistic
-	// concurrency. Here it matches, so the subsequent ops apply.
-	t.Run("test op passes", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "test",    "path": "/spec/display/name", "value": "Service overview"},
-			{"op": "replace", "path": "/spec/display/name", "value": "Confirmed"}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Confirmed", out.Spec.Display.Name)
-	})
-
-	// ─────────────────────────────────────────────────────────────────
-	// Failure cases
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("decode rejects non-array body", func(t *testing.T) {
-		var patch PatchableDashboardV2
-		err := json.Unmarshal([]byte(`{"op": "replace"}`), &patch)
-		require.Error(t, err)
-	})
-
-	t.Run("decode rejects malformed JSON", func(t *testing.T) {
-		var patch PatchableDashboardV2
-		// Outer json.Unmarshal rejects non-JSON before PatchableDashboardV2's
-		// UnmarshalJSON runs, so the error is a stdlib SyntaxError rather
-		// than the InvalidInput-classified wrap.
-		err := json.Unmarshal([]byte(`not json`), &patch)
-		require.Error(t, err)
-	})
-
-	// `test` precondition fails — the whole patch is rejected, including
-	// the subsequent replace.
-	t.Run("test op failure rejected", func(t *testing.T) {
-		_, err := decode(t, `[
-			{"op": "test", "path": "/spec/display/name", "value": "Wrong"},
-			{"op": "replace", "path": "/spec/display/name", "value": "Should not apply"}
-		]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("remove at missing path rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "remove", "path": "/spec/panels/does-not-exist"}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("remove schemaVersion rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "remove", "path": "/schemaVersion"}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("wrong schemaVersion rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "replace", "path": "/schemaVersion", "value": "v5"}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), SchemaVersion)
-	})
-
-	t.Run("empty display name defaults to dashboard name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/display/name", "value": ""}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, base.Name, out.Spec.Display.Name, "empty display.name should default from name")
-	})
-
-	t.Run("unknown top-level field rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "add", "path": "/bogus", "value": 42}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "bogus")
-	})
-
-	t.Run("invalid panel kind rejected", func(t *testing.T) {
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1",
-			"value": {
-				"kind": "Panel",
-				"spec": {"plugin": {"kind": "signoz/NotAPanel", "spec": {}}}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "NotAPanel")
-	})
-
-	t.Run("query kind incompatible with panel rejected", func(t *testing.T) {
-		// PromQLQuery is not allowed on ListPanel — verify the cross-check
-		// in Validate still runs after a patch.
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p2",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/ListPanel", "spec": {}},
-					"queries": [{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
-				}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("removing the only query rejected", func(t *testing.T) {
-		// Validate requires exactly one query per panel — leaving zero is rejected.
-		_, err := decode(t, `[{"op": "remove", "path": "/spec/panels/p2/spec/queries/0"}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "panel must have one query")
-	})
-
-	t.Run("two direct queries rejected", func(t *testing.T) {
-		// Validate requires exactly one query per panel. To display multiple
-		// data sources in one panel, wrap them in a CompositeQuery (see the
-		// "replace query with composite" subtest below).
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-					"queries": [
-						{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A", "signal": "metrics",
-							"aggregations": [{"metricName": "signoz_calls_total", "temporality": "cumulative", "timeAggregation": "rate", "spaceAggregation": "sum"}]
-						}}}},
-						{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "B", "signal": "metrics",
-							"aggregations": [{"metricName": "signoz_db_calls_total", "temporality": "cumulative", "timeAggregation": "rate", "spaceAggregation": "sum"}]
-						}}}}
-					]
-				}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "panel must have one query")
-	})
-
-	t.Run("too many tags rejected", func(t *testing.T) {
-		// Base already has 2 tags; add 9 more to exceed MaxTagsPerDashboard (10).
-		_, err := decode(t, `[
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "1"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "2"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "3"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "4"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "5"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "6"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "7"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "8"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "9"}}
-		]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "at most")
-	})
-}

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -10,11 +10,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"k8s.io/apimachinery/pkg/util/validation"
 )
 
-func unmarshalDashboard(data []byte) (*DashboardSpec, error) {
-	var d DashboardSpec
+func unmarshalDashboard(data []byte) (*DashboardData, error) {
+	var d DashboardData
 	if err := json.Unmarshal(data, &d); err != nil {
 		return nil, err
 	}
@@ -41,7 +40,7 @@ func TestInvalidateNotAJSON(t *testing.T) {
 }
 
 // TestUnmarshalErrorPreservesNestedMessage guards the wrap on dec.Decode in
-// DashboardSpec.UnmarshalJSON. The wrap stamps a consistent type/code on
+// DashboardData.UnmarshalJSON. The wrap stamps a consistent type/code on
 // decode failures, but must not smother the rich messages produced by nested
 // UnmarshalJSON methods (panel/query/variable/datasource plugin envelopes).
 func TestUnmarshalErrorPreservesNestedMessage(t *testing.T) {
@@ -821,7 +820,7 @@ func TestPersesFixtureStorageRoundTrip(t *testing.T) {
 	raw, err := os.ReadFile("testdata/perses.json")
 	require.NoError(t, err)
 
-	var data DashboardSpec
+	var data DashboardData
 	require.NoError(t, json.Unmarshal(raw, &data), "initial unmarshal")
 
 	marshaled, err := json.Marshal(data)
@@ -833,7 +832,7 @@ func TestPersesFixtureStorageRoundTrip(t *testing.T) {
 	remarshaled, err := json.Marshal(asMap)
 	require.NoError(t, err, "map → JSON (read-back shape)")
 
-	var roundtripped DashboardSpec
+	var roundtripped DashboardData
 	require.NoError(t, json.Unmarshal(remarshaled, &roundtripped), "JSON → typed (the failure mode)")
 }
 
@@ -926,112 +925,6 @@ func TestStorageRoundTrip(t *testing.T) {
 		"expected operator:> after storage round-trip")
 }
 
-func TestPostableDashboardV2GenerateNameFlag(t *testing.T) {
-	const validSpec = `"spec": {"panels": {}, "layouts": []}`
-
-	tests := []struct {
-		scenario     string
-		body         string
-		wantErr      bool
-		wantErrMatch string
-		wantName     string
-		wantDisplay  string
-	}{
-		{
-			scenario:    "flag true with display.name derives name on conversion",
-			body:        `{"schemaVersion":"` + SchemaVersion + `","generateName":true,"spec":{"display":{"name":"My Dashboard!"},"panels":{},"layouts":[]}}`,
-			wantName:    "",
-			wantDisplay: "My Dashboard!",
-		},
-		{
-			scenario:     "flag true with non-empty name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `","name":"already-set","generateName":true,"spec":{"display":{"name":"My Dashboard"},"panels":{},"layouts":[]}}`,
-			wantErr:      true,
-			wantErrMatch: "name must be empty when generateName is true",
-		},
-		{
-			scenario:     "flag true with empty display.name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `","generateName":true,` + validSpec + `}`,
-			wantErr:      true,
-			wantErrMatch: "spec.display.name is required",
-		},
-		{
-			scenario:    "flag false",
-			body:        `{"schemaVersion":"` + SchemaVersion + `","name":"my-dashboard",` + validSpec + `}`,
-			wantName:    "my-dashboard",
-			wantDisplay: "my-dashboard",
-		},
-		{
-			scenario:     "flag false with missing name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `",` + validSpec + `}`,
-			wantErr:      true,
-			wantErrMatch: "name is required",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.scenario, func(t *testing.T) {
-			var p PostableDashboardV2
-			err := json.Unmarshal([]byte(tt.body), &p)
-			if tt.wantErr {
-				require.Error(t, err, "expected validation error")
-				assert.Contains(t, err.Error(), tt.wantErrMatch)
-				return
-			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.wantName, p.Name)
-			assert.Equal(t, tt.wantDisplay, p.Spec.Display.Name)
-		})
-	}
-}
-
-func TestGenerateDashboardName(t *testing.T) {
-	tests := []struct {
-		scenario   string
-		input      string
-		wantPrefix string // expected slug prefix before the "-<suffix>" tail (empty if prefix is dropped)
-	}{
-		{scenario: "simple words with spaces", input: "My Dashboard", wantPrefix: "my-dashboard"},
-		{scenario: "punctuation collapses", input: "Hello, World!", wantPrefix: "hello-world"},
-		{scenario: "leading and trailing whitespace", input: "  hello  ", wantPrefix: "hello"},
-		{scenario: "leading and trailing hyphens", input: "---abc---", wantPrefix: "abc"},
-		{scenario: "consecutive non-alphanumerics collapse", input: "a___b...c", wantPrefix: "a-b-c"},
-		{scenario: "digits are preserved", input: "Region us-east-1", wantPrefix: "region-us-east-1"},
-		{scenario: "no alphanumerics drops prefix and returns suffix only", input: "!!! ???", wantPrefix: ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.scenario, func(t *testing.T) {
-			got := generateDashboardName(tt.input)
-			require.NotEmpty(t, got)
-			require.LessOrEqual(t, len(got), 63)
-			require.Empty(t, validation.IsDNS1123Label(got), "result must be a valid DNS-1123 label")
-
-			if tt.wantPrefix == "" {
-				assert.Len(t, got, dashboardNameSuffixLen, "expected the bare random suffix")
-				return
-			}
-			expectedPrefix := tt.wantPrefix + "-"
-			assert.True(t, strings.HasPrefix(got, expectedPrefix), "expected prefix %q, got %q", expectedPrefix, got)
-			assert.Len(t, got, len(expectedPrefix)+dashboardNameSuffixLen)
-		})
-	}
-
-	t.Run("prefix is truncated to leave room for the suffix", func(t *testing.T) {
-		input := strings.Repeat("a", 100)
-		got := generateDashboardName(input)
-		require.LessOrEqual(t, len(got), 63)
-		require.Empty(t, validation.IsDNS1123Label(got))
-		assert.Equal(t, len(got), 63, "expected the result to be padded to the max DNS-1123 length")
-	})
-
-	t.Run("suffix differs across calls", func(t *testing.T) {
-		first := generateDashboardName("collision-test")
-		second := generateDashboardName("collision-test")
-		assert.NotEqual(t, first, second, "expected the random suffix to differ across calls")
-	})
-}
-
 func TestSpanGaps(t *testing.T) {
 	unmarshal := func(t *testing.T, val string) SpanGaps {
 		t.Helper()

pkg/types/dashboardtypes/perses_drift_test.go

@@ -1,6 +1,6 @@
 package dashboardtypes
 
-// TestDashboardSpecMatchesPerses asserts that DashboardData
+// TestDashboardDataMatchesPerses asserts that DashboardData
 // and every nested SigNoz-owned type cover the JSON field set of their Perses
 // counterpart.
 
@@ -16,13 +16,13 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestDashboardSpecMatchesPerses(t *testing.T) {
+func TestDashboardDataMatchesPerses(t *testing.T) {
 	cases := []struct {
 		name   string
 		ours   reflect.Type
 		perses reflect.Type
 	}{
-		{"DashboardSpec", typeOf[DashboardSpec](), typeOf[v1.DashboardSpec]()},
+		{"DashboardSpec", typeOf[DashboardData](), typeOf[v1.DashboardSpec]()},
 		{"Panel", typeOf[Panel](), typeOf[v1.Panel]()},
 		{"PanelSpec", typeOf[PanelSpec](), typeOf[v1.PanelSpec]()},
 		{"Query", typeOf[Query](), typeOf[v1.Query]()},
@@ -38,10 +38,10 @@ func TestDashboardSpecMatchesPerses(t *testing.T) {
 			missing, extra := drift(c.ours, c.perses)
 
 			assert.Empty(t, missing,
-				"DashboardSpec (%s) is missing json fields present on Perses %s — upstream likely added or renamed a field",
+				"DashboardData (%s) is missing json fields present on Perses %s — upstream likely added or renamed a field",
 				c.ours.Name(), c.perses.Name())
 			assert.Empty(t, extra,
-				"DashboardSpec (%s) has json fields absent on Perses %s — upstream likely removed a field or we added one without the counterpart",
+				"DashboardData (%s) has json fields absent on Perses %s — upstream likely removed a field or we added one without the counterpart",
 				c.ours.Name(), c.perses.Name())
 		})
 	}

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -397,7 +397,12 @@ func (f *ThresholdFormat) UnmarshalJSON(data []byte) error {
 type ComparisonOperator struct{ valuer.String }
 
 var (
-	ComparisonOperatorAbove        = ComparisonOperator{valuer.NewString("above")} // default
+	ComparisonOperatorGT           = ComparisonOperator{valuer.NewString(">")} // default
+	ComparisonOperatorLT           = ComparisonOperator{valuer.NewString("<")}
+	ComparisonOperatorGTE          = ComparisonOperator{valuer.NewString(">=")}
+	ComparisonOperatorLTE          = ComparisonOperator{valuer.NewString("<=")}
+	ComparisonOperatorEQ           = ComparisonOperator{valuer.NewString("=")}
+	ComparisonOperatorAbove        = ComparisonOperator{valuer.NewString("above")}
 	ComparisonOperatorBelow        = ComparisonOperator{valuer.NewString("below")}
 	ComparisonOperatorAboveOrEqual = ComparisonOperator{valuer.NewString("above_or_equal")}
 	ComparisonOperatorBelowOrEqual = ComparisonOperator{valuer.NewString("below_or_equal")}
@@ -406,12 +411,12 @@ var (
 )
 
 func (ComparisonOperator) Enum() []any {
-	return []any{ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual, ComparisonOperatorEqual, ComparisonOperatorNotEqual}
+	return []any{ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ, ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual, ComparisonOperatorEqual, ComparisonOperatorNotEqual}
 }
 
 func (o ComparisonOperator) ValueOrDefault() string {
 	if o.IsZero() {
-		return ComparisonOperatorAbove.StringValue()
+		return ComparisonOperatorGT.StringValue()
 	}
 	return o.StringValue()
 }
@@ -426,12 +431,13 @@ func (o *ComparisonOperator) UnmarshalJSON(data []byte) error {
 		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid comparison operator: must be a string, one of `>`, `<`, `>=`, `<=`, `=`, `above`, `below`, `above_or_equal`, `below_or_equal`, `equal`, or `not_equal`")
 	}
 	if v == "" {
-		*o = ComparisonOperatorAbove
+		*o = ComparisonOperatorGT
 		return nil
 	}
 	co := ComparisonOperator{valuer.NewString(v)}
 	switch co {
-	case ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual,
+	case ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ,
+		ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual,
 		ComparisonOperatorEqual, ComparisonOperatorNotEqual:
 		*o = co
 		return nil

pkg/types/dashboardtypes/pinned_dashboard.go

@@ -1,22 +0,0 @@
-package dashboardtypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-const MaxPinnedDashboardsPerUser = 10
-
-var ErrCodePinnedDashboardLimitHit = errors.MustNewCode("pinned_dashboard_limit_hit")
-
-type PinnedDashboard struct {
-	bun.BaseModel `bun:"table:pinned_dashboard,alias:pinned_dashboard"`
-
-	UserID      valuer.UUID `bun:"user_id,pk,type:text"`
-	DashboardID valuer.UUID `bun:"dashboard_id,pk,type:text"`
-	OrgID       valuer.UUID `bun:"org_id,type:text,notnull"`
-	PinnedAt    time.Time   `bun:"pinned_at,notnull,default:current_timestamp"`
-}

pkg/types/dashboardtypes/store.go

@@ -32,21 +32,4 @@ type Store interface {
 	DeletePublic(context.Context, string) error
 
 	RunInTx(context.Context, func(context.Context) error) error
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-	GetV2(context.Context, valuer.UUID, valuer.UUID) (*StorableDashboard, *StorablePublicDashboard, error)
-
-	UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data StorableDashboardData) error
-
-	LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, locked bool, updatedBy string) error
-
-	// int64 return is the total row count for the filter (pre-limit/offset),
-	ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *ListDashboardsV2Params) ([]*DashboardListRow, int64, error)
-
-	// Returns ErrCodePinnedDashboardLimitHit when the user is at MaxPinnedDashboardsPerUser.
-	PinForUser(ctx context.Context, pd *PinnedDashboard) error
-
-	UnpinForUser(ctx context.Context, userID valuer.UUID, dashboardID valuer.UUID) error
 }

pkg/types/spantypes/store.go

@@ -2,6 +2,7 @@ package spantypes
 
 import (
 	"context"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -26,4 +27,6 @@ type SpanMapperStore interface {
 type TraceStore interface {
 	GetTraceSummary(ctx context.Context, traceID string) (*TraceSummary, error)
 	GetTraceSpans(ctx context.Context, traceID string, summary *TraceSummary) ([]StorableSpan, error)
+	GetMinimalSpans(ctx context.Context, traceID string, start, end time.Time) ([]MinimalSpan, error)
+	GetTraceSpansByIDs(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]StorableSpan, error)
 }

pkg/types/spantypes/waterfall_span.go

@@ -103,12 +103,10 @@ type StorableSpan struct {
 	StartTime          time.Time          `ch:"timestamp"`
 	DurationNano       uint64             `ch:"duration_nano"`
 	SpanID             string             `ch:"span_id"`
-	TraceID            string             `ch:"trace_id"`
 	HasError           bool               `ch:"has_error"`
 	Kind               int8               `ch:"kind"`
 	ServiceName        string             `ch:"resource_string_service$$name"`
 	Name               string             `ch:"name"`
-	References         string             `ch:"references"`
 	AttributesString   map[string]string  `ch:"attributes_string"`
 	AttributesNumber   map[string]float64 `ch:"attributes_number"`
 	AttributesBool     map[string]bool    `ch:"attributes_bool"`
@@ -132,6 +130,32 @@ type StorableSpan struct {
 	ResponseStatusCode string             `ch:"response_status_code"`
 }
 
+// MinimalSpan with only the fields needed to build the parent-child tree.
+type MinimalSpan struct {
+	SpanID       string    `ch:"span_id"`
+	ParentSpanID string    `ch:"parent_span_id"`
+	StartTime    time.Time `ch:"timestamp"`
+	DurationNano uint64    `ch:"duration_nano"`
+	HasError     bool      `ch:"has_error"`
+	ServiceName  string    `ch:"resource_string_service$$name"`
+}
+
+func (item *MinimalSpan) ToWaterfallSpan(traceID string) *WaterfallSpan {
+	return &WaterfallSpan{
+		SpanID:       item.SpanID,
+		TraceID:      traceID,
+		ParentSpanID: item.ParentSpanID,
+		TimeUnix:     uint64(item.StartTime.UnixNano()),
+		DurationNano: item.DurationNano,
+		HasError:     item.HasError,
+		ServiceName:  item.ServiceName,
+		Resource:     map[string]string{"service.name": item.ServiceName},
+		Children:     make([]*WaterfallSpan, 0),
+		Attributes:   make(map[string]any),
+		Events:       make([]Event, 0),
+	}
+}
+
 // NewMissingWaterfallSpan creates a synthetic placeholder span for a parent that has no recorded data.
 func NewMissingWaterfallSpan(spanID, traceID string, timeUnixNano, durationNano uint64) *WaterfallSpan {
 	return &WaterfallSpan{
@@ -261,7 +285,7 @@ func (item *StorableSpan) UnmarshalledEvents() []Event {
 	return events
 }
 
-func (item *StorableSpan) ToWaterfallSpan() *WaterfallSpan {
+func (item *StorableSpan) ToWaterfallSpan(traceID string) *WaterfallSpan {
 	resources := make(map[string]string)
 	maps.Copy(resources, item.ResourcesString)
 
@@ -289,7 +313,7 @@ func (item *StorableSpan) ToWaterfallSpan() *WaterfallSpan {
 		StatusCode:         item.StatusCode,
 		StatusCodeString:   item.StatusCodeString,
 		StatusMessage:      item.StatusMessage,
-		TraceID:            item.TraceID,
+		TraceID:            traceID,
 		TraceState:         item.TraceState,
 		Children:           make([]*WaterfallSpan, 0),
 		TimeUnix:           uint64(item.StartTime.UnixNano()),
@@ -297,6 +321,24 @@ func (item *StorableSpan) ToWaterfallSpan() *WaterfallSpan {
 	}
 }
 
+func EnrichSelectedSpans(window []*WaterfallSpan, fullSpans []StorableSpan) {
+	fullByID := make(map[string]*StorableSpan, len(fullSpans))
+	for i := range fullSpans {
+		fullByID[fullSpans[i].SpanID] = &fullSpans[i]
+	}
+	for i, ws := range window {
+		full, ok := fullByID[ws.SpanID]
+		if !ok {
+			continue // synthesized MissingSpan — keep empty shell
+		}
+		newWS := full.ToWaterfallSpan(ws.TraceID)
+		newWS.Level = ws.Level
+		newWS.HasChildren = ws.HasChildren
+		newWS.SubTreeNodeCount = ws.SubTreeNodeCount
+		window[i] = newWS
+	}
+}
+
 // getSpanIndex returns the index of matched span and -1 for no match.
 func getSpanIndex(spans []*WaterfallSpan, targetSpanID string) int {
 	for i, s := range spans {

pkg/types/spantypes/waterfall_trace.go

@@ -62,26 +62,24 @@ func NewWaterfallTrace(
 	}
 }
 
-func NewWaterfallTraceFromSpans(spans []StorableSpan) *WaterfallTrace {
+// NewWaterfallTraceFromSpans requires WaterfallSpan nodes with only below fields:
+// SpanID, ParentSpanID, TimeUnix, DurationNano, HasError, and ServiceName.
+func NewWaterfallTraceFromSpans(nodes []*WaterfallSpan) *WaterfallTrace {
 	var (
 		startTime, endTime, totalErrorSpans uint64
-		spanIDToSpanNodeMap                 = make(map[string]*WaterfallSpan, len(spans))
+		spanIDToSpanNodeMap                 = make(map[string]*WaterfallSpan, len(nodes))
 		traceRoots                          []*WaterfallSpan
 		hasMissingSpans                     bool
 	)
 
-	for _, item := range spans {
-		span := item.ToWaterfallSpan()
-		startTimeUnixNano := uint64(item.StartTime.UnixNano())
-		if startTime == 0 || startTimeUnixNano < startTime {
-			startTime = startTimeUnixNano
+	for _, span := range nodes {
+		if startTime == 0 || span.TimeUnix < startTime {
+			startTime = span.TimeUnix
 		}
-		endTime = max(endTime, startTimeUnixNano+span.DurationNano)
-
+		endTime = max(endTime, span.TimeUnix+span.DurationNano)
 		if span.HasError {
 			totalErrorSpans++
 		}
-
 		spanIDToSpanNodeMap[span.SpanID] = span
 	}
 
@@ -116,7 +114,7 @@ func NewWaterfallTraceFromSpans(spans []StorableSpan) *WaterfallTrace {
 	return NewWaterfallTrace(
 		startTime,
 		endTime,
-		uint64(len(spans)),
+		uint64(len(nodes)),
 		totalErrorSpans,
 		spanIDToSpanNodeMap,
 		traceRoots,

pkg/types/tagtypes/tag.go

@@ -69,14 +69,6 @@ func NewPostableTagsFromTags(tags []*Tag) []PostableTag {
 	return out
 }
 
-func NewTagsFromPostableTags(orgID valuer.UUID, kind coretypes.Kind, tags []PostableTag) []*Tag {
-	out := make([]*Tag, len(tags))
-	for i, t := range tags {
-		out[i] = NewTag(orgID, kind, t.Key, t.Value)
-	}
-	return out
-}
-
 func NewTag(orgID valuer.UUID, kind coretypes.Kind, key, value string) *Tag {
 	now := time.Now()
 	return &Tag{