fix: return error in enrich function

* feat: added trace export

feat: added types for export

feat: added support for complex queries

fix: added correct open api spec

fix: updated unit tests

fix: type handling logic

fix: improve order by

feat: added integration tests

fix: address comments

* fix: address comments

* fix: removed nits

* fix: go fmt

* fix: rebased main and ran generate cmd

* fix: renamed method

* fix: address comments

* fix: lint error

* fix: lint error

* fix: ran yarn generate:api

* fix: address comments

* fix: address comments

* fix: typo

* fix: better names for functions

* fix: added unit tests, renamed file, added validation

* fix: update integration test

* fix: removed get method for export

* fix: yarn generate:api

* chore: yarn generate:api

* fix: rename file

---------

Co-authored-by: Srikanth Chekuri <srikanth.chekuri92@gmail.com>

.vscode/settings.json

@@ -17,5 +17,7 @@
 	},
 	"[html]": {
 		"editor.defaultFormatter": "vscode.html-language-features"
-	}
+	},
+	"python-envs.defaultEnvManager": "ms-python.python:system",
+	"python-envs.pythonProjects": []
 }

docs/api/openapi.yml

@@ -417,6 +417,18 @@ components:
         message:
           type: string
       type: object
+    FactoryResponse:
+      properties:
+        healthy:
+          type: boolean
+        services:
+          additionalProperties:
+            items:
+              type: string
+            type: array
+          nullable: true
+          type: object
+      type: object
     FeaturetypesGettableFeature:
       properties:
         defaultVariant:
@@ -3039,6 +3051,68 @@ paths:
       summary: Update auth domain
       tags:
       - authdomains
+  /api/v1/export_raw_data:
+    post:
+      deprecated: false
+      description: This endpoints allows complex query exporting raw data for traces
+        and logs
+      operationId: HandleExportRawDataPOST
+      parameters:
+      - description: The output format for the export.
+        in: query
+        name: format
+        schema:
+          default: csv
+          description: The output format for the export.
+          enum:
+          - csv
+          - jsonl
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Querybuildertypesv5QueryRangeRequest'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                type: string
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Export raw data
+      tags:
+      - logs
+      - traces
   /api/v1/fields/keys:
     get:
       deprecated: false
@@ -5984,6 +6058,70 @@ paths:
       summary: Search ingestion keys for workspace
       tags:
       - gateway
+  /api/v2/healthz:
+    get:
+      operationId: Healthz
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/FactoryResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "503":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/FactoryResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Service Unavailable
+      summary: Health check
+      tags:
+      - health
+  /api/v2/livez:
+    get:
+      deprecated: false
+      description: ""
+      operationId: Livez
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/FactoryResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      summary: Liveness check
+      tags:
+      - health
   /api/v2/metrics:
     get:
       deprecated: false
@@ -6660,6 +6798,41 @@ paths:
       summary: Update my organization
       tags:
       - orgs
+  /api/v2/readyz:
+    get:
+      operationId: Readyz
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/FactoryResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "503":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/FactoryResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Service Unavailable
+      summary: Readiness check
+      tags:
+      - health
   /api/v2/sessions:
     delete:
       deprecated: false

docs/contributing/go/handler.md

@@ -123,6 +123,7 @@ if err := router.Handle("/api/v1/things", handler.New(
         Description:         "This endpoint creates a thing",
         Request:             new(types.PostableThing),
         RequestContentType:  "application/json",
+        RequestQuery:        new(types.QueryableThing),
         Response:            new(types.GettableThing),
         ResponseContentType: "application/json",
         SuccessStatusCode:   http.StatusCreated,
@@ -155,6 +156,8 @@ The `handler.New` function ties the HTTP handler to OpenAPI metadata via `OpenAP
 - **Request / RequestContentType**:
   - `Request` is a Go type that describes the request body or form.
   - `RequestContentType` is usually `"application/json"` or `"application/x-www-form-urlencoded"` (for callbacks like SAML).
+- **RequestQuery**:
+  - `RequestQuery` is a Go type that descirbes query url params.
 - **RequestExamples**: An array of `handler.OpenAPIExample` that provide concrete request payloads in the generated spec. See [Adding request examples](#adding-request-examples) below.
 - **Response / ResponseContentType**:
   - `Response` is the Go type for the successful response payload.

docs/contributing/onboarding.md

@@ -273,6 +273,7 @@ Options can be simple (direct link) or nested (with another question):
 - Place logo files in `public/Logos/`
 - Use SVG format
 - Reference as `"/Logos/your-logo.svg"`
+- **Fetching Icons**: New icons can be easily fetched from [OpenBrand](https://openbrand.sh/). Use the pattern `https://openbrand.sh/?url=<TARGET_URL>`, where `<TARGET_URL>` is the URL-encoded link to the service's website. For example, to get Render's logo, use [https://openbrand.sh/?url=https%3A%2F%2Frender.com](https://openbrand.sh/?url=https%3A%2F%2Frender.com).
 - **Optimize new SVGs**: Run any newly downloaded SVGs through an optimizer like [SVGOMG (svgo)](https://svgomg.net/) or use `npx svgo public/Logos/your-logo.svg` to minimise their size before committing.
 
 ### 4. Links

ee/authz/openfgaauthz/provider.go

@@ -57,6 +57,10 @@ func (provider *provider) Start(ctx context.Context) error {
 	return provider.openfgaServer.Start(ctx)
 }
 
+func (provider *provider) Healthy() <-chan struct{} {
+	return provider.openfgaServer.Healthy()
+}
+
 func (provider *provider) Stop(ctx context.Context) error {
 	return provider.openfgaServer.Stop(ctx)
 }

ee/authz/openfgaserver/server.go

@@ -16,7 +16,6 @@ type Server struct {
 }
 
 func NewOpenfgaServer(ctx context.Context, pkgAuthzService authz.AuthZ) (*Server, error) {
-
 	return &Server{
 		pkgAuthzService: pkgAuthzService,
 	}, nil
@@ -26,6 +25,10 @@ func (server *Server) Start(ctx context.Context) error {
 	return server.pkgAuthzService.Start(ctx)
 }
 
+func (server *Server) Healthy() <-chan struct{} {
+	return server.pkgAuthzService.Healthy()
+}
+
 func (server *Server) Stop(ctx context.Context) error {
 	return server.pkgAuthzService.Stop(ctx)
 }

ee/query-service/app/server.go

@@ -136,6 +136,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
 		signoz.SQLStore,
 		integrationsController.GetPipelinesForInstalledIntegrations,
+		reader,
 	)
 	if err != nil {
 		return nil, err

frontend/public/Logos/mistral.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="#fa520f" viewBox="0 0 24 24"><title>Mistral AI</title><path d="M17.143 3.429v3.428h-3.429v3.429h-3.428V6.857H6.857V3.43H3.43v13.714H0v3.428h10.286v-3.428H6.857v-3.429h3.429v3.429h3.429v-3.429h3.428v3.429h-3.428v3.428H24v-3.428h-3.43V3.429z"/></svg>

frontend/public/Logos/openclaw.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 120 120"><defs><linearGradient id="a" x1="0%" x2="100%" y1="0%" y2="100%"><stop offset="0%" stop-color="#ff4d4d"/><stop offset="100%" stop-color="#991b1b"/></linearGradient></defs><path fill="url(#a)" d="M60 10c-30 0-45 25-45 45s15 40 30 45v10h10v-10s5 2 10 0v10h10v-10c15-5 30-25 30-45S90 10 60 10"/><path fill="url(#a)" d="M20 45C5 40 0 50 5 60s15 5 20-5c3-7 0-10-5-10"/><path fill="url(#a)" d="M100 45c15-5 20 5 15 15s-15 5-20-5c-3-7 0-10 5-10"/><path stroke="#ff4d4d" stroke-linecap="round" stroke-width="3" d="M45 15Q35 5 30 8M75 15Q85 5 90 8"/><circle cx="45" cy="35" r="6" fill="#050810"/><circle cx="75" cy="35" r="6" fill="#050810"/><circle cx="46" cy="34" r="2.5" fill="#00e5cc"/><circle cx="76" cy="34" r="2.5" fill="#00e5cc"/></svg>

frontend/public/Logos/render.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>Render</title><path d="M18.263.007c-3.121-.147-5.744 2.109-6.192 5.082-.018.138-.045.272-.067.405-.696 3.703-3.936 6.507-7.827 6.507a7.9 7.9 0 0 1-3.825-.979.202.202 0 0 0-.302.178V24H12v-8.999c0-1.656 1.338-3 2.987-3h2.988c3.382 0 6.103-2.817 5.97-6.244-.12-3.084-2.61-5.603-5.682-5.75"/></svg>

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

@@ -0,0 +1,250 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useQuery } from 'react-query';
+
+import type { ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type {
+	Healthz200,
+	Healthz503,
+	Livez200,
+	Readyz200,
+	Readyz503,
+	RenderErrorResponseDTO,
+} from '../sigNoz.schemas';
+
+/**
+ * @summary Health check
+ */
+export const healthz = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<Healthz200>({
+		url: `/api/v2/healthz`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getHealthzQueryKey = () => {
+	return [`/api/v2/healthz`] as const;
+};
+
+export const getHealthzQueryOptions = <
+	TData = Awaited<ReturnType<typeof healthz>>,
+	TError = ErrorType<Healthz503>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof healthz>>, TError, TData>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getHealthzQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof healthz>>> = ({
+		signal,
+	}) => healthz(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof healthz>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type HealthzQueryResult = NonNullable<
+	Awaited<ReturnType<typeof healthz>>
+>;
+export type HealthzQueryError = ErrorType<Healthz503>;
+
+/**
+ * @summary Health check
+ */
+
+export function useHealthz<
+	TData = Awaited<ReturnType<typeof healthz>>,
+	TError = ErrorType<Healthz503>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof healthz>>, TError, TData>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getHealthzQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Health check
+ */
+export const invalidateHealthz = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getHealthzQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * @summary Liveness check
+ */
+export const livez = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<Livez200>({
+		url: `/api/v2/livez`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getLivezQueryKey = () => {
+	return [`/api/v2/livez`] as const;
+};
+
+export const getLivezQueryOptions = <
+	TData = Awaited<ReturnType<typeof livez>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof livez>>, TError, TData>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getLivezQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof livez>>> = ({
+		signal,
+	}) => livez(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof livez>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type LivezQueryResult = NonNullable<Awaited<ReturnType<typeof livez>>>;
+export type LivezQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Liveness check
+ */
+
+export function useLivez<
+	TData = Awaited<ReturnType<typeof livez>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof livez>>, TError, TData>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getLivezQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Liveness check
+ */
+export const invalidateLivez = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries({ queryKey: getLivezQueryKey() }, options);
+
+	return queryClient;
+};
+
+/**
+ * @summary Readiness check
+ */
+export const readyz = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<Readyz200>({
+		url: `/api/v2/readyz`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getReadyzQueryKey = () => {
+	return [`/api/v2/readyz`] as const;
+};
+
+export const getReadyzQueryOptions = <
+	TData = Awaited<ReturnType<typeof readyz>>,
+	TError = ErrorType<Readyz503>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof readyz>>, TError, TData>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getReadyzQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof readyz>>> = ({
+		signal,
+	}) => readyz(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof readyz>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ReadyzQueryResult = NonNullable<Awaited<ReturnType<typeof readyz>>>;
+export type ReadyzQueryError = ErrorType<Readyz503>;
+
+/**
+ * @summary Readiness check
+ */
+
+export function useReadyz<
+	TData = Awaited<ReturnType<typeof readyz>>,
+	TError = ErrorType<Readyz503>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof readyz>>, TError, TData>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getReadyzQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Readiness check
+ */
+export const invalidateReadyz = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getReadyzQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};

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

@@ -20,11 +20,113 @@ import { useMutation, useQuery } from 'react-query';
 import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
+	HandleExportRawDataPOSTParams,
 	ListPromotedAndIndexedPaths200,
 	PromotetypesPromotePathDTO,
+	Querybuildertypesv5QueryRangeRequestDTO,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';
 
+/**
+ * This endpoints allows complex query exporting raw data for traces and logs
+ * @summary Export raw data
+ */
+export const handleExportRawDataPOST = (
+	querybuildertypesv5QueryRangeRequestDTO: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
+	params?: HandleExportRawDataPOSTParams,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v1/export_raw_data`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: querybuildertypesv5QueryRangeRequestDTO,
+		params,
+		signal,
+	});
+};
+
+export const getHandleExportRawDataPOSTMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof handleExportRawDataPOST>>,
+		TError,
+		{
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			params?: HandleExportRawDataPOSTParams;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof handleExportRawDataPOST>>,
+	TError,
+	{
+		data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+		params?: HandleExportRawDataPOSTParams;
+	},
+	TContext
+> => {
+	const mutationKey = ['handleExportRawDataPOST'];
+	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 handleExportRawDataPOST>>,
+		{
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			params?: HandleExportRawDataPOSTParams;
+		}
+	> = (props) => {
+		const { data, params } = props ?? {};
+
+		return handleExportRawDataPOST(data, params);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type HandleExportRawDataPOSTMutationResult = NonNullable<
+	Awaited<ReturnType<typeof handleExportRawDataPOST>>
+>;
+export type HandleExportRawDataPOSTMutationBody = BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+export type HandleExportRawDataPOSTMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Export raw data
+ */
+export const useHandleExportRawDataPOST = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof handleExportRawDataPOST>>,
+		TError,
+		{
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			params?: HandleExportRawDataPOSTParams;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof handleExportRawDataPOST>>,
+	TError,
+	{
+		data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+		params?: HandleExportRawDataPOSTParams;
+	},
+	TContext
+> => {
+	const mutationOptions = getHandleExportRawDataPOSTMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
 /**
  * This endpoints promotes and indexes paths
  * @summary Promote and index paths

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -543,6 +543,23 @@ export interface ErrorsResponseerroradditionalDTO {
 	message?: string;
 }
 
+/**
+ * @nullable
+ */
+export type FactoryResponseDTOServices = { [key: string]: string[] } | null;
+
+export interface FactoryResponseDTO {
+	/**
+	 * @type boolean
+	 */
+	healthy?: boolean;
+	/**
+	 * @type object
+	 * @nullable true
+	 */
+	services?: FactoryResponseDTOServices;
+}
+
 /**
  * @nullable
  */
@@ -2942,6 +2959,19 @@ export type DeleteAuthDomainPathParameters = {
 export type UpdateAuthDomainPathParameters = {
 	id: string;
 };
+export type HandleExportRawDataPOSTParams = {
+	/**
+	 * @enum csv,jsonl
+	 * @type string
+	 * @description The output format for the export.
+	 */
+	format?: HandleExportRawDataPOSTFormat;
+};
+
+export enum HandleExportRawDataPOSTFormat {
+	csv = 'csv',
+	jsonl = 'jsonl',
+}
 export type GetFieldsKeysParams = {
 	/**
 	 * @description undefined
@@ -3457,6 +3487,30 @@ export type SearchIngestionKeys200 = {
 	status: string;
 };
 
+export type Healthz200 = {
+	data: FactoryResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type Healthz503 = {
+	data: FactoryResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type Livez200 = {
+	data: FactoryResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type ListMetricsParams = {
 	/**
 	 * @type integer
@@ -3592,6 +3646,22 @@ export type GetMyOrganization200 = {
 	status: string;
 };
 
+export type Readyz200 = {
+	data: FactoryResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type Readyz503 = {
+	data: FactoryResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type GetSessionContext200 = {
 	data: AuthtypesSessionContextDTO;
 	/**

frontend/src/components/CeleryTask/useNavigateToExplorer.ts

@@ -7,7 +7,7 @@ import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useNotifications } from 'hooks/useNotifications';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { AppState } from 'store/reducers';
 import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, MetricAggregateOperator } from 'types/common/queryBuilder';
@@ -79,7 +79,7 @@ export function useNavigateToExplorer(): (
 	);
 
 	const { getUpdatedQuery } = useUpdatedQuery();
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 	const { notifications } = useNotifications();
 
 	return useCallback(

frontend/src/components/QueryBuilderV2/QueryV2/__tests__/QuerySearch.test.tsx

@@ -86,8 +86,8 @@ jest.mock('hooks/useDarkMode', () => ({
 	useIsDarkMode: (): boolean => false,
 }));
 
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): { selectedDashboard: undefined } => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): { selectedDashboard: undefined } => ({
 		selectedDashboard: undefined,
 	}),
 }));

frontend/src/container/DashboardContainer/DashboardDescription/__tests__/DashboardDescription.test.tsx

@@ -1,4 +1,6 @@
+import { ReactNode } from 'react';
 import { MemoryRouter, useLocation } from 'react-router-dom';
+import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
 import {
 	getDashboardById,
 	getNonIntegrationDashboardById,
@@ -6,10 +8,9 @@ import {
 import { server } from 'mocks-server/server';
 import { rest } from 'msw';
 import {
-	DashboardContext,
-	DashboardProvider,
-} from 'providers/Dashboard/Dashboard';
-import { IDashboardContext } from 'providers/Dashboard/types';
+	resetDashboard,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import {
 	fireEvent,
 	render,
@@ -21,6 +22,18 @@ import { Dashboard } from 'types/api/dashboard/getAll';
 
 import DashboardDescription from '..';
 
+function DashboardBootstrapWrapper({
+	dashboardId,
+	children,
+}: {
+	dashboardId: string;
+	children: ReactNode;
+}): JSX.Element {
+	useDashboardBootstrap(dashboardId);
+	// eslint-disable-next-line react/jsx-no-useless-fragment
+	return <>{children}</>;
+}
+
 interface MockSafeNavigateReturn {
 	safeNavigate: jest.MockedFunction<(url: string) => void>;
 }
@@ -54,6 +67,7 @@ describe('Dashboard landing page actions header tests', () => {
 	beforeEach(() => {
 		mockSafeNavigate.mockClear();
 		sessionStorage.clear();
+		resetDashboard();
 	});
 
 	it('unlock dashboard should be disabled for integrations created dashboards', async () => {
@@ -64,7 +78,7 @@ describe('Dashboard landing page actions header tests', () => {
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);
 		const { getByTestId } = render(
 			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
-				<DashboardProvider dashboardId="4">
+				<DashboardBootstrapWrapper dashboardId="4">
 					<DashboardDescription
 						handle={{
 							active: false,
@@ -73,7 +87,7 @@ describe('Dashboard landing page actions header tests', () => {
 							node: { current: null },
 						}}
 					/>
-				</DashboardProvider>
+				</DashboardBootstrapWrapper>
 			</MemoryRouter>,
 		);
 
@@ -105,7 +119,7 @@ describe('Dashboard landing page actions header tests', () => {
 		);
 		const { getByTestId } = render(
 			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
-				<DashboardProvider dashboardId="4">
+				<DashboardBootstrapWrapper dashboardId="4">
 					<DashboardDescription
 						handle={{
 							active: false,
@@ -114,7 +128,7 @@ describe('Dashboard landing page actions header tests', () => {
 							node: { current: null },
 						}}
 					/>
-				</DashboardProvider>
+				</DashboardBootstrapWrapper>
 			</MemoryRouter>,
 		);
 
@@ -144,7 +158,7 @@ describe('Dashboard landing page actions header tests', () => {
 
 		const { getByText } = render(
 			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
-				<DashboardProvider dashboardId="4">
+				<DashboardBootstrapWrapper dashboardId="4">
 					<DashboardDescription
 						handle={{
 							active: false,
@@ -153,7 +167,7 @@ describe('Dashboard landing page actions header tests', () => {
 							node: { current: null },
 						}}
 					/>
-				</DashboardProvider>
+				</DashboardBootstrapWrapper>
 			</MemoryRouter>,
 		);
 
@@ -181,37 +195,26 @@ describe('Dashboard landing page actions header tests', () => {
 
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);
 
-		const mockContextValue: IDashboardContext = {
-			isDashboardLocked: false,
-			handleDashboardLockToggle: jest.fn(),
-			dashboardResponse: {} as IDashboardContext['dashboardResponse'],
+		useDashboardStore.setState({
 			selectedDashboard: (getDashboardById.data as unknown) as Dashboard,
 			layouts: [],
 			panelMap: {},
 			setPanelMap: jest.fn(),
 			setLayouts: jest.fn(),
 			setSelectedDashboard: jest.fn(),
-			updatedTimeRef: { current: null },
-			updateLocalStorageDashboardVariables: jest.fn(),
-			dashboardQueryRangeCalled: false,
-			setDashboardQueryRangeCalled: jest.fn(),
-			isDashboardFetching: false,
 			columnWidths: {},
-			setColumnWidths: jest.fn(),
-		};
+		});
 
 		const { getByText } = render(
 			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
-				<DashboardContext.Provider value={mockContextValue}>
-					<DashboardDescription
-						handle={{
-							active: false,
-							enter: (): Promise<void> => Promise.resolve(),
-							exit: (): Promise<void> => Promise.resolve(),
-							node: { current: null },
-						}}
-					/>
-				</DashboardContext.Provider>
+				<DashboardDescription
+					handle={{
+						active: false,
+						enter: (): Promise<void> => Promise.resolve(),
+						exit: (): Promise<void> => Promise.resolve(),
+						node: { current: null },
+					}}
+				/>
 			</MemoryRouter>,
 		);
 

frontend/src/container/DashboardContainer/DashboardDescription/index.tsx

@@ -21,6 +21,7 @@ import { DeleteButton } from 'container/ListOfDashboard/TableComponents/DeleteBu
 import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
 import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
 import { useGetPublicDashboardMeta } from 'hooks/dashboard/useGetPublicDashboardMeta';
+import { useLockDashboard } from 'hooks/dashboard/useLockDashboard';
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
@@ -39,8 +40,11 @@ import {
 	X,
 } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import { sortLayout } from 'providers/Dashboard/util';
 import { DashboardData } from 'types/api/dashboard/getAll';
 import { Props } from 'types/api/dashboard/update';
@@ -79,10 +83,11 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		setPanelMap,
 		layouts,
 		setLayouts,
-		isDashboardLocked,
 		setSelectedDashboard,
-		handleDashboardLockToggle,
-	} = useDashboard();
+	} = useDashboardStore();
+
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
+	const handleDashboardLockToggle = useLockDashboard();
 
 	const variablesSettingsTabHandle = useRef<VariablesSettingsTab>(null);
 	const [isSettingsDrawerOpen, setIsSettingsDrawerOpen] = useState<boolean>(

frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/VariableItem.tsx

@@ -30,7 +30,7 @@ import {
 	Pyramid,
 	X,
 } from 'lucide-react';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { AppState } from 'store/reducers';
 import {
 	IDashboardVariable,
@@ -239,7 +239,7 @@ function VariableItem({
 
 	const [selectedWidgets, setSelectedWidgets] = useState<string[]>([]);
 
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 	const widgetsByDynamicVariableId = useWidgetsByDynamicVariableId();
 
 	useEffect(() => {

frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/WidgetSelector.tsx

@@ -2,7 +2,7 @@ import React from 'react';
 import { CustomMultiSelect } from 'components/NewSelect';
 import { PANEL_GROUP_TYPES } from 'constants/queryBuilder';
 import { generateGridTitle } from 'container/GridPanelSwitch/utils';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { WidgetRow, Widgets } from 'types/api/dashboard/getAll';
 
 export function WidgetSelector({
@@ -12,7 +12,7 @@ export function WidgetSelector({
 	selectedWidgets: string[];
 	setSelectedWidgets: (widgets: string[]) => void;
 }): JSX.Element {
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 
 	// Get layout IDs for cross-referencing
 	const layoutIds = new Set(

frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/index.tsx

@@ -19,8 +19,8 @@ import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import { useNotifications } from 'hooks/useNotifications';
 import { PenLine, Trash2 } from 'lucide-react';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { IDashboardVariables } from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreTypes';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
 
 import { TVariableMode } from './types';
@@ -87,7 +87,7 @@ function VariablesSettings({
 
 	const { t } = useTranslation(['dashboard']);
 
-	const { selectedDashboard, setSelectedDashboard } = useDashboard();
+	const { selectedDashboard, setSelectedDashboard } = useDashboardStore();
 	const { dashboardVariables } = useDashboardVariables();
 
 	const { notifications } = useNotifications();

frontend/src/container/DashboardContainer/DashboardSettings/General/index.tsx

@@ -5,7 +5,7 @@ import AddTags from 'container/DashboardContainer/DashboardSettings/General/AddT
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import { isEqual } from 'lodash-es';
 import { Check, X } from 'lucide-react';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 
 import { Button } from './styles';
 import { Base64Icons } from './utils';
@@ -15,7 +15,7 @@ import './GeneralSettings.styles.scss';
 const { Option } = Select;
 
 function GeneralDashboardSettings(): JSX.Element {
-	const { selectedDashboard, setSelectedDashboard } = useDashboard();
+	const { selectedDashboard, setSelectedDashboard } = useDashboardStore();
 
 	const updateDashboardMutation = useUpdateDashboard();
 

frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/__tests__/PublicDashboard.test.tsx

@@ -7,14 +7,14 @@ import {
 	unpublishedPublicDashboardMeta,
 } from 'mocks-server/__mockdata__/publicDashboard';
 import { rest, server } from 'mocks-server/server';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
 import { USER_ROLES } from 'types/roles';
 
 import PublicDashboardSetting from '../index';
 
 // Mock dependencies
-jest.mock('providers/Dashboard/Dashboard');
+jest.mock('providers/Dashboard/store/useDashboardStore');
 jest.mock('react-use', () => ({
 	...jest.requireActual('react-use'),
 	useCopyToClipboard: jest.fn(),
@@ -26,7 +26,7 @@ jest.mock('@signozhq/sonner', () => ({
 	},
 }));
 
-const mockUseDashboard = jest.mocked(useDashboard);
+const mockUseDashboard = jest.mocked(useDashboardStore);
 const mockUseCopyToClipboard = jest.mocked(useCopyToClipboard);
 const mockToast = jest.mocked(toast);
 
@@ -67,10 +67,10 @@ beforeEach(() => {
 	// Mock window.open
 	window.open = jest.fn();
 
-	// Mock useDashboard
+	// Mock useDashboardStore
 	mockUseDashboard.mockReturnValue(({
 		selectedDashboard: mockSelectedDashboard,
-	} as unknown) as ReturnType<typeof useDashboard>);
+	} as unknown) as ReturnType<typeof useDashboardStore>);
 
 	// Mock useCopyToClipboard
 	mockUseCopyToClipboard.mockReturnValue(([

frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx

@@ -11,7 +11,7 @@ import { useGetPublicDashboardMeta } from 'hooks/dashboard/useGetPublicDashboard
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Copy, ExternalLink, Globe, Info, Loader2, Trash } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { PublicDashboardMetaProps } from 'types/api/dashboard/public/getMeta';
 import APIError from 'types/api/error';
 import { USER_ROLES } from 'types/roles';
@@ -59,7 +59,7 @@ function PublicDashboardSetting(): JSX.Element {
 	const [defaultTimeRange, setDefaultTimeRange] = useState('30m');
 	const [, setCopyPublicDashboardURL] = useCopyToClipboard();
 
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 
 	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
 

frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx

@@ -3,13 +3,14 @@ import { memo, useCallback, useEffect, useMemo } from 'react';
 import { useSelector } from 'react-redux';
 import { Row } from 'antd';
 import { ALL_SELECTED_VALUE } from 'components/NewSelect/utils';
+import { updateLocalStorageDashboardVariable } from 'hooks/dashboard/useDashboardFromLocalStorage';
 import {
 	useDashboardVariables,
 	useDashboardVariablesSelector,
 } from 'hooks/dashboard/useDashboardVariables';
 import useVariablesFromUrl from 'hooks/dashboard/useVariablesFromUrl';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { updateDashboardVariablesStore } from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStore';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import {
 	enqueueDescendantsOfVariable,
 	enqueueFetchOfAllVariables,
@@ -18,23 +19,23 @@ import {
 import { AppState } from 'store/reducers';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { useShallow } from 'zustand/react/shallow';
 
 import VariableItem from './VariableItem';
 
 import './DashboardVariableSelection.styles.scss';
 
 function DashboardVariableSelection(): JSX.Element | null {
-	const {
-		setSelectedDashboard,
-		updateLocalStorageDashboardVariables,
-	} = useDashboard();
+	const { dashboardId, setSelectedDashboard } = useDashboardStore(
+		useShallow((s) => ({
+			dashboardId: s.selectedDashboard?.id ?? '',
+			setSelectedDashboard: s.setSelectedDashboard,
+		})),
+	);
 
 	const { updateUrlVariable } = useVariablesFromUrl();
 
 	const { dashboardVariables } = useDashboardVariables();
-	const dashboardId = useDashboardVariablesSelector(
-		(state) => state.dashboardId,
-	);
 	const sortedVariablesArray = useDashboardVariablesSelector(
 		(state) => state.sortedVariablesArray,
 	);
@@ -82,7 +83,13 @@ function DashboardVariableSelection(): JSX.Element | null {
 			// This makes localStorage much lighter by avoiding storing all individual values
 			const variable = dashboardVariables[id] || dashboardVariables[name];
 			const isDynamic = variable.type === 'DYNAMIC';
-			updateLocalStorageDashboardVariables(name, value, allSelected, isDynamic);
+			updateLocalStorageDashboardVariable(
+				dashboardId,
+				name,
+				value,
+				allSelected,
+				isDynamic,
+			);
 
 			if (allSelected) {
 				updateUrlVariable(name || id, ALL_SELECTED_VALUE);
@@ -150,13 +157,7 @@ function DashboardVariableSelection(): JSX.Element | null {
 			// Safe to call synchronously now that the store already has the updated value.
 			enqueueDescendantsOfVariable(name);
 		},
-		[
-			dashboardId,
-			dashboardVariables,
-			updateLocalStorageDashboardVariables,
-			updateUrlVariable,
-			setSelectedDashboard,
-		],
+		[dashboardId, dashboardVariables, updateUrlVariable, setSelectedDashboard],
 	);
 
 	return (

frontend/src/container/DashboardContainer/DashboardVariablesSelection/__test__/DashboardVariableSelection.test.tsx

@@ -32,11 +32,22 @@ const mockVariableItemCallbacks: {
 // Mock providers/Dashboard/Dashboard
 const mockSetSelectedDashboard = jest.fn();
 const mockUpdateLocalStorageDashboardVariables = jest.fn();
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): Record<string, unknown> => ({
-		setSelectedDashboard: mockSetSelectedDashboard,
-		updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,
-	}),
+interface MockDashboardStoreState {
+	selectedDashboard?: { id: string };
+	setSelectedDashboard: typeof mockSetSelectedDashboard;
+	updateLocalStorageDashboardVariables: typeof mockUpdateLocalStorageDashboardVariables;
+}
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (
+		selector?: (s: Record<string, unknown>) => MockDashboardStoreState,
+	): MockDashboardStoreState => {
+		const state = {
+			selectedDashboard: { id: 'dash-1' },
+			setSelectedDashboard: mockSetSelectedDashboard,
+			updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,
+		};
+		return selector ? selector(state) : state;
+	},
 }));
 
 // Mock hooks/dashboard/useVariablesFromUrl

frontend/src/container/DashboardContainer/DashboardVariablesSelection/useDashboardVariableUpdate.ts

@@ -1,11 +1,13 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 import { useCallback } from 'react';
 import { useAddDynamicVariableToPanels } from 'hooks/dashboard/useAddDynamicVariableToPanels';
+import { updateLocalStorageDashboardVariable } from 'hooks/dashboard/useDashboardFromLocalStorage';
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { IDashboardVariables } from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreTypes';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
 import { v4 as uuidv4 } from 'uuid';
+import { useShallow } from 'zustand/react/shallow';
 
 import { convertVariablesToDbFormat } from './util';
 
@@ -37,11 +39,16 @@ interface UseDashboardVariableUpdateReturn {
 
 export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn => {
 	const {
+		dashboardId,
 		selectedDashboard,
 		setSelectedDashboard,
-		updateLocalStorageDashboardVariables,
-	} = useDashboard();
-
+	} = useDashboardStore(
+		useShallow((s) => ({
+			dashboardId: s.selectedDashboard?.id ?? '',
+			selectedDashboard: s.selectedDashboard,
+			setSelectedDashboard: s.setSelectedDashboard,
+		})),
+	);
 	const addDynamicVariableToPanels = useAddDynamicVariableToPanels();
 	const updateMutation = useUpdateDashboard();
 
@@ -59,7 +66,13 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 				// This makes localStorage much lighter and more efficient.
 				// currently all the variables are dynamic
 				const isDynamic = true;
-				updateLocalStorageDashboardVariables(name, value, allSelected, isDynamic);
+				updateLocalStorageDashboardVariable(
+					dashboardId,
+					name,
+					value,
+					allSelected,
+					isDynamic,
+				);
 
 				if (selectedDashboard) {
 					setSelectedDashboard((prev) => {
@@ -97,11 +110,7 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 				}
 			}
 		},
-		[
-			selectedDashboard,
-			setSelectedDashboard,
-			updateLocalStorageDashboardVariables,
-		],
+		[dashboardId, selectedDashboard, setSelectedDashboard],
 	);
 
 	const updateVariables = useCallback(

frontend/src/container/DashboardContainer/__test__/IntegrationTests.test.tsx

@@ -49,8 +49,8 @@ const mockDashboard = {
 // Mock the dashboard provider with stable functions to prevent infinite loops
 const mockSetSelectedDashboard = jest.fn();
 const mockUpdateLocalStorageDashboardVariables = jest.fn();
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): any => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): any => ({
 		selectedDashboard: mockDashboard,
 		setSelectedDashboard: mockSetSelectedDashboard,
 		updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,

frontend/src/container/DashboardContainer/__test__/PanelManagement.test.tsx

@@ -56,8 +56,8 @@ const mockDashboard = {
 	},
 };
 // Mock dependencies
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): any => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): any => ({
 		selectedDashboard: mockDashboard,
 	}),
 }));
@@ -152,8 +152,8 @@ describe('Panel Management Tests', () => {
 			};
 
 			// Temporarily mock the dashboard
-			jest.doMock('providers/Dashboard/Dashboard', () => ({
-				useDashboard: (): any => ({
+			jest.doMock('providers/Dashboard/store/useDashboardStore', () => ({
+				useDashboardStore: (): any => ({
 					selectedDashboard: modifiedDashboard,
 				}),
 			}));

frontend/src/container/DashboardContainer/components/DashboardHeader/DashboardBreadcrumbs.tsx

@@ -4,7 +4,7 @@ import ROUTES from 'constants/routes';
 import { DASHBOARDS_LIST_QUERY_PARAMS_STORAGE_KEY } from 'hooks/dashboard/useDashboardsListQueryParams';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { LayoutGrid } from 'lucide-react';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { DashboardData } from 'types/api/dashboard/getAll';
 
 import { Base64Icons } from '../../DashboardSettings/General/utils';
@@ -13,7 +13,7 @@ import './DashboardBreadcrumbs.styles.scss';
 
 function DashboardBreadcrumbs(): JSX.Element {
 	const { safeNavigate } = useSafeNavigate();
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 	const updatedAtRef = useRef(selectedDashboard?.updatedAt);
 
 	const selectedData = selectedDashboard

frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.tsx

@@ -6,7 +6,10 @@ import { useNotifications } from 'hooks/useNotifications';
 import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
 import { usePlotContext } from 'lib/uPlotV2/context/PlotContext';
 import useLegendsSync from 'lib/uPlotV2/hooks/useLegendsSync';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 
 import { getChartManagerColumns } from './getChartMangerColumns';
 import { ExtendedChartDataset, getDefaultTableDataSet } from './utils';
@@ -50,7 +53,7 @@ export default function ChartManager({
 		onToggleSeriesVisibility,
 		syncSeriesVisibilityToLocalStorage,
 	} = usePlotContext();
-	const { isDashboardLocked } = useDashboard();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 
 	const [tableDataSet, setTableDataSet] = useState<ExtendedChartDataset[]>(() =>
 		getDefaultTableDataSet(

frontend/src/container/DashboardContainer/visualization/components/ChartManager/__tests__/ChartManager.test.tsx

@@ -32,10 +32,18 @@ jest.mock('lib/uPlotV2/hooks/useLegendsSync', () => ({
 	}),
 }));
 
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): { isDashboardLocked: boolean } => ({
-		isDashboardLocked: false,
-	}),
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (
+		selector?: (s: {
+			selectedDashboard: { locked: boolean } | undefined;
+		}) => { selectedDashboard: { locked: boolean } },
+	): { selectedDashboard: { locked: boolean } } => {
+		const mockState = { selectedDashboard: { locked: false } };
+		return selector ? selector(mockState) : mockState;
+	},
+	selectIsDashboardLocked: (s: {
+		selectedDashboard: { locked: boolean } | undefined;
+	}): boolean => s.selectedDashboard?.locked ?? false,
 }));
 
 jest.mock('hooks/useNotifications', () => ({

frontend/src/container/GridCardLayout/DashboardEmptyState/DashboardEmptyState.tsx

@@ -8,8 +8,11 @@ import { VariablesSettingsTab } from 'container/DashboardContainer/DashboardDesc
 import DashboardSettings from 'container/DashboardContainer/DashboardSettings';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import { ROLES, USER_ROLES } from 'types/roles';
 import { ComponentTypes } from 'utils/permission';
 
@@ -20,7 +23,8 @@ export default function DashboardEmptyState(): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);
 
-	const { selectedDashboard, isDashboardLocked } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 
 	const variablesSettingsTabHandle = useRef<VariablesSettingsTab>(null);
 	const [isSettingsDrawerOpen, setIsSettingsDrawerOpen] = useState<boolean>(

frontend/src/container/GridCardLayout/GridCard/FullView/GraphManager.tsx

@@ -3,7 +3,10 @@ import { Button, Input } from 'antd';
 import type { CheckboxChangeEvent } from 'antd/es/checkbox';
 import { ResizeTable } from 'components/ResizeTable';
 import { useNotifications } from 'hooks/useNotifications';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 
 import { getGraphManagerTableColumns } from './TableRender/GraphManagerColumns';
 import { ExtendedChartDataset, GraphManagerProps } from './types';
@@ -34,7 +37,7 @@ function GraphManager({
 	}, [data, options]);
 
 	const { notifications } = useNotifications();
-	const { isDashboardLocked } = useDashboard();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 
 	const checkBoxOnChangeHandler = useCallback(
 		(e: CheckboxChangeEvent, index: number): void => {

frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx

@@ -39,7 +39,10 @@ import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariab
 import GetMinMax from 'lib/getMinMax';
 import { isEmpty } from 'lodash-es';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import { AppState } from 'store/reducers';
 import { Warning } from 'types/api';
 import { GlobalReducer } from 'types/reducer/globalTime';
@@ -81,11 +84,8 @@ function FullView({
 		setCurrentGraphRef(fullViewRef);
 	}, [setCurrentGraphRef]);
 
-	const {
-		selectedDashboard,
-		isDashboardLocked,
-		setColumnWidths,
-	} = useDashboard();
+	const { selectedDashboard, setColumnWidths } = useDashboardStore();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 
 	const onColumnWidthsChange = useCallback(
 		(widths: Record<string, number>) => {

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

@@ -161,8 +161,8 @@ const mockProps: WidgetGraphComponentProps = {
 };
 
 // Mock useDashabord hook
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): any => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): any => ({
 		selectedDashboard: {
 			data: {
 				variables: [],

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

@@ -28,7 +28,7 @@ import {
 	getCustomTimeRangeWindowSweepInMS,
 	getStartAndEndTimesInMilliseconds,
 } from 'pages/MessagingQueues/MessagingQueuesUtils';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { Props } from 'types/api/dashboard/update';
 import { EQueryType } from 'types/common/dashboard';
@@ -106,7 +106,7 @@ function WidgetGraphComponent({
 		selectedDashboard,
 		setSelectedDashboard,
 		setColumnWidths,
-	} = useDashboard();
+	} = useDashboardStore();
 
 	const onColumnWidthsChange = useCallback(
 		(widths: Record<string, number>) => {

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

@@ -1,6 +1,7 @@
 import { memo, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useDispatch, useSelector } from 'react-redux';
+import * as Sentry from '@sentry/react';
 import logEvent from 'api/common/logEvent';
 import { DEFAULT_ENTITY_VERSION, ENTITY_VERSION_V5 } from 'constants/app';
 import { QueryParams } from 'constants/query';
@@ -17,7 +18,6 @@ import { getVariableReferencesInQuery } from 'lib/dashboardVariables/variableRef
 import getTimeString from 'lib/getTimeString';
 import { isEqual } from 'lodash-es';
 import isEmpty from 'lodash-es/isEmpty';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { UpdateTimeInterval } from 'store/actions';
 import { AppState } from 'store/reducers';
 import APIError from 'types/api/error';
@@ -68,7 +68,19 @@ function GridCardGraph({
 	const [isInternalServerError, setIsInternalServerError] = useState<boolean>(
 		false,
 	);
-	const { setDashboardQueryRangeCalled } = useDashboard();
+	const queryRangeCalledRef = useRef(false);
+
+	useEffect(() => {
+		const timeoutId = setTimeout(() => {
+			if (!queryRangeCalledRef.current) {
+				Sentry.captureEvent({
+					message: `Dashboard query range not called within expected timeframe for widget ${widget?.id}`,
+					level: 'warning',
+				});
+			}
+		}, 120000);
+		return (): void => clearTimeout(timeoutId);
+	}, [widget?.id]);
 
 	const {
 		minTime,
@@ -260,14 +272,14 @@ function GridCardGraph({
 						});
 					}
 				}
-				setDashboardQueryRangeCalled(true);
+				queryRangeCalledRef.current = true;
 			},
 			onSettled: (data) => {
 				dataAvailable?.(
 					isDataAvailableByPanelType(data?.payload?.data, widget?.panelTypes),
 				);
 				getGraphData?.(data?.payload?.data);
-				setDashboardQueryRangeCalled(true);
+				queryRangeCalledRef.current = true;
 			},
 		},
 	);

frontend/src/container/GridCardLayout/GridCardLayout.tsx

@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { FullScreen, FullScreenHandle } from 'react-full-screen';
 import { ItemCallback, Layout } from 'react-grid-layout';
+import { useIsFetching } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useDispatch } from 'react-redux';
 import { useLocation } from 'react-router-dom';
-import * as Sentry from '@sentry/react';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Form, Input, Modal, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -12,6 +12,7 @@ import cx from 'classnames';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { QueryParams } from 'constants/query';
 import { PANEL_GROUP_TYPES, PANEL_TYPES } from 'constants/queryBuilder';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { themeColors } from 'constants/theme';
 import { DEFAULT_ROW_NAME } from 'container/DashboardContainer/DashboardDescription/utils';
 import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
@@ -31,7 +32,10 @@ import {
 	X,
 } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import { sortLayout } from 'providers/Dashboard/util';
 import { UpdateTimeInterval } from 'store/actions';
 import { Widgets } from 'types/api/dashboard/getAll';
@@ -61,6 +65,9 @@ interface GraphLayoutProps {
 function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	const { handle, enableDrillDown = false } = props;
 	const { safeNavigate } = useSafeNavigate();
+	const isDashboardFetching =
+		useIsFetching([REACT_QUERY_KEY.DASHBOARD_BY_ID]) > 0;
+
 	const {
 		selectedDashboard,
 		layouts,
@@ -68,12 +75,9 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 		panelMap,
 		setPanelMap,
 		setSelectedDashboard,
-		isDashboardLocked,
-		dashboardQueryRangeCalled,
-		setDashboardQueryRangeCalled,
-		isDashboardFetching,
 		columnWidths,
-	} = useDashboard();
+	} = useDashboardStore();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 	const { data } = selectedDashboard || {};
 	const { pathname } = useLocation();
 	const dispatch = useDispatch();
@@ -137,25 +141,6 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 		setDashboardLayout(sortLayout(layouts));
 	}, [layouts]);
 
-	useEffect(() => {
-		setDashboardQueryRangeCalled(false);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, []);
-
-	useEffect(() => {
-		const timeoutId = setTimeout(() => {
-			// Send Sentry event if query_range is not called within expected timeframe (2 mins) when there are widgets
-			if (!dashboardQueryRangeCalled && data?.widgets?.length) {
-				Sentry.captureEvent({
-					message: `Dashboard query range not called within expected timeframe even when there are ${data?.widgets?.length} widgets`,
-					level: 'warning',
-				});
-			}
-		}, 120000);
-
-		return (): void => clearTimeout(timeoutId);
-	}, [dashboardQueryRangeCalled, data?.widgets?.length]);
-
 	const logEventCalledRef = useRef(false);
 	useEffect(() => {
 		if (!logEventCalledRef.current && !isUndefined(data)) {

frontend/src/container/GridCardLayout/WidgetRow.tsx

@@ -4,9 +4,12 @@ import { Button, Popover } from 'antd';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { EllipsisIcon, PenLine, Plus, X } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
 import { setSelectedRowWidgetId } from 'providers/Dashboard/helpers/selectedRowWidgetIdHelper';
+import {
+	selectIsDashboardLocked,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
 import { ROLES, USER_ROLES } from 'types/roles';
 import { ComponentTypes } from 'utils/permission';
 
@@ -39,7 +42,8 @@ export function WidgetRowHeader(props: WidgetRowHeaderProps): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);
 
-	const { selectedDashboard, isDashboardLocked } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
+	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
 
 	const permissions: ComponentTypes[] = ['add_panel'];
 	const { user } = useAppContext();

frontend/src/container/GridCardLayout/useNavigateToExplorerPages.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { useNotifications } from 'hooks/useNotifications';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import {
@@ -121,7 +121,7 @@ function useNavigateToExplorerPages(): (
 ) => Promise<{
 	[queryName: string]: { filters: TagFilterItem[]; dataSource?: string };
 }> {
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 	const { notifications } = useNotifications();
 
 	return useCallback(

frontend/src/container/LogExplorerQuerySection/LogExplorerQuerySection.test.tsx

@@ -92,8 +92,8 @@ jest.mock('hooks/useDarkMode', () => ({
 	useIsDarkMode: (): boolean => false,
 }));
 
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): { selectedDashboard: undefined } => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): { selectedDashboard: undefined } => ({
 		selectedDashboard: undefined,
 	}),
 }));

frontend/src/container/NewWidget/__test__/NewWidget.test.tsx

@@ -6,11 +6,24 @@
 // - Handling multiple rows correctly
 // - Handling widgets with different heights
 
+import { ReactNode } from 'react';
 import { I18nextProvider } from 'react-i18next';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import { screen } from '@testing-library/react';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import { DashboardProvider } from 'providers/Dashboard/Dashboard';
+import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
+
+function DashboardBootstrapWrapper({
+	dashboardId,
+	children,
+}: {
+	dashboardId: string;
+	children: ReactNode;
+}): JSX.Element {
+	useDashboardBootstrap(dashboardId);
+	// eslint-disable-next-line react/jsx-no-useless-fragment
+	return <>{children}</>;
+}
 import { PreferenceContextProvider } from 'providers/preferences/context/PreferenceContextProvider';
 import i18n from 'ReactI18';
 import {
@@ -309,7 +322,7 @@ describe('Stacking bar in new panel', () => {
 
 		const { container, getByText } = render(
 			<I18nextProvider i18n={i18n}>
-				<DashboardProvider dashboardId="">
+				<DashboardBootstrapWrapper dashboardId="">
 					<PreferenceContextProvider>
 						<NewWidget
 							dashboardId=""
@@ -317,7 +330,7 @@ describe('Stacking bar in new panel', () => {
 							selectedGraph={PANEL_TYPES.BAR}
 						/>
 					</PreferenceContextProvider>
-				</DashboardProvider>
+				</DashboardBootstrapWrapper>
 			</I18nextProvider>,
 		);
 
@@ -362,13 +375,13 @@ describe('when switching to BAR panel type', () => {
 		});
 
 		const { getByTestId, getByText, container } = render(
-			<DashboardProvider dashboardId="">
+			<DashboardBootstrapWrapper dashboardId="">
 				<NewWidget
 					dashboardId=""
 					selectedDashboard={undefined}
 					selectedGraph={PANEL_TYPES.BAR}
 				/>
-			</DashboardProvider>,
+			</DashboardBootstrapWrapper>,
 		);
 
 		expect(getByTestId('panel-change-select')).toHaveAttribute(

frontend/src/container/NewWidget/types.ts

@@ -2,16 +2,15 @@ import { Dispatch, SetStateAction } from 'react';
 import { UseQueryResult } from 'react-query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { IDashboardContext } from 'providers/Dashboard/types';
 import { SuccessResponse, Warning } from 'types/api';
-import { Widgets } from 'types/api/dashboard/getAll';
+import { Dashboard, Widgets } from 'types/api/dashboard/getAll';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 
 import { timePreferance } from './RightContainer/timeItems';
 
 export interface NewWidgetProps {
 	dashboardId: string;
-	selectedDashboard: IDashboardContext['selectedDashboard'];
+	selectedDashboard: Dashboard | undefined;
 	selectedGraph: PANEL_TYPES;
 	enableDrillDown?: boolean;
 }
@@ -35,7 +34,7 @@ export interface WidgetGraphProps {
 		>
 	>;
 	enableDrillDown?: boolean;
-	selectedDashboard: IDashboardContext['selectedDashboard'];
+	selectedDashboard: Dashboard | undefined;
 	isNewPanel?: boolean;
 }
 

frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.json

@@ -6122,5 +6122,95 @@
 		],
 		"id": "huggingface-observability",
 		"link": "/docs/huggingface-observability/"
+	},
+	{
+		"dataSource": "mistral-observability",
+		"label": "Mistral AI",
+		"imgUrl": "/Logos/mistral.svg",
+		"tags": [
+			"LLM Monitoring"
+		],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"llm",
+			"llm monitoring",
+			"mistral",
+			"mistral ai",
+			"monitoring",
+			"observability",
+			"otel mistral",
+			"traces",
+			"tracing"
+		],
+		"id": "mistral-observability",
+		"link": "/docs/mistral-observability/"
+	},
+	{
+		"dataSource": "openclaw-observability",
+		"label": "OpenClaw",
+		"imgUrl": "/Logos/openclaw.svg",
+		"tags": [
+			"LLM Monitoring"
+		],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"llm",
+			"llm monitoring",
+			"monitoring",
+			"observability",
+			"openclaw",
+			"otel openclaw",
+			"traces",
+			"tracing"
+		],
+		"id": "openclaw-observability",
+		"link": "/docs/openclaw-monitoring/"
+	},
+	{
+		"dataSource": "claude-agent-monitoring",
+		"label": "Claude Agent SDK",
+		"imgUrl": "/Logos/claude-code.svg",
+		"tags": [
+			"LLM Monitoring"
+		],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"anthropic",
+			"claude",
+			"claude agent",
+			"claude agent sdk",
+			"claude sdk",
+			"llm",
+			"llm monitoring",
+			"monitoring",
+			"observability",
+			"otel claude",
+			"traces",
+			"tracing"
+		],
+		"id": "claude-agent-monitoring",
+		"link": "/docs/claude-agent-monitoring/"
+	},
+	{
+		"dataSource": "render-metrics",
+		"label": "Render",
+		"imgUrl": "/Logos/render.svg",
+		"tags": [
+			"infrastructure monitoring",
+			"metrics"
+		],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"infrastructure",
+			"metrics",
+			"monitoring",
+			"observability",
+			"paas",
+			"render",
+			"render metrics",
+			"render monitoring"
+		],
+		"id": "render-metrics",
+		"link": "/docs/metrics-management/render-metrics/"
 	}
 ]

frontend/src/container/QueryTable/Drilldown/useBaseAggregateOptions.tsx

@@ -11,7 +11,7 @@ import useContextVariables from 'hooks/dashboard/useContextVariables';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import createQueryParams from 'lib/createQueryParams';
 import ContextMenu from 'periscope/components/ContextMenu';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
@@ -66,7 +66,7 @@ const useBaseAggregateOptions = ({
 		getUpdatedQuery,
 		isLoading: isResolveQueryLoading,
 	} = useUpdatedQuery();
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 
 	useEffect(() => {
 		if (!aggregateData) {

frontend/src/container/QueryTable/__test__/QueryTable.test.tsx

@@ -12,8 +12,8 @@ jest.mock('react-router-dom', () => ({
 }));
 
 // Mock useDashabord hook
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): any => ({
+jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
+	useDashboardStore: (): any => ({
 		selectedDashboard: {
 			data: {
 				variables: [],

frontend/src/hooks/dashboard/__test__/useTransformDashboardVariables.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook } from '@testing-library/react';
-import { useDashboardVariablesFromLocalStorage } from 'hooks/dashboard/useDashboardFromLocalStorage';
+import { getLocalStorageDashboardVariables } from 'hooks/dashboard/useDashboardFromLocalStorage';
 import { useTransformDashboardVariables } from 'hooks/dashboard/useTransformDashboardVariables';
 import useVariablesFromUrl from 'hooks/dashboard/useVariablesFromUrl';
 import { Dashboard, IDashboardVariable } from 'types/api/dashboard/getAll';
@@ -7,8 +7,8 @@ import { Dashboard, IDashboardVariable } from 'types/api/dashboard/getAll';
 jest.mock('hooks/dashboard/useDashboardFromLocalStorage');
 jest.mock('hooks/dashboard/useVariablesFromUrl');
 
-const mockUseDashboardVariablesFromLocalStorage = useDashboardVariablesFromLocalStorage as jest.MockedFunction<
-	typeof useDashboardVariablesFromLocalStorage
+const mockGetLocalStorageDashboardVariables = getLocalStorageDashboardVariables as jest.MockedFunction<
+	typeof getLocalStorageDashboardVariables
 >;
 const mockUseVariablesFromUrl = useVariablesFromUrl as jest.MockedFunction<
 	typeof useVariablesFromUrl
@@ -46,10 +46,7 @@ const setupHook = (
 	currentDashboard: Record<string, any> = {},
 	urlVariables: Record<string, any> = {},
 ): ReturnType<typeof useTransformDashboardVariables> => {
-	mockUseDashboardVariablesFromLocalStorage.mockReturnValue({
-		currentDashboard,
-		updateLocalStorageDashboardVariables: jest.fn(),
-	});
+	mockGetLocalStorageDashboardVariables.mockReturnValue(currentDashboard as any);
 	mockUseVariablesFromUrl.mockReturnValue({
 		getUrlVariables: () => urlVariables,
 		setUrlVariables: jest.fn(),

frontend/src/hooks/dashboard/useDashboardBootstrap.ts

@@ -0,0 +1,164 @@
+import { useEffect, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+// eslint-disable-next-line no-restricted-imports
+import { useDispatch, useSelector } from 'react-redux';
+import { Modal } from 'antd';
+import dayjs from 'dayjs';
+import { useTransformDashboardVariables } from 'hooks/dashboard/useTransformDashboardVariables';
+import useTabVisibility from 'hooks/useTabFocus';
+import { getUpdatedLayout } from 'lib/dashboard/getUpdatedLayout';
+import { getMinMaxForSelectedTime } from 'lib/getMinMax';
+import { defaultTo } from 'lodash-es';
+import { initializeDefaultVariables } from 'providers/Dashboard/initializeDefaultVariables';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
+import { sortLayout } from 'providers/Dashboard/util';
+// eslint-disable-next-line no-restricted-imports
+import { Dispatch } from 'redux';
+import { AppState } from 'store/reducers';
+import AppActions from 'types/actions';
+import { UPDATE_TIME_INTERVAL } from 'types/actions/globalTime';
+import { Dashboard } from 'types/api/dashboard/getAll';
+import { GlobalReducer } from 'types/reducer/globalTime';
+
+import { useDashboardQuery } from './useDashboardQuery';
+import { useDashboardVariablesSync } from './useDashboardVariablesSync';
+
+interface UseDashboardBootstrapOptions {
+	/** Pass `onModal.confirm` from `Modal.useModal()` to get theme-aware modals. Falls back to static `Modal.confirm`. */
+	confirm?: typeof Modal.confirm;
+}
+
+export interface UseDashboardBootstrapReturn {
+	isLoading: boolean;
+	isError: boolean;
+	isFetching: boolean;
+	error: unknown;
+}
+
+export function useDashboardBootstrap(
+	dashboardId: string,
+	options: UseDashboardBootstrapOptions = {},
+): UseDashboardBootstrapReturn {
+	const confirm = options.confirm ?? Modal.confirm;
+
+	const { t } = useTranslation(['dashboard']);
+	const dispatch = useDispatch<Dispatch<AppActions>>();
+	const globalTime = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	const {
+		setSelectedDashboard,
+		setLayouts,
+		setPanelMap,
+		resetDashboardStore,
+	} = useDashboardStore();
+
+	const dashboardRef = useRef<Dashboard>();
+	const modalRef = useRef<ReturnType<typeof Modal.confirm>>();
+
+	const isVisible = useTabVisibility();
+
+	const {
+		getUrlVariables,
+		updateUrlVariable,
+		transformDashboardVariables,
+	} = useTransformDashboardVariables(dashboardId);
+
+	// Keep the external variables store in sync with selectedDashboard
+	useDashboardVariablesSync(dashboardId);
+
+	const dashboardQuery = useDashboardQuery(dashboardId);
+
+	// Handle new dashboard data: initialize on first load, detect changes on subsequent fetches.
+	// React Query's structural sharing means this effect only fires when data actually changes.
+	useEffect(() => {
+		if (!dashboardQuery.data?.data) {
+			return;
+		}
+
+		const updatedDashboardData = transformDashboardVariables(
+			dashboardQuery.data.data,
+		);
+		const updatedDate = dayjs(updatedDashboardData?.updatedAt);
+
+		// First load: initialize store and URL variables, then return
+		if (!dashboardRef.current) {
+			const variables = updatedDashboardData?.data?.variables;
+			if (variables) {
+				initializeDefaultVariables(variables, getUrlVariables, updateUrlVariable);
+			}
+			setSelectedDashboard(updatedDashboardData);
+			dashboardRef.current = updatedDashboardData;
+			setLayouts(sortLayout(getUpdatedLayout(updatedDashboardData?.data.layout)));
+			setPanelMap(defaultTo(updatedDashboardData?.data?.panelMap, {}));
+			return;
+		}
+
+		// Subsequent fetches: skip if updatedAt hasn't advanced
+		if (!updatedDate.isAfter(dayjs(dashboardRef.current.updatedAt))) {
+			return;
+		}
+
+		// Data has changed: prompt user if tab is visible
+		if (isVisible && dashboardRef.current.id === updatedDashboardData?.id) {
+			const modal = confirm({
+				centered: true,
+				title: t('dashboard_has_been_updated'),
+				content: t('do_you_want_to_refresh_the_dashboard'),
+				onOk() {
+					setSelectedDashboard(updatedDashboardData);
+
+					const { maxTime, minTime } = getMinMaxForSelectedTime(
+						globalTime.selectedTime,
+						globalTime.minTime,
+						globalTime.maxTime,
+					);
+					dispatch({
+						type: UPDATE_TIME_INTERVAL,
+						payload: { maxTime, minTime, selectedTime: globalTime.selectedTime },
+					});
+
+					dashboardRef.current = updatedDashboardData;
+					setLayouts(
+						sortLayout(getUpdatedLayout(updatedDashboardData?.data.layout)),
+					);
+					setPanelMap(defaultTo(updatedDashboardData?.data.panelMap, {}));
+				},
+			});
+			modalRef.current = modal;
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [dashboardQuery.data]);
+
+	// Refetch when tab becomes visible (after initial load)
+	useEffect(() => {
+		if (isVisible && dashboardRef.current && !!dashboardId) {
+			dashboardQuery.refetch();
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [isVisible]);
+
+	// Dismiss stale modal when tab is hidden
+	useEffect(() => {
+		if (!isVisible && modalRef.current) {
+			modalRef.current.destroy();
+		}
+	}, [isVisible]);
+
+	// Reset store on unmount so stale state doesn't bleed across dashboards
+	useEffect(
+		() => (): void => {
+			resetDashboardStore();
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
+	);
+
+	return {
+		isLoading: dashboardQuery.isLoading,
+		isError: dashboardQuery.isError,
+		isFetching: dashboardQuery.isFetching,
+		error: dashboardQuery.error,
+	};
+}

frontend/src/hooks/dashboard/useDashboardFromLocalStorage.ts

@@ -0,0 +1,68 @@
+import getLocalStorageKey from 'api/browser/localstorage/get';
+import setLocalStorageKey from 'api/browser/localstorage/set';
+import { LOCALSTORAGE } from 'constants/localStorage';
+import { IDashboardVariable } from 'types/api/dashboard/getAll';
+
+export interface LocalStoreDashboardVariables {
+	[id: string]: {
+		selectedValue: IDashboardVariable['selectedValue'];
+		allSelected: boolean;
+	};
+}
+
+interface DashboardLocalStorageVariables {
+	[id: string]: LocalStoreDashboardVariables;
+}
+
+function readAll(): DashboardLocalStorageVariables {
+	const raw = getLocalStorageKey(LOCALSTORAGE.DASHBOARD_VARIABLES);
+	if (!raw) {
+		return {};
+	}
+	try {
+		return JSON.parse(raw);
+	} catch {
+		console.error('Failed to parse dashboard variables from local storage');
+		return {};
+	}
+}
+
+function writeAll(data: DashboardLocalStorageVariables): void {
+	try {
+		setLocalStorageKey(LOCALSTORAGE.DASHBOARD_VARIABLES, JSON.stringify(data));
+	} catch {
+		console.error('Failed to set dashboard variables in local storage');
+	}
+}
+
+/** Read the saved variable selections for a dashboard from localStorage. */
+export function getLocalStorageDashboardVariables(
+	dashboardId: string,
+): LocalStoreDashboardVariables {
+	return readAll()[dashboardId] ?? {};
+}
+
+/**
+ * Write one variable's selection for a dashboard to localStorage.
+ * All call sites write to the same store with no React state coordination.
+ */
+export function updateLocalStorageDashboardVariable(
+	dashboardId: string,
+	id: string,
+	selectedValue: IDashboardVariable['selectedValue'],
+	allSelected: boolean,
+	isDynamic?: boolean,
+): void {
+	const all = readAll();
+	all[dashboardId] = {
+		...(all[dashboardId] ?? {}),
+		[id]:
+			isDynamic && allSelected
+				? {
+						selectedValue: (undefined as unknown) as IDashboardVariable['selectedValue'],
+						allSelected: true,
+				  }
+				: { selectedValue, allSelected },
+	};
+	writeAll(all);
+}

frontend/src/hooks/dashboard/useDashboardFromLocalStorage.tsx

@@ -1,110 +0,0 @@
-import { useEffect, useState } from 'react';
-import getLocalStorageKey from 'api/browser/localstorage/get';
-import setLocalStorageKey from 'api/browser/localstorage/set';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { defaultTo } from 'lodash-es';
-import { IDashboardVariable } from 'types/api/dashboard/getAll';
-
-interface LocalStoreDashboardVariables {
-	[id: string]: {
-		selectedValue: IDashboardVariable['selectedValue'];
-		allSelected: boolean;
-	};
-}
-interface DashboardLocalStorageVariables {
-	[id: string]: LocalStoreDashboardVariables;
-}
-
-export interface UseDashboardVariablesFromLocalStorageReturn {
-	currentDashboard: LocalStoreDashboardVariables;
-	updateLocalStorageDashboardVariables: (
-		id: string,
-		selectedValue: IDashboardVariable['selectedValue'],
-		allSelected: boolean,
-		isDynamic?: boolean,
-	) => void;
-}
-
-export const useDashboardVariablesFromLocalStorage = (
-	dashboardId: string,
-): UseDashboardVariablesFromLocalStorageReturn => {
-	const [
-		allDashboards,
-		setAllDashboards,
-	] = useState<DashboardLocalStorageVariables>({});
-
-	const [
-		currentDashboard,
-		setCurrentDashboard,
-	] = useState<LocalStoreDashboardVariables>({});
-
-	useEffect(() => {
-		const localStoreDashboardVariablesString = getLocalStorageKey(
-			LOCALSTORAGE.DASHBOARD_VARIABLES,
-		);
-		let localStoreDashboardVariables: DashboardLocalStorageVariables = {};
-		if (localStoreDashboardVariablesString === null) {
-			try {
-				const serialzedData = JSON.stringify({
-					[dashboardId]: {},
-				});
-
-				setLocalStorageKey(LOCALSTORAGE.DASHBOARD_VARIABLES, serialzedData);
-			} catch {
-				console.error('Failed to seralise the data');
-			}
-		} else {
-			try {
-				localStoreDashboardVariables = JSON.parse(
-					localStoreDashboardVariablesString,
-				);
-			} catch {
-				console.error('Failed to parse dashboards from local storage');
-				localStoreDashboardVariables = {};
-			} finally {
-				setAllDashboards(localStoreDashboardVariables);
-			}
-		}
-		setCurrentDashboard(defaultTo(localStoreDashboardVariables[dashboardId], {}));
-	}, [dashboardId]);
-
-	useEffect(() => {
-		try {
-			const serializedData = JSON.stringify(allDashboards);
-			setLocalStorageKey(LOCALSTORAGE.DASHBOARD_VARIABLES, serializedData);
-		} catch {
-			console.error('Failed to set dashboards in local storage');
-		}
-	}, [allDashboards]);
-
-	useEffect(() => {
-		setAllDashboards((prev) => ({
-			...prev,
-			[dashboardId]: { ...currentDashboard },
-		}));
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [currentDashboard]);
-
-	const updateLocalStorageDashboardVariables = (
-		id: string,
-		selectedValue: IDashboardVariable['selectedValue'],
-		allSelected: boolean,
-		isDynamic?: boolean,
-	): void => {
-		setCurrentDashboard((prev) => ({
-			...prev,
-			[id]:
-				isDynamic && allSelected
-					? {
-							selectedValue: (undefined as unknown) as IDashboardVariable['selectedValue'],
-							allSelected: true,
-					  }
-					: { selectedValue, allSelected },
-		}));
-	};
-
-	return {
-		currentDashboard,
-		updateLocalStorageDashboardVariables,
-	};
-};

frontend/src/hooks/dashboard/useDashboardQuery.ts

@@ -0,0 +1,49 @@
+import { useQuery, UseQueryResult } from 'react-query';
+// eslint-disable-next-line no-restricted-imports
+import { useSelector } from 'react-redux';
+import getDashboard from 'api/v1/dashboards/id/get';
+import {
+	DASHBOARD_CACHE_TIME,
+	DASHBOARD_CACHE_TIME_ON_REFRESH_ENABLED,
+} from 'constants/queryCacheTime';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useAppContext } from 'providers/App/App';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { AppState } from 'store/reducers';
+import { SuccessResponseV2 } from 'types/api';
+import { Dashboard } from 'types/api/dashboard/getAll';
+import APIError from 'types/api/error';
+import { GlobalReducer } from 'types/reducer/globalTime';
+
+/**
+ * Fetches a dashboard by ID. Handles auth gating, cache time based on
+ * auto-refresh setting, and surfaces API errors via the error modal.
+ */
+export function useDashboardQuery(
+	dashboardId: string,
+): UseQueryResult<SuccessResponseV2<Dashboard>> {
+	const { isLoggedIn } = useAppContext();
+	const { showErrorModal } = useErrorModal();
+	const globalTime = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	return useQuery(
+		[
+			REACT_QUERY_KEY.DASHBOARD_BY_ID,
+			dashboardId,
+			globalTime.isAutoRefreshDisabled,
+		],
+		{
+			enabled: !!dashboardId && isLoggedIn,
+			queryFn: () => getDashboard({ id: dashboardId }),
+			refetchOnWindowFocus: false,
+			cacheTime: globalTime.isAutoRefreshDisabled
+				? DASHBOARD_CACHE_TIME
+				: DASHBOARD_CACHE_TIME_ON_REFRESH_ENABLED,
+			onError: (error) => {
+				showErrorModal(error as APIError);
+			},
+		},
+	);
+}

frontend/src/hooks/dashboard/useDashboardVariablesSync.ts

@@ -0,0 +1,33 @@
+import { useEffect } from 'react';
+import isEqual from 'lodash-es/isEqual';
+import {
+	setDashboardVariablesStore,
+	updateDashboardVariablesStore,
+} from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStore';
+import {
+	DashboardStore,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
+
+import { useDashboardVariablesSelector } from './useDashboardVariables';
+
+/**
+ * Keeps the external variables store in sync with the zustand dashboard store.
+ * When selectedDashboard changes, propagates variable updates to the variables store.
+ */
+export function useDashboardVariablesSync(dashboardId: string): void {
+	const dashboardVariables = useDashboardVariablesSelector((s) => s.variables);
+	const savedDashboardId = useDashboardVariablesSelector((s) => s.dashboardId);
+	const selectedDashboard = useDashboardStore(
+		(s: DashboardStore) => s.selectedDashboard,
+	);
+
+	useEffect(() => {
+		const updatedVariables = selectedDashboard?.data.variables || {};
+		if (savedDashboardId !== dashboardId) {
+			setDashboardVariablesStore({ dashboardId, variables: updatedVariables });
+		} else if (!isEqual(dashboardVariables, updatedVariables)) {
+			updateDashboardVariablesStore({ dashboardId, variables: updatedVariables });
+		}
+	}, [selectedDashboard]); // eslint-disable-line react-hooks/exhaustive-deps
+}

frontend/src/hooks/dashboard/useLockDashboard.ts

@@ -0,0 +1,42 @@
+import { useMutation } from 'react-query';
+import locked from 'api/v1/dashboards/id/lock';
+import {
+	getSelectedDashboard,
+	useDashboardStore,
+} from 'providers/Dashboard/store/useDashboardStore';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+/**
+ * Hook for toggling dashboard locked state.
+ * Calls the lock API and syncs the result into the Zustand store.
+ */
+export function useLockDashboard(): (value: boolean) => Promise<void> {
+	const { showErrorModal } = useErrorModal();
+	const { setSelectedDashboard } = useDashboardStore();
+
+	const { mutate: lockDashboard } = useMutation(locked, {
+		onSuccess: (_, props) => {
+			setSelectedDashboard((prev) =>
+				prev ? { ...prev, locked: props.lock } : prev,
+			);
+		},
+		onError: (error) => {
+			showErrorModal(error as APIError);
+		},
+	});
+
+	return async (value: boolean): Promise<void> => {
+		const selectedDashboard = getSelectedDashboard();
+		if (selectedDashboard) {
+			try {
+				await lockDashboard({
+					id: selectedDashboard.id,
+					lock: value,
+				});
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		}
+	};
+}

frontend/src/hooks/dashboard/useTransformDashboardVariables.ts

@@ -1,8 +1,5 @@
 import { ALL_SELECTED_VALUE } from 'components/NewSelect/utils';
-import {
-	useDashboardVariablesFromLocalStorage,
-	UseDashboardVariablesFromLocalStorageReturn,
-} from 'hooks/dashboard/useDashboardFromLocalStorage';
+import { getLocalStorageDashboardVariables } from 'hooks/dashboard/useDashboardFromLocalStorage';
 import useVariablesFromUrl, {
 	UseVariablesFromUrlReturn,
 } from 'hooks/dashboard/useVariablesFromUrl';
@@ -13,14 +10,10 @@ import { v4 as generateUUID } from 'uuid';
 
 export function useTransformDashboardVariables(
 	dashboardId: string,
-): Pick<UseVariablesFromUrlReturn, 'getUrlVariables' | 'updateUrlVariable'> &
-	UseDashboardVariablesFromLocalStorageReturn & {
-		transformDashboardVariables: (data: Dashboard) => Dashboard;
-	} {
-	const {
-		currentDashboard,
-		updateLocalStorageDashboardVariables,
-	} = useDashboardVariablesFromLocalStorage(dashboardId);
+): Pick<UseVariablesFromUrlReturn, 'getUrlVariables' | 'updateUrlVariable'> & {
+	transformDashboardVariables: (data: Dashboard) => Dashboard;
+	currentDashboard: ReturnType<typeof getLocalStorageDashboardVariables>;
+} {
 	const { getUrlVariables, updateUrlVariable } = useVariablesFromUrl();
 
 	const mergeDBWithLocalStorage = (
@@ -80,7 +73,7 @@ export function useTransformDashboardVariables(
 		if (data && data.data && data.data.variables) {
 			const clonedDashboardData = mergeDBWithLocalStorage(
 				JSON.parse(JSON.stringify(data)),
-				currentDashboard,
+				getLocalStorageDashboardVariables(dashboardId),
 			);
 			const { variables } = clonedDashboardData.data;
 			const existingOrders: Set<number> = new Set();
@@ -122,7 +115,6 @@ export function useTransformDashboardVariables(
 		transformDashboardVariables,
 		getUrlVariables,
 		updateUrlVariable,
-		currentDashboard,
-		updateLocalStorageDashboardVariables,
+		currentDashboard: getLocalStorageDashboardVariables(dashboardId),
 	};
 }

frontend/src/hooks/dashboard/useUpdateDashboard.tsx

@@ -1,7 +1,5 @@
 import { useMutation, UseMutationResult } from 'react-query';
 import update from 'api/v1/dashboards/id/update';
-import dayjs from 'dayjs';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import { SuccessResponseV2 } from 'types/api';
 import { Dashboard } from 'types/api/dashboard/getAll';
@@ -9,14 +7,8 @@ import { Props } from 'types/api/dashboard/update';
 import APIError from 'types/api/error';
 
 export const useUpdateDashboard = (): UseUpdateDashboard => {
-	const { updatedTimeRef } = useDashboard();
 	const { showErrorModal } = useErrorModal();
 	return useMutation(update, {
-		onSuccess: (data) => {
-			if (data.data) {
-				updatedTimeRef.current = dayjs(data.data.updatedAt);
-			}
-		},
 		onError: (error) => {
 			showErrorModal(error);
 		},

frontend/src/hooks/dashboard/useWidgetsByDynamicVariableId.ts

@@ -1,7 +1,7 @@
 import { useMemo } from 'react';
 import { PANEL_GROUP_TYPES } from 'constants/queryBuilder';
 import { createDynamicVariableToWidgetsMap } from 'hooks/dashboard/utils';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { Widgets } from 'types/api/dashboard/getAll';
 
 import { useDashboardVariablesByType } from './useDashboardVariablesByType';
@@ -12,7 +12,7 @@ import { useDashboardVariablesByType } from './useDashboardVariablesByType';
  */
 export function useWidgetsByDynamicVariableId(): Record<string, string[]> {
 	const dynamicVariables = useDashboardVariablesByType('DYNAMIC', 'values');
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 
 	return useMemo(() => {
 		const widgets =

frontend/src/hooks/queryBuilder/useCreateAlerts.tsx

@@ -17,7 +17,7 @@ import { useNotifications } from 'hooks/useNotifications';
 import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { isEmpty } from 'lodash-es';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { AppState } from 'store/reducers';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { GlobalReducer } from 'types/reducer/globalTime';
@@ -33,7 +33,7 @@ const useCreateAlerts = (widget?: Widgets, caller?: string): VoidFunction => {
 
 	const { notifications } = useNotifications();
 
-	const { selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 
 	const { dashboardVariables } = useDashboardVariables();
 	const dashboardDynamicVariables = useDashboardVariablesByType(

frontend/src/pages/DashboardPage/DashboardPage.tsx

@@ -1,40 +0,0 @@
-import { useEffect } from 'react';
-import { Typography } from 'antd';
-import { AxiosError } from 'axios';
-import NotFound from 'components/NotFound';
-import Spinner from 'components/Spinner';
-import DashboardContainer from 'container/DashboardContainer';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
-import { ErrorType } from 'types/common';
-
-function DashboardPage(): JSX.Element {
-	const { dashboardResponse } = useDashboard();
-
-	const { isFetching, isError, isLoading } = dashboardResponse;
-
-	const errorMessage = isError
-		? (dashboardResponse?.error as AxiosError<{ errorType: string }>)?.response
-				?.data?.errorType
-		: 'Something went wrong';
-
-	useEffect(() => {
-		const dashboardTitle = dashboardResponse.data?.data.data.title;
-		document.title = dashboardTitle || document.title;
-	}, [dashboardResponse.data?.data.data.title, isFetching]);
-
-	if (isError && !isFetching && errorMessage === ErrorType.NotFound) {
-		return <NotFound />;
-	}
-
-	if (isError && errorMessage) {
-		return <Typography>{errorMessage}</Typography>;
-	}
-
-	if (isLoading) {
-		return <Spinner tip="Loading.." />;
-	}
-
-	return <DashboardContainer />;
-}
-
-export default DashboardPage;

frontend/src/pages/DashboardPage/index.tsx

@@ -1,16 +1,56 @@
+import { useEffect } from 'react';
 import { useParams } from 'react-router-dom';
-import { DashboardProvider } from 'providers/Dashboard/Dashboard';
+import { Modal, Typography } from 'antd';
+import { AxiosError } from 'axios';
+import NotFound from 'components/NotFound';
+import Spinner from 'components/Spinner';
+import DashboardContainer from 'container/DashboardContainer';
+import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
+import { ErrorType } from 'types/common';
 
-import DashboardPage from './DashboardPage';
-
-function DashboardPageWithProvider(): JSX.Element {
+function DashboardPage(): JSX.Element {
 	const { dashboardId } = useParams<{ dashboardId: string }>();
 
+	const [onModal, Content] = Modal.useModal();
+
+	const {
+		isLoading,
+		isError,
+		isFetching,
+		error,
+	} = useDashboardBootstrap(dashboardId, { confirm: onModal.confirm });
+
+	const dashboardTitle = useDashboardStore(
+		(s) => s.selectedDashboard?.data.title,
+	);
+
+	useEffect(() => {
+		document.title = dashboardTitle || document.title;
+	}, [dashboardTitle]);
+
+	const errorMessage = isError
+		? (error as AxiosError<{ errorType: string }>)?.response?.data?.errorType
+		: 'Something went wrong';
+
+	if (isError && !isFetching && errorMessage === ErrorType.NotFound) {
+		return <NotFound />;
+	}
+
+	if (isError && errorMessage) {
+		return <Typography>{errorMessage}</Typography>;
+	}
+
+	if (isLoading) {
+		return <Spinner tip="Loading.." />;
+	}
+
 	return (
-		<DashboardProvider dashboardId={dashboardId}>
-			<DashboardPage />
-		</DashboardProvider>
+		<>
+			{Content}
+			<DashboardContainer />
+		</>
 	);
 }
 
-export default DashboardPageWithProvider;
+export default DashboardPage;

frontend/src/providers/Dashboard/Dashboard.tsx

@@ -1,365 +0,0 @@
-import {
-	// eslint-disable-next-line no-restricted-imports
-	createContext,
-	PropsWithChildren,
-	// eslint-disable-next-line no-restricted-imports
-	useContext,
-	useEffect,
-	useMemo,
-	useRef,
-	useState,
-} from 'react';
-import { Layout } from 'react-grid-layout';
-import { useTranslation } from 'react-i18next';
-import { useMutation, useQuery, UseQueryResult } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { useDispatch, useSelector } from 'react-redux';
-import { Modal } from 'antd';
-import getDashboard from 'api/v1/dashboards/id/get';
-import locked from 'api/v1/dashboards/id/lock';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import dayjs, { Dayjs } from 'dayjs';
-import { useTransformDashboardVariables } from 'hooks/dashboard/useTransformDashboardVariables';
-import useTabVisibility from 'hooks/useTabFocus';
-import { getUpdatedLayout } from 'lib/dashboard/getUpdatedLayout';
-import { getMinMaxForSelectedTime } from 'lib/getMinMax';
-import { defaultTo } from 'lodash-es';
-import isEqual from 'lodash-es/isEqual';
-import isUndefined from 'lodash-es/isUndefined';
-import omitBy from 'lodash-es/omitBy';
-import { useAppContext } from 'providers/App/App';
-import { initializeDefaultVariables } from 'providers/Dashboard/initializeDefaultVariables';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-// eslint-disable-next-line no-restricted-imports
-import { Dispatch } from 'redux';
-import { AppState } from 'store/reducers';
-import AppActions from 'types/actions';
-import { UPDATE_TIME_INTERVAL } from 'types/actions/globalTime';
-import { SuccessResponseV2 } from 'types/api';
-import { Dashboard } from 'types/api/dashboard/getAll';
-import APIError from 'types/api/error';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import {
-	DASHBOARD_CACHE_TIME,
-	DASHBOARD_CACHE_TIME_ON_REFRESH_ENABLED,
-} from '../../constants/queryCacheTime';
-import { useDashboardVariablesSelector } from '../../hooks/dashboard/useDashboardVariables';
-import {
-	setDashboardVariablesStore,
-	updateDashboardVariablesStore,
-} from './store/dashboardVariables/dashboardVariablesStore';
-import { IDashboardContext, WidgetColumnWidths } from './types';
-import { sortLayout } from './util';
-
-export const DashboardContext = createContext<IDashboardContext>({
-	isDashboardLocked: false,
-	handleDashboardLockToggle: () => {},
-	dashboardResponse: {} as UseQueryResult<
-		SuccessResponseV2<Dashboard>,
-		APIError
-	>,
-	selectedDashboard: {} as Dashboard,
-	layouts: [],
-	panelMap: {},
-	setPanelMap: () => {},
-
-	setLayouts: () => {},
-	setSelectedDashboard: () => {},
-	updatedTimeRef: {} as React.MutableRefObject<Dayjs | null>,
-	updateLocalStorageDashboardVariables: () => {},
-	dashboardQueryRangeCalled: false,
-	setDashboardQueryRangeCalled: () => {},
-	isDashboardFetching: false,
-	columnWidths: {},
-	setColumnWidths: () => {},
-});
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function DashboardProvider({
-	children,
-	dashboardId,
-}: PropsWithChildren<{ dashboardId: string }>): JSX.Element {
-	const [isDashboardLocked, setIsDashboardLocked] = useState<boolean>(false);
-
-	const [
-		dashboardQueryRangeCalled,
-		setDashboardQueryRangeCalled,
-	] = useState<boolean>(false);
-
-	const { showErrorModal } = useErrorModal();
-
-	const dispatch = useDispatch<Dispatch<AppActions>>();
-
-	const globalTime = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [onModal, Content] = Modal.useModal();
-
-	const [layouts, setLayouts] = useState<Layout[]>([]);
-
-	const [panelMap, setPanelMap] = useState<
-		Record<string, { widgets: Layout[]; collapsed: boolean }>
-	>({});
-
-	const { isLoggedIn } = useAppContext();
-
-	const [selectedDashboard, setSelectedDashboard] = useState<Dashboard>();
-	const dashboardVariables = useDashboardVariablesSelector((s) => s.variables);
-	const savedDashboardId = useDashboardVariablesSelector((s) => s.dashboardId);
-
-	useEffect(() => {
-		const existingVariables = dashboardVariables;
-		const updatedVariables = selectedDashboard?.data.variables || {};
-
-		if (savedDashboardId !== dashboardId) {
-			setDashboardVariablesStore({
-				dashboardId,
-				variables: updatedVariables,
-			});
-		} else if (!isEqual(existingVariables, updatedVariables)) {
-			updateDashboardVariablesStore({
-				dashboardId,
-				variables: updatedVariables,
-			});
-		}
-	}, [selectedDashboard]);
-
-	const {
-		currentDashboard,
-		updateLocalStorageDashboardVariables,
-		getUrlVariables,
-		updateUrlVariable,
-		transformDashboardVariables,
-	} = useTransformDashboardVariables(dashboardId);
-
-	const updatedTimeRef = useRef<Dayjs | null>(null); // Using ref to store the updated time
-	const modalRef = useRef<any>(null);
-
-	const isVisible = useTabVisibility();
-
-	const { t } = useTranslation(['dashboard']);
-	const dashboardRef = useRef<Dashboard>();
-
-	const [isDashboardFetching, setIsDashboardFetching] = useState<boolean>(false);
-
-	const dashboardResponse = useQuery(
-		[
-			REACT_QUERY_KEY.DASHBOARD_BY_ID,
-			dashboardId,
-			globalTime.isAutoRefreshDisabled,
-		],
-		{
-			enabled: !!dashboardId && isLoggedIn,
-			queryFn: async () => {
-				setIsDashboardFetching(true);
-				try {
-					return await getDashboard({
-						id: dashboardId,
-					});
-				} catch (error) {
-					showErrorModal(error as APIError);
-					return;
-				} finally {
-					setIsDashboardFetching(false);
-				}
-			},
-			refetchOnWindowFocus: false,
-			cacheTime: globalTime.isAutoRefreshDisabled
-				? DASHBOARD_CACHE_TIME
-				: DASHBOARD_CACHE_TIME_ON_REFRESH_ENABLED,
-			onError: (error) => {
-				showErrorModal(error as APIError);
-			},
-
-			onSuccess: (data: SuccessResponseV2<Dashboard>) => {
-				const updatedDashboardData = transformDashboardVariables(data?.data);
-
-				// initialize URL variables after dashboard state is set to avoid race conditions
-				const variables = updatedDashboardData?.data?.variables;
-				if (variables) {
-					initializeDefaultVariables(variables, getUrlVariables, updateUrlVariable);
-				}
-
-				const updatedDate = dayjs(updatedDashboardData?.updatedAt);
-
-				setIsDashboardLocked(updatedDashboardData?.locked || false);
-
-				// on first render
-				if (updatedTimeRef.current === null) {
-					setSelectedDashboard(updatedDashboardData);
-
-					updatedTimeRef.current = updatedDate;
-
-					dashboardRef.current = updatedDashboardData;
-
-					setLayouts(
-						sortLayout(getUpdatedLayout(updatedDashboardData?.data.layout)),
-					);
-
-					setPanelMap(defaultTo(updatedDashboardData?.data?.panelMap, {}));
-				}
-
-				if (
-					updatedTimeRef.current !== null &&
-					updatedDate.isAfter(updatedTimeRef.current) &&
-					isVisible &&
-					dashboardRef.current?.id === updatedDashboardData?.id
-				) {
-					// show modal when state is out of sync
-					const modal = onModal.confirm({
-						centered: true,
-						title: t('dashboard_has_been_updated'),
-						content: t('do_you_want_to_refresh_the_dashboard'),
-						onOk() {
-							setSelectedDashboard(updatedDashboardData);
-
-							const { maxTime, minTime } = getMinMaxForSelectedTime(
-								globalTime.selectedTime,
-								globalTime.minTime,
-								globalTime.maxTime,
-							);
-
-							dispatch({
-								type: UPDATE_TIME_INTERVAL,
-								payload: {
-									maxTime,
-									minTime,
-									selectedTime: globalTime.selectedTime,
-								},
-							});
-
-							dashboardRef.current = updatedDashboardData;
-
-							updatedTimeRef.current = dayjs(updatedDashboardData?.updatedAt);
-
-							setLayouts(
-								sortLayout(getUpdatedLayout(updatedDashboardData?.data.layout)),
-							);
-
-							setPanelMap(defaultTo(updatedDashboardData?.data.panelMap, {}));
-						},
-					});
-
-					modalRef.current = modal;
-				} else {
-					// normal flow
-					updatedTimeRef.current = dayjs(updatedDashboardData?.updatedAt);
-
-					dashboardRef.current = updatedDashboardData;
-
-					if (!isEqual(selectedDashboard, updatedDashboardData)) {
-						setSelectedDashboard(updatedDashboardData);
-					}
-
-					if (
-						!isEqual(
-							[omitBy(layouts, (value): boolean => isUndefined(value))[0]],
-							updatedDashboardData?.data.layout,
-						)
-					) {
-						setLayouts(
-							sortLayout(getUpdatedLayout(updatedDashboardData?.data.layout)),
-						);
-
-						setPanelMap(defaultTo(updatedDashboardData?.data.panelMap, {}));
-					}
-				}
-			},
-		},
-	);
-
-	useEffect(() => {
-		// make the call on tab visibility only if the user is on dashboard / widget page
-		if (isVisible && updatedTimeRef.current && !!dashboardId) {
-			dashboardResponse.refetch();
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [isVisible]);
-
-	useEffect(() => {
-		if (!isVisible && modalRef.current) {
-			modalRef.current.destroy();
-		}
-	}, [isVisible]);
-
-	const { mutate: lockDashboard } = useMutation(locked, {
-		onSuccess: (_, props) => {
-			setIsDashboardLocked(props.lock);
-		},
-		onError: (error) => {
-			showErrorModal(error as APIError);
-		},
-	});
-
-	const handleDashboardLockToggle = async (value: boolean): Promise<void> => {
-		if (selectedDashboard) {
-			try {
-				await lockDashboard({
-					id: selectedDashboard.id,
-					lock: value,
-				});
-			} catch (error) {
-				showErrorModal(error as APIError);
-			}
-		}
-	};
-
-	const [columnWidths, setColumnWidths] = useState<WidgetColumnWidths>({});
-
-	const value: IDashboardContext = useMemo(
-		() => ({
-			isDashboardLocked,
-			handleDashboardLockToggle,
-			dashboardResponse,
-			selectedDashboard,
-			dashboardId,
-			layouts,
-			panelMap,
-			setLayouts,
-			setPanelMap,
-			setSelectedDashboard,
-			updatedTimeRef,
-			updateLocalStorageDashboardVariables,
-			dashboardQueryRangeCalled,
-			setDashboardQueryRangeCalled,
-			isDashboardFetching,
-			columnWidths,
-			setColumnWidths,
-		}),
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[
-			isDashboardLocked,
-			dashboardResponse,
-			selectedDashboard,
-			dashboardId,
-			layouts,
-			panelMap,
-			updateLocalStorageDashboardVariables,
-			currentDashboard,
-			dashboardQueryRangeCalled,
-			setDashboardQueryRangeCalled,
-			isDashboardFetching,
-			columnWidths,
-			setColumnWidths,
-		],
-	);
-
-	return (
-		<DashboardContext.Provider value={value}>
-			{Content}
-			{children}
-		</DashboardContext.Provider>
-	);
-}
-
-export const useDashboard = (): IDashboardContext => {
-	const context = useContext(DashboardContext);
-
-	if (!context) {
-		throw new Error('Should be used inside the context');
-	}
-
-	return context;
-};

frontend/src/providers/Dashboard/__tests__/Dashboard.test.tsx

@@ -1,3 +1,4 @@
+import { ReactNode } from 'react';
 import { QueryClient, QueryClientProvider } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
@@ -6,7 +7,20 @@ import { render, RenderResult, screen, waitFor } from '@testing-library/react';
 import getDashboard from 'api/v1/dashboards/id/get';
 import { DASHBOARD_CACHE_TIME_ON_REFRESH_ENABLED } from 'constants/queryCacheTime';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { DashboardProvider, useDashboard } from 'providers/Dashboard/Dashboard';
+import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
+
+function DashboardBootstrapWrapper({
+	dashboardId,
+	children,
+}: {
+	dashboardId: string;
+	children: ReactNode;
+}): JSX.Element {
+	useDashboardBootstrap(dashboardId);
+	// eslint-disable-next-line react/jsx-no-useless-fragment
+	return <>{children}</>;
+}
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
 
 import { useDashboardVariables } from '../../../hooks/dashboard/useDashboardVariables';
@@ -55,17 +69,12 @@ jest.mock('react-redux', () => ({
 jest.mock('uuid', () => ({ v4: jest.fn(() => 'mock-uuid') }));
 
 function TestComponent(): JSX.Element {
-	const { dashboardResponse, selectedDashboard } = useDashboard();
+	const { selectedDashboard } = useDashboardStore();
 	const { dashboardVariables } = useDashboardVariables();
 
 	return (
 		<div>
 			<div data-testid="dashboard-id">{selectedDashboard?.id}</div>
-			<div data-testid="query-status">{dashboardResponse.status}</div>
-			<div data-testid="is-loading">{dashboardResponse.isLoading.toString()}</div>
-			<div data-testid="is-fetching">
-				{dashboardResponse.isFetching.toString()}
-			</div>
 			<div data-testid="dashboard-variables">
 				{dashboardVariables ? JSON.stringify(dashboardVariables) : 'null'}
 			</div>
@@ -89,7 +98,7 @@ function createTestQueryClient(): QueryClient {
 }
 
 // Helper to render with dashboard provider
-function renderWithDashboardProvider(
+function renderWithDashboardBootstrap(
 	dashboardId = 'test-dashboard-id',
 ): RenderResult {
 	const queryClient = createTestQueryClient();
@@ -98,9 +107,9 @@ function renderWithDashboardProvider(
 	return render(
 		<QueryClientProvider client={queryClient}>
 			<MemoryRouter initialEntries={[initialRoute]}>
-				<DashboardProvider dashboardId={dashboardId}>
+				<DashboardBootstrapWrapper dashboardId={dashboardId}>
 					<TestComponent />
-				</DashboardProvider>
+				</DashboardBootstrapWrapper>
 			</MemoryRouter>
 		</QueryClientProvider>,
 	);
@@ -172,7 +181,7 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 	describe('Query Key Behavior', () => {
 		it('should include route params in query key when on dashboard page', async () => {
 			const dashboardId = 'test-dashboard-id';
-			renderWithDashboardProvider(dashboardId);
+			renderWithDashboardBootstrap(dashboardId);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: dashboardId });
@@ -187,7 +196,7 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 			const newDashboardId = 'new-dashboard-id';
 
 			// First render with initial dashboard ID
-			const { rerender } = renderWithDashboardProvider(initialDashboardId);
+			const { rerender } = renderWithDashboardBootstrap(initialDashboardId);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: initialDashboardId });
@@ -197,9 +206,9 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 			rerender(
 				<QueryClientProvider client={createTestQueryClient()}>
 					<MemoryRouter initialEntries={[`/dashboard/${newDashboardId}`]}>
-						<DashboardProvider dashboardId={newDashboardId}>
+						<DashboardBootstrapWrapper dashboardId={newDashboardId}>
 							<TestComponent />
-						</DashboardProvider>
+						</DashboardBootstrapWrapper>
 					</MemoryRouter>
 				</QueryClientProvider>,
 			);
@@ -213,7 +222,7 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 		});
 
 		it('should not fetch when no dashboardId is provided', () => {
-			renderWithDashboardProvider('');
+			renderWithDashboardBootstrap('');
 
 			// Should not call the API
 			expect(mockGetDashboard).not.toHaveBeenCalled();
@@ -229,9 +238,9 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 			const { rerender } = render(
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter initialEntries={[`/dashboard/${dashboardId1}`]}>
-						<DashboardProvider dashboardId={dashboardId1}>
+						<DashboardBootstrapWrapper dashboardId={dashboardId1}>
 							<TestComponent />
-						</DashboardProvider>
+						</DashboardBootstrapWrapper>
 					</MemoryRouter>
 				</QueryClientProvider>,
 			);
@@ -243,9 +252,9 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 			rerender(
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter initialEntries={[`/dashboard/${dashboardId2}`]}>
-						<DashboardProvider dashboardId={dashboardId2}>
+						<DashboardBootstrapWrapper dashboardId={dashboardId2}>
 							<TestComponent />
-						</DashboardProvider>
+						</DashboardBootstrapWrapper>
 					</MemoryRouter>
 				</QueryClientProvider>,
 			);
@@ -286,9 +295,9 @@ describe('Dashboard Provider - Query Key with Route Params', () => {
 			render(
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter initialEntries={[`/dashboard/${dashboardId}`]}>
-						<DashboardProvider dashboardId={dashboardId}>
+						<DashboardBootstrapWrapper dashboardId={dashboardId}>
 							<TestComponent />
-						</DashboardProvider>
+						</DashboardBootstrapWrapper>
 					</MemoryRouter>
 				</QueryClientProvider>,
 			);
@@ -365,7 +374,7 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			// Empty URL variables - tests initialization flow
 			mockGetUrlVariables.mockReturnValue({});
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -421,7 +430,7 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 				.mockReturnValueOnce('development')
 				.mockReturnValueOnce(['db', 'cache']);
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -481,7 +490,7 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 
 			mockGetUrlVariables.mockReturnValue(urlVariables);
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -517,7 +526,7 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 				.mockReturnValueOnce('development')
 				.mockReturnValueOnce(['api']);
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				// Verify normalization was called with the specific values and variable configs
@@ -584,7 +593,7 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			} as any);
 			/* eslint-enable @typescript-eslint/no-explicit-any */
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -626,7 +635,7 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			} as any);
 			/* eslint-enable @typescript-eslint/no-explicit-any */
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -669,7 +678,7 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			} as any);
 			/* eslint-enable @typescript-eslint/no-explicit-any */
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });
@@ -711,7 +720,7 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			} as any);
 			/* eslint-enable @typescript-eslint/no-explicit-any */
 
-			renderWithDashboardProvider(DASHBOARD_ID);
+			renderWithDashboardBootstrap(DASHBOARD_ID);
 
 			await waitFor(() => {
 				expect(mockGetDashboard).toHaveBeenCalledWith({ id: DASHBOARD_ID });

frontend/src/providers/Dashboard/store/slices/dashboardLayoutSlice.ts

@@ -0,0 +1,51 @@
+import type { Layout } from 'react-grid-layout';
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+export interface DashboardLayoutSlice {
+	//
+	layouts: Layout[];
+	setLayouts: (updater: Layout[] | ((prev: Layout[]) => Layout[])) => void;
+	//
+	panelMap: Record<string, { widgets: Layout[]; collapsed: boolean }>;
+	setPanelMap: (
+		updater:
+			| Record<string, { widgets: Layout[]; collapsed: boolean }>
+			| ((
+					prev: Record<string, { widgets: Layout[]; collapsed: boolean }>,
+			  ) => Record<string, { widgets: Layout[]; collapsed: boolean }>),
+	) => void;
+	// resetDashboardLayout: () => void;
+}
+
+export const initialDashboardLayoutState = {
+	layouts: [] as Layout[],
+	panelMap: {} as Record<string, { widgets: Layout[]; collapsed: boolean }>,
+};
+
+export const createDashboardLayoutSlice: StateCreator<
+	DashboardStore,
+	[['zustand/immer', never]],
+	[],
+	DashboardLayoutSlice
+> = (set) => ({
+	...initialDashboardLayoutState,
+
+	setLayouts: (updater): void =>
+		set((state) => {
+			state.layouts =
+				typeof updater === 'function' ? updater(state.layouts) : updater;
+		}),
+
+	setPanelMap: (updater): void =>
+		set((state) => {
+			state.panelMap =
+				typeof updater === 'function' ? updater(state.panelMap) : updater;
+		}),
+
+	// resetDashboardLayout: () =>
+	// 	set((state) => {
+	// 		Object.assign(state, initialDashboardLayoutState);
+	// 	}),
+});

frontend/src/providers/Dashboard/store/slices/dashboardUISlice.ts

@@ -0,0 +1,57 @@
+import type { Dashboard } from 'types/api/dashboard/getAll';
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+export type WidgetColumnWidths = {
+	[widgetId: string]: Record<string, number>;
+};
+
+export interface DashboardUISlice {
+	//
+	selectedDashboard: Dashboard | undefined;
+	setSelectedDashboard: (
+		updater:
+			| Dashboard
+			| undefined
+			| ((prev: Dashboard | undefined) => Dashboard | undefined),
+	) => void;
+	//
+	columnWidths: WidgetColumnWidths;
+	setColumnWidths: (
+		updater:
+			| WidgetColumnWidths
+			| ((prev: WidgetColumnWidths) => WidgetColumnWidths),
+	) => void;
+}
+
+export const initialDashboardUIState = {
+	selectedDashboard: undefined as Dashboard | undefined,
+	columnWidths: {} as WidgetColumnWidths,
+};
+
+export const createDashboardUISlice: StateCreator<
+	DashboardStore,
+	[['zustand/immer', never]],
+	[],
+	DashboardUISlice
+> = (set) => ({
+	...initialDashboardUIState,
+
+	setSelectedDashboard: (updater): void =>
+		set((state: DashboardUISlice): void => {
+			state.selectedDashboard =
+				typeof updater === 'function' ? updater(state.selectedDashboard) : updater;
+		}),
+
+	setColumnWidths: (updater): void =>
+		set((state: DashboardUISlice): void => {
+			state.columnWidths =
+				typeof updater === 'function' ? updater(state.columnWidths) : updater;
+		}),
+
+	resetDashboardUI: (): void =>
+		set((state: DashboardUISlice): void => {
+			Object.assign(state, initialDashboardUIState);
+		}),
+});

frontend/src/providers/Dashboard/store/useDashboardStore.ts

@@ -0,0 +1,50 @@
+import type { Layout } from 'react-grid-layout';
+import type { Dashboard } from 'types/api/dashboard/getAll';
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+
+import {
+	createDashboardLayoutSlice,
+	DashboardLayoutSlice,
+	initialDashboardLayoutState,
+} from './slices/dashboardLayoutSlice';
+import {
+	createDashboardUISlice,
+	DashboardUISlice,
+	initialDashboardUIState,
+} from './slices/dashboardUISlice';
+
+export type DashboardStore = DashboardUISlice &
+	DashboardLayoutSlice & {
+		resetDashboardStore: () => void;
+	};
+
+/**
+ * 'select*' is a redux naming convention that can be carried over to zustand.
+ * It is used to select a piece of state from the store.
+ * In this case, we are selecting the locked state of the selected dashboard.
+ * */
+export const selectIsDashboardLocked = (s: DashboardStore): boolean =>
+	s.selectedDashboard?.locked ?? false;
+
+export const useDashboardStore = create<DashboardStore>()(
+	immer((set, get, api) => ({
+		...createDashboardUISlice(set, get, api),
+		...createDashboardLayoutSlice(set, get, api),
+
+		resetDashboardStore: (): void =>
+			set((state: DashboardStore) => {
+				Object.assign(state, initialDashboardUIState, initialDashboardLayoutState);
+			}),
+	})),
+);
+
+// Standalone imperative accessors — use these instead of calling useDashboardStore.getState() at call sites.
+export const getSelectedDashboard = (): Dashboard | undefined =>
+	useDashboardStore.getState().selectedDashboard;
+
+export const getDashboardLayouts = (): Layout[] =>
+	useDashboardStore.getState().layouts;
+
+export const resetDashboard = (): void =>
+	useDashboardStore.getState().resetDashboardStore();

frontend/src/providers/Dashboard/types.ts

@@ -1,41 +0,0 @@
-import { Layout } from 'react-grid-layout';
-import { UseQueryResult } from 'react-query';
-import dayjs from 'dayjs';
-import { SuccessResponseV2 } from 'types/api';
-import { Dashboard } from 'types/api/dashboard/getAll';
-
-export type WidgetColumnWidths = {
-	[widgetId: string]: Record<string, number>;
-};
-
-export interface IDashboardContext {
-	isDashboardLocked: boolean;
-	handleDashboardLockToggle: (value: boolean) => void;
-	dashboardResponse: UseQueryResult<SuccessResponseV2<Dashboard>, unknown>;
-	selectedDashboard: Dashboard | undefined;
-	layouts: Layout[];
-	panelMap: Record<string, { widgets: Layout[]; collapsed: boolean }>;
-	setPanelMap: React.Dispatch<React.SetStateAction<Record<string, any>>>;
-	setLayouts: React.Dispatch<React.SetStateAction<Layout[]>>;
-	setSelectedDashboard: React.Dispatch<
-		React.SetStateAction<Dashboard | undefined>
-	>;
-	updatedTimeRef: React.MutableRefObject<dayjs.Dayjs | null>;
-	updateLocalStorageDashboardVariables: (
-		id: string,
-		selectedValue:
-			| string
-			| number
-			| boolean
-			| (string | number | boolean)[]
-			| null
-			| undefined,
-		allSelected: boolean,
-		isDynamic?: boolean,
-	) => void;
-	dashboardQueryRangeCalled: boolean;
-	setDashboardQueryRangeCalled: (value: boolean) => void;
-	isDashboardFetching: boolean;
-	columnWidths: WidgetColumnWidths;
-	setColumnWidths: React.Dispatch<React.SetStateAction<WidgetColumnWidths>>;
-}

go.mod

@@ -81,6 +81,8 @@ require (
 	golang.org/x/oauth2 v0.34.0
 	golang.org/x/sync v0.19.0
 	golang.org/x/text v0.33.0
+	gonum.org/v1/gonum v0.17.0
+	google.golang.org/api v0.265.0
 	google.golang.org/protobuf v1.36.11
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
@@ -377,8 +379,6 @@ require (
 	golang.org/x/sys v0.40.0 // indirect
 	golang.org/x/time v0.14.0 // indirect
 	golang.org/x/tools v0.41.0 // indirect
-	gonum.org/v1/gonum v0.17.0 // indirect
-	google.golang.org/api v0.265.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260128011058-8636f8732409 // indirect
 	google.golang.org/grpc v1.78.0 // indirect

pkg/apiserver/signozapiserver/provider.go

@@ -18,6 +18,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
@@ -47,9 +48,11 @@ type provider struct {
 	gatewayHandler         gateway.Handler
 	fieldsHandler          fields.Handler
 	authzHandler           authz.Handler
+	rawDataExportHandler   rawdataexport.Handler
 	zeusHandler            zeus.Handler
 	querierHandler         querier.Handler
 	serviceAccountHandler  serviceaccount.Handler
+	factoryHandler         factory.Handler
 }
 
 func NewFactory(
@@ -69,9 +72,11 @@ func NewFactory(
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
+	rawDataExportHandler rawdataexport.Handler,
 	zeusHandler zeus.Handler,
 	querierHandler querier.Handler,
 	serviceAccountHandler serviceaccount.Handler,
+	factoryHandler factory.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
 		return newProvider(
@@ -94,9 +99,11 @@ func NewFactory(
 			gatewayHandler,
 			fieldsHandler,
 			authzHandler,
+			rawDataExportHandler,
 			zeusHandler,
 			querierHandler,
 			serviceAccountHandler,
+			factoryHandler,
 		)
 	})
 }
@@ -121,9 +128,11 @@ func newProvider(
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
+	rawDataExportHandler rawdataexport.Handler,
 	zeusHandler zeus.Handler,
 	querierHandler querier.Handler,
 	serviceAccountHandler serviceaccount.Handler,
+	factoryHandler factory.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -146,9 +155,11 @@ func newProvider(
 		gatewayHandler:         gatewayHandler,
 		fieldsHandler:          fieldsHandler,
 		authzHandler:           authzHandler,
+		rawDataExportHandler:   rawDataExportHandler,
 		zeusHandler:            zeusHandler,
 		querierHandler:         querierHandler,
 		serviceAccountHandler:  serviceAccountHandler,
+		factoryHandler:         factoryHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -221,6 +232,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addRawDataExportRoutes(router); err != nil {
+		return err
+	}
+
 	if err := provider.addZeusRoutes(router); err != nil {
 		return err
 	}
@@ -233,6 +248,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addRegistryRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/apiserver/signozapiserver/rawdataexport.go

@@ -0,0 +1,33 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/exporttypes"
+	v5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addRawDataExportRoutes(router *mux.Router) error {
+
+	if err := router.Handle("/api/v1/export_raw_data", handler.New(provider.authZ.ViewAccess(provider.rawDataExportHandler.ExportRawData), handler.OpenAPIDef{
+		ID:                  "HandleExportRawDataPOST",
+		Tags:                []string{"logs", "traces"},
+		Summary:             "Export raw data",
+		Description:         "This endpoints allows complex query exporting raw data for traces and logs",
+		Request:             new(v5.QueryRangeRequest),
+		RequestQuery:        new(exporttypes.ExportRawDataFormatQueryParam),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/apiserver/signozapiserver/registry.go

@@ -0,0 +1,84 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	pkghandler "github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/gorilla/mux"
+	openapi "github.com/swaggest/openapi-go"
+)
+
+type healthOpenAPIHandler struct {
+	handlerFunc http.HandlerFunc
+	id          string
+	summary     string
+}
+
+func newHealthOpenAPIHandler(handlerFunc http.HandlerFunc, id, summary string) pkghandler.Handler {
+	return &healthOpenAPIHandler{
+		handlerFunc: handlerFunc,
+		id:          id,
+		summary:     summary,
+	}
+}
+
+func (handler *healthOpenAPIHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	handler.handlerFunc.ServeHTTP(rw, req)
+}
+
+func (handler *healthOpenAPIHandler) ServeOpenAPI(opCtx openapi.OperationContext) {
+	opCtx.SetID(handler.id)
+	opCtx.SetTags("health")
+	opCtx.SetSummary(handler.summary)
+
+	response := render.SuccessResponse{
+		Status: render.StatusSuccess.String(),
+		Data:   new(factory.Response),
+	}
+
+	opCtx.AddRespStructure(
+		response,
+		openapi.WithContentType("application/json"),
+		openapi.WithHTTPStatus(http.StatusOK),
+	)
+	opCtx.AddRespStructure(
+		response,
+		openapi.WithContentType("application/json"),
+		openapi.WithHTTPStatus(http.StatusServiceUnavailable),
+	)
+}
+
+func (provider *provider) addRegistryRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v2/healthz", newHealthOpenAPIHandler(
+		provider.authZ.OpenAccess(provider.factoryHandler.Healthz),
+		"Healthz",
+		"Health check",
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/readyz", newHealthOpenAPIHandler(
+		provider.authZ.OpenAccess(provider.factoryHandler.Readyz),
+		"Readyz",
+		"Readiness check",
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/livez", pkghandler.New(provider.authZ.OpenAccess(provider.factoryHandler.Livez),
+		pkghandler.OpenAPIDef{
+			ID:                  "Livez",
+			Tags:                []string{"health"},
+			Summary:             "Liveness check",
+			Response:            new(factory.Response),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+		},
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/authz/authz.go

@@ -11,7 +11,7 @@ import (
 )
 
 type AuthZ interface {
-	factory.Service
+	factory.ServiceWithHealthy
 
 	// CheckWithTupleCreation takes upon the responsibility for generating the tuples alongside everything Check does.
 	CheckWithTupleCreation(context.Context, authtypes.Claims, valuer.UUID, authtypes.Relation, authtypes.Typeable, []authtypes.Selector, []authtypes.Selector) error

pkg/authz/openfgaauthz/provider.go

@@ -43,6 +43,10 @@ func (provider *provider) Start(ctx context.Context) error {
 	return provider.server.Start(ctx)
 }
 
+func (provider *provider) Healthy() <-chan struct{} {
+	return provider.server.Healthy()
+}
+
 func (provider *provider) Stop(ctx context.Context) error {
 	return provider.server.Stop(ctx)
 }

pkg/authz/openfgaserver/server.go

@@ -31,6 +31,7 @@ type Server struct {
 	modelID       string
 	mtx           sync.RWMutex
 	stopChan      chan struct{}
+	healthyC      chan struct{}
 }
 
 func NewOpenfgaServer(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) (*Server, error) {
@@ -61,6 +62,7 @@ func NewOpenfgaServer(ctx context.Context, settings factory.ProviderSettings, co
 		openfgaSchema: openfgaSchema,
 		mtx:           sync.RWMutex{},
 		stopChan:      make(chan struct{}),
+		healthyC:      make(chan struct{}),
 	}, nil
 }
 
@@ -80,10 +82,16 @@ func (server *Server) Start(ctx context.Context) error {
 	server.storeID = storeID
 	server.mtx.Unlock()
 
+	close(server.healthyC)
+
 	<-server.stopChan
 	return nil
 }
 
+func (server *Server) Healthy() <-chan struct{} {
+	return server.healthyC
+}
+
 func (server *Server) Stop(ctx context.Context) error {
 	server.openfgaServer.Close()
 	close(server.stopChan)

pkg/factory/handler.go

@@ -0,0 +1,67 @@
+package factory
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/render"
+)
+
+// Handler provides HTTP handler functions for service health checks.
+type Handler interface {
+	// Readyz reports whether services are ready.
+	Readyz(http.ResponseWriter, *http.Request)
+
+	// Livez reports whether services are alive.
+	Livez(http.ResponseWriter, *http.Request)
+
+	// Healthz reports overall service health.
+	Healthz(http.ResponseWriter, *http.Request)
+}
+
+type handler struct {
+	registry *Registry
+}
+
+func NewHandler(registry *Registry) Handler {
+	return &handler{
+		registry: registry,
+	}
+}
+
+type Response struct {
+	Healthy  bool             `json:"healthy"`
+	Services map[State][]Name `json:"services"`
+}
+
+func (handler *handler) Healthz(rw http.ResponseWriter, req *http.Request) {
+	byState := handler.registry.ServicesByState()
+	healthy := handler.registry.IsHealthy()
+
+	statusCode := http.StatusOK
+	if !healthy {
+		statusCode = http.StatusServiceUnavailable
+	}
+
+	render.Success(rw, statusCode, Response{
+		Healthy:  healthy,
+		Services: byState,
+	})
+}
+
+func (handler *handler) Readyz(rw http.ResponseWriter, req *http.Request) {
+	healthy := handler.registry.IsHealthy()
+
+	statusCode := http.StatusOK
+	if !healthy {
+		statusCode = http.StatusServiceUnavailable
+	}
+
+	render.Success(rw, statusCode, Response{
+		Healthy:  healthy,
+		Services: handler.registry.ServicesByState(),
+	})
+}
+
+func (handler *handler) Livez(rw http.ResponseWriter, req *http.Request) {
+	render.Success(rw, http.StatusOK, nil)
+}

pkg/factory/name.go

@@ -5,9 +5,11 @@ import (
 	"regexp"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/swaggest/jsonschema-go"
 )
 
 var _ slog.LogValuer = (Name{})
+var _ jsonschema.Exposer = (Name{})
 
 var (
 	// nameRegex is a regex that matches a valid name.
@@ -27,6 +29,21 @@ func (n Name) String() string {
 	return n.name
 }
 
+// MarshalText implements encoding.TextMarshaler for JSON serialization.
+func (n Name) MarshalText() ([]byte, error) {
+	return []byte(n.name), nil
+}
+
+// MarshalJSON implements json.Marshaler so Name serializes as a JSON string.
+func (n Name) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + n.name + `"`), nil
+}
+
+// JSONSchema implements jsonschema.Exposer so OpenAPI reflects Name as a string.
+func (n Name) JSONSchema() (jsonschema.Schema, error) {
+	return *new(jsonschema.Schema).WithType(jsonschema.String.Type()), nil
+}
+
 // NewName creates a new name.
 func NewName(name string) (Name, error) {
 	if !nameRegex.MatchString(name) {

pkg/factory/registry.go

@@ -8,21 +8,26 @@ import (
 	"syscall"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"gonum.org/v1/gonum/graph/simple"
+	"gonum.org/v1/gonum/graph/topo"
 )
 
 var (
-	ErrCodeInvalidRegistry = errors.MustNewCode("invalid_registry")
+	ErrCodeInvalidRegistry  = errors.MustNewCode("invalid_registry")
+	ErrCodeDependencyFailed = errors.MustNewCode("dependency_failed")
+	ErrCodeServiceFailed    = errors.MustNewCode("service_failed")
 )
 
 type Registry struct {
-	services NamedMap[NamedService]
-	logger   *slog.Logger
-	startCh  chan error
-	stopCh   chan error
+	services       []*serviceWithState
+	servicesByName map[Name]*serviceWithState
+	logger         *slog.Logger
+	startC         chan error
+	stopC          chan error
 }
 
 // New creates a new registry of services. It needs at least one service in the input.
-func NewRegistry(logger *slog.Logger, services ...NamedService) (*Registry, error) {
+func NewRegistry(ctx context.Context, logger *slog.Logger, services ...NamedService) (*Registry, error) {
 	if logger == nil {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidRegistry, "cannot build registry, logger is required")
 	}
@@ -31,59 +36,131 @@ func NewRegistry(logger *slog.Logger, services ...NamedService) (*Registry, erro
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidRegistry, "cannot build registry, at least one service is required")
 	}
 
-	m, err := NewNamedMap(services...)
-	if err != nil {
+	servicesWithState := make([]*serviceWithState, len(services))
+	servicesByName := make(map[Name]*serviceWithState, len(services))
+	for i, s := range services {
+		if _, ok := servicesByName[s.Name()]; ok {
+			return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidRegistry, "cannot build registry, duplicate service name %q", s.Name())
+		}
+		ss := newServiceWithState(s)
+		servicesWithState[i] = ss
+		servicesByName[s.Name()] = ss
+	}
+
+	registryLogger := logger.With(slog.String("pkg", "github.com/SigNoz/signoz/pkg/factory"))
+
+	for _, ss := range servicesWithState {
+		for _, dep := range ss.service.DependsOn() {
+			if dep == ss.service.Name() {
+				registryLogger.ErrorContext(ctx, "ignoring self-dependency", slog.Any("service", ss.service.Name()))
+				continue
+			}
+
+			if _, ok := servicesByName[dep]; !ok {
+				registryLogger.ErrorContext(ctx, "ignoring unknown dependency", slog.Any("service", ss.service.Name()), slog.Any("dependency", dep))
+				continue
+			}
+
+			ss.dependsOn = append(ss.dependsOn, dep)
+		}
+	}
+
+	if err := detectCyclicDeps(servicesWithState); err != nil {
 		return nil, err
 	}
 
 	return &Registry{
-		logger:   logger.With(slog.String("pkg", "go.signoz.io/pkg/factory")),
-		services: m,
-		startCh:  make(chan error, 1),
-		stopCh:   make(chan error, len(services)),
+		logger:         registryLogger,
+		services:       servicesWithState,
+		servicesByName: servicesByName,
+		startC:         make(chan error, 1),
+		stopC:          make(chan error, len(services)),
 	}, nil
 }
 
-func (r *Registry) Start(ctx context.Context) {
-	for _, s := range r.services.GetInOrder() {
-		go func(s NamedService) {
-			r.logger.InfoContext(ctx, "starting service", slog.Any("service", s.Name()))
-			err := s.Start(ctx)
-			r.startCh <- err
-		}(s)
-	}
+func (registry *Registry) Start(ctx context.Context) {
+	for _, ss := range registry.services {
+		go func(ss *serviceWithState) {
+			// Wait for all dependencies to be healthy before starting.
+			for _, dep := range ss.dependsOn {
+				depState := registry.servicesByName[dep]
+				registry.logger.InfoContext(ctx, "service waiting for dependency", slog.Any("service", ss.service.Name()), slog.Any("dependency", dep))
+				select {
+				case <-ctx.Done():
+					ss.mu.Lock()
+					ss.state = StateFailed
+					ss.startErr = ctx.Err()
+					ss.mu.Unlock()
+					close(ss.startReturnedC)
+					registry.startC <- ctx.Err()
+					return
+				case <-depState.healthyC:
+					// Dependency is healthy, continue.
+				case <-depState.startReturnedC:
+					// Dependency failed before becoming healthy.
+					err := errors.Newf(errors.TypeInternal, ErrCodeDependencyFailed, "dependency %q of service %q failed", dep, ss.service.Name())
+					ss.mu.Lock()
+					ss.state = StateFailed
+					ss.startErr = err
+					ss.mu.Unlock()
+					close(ss.startReturnedC)
+					registry.startC <- err
+					return
+				}
+			}
 
+			registry.logger.InfoContext(ctx, "starting service", slog.Any("service", ss.service.Name()))
+
+			go func() {
+				select {
+				case <-ss.service.Healthy():
+					ss.setState(StateRunning)
+				case <-ss.startReturnedC:
+				}
+			}()
+
+			err := ss.service.Start(ctx)
+			if err != nil {
+				ss.mu.Lock()
+				ss.state = StateFailed
+				ss.startErr = err
+				ss.mu.Unlock()
+			}
+			close(ss.startReturnedC)
+			registry.startC <- err
+		}(ss)
+	}
 }
 
-func (r *Registry) Wait(ctx context.Context) error {
+func (registry *Registry) Wait(ctx context.Context) error {
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
 
 	select {
 	case <-ctx.Done():
-		r.logger.InfoContext(ctx, "caught context error, exiting", errors.Attr(ctx.Err()))
+		registry.logger.InfoContext(ctx, "caught context error, exiting", errors.Attr(ctx.Err()))
 	case s := <-interrupt:
-		r.logger.InfoContext(ctx, "caught interrupt signal, exiting", slog.Any("signal", s))
-	case err := <-r.startCh:
-		r.logger.ErrorContext(ctx, "caught service error, exiting", errors.Attr(err))
+		registry.logger.InfoContext(ctx, "caught interrupt signal, exiting", slog.Any("signal", s))
+	case err := <-registry.startC:
+		registry.logger.ErrorContext(ctx, "caught service error, exiting", errors.Attr(err))
 		return err
 	}
 
 	return nil
 }
 
-func (r *Registry) Stop(ctx context.Context) error {
-	for _, s := range r.services.GetInOrder() {
-		go func(s NamedService) {
-			r.logger.InfoContext(ctx, "stopping service", slog.Any("service", s.Name()))
-			err := s.Stop(ctx)
-			r.stopCh <- err
-		}(s)
+func (registry *Registry) Stop(ctx context.Context) error {
+	for _, ss := range registry.services {
+		go func(ss *serviceWithState) {
+			registry.logger.InfoContext(ctx, "stopping service", slog.Any("service", ss.service.Name()))
+			err := ss.service.Stop(ctx)
+			registry.stopC <- err
+		}(ss)
 	}
 
-	errs := make([]error, len(r.services.GetInOrder()))
-	for i := 0; i < len(r.services.GetInOrder()); i++ {
-		err := <-r.stopCh
+	errs := make([]error, len(registry.services))
+	for i := 0; i < len(registry.services); i++ {
+		err := <-registry.stopC
 		if err != nil {
 			errs = append(errs, err)
 		}
@@ -91,3 +168,83 @@ func (r *Registry) Stop(ctx context.Context) error {
 
 	return errors.Join(errs...)
 }
+
+// AwaitHealthy blocks until all services reach the RUNNING state or any service fails.
+func (registry *Registry) AwaitHealthy(ctx context.Context) error {
+	for _, ss := range registry.services {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-ss.healthyC:
+		case <-ss.startReturnedC:
+			ss.mu.RLock()
+			err := ss.startErr
+			ss.mu.RUnlock()
+			if err != nil {
+				return errors.Wrapf(err, errors.TypeInternal, ErrCodeServiceFailed, "service %q failed before becoming healthy", ss.service.Name())
+			}
+			return errors.Newf(errors.TypeInternal, ErrCodeServiceFailed, "service %q terminated before becoming healthy", ss.service.Name())
+		}
+	}
+	return nil
+}
+
+// ServicesByState returns a snapshot of the current state of all services.
+func (registry *Registry) ServicesByState() map[State][]Name {
+	result := make(map[State][]Name)
+	for _, ss := range registry.services {
+		state := ss.getState()
+		result[state] = append(result[state], ss.service.Name())
+	}
+	return result
+}
+
+// IsHealthy returns true if all services are in the RUNNING state.
+func (registry *Registry) IsHealthy() bool {
+	for _, ss := range registry.services {
+		if ss.getState() != StateRunning {
+			return false
+		}
+	}
+	return true
+}
+
+// detectCyclicDeps returns an error listing all dependency cycles found using
+// gonum's Tarjan SCC algorithm.
+func detectCyclicDeps(services []*serviceWithState) error {
+	nameToID := make(map[Name]int64, len(services))
+	idToName := make(map[int64]Name, len(services))
+	for i, ss := range services {
+		id := int64(i)
+		nameToID[ss.service.Name()] = id
+		idToName[id] = ss.service.Name()
+	}
+
+	g := simple.NewDirectedGraph()
+	for _, ss := range services {
+		g.AddNode(simple.Node(nameToID[ss.service.Name()]))
+	}
+	for _, ss := range services {
+		fromID := nameToID[ss.service.Name()]
+		for _, dep := range ss.dependsOn {
+			g.SetEdge(simple.Edge{F: simple.Node(fromID), T: simple.Node(nameToID[dep])})
+		}
+	}
+
+	if _, err := topo.Sort(g); err == nil {
+		return nil
+	}
+
+	var cycles [][]Name
+	for _, scc := range topo.TarjanSCC(g) {
+		if len(scc) > 1 {
+			cycle := make([]Name, len(scc))
+			for i, n := range scc {
+				cycle[i] = idToName[n.ID()]
+			}
+			cycles = append(cycles, cycle)
+		}
+	}
+
+	return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidRegistry, "dependency cycles detected: %v", cycles)
+}

pkg/factory/registry_test.go

@@ -5,7 +5,10 @@ import (
 	"log/slog"
 	"sync"
 	"testing"
+	"time"
 
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -28,11 +31,46 @@ func (s *tservice) Stop(_ context.Context) error {
 	return nil
 }
 
+type healthyTestService struct {
+	tservice
+	healthyC chan struct{}
+}
+
+func newHealthyTestService(t *testing.T) *healthyTestService {
+	t.Helper()
+	return &healthyTestService{
+		tservice: tservice{c: make(chan struct{})},
+		healthyC: make(chan struct{}),
+	}
+}
+
+func (s *healthyTestService) Healthy() <-chan struct{} {
+	return s.healthyC
+}
+
+// failingHealthyService implements Healthy but fails before signaling healthy.
+type failingHealthyService struct {
+	healthyC chan struct{}
+	err      error
+}
+
+func (s *failingHealthyService) Start(_ context.Context) error {
+	return s.err
+}
+
+func (s *failingHealthyService) Stop(_ context.Context) error {
+	return nil
+}
+
+func (s *failingHealthyService) Healthy() <-chan struct{} {
+	return s.healthyC
+}
+
 func TestRegistryWith2Services(t *testing.T) {
 	s1 := newTestService(t)
 	s2 := newTestService(t)
 
-	registry, err := NewRegistry(slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
 	require.NoError(t, err)
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -41,8 +79,8 @@ func TestRegistryWith2Services(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		registry.Start(ctx)
-		require.NoError(t, registry.Wait(ctx))
-		require.NoError(t, registry.Stop(ctx))
+		assert.NoError(t, registry.Wait(ctx))
+		assert.NoError(t, registry.Stop(ctx))
 	}()
 	cancel()
 
@@ -53,7 +91,7 @@ func TestRegistryWith2ServicesWithoutWait(t *testing.T) {
 	s1 := newTestService(t)
 	s2 := newTestService(t)
 
-	registry, err := NewRegistry(slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
 	require.NoError(t, err)
 
 	ctx := context.Background()
@@ -62,8 +100,245 @@ func TestRegistryWith2ServicesWithoutWait(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		registry.Start(ctx)
-		require.NoError(t, registry.Stop(ctx))
+		assert.NoError(t, registry.Stop(ctx))
 	}()
 
 	wg.Wait()
 }
+
+func TestServiceStateTransitions(t *testing.T) {
+	s1 := newTestService(t)
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	require.NoError(t, registry.AwaitHealthy(ctx))
+
+	byState := registry.ServicesByState()
+	assert.Len(t, byState[StateRunning], 1)
+	assert.True(t, registry.IsHealthy())
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestServiceStateWithHealthy(t *testing.T) {
+	s1 := newHealthyTestService(t)
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	// Poll until STARTING state is observed
+	require.Eventually(t, func() bool {
+		byState := registry.ServicesByState()
+		return len(byState[StateStarting]) == 1
+	}, time.Second, time.Millisecond)
+	assert.False(t, registry.IsHealthy())
+
+	// Signal healthy
+	close(s1.healthyC)
+
+	require.NoError(t, registry.AwaitHealthy(ctx))
+	assert.True(t, registry.IsHealthy())
+
+	byState := registry.ServicesByState()
+	assert.Len(t, byState[StateRunning], 1)
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestAwaitHealthy(t *testing.T) {
+	s1 := newTestService(t)
+	s2 := newTestService(t)
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	assert.NoError(t, registry.AwaitHealthy(ctx))
+	assert.True(t, registry.IsHealthy())
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestAwaitHealthyWithFailure(t *testing.T) {
+	s1 := &failingHealthyService{
+		healthyC: make(chan struct{}),
+		err:      errors.Newf(errors.TypeInternal, errors.CodeInternal,"startup failed"),
+	}
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	err = registry.AwaitHealthy(ctx)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "startup failed")
+}
+
+func TestServicesByState(t *testing.T) {
+	s1 := newTestService(t)
+	s2 := newHealthyTestService(t)
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1), NewNamedService(MustNewName("s2"), s2))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	// Wait for s1 to be running (no Healthy interface) and s2 to be starting
+	require.Eventually(t, func() bool {
+		byState := registry.ServicesByState()
+		return len(byState[StateRunning]) == 1 && len(byState[StateStarting]) == 1
+	}, time.Second, time.Millisecond)
+
+	// Make s2 healthy
+	close(s2.healthyC)
+
+	require.NoError(t, registry.AwaitHealthy(ctx))
+	byState := registry.ServicesByState()
+	assert.Len(t, byState[StateRunning], 2)
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestDependsOnStartsAfterDependency(t *testing.T) {
+	s1 := newHealthyTestService(t)
+	s2 := newTestService(t)
+
+	// s2 depends on s1
+	registry, err := NewRegistry(
+		context.Background(),
+		slog.New(slog.DiscardHandler),
+		NewNamedService(MustNewName("s1"), s1),
+		NewNamedService(MustNewName("s2"), s2, MustNewName("s1")),
+	)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	// s2 should still be STARTING because s1 hasn't become healthy yet
+	require.Eventually(t, func() bool {
+		byState := registry.ServicesByState()
+		return len(byState[StateStarting]) == 2
+	}, time.Second, time.Millisecond)
+
+	// Make s1 healthy — s2 should then start and become RUNNING
+	close(s1.healthyC)
+
+	assert.NoError(t, registry.AwaitHealthy(ctx))
+	assert.True(t, registry.IsHealthy())
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestDependsOnFailsWhenDependencyFails(t *testing.T) {
+	s1 := &failingHealthyService{
+		healthyC: make(chan struct{}),
+		err:      errors.Newf(errors.TypeInternal, errors.CodeInternal,"s1 crashed"),
+	}
+	s2 := newTestService(t)
+
+	// s2 depends on s1
+	registry, err := NewRegistry(
+		context.Background(),
+		slog.New(slog.DiscardHandler),
+		NewNamedService(MustNewName("s1"), s1),
+		NewNamedService(MustNewName("s2"), s2, MustNewName("s1")),
+	)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	// Both should eventually fail
+	assert.Eventually(t, func() bool {
+		byState := registry.ServicesByState()
+		return len(byState[StateFailed]) == 2
+	}, time.Second, time.Millisecond)
+}
+
+func TestDependsOnUnknownServiceIsIgnored(t *testing.T) {
+	s1 := newTestService(t)
+
+	// Unknown dependency is logged and ignored, not an error.
+	registry, err := NewRegistry(
+		context.Background(),
+		slog.New(slog.DiscardHandler),
+		NewNamedService(MustNewName("s1"), s1, MustNewName("unknown")),
+	)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	assert.NoError(t, registry.AwaitHealthy(ctx))
+	assert.True(t, registry.IsHealthy())
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestServiceStateFailed(t *testing.T) {
+	s1 := &failingHealthyService{
+		healthyC: make(chan struct{}),
+		err:      errors.Newf(errors.TypeInternal, errors.CodeInternal,"fatal error"),
+	}
+
+	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	// Wait for the service to fail
+	assert.Eventually(t, func() bool {
+		byState := registry.ServicesByState()
+		return len(byState[StateFailed]) == 1
+	}, time.Second, time.Millisecond)
+	assert.False(t, registry.IsHealthy())
+}
+
+func TestDependsOnSelfDependencyIsIgnored(t *testing.T) {
+	s1 := newTestService(t)
+
+	// Self-dependency is logged and ignored.
+	registry, err := NewRegistry(
+		context.Background(),
+		slog.New(slog.DiscardHandler),
+		NewNamedService(MustNewName("s1"), s1, MustNewName("s1")),
+	)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	registry.Start(ctx)
+
+	assert.NoError(t, registry.AwaitHealthy(ctx))
+	assert.True(t, registry.IsHealthy())
+
+	assert.NoError(t, registry.Stop(ctx))
+}
+
+func TestDependsOnCycleReturnsError(t *testing.T) {
+	s1 := newTestService(t)
+	s2 := newTestService(t)
+
+	// A -> B and B -> A is a cycle.
+	_, err := NewRegistry(
+		context.Background(),
+		slog.New(slog.DiscardHandler),
+		NewNamedService(MustNewName("s1"), s1, MustNewName("s2")),
+		NewNamedService(MustNewName("s2"), s2, MustNewName("s1")),
+	)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "dependency cycles detected")
+}

pkg/factory/service.go

@@ -2,30 +2,81 @@ package factory
 
 import "context"
 
+// Service is the core lifecycle interface for long-running services.
 type Service interface {
 	// Starts a service. It should block and should not return until the service is stopped or it fails.
 	Start(context.Context) error
+
 	// Stops a service.
 	Stop(context.Context) error
 }
 
-type NamedService interface {
-	Named
-	Service
+// Healthy is an optional interface that services can implement to signal
+// when they have completed startup and are ready to serve.
+// Services that do not implement this interface are considered healthy
+// immediately after Start() is called.
+type Healthy interface {
+	// Healthy returns a channel that is closed when the service is healthy.
+	Healthy() <-chan struct{}
 }
 
-type namedService struct {
-	name Name
+// ServiceWithHealthy is a Service that explicitly signals when it is healthy.
+type ServiceWithHealthy interface {
 	Service
+	Healthy
+}
+
+// NamedService is a Service with a Name and optional dependencies.
+type NamedService interface {
+	Named
+	ServiceWithHealthy
+	// DependsOn returns the names of services that must be healthy before this service starts.
+	DependsOn() []Name
+}
+
+// closedC is a pre-closed channel returned for services that don't implement Healthy.
+var closedC = func() chan struct{} {
+	c := make(chan struct{})
+	close(c)
+	return c
+}()
+
+type namedService struct {
+	name      Name
+	dependsOn []Name
+	service   Service
+}
+
+// NewNamedService wraps a Service with a Name and optional dependency names.
+func NewNamedService(name Name, service Service, dependsOn ...Name) NamedService {
+	return &namedService{
+		name:      name,
+		dependsOn: dependsOn,
+		service:   service,
+	}
 }
 
 func (s *namedService) Name() Name {
 	return s.name
 }
 
-func NewNamedService(name Name, service Service) NamedService {
-	return &namedService{
-		name:    name,
-		Service: service,
-	}
+func (s *namedService) DependsOn() []Name {
+	return s.dependsOn
+}
+
+func (s *namedService) Start(ctx context.Context) error {
+	return s.service.Start(ctx)
+}
+
+func (s *namedService) Stop(ctx context.Context) error {
+	return s.service.Stop(ctx)
+}
+
+// Healthy delegates to the underlying service if it implements Healthy,
+// otherwise returns an already-closed channel (immediately healthy).
+func (s *namedService) Healthy() <-chan struct{} {
+	if h, ok := s.service.(Healthy); ok {
+		return h.Healthy()
+	}
+	return closedC
 }

pkg/factory/state.go

@@ -0,0 +1,75 @@
+package factory
+
+import "sync"
+
+// State represents the lifecycle state of a service.
+type State struct {
+	s string
+}
+
+func (s State) String() string {
+	return s.s
+}
+
+// MarshalText implements encoding.TextMarshaler so State can be used as a JSON map key.
+func (s State) MarshalText() ([]byte, error) {
+	return []byte(s.s), nil
+}
+
+var (
+	StateStarting = State{"starting"}
+	StateRunning  = State{"running"}
+	StateFailed   = State{"failed"}
+)
+
+// serviceWithState wraps a NamedService with thread-safe state tracking.
+type serviceWithState struct {
+	// service is the underlying named service.
+	service NamedService
+
+	// dependsOn is the validated subset of declared dependencies that exist in the registry.
+	dependsOn []Name
+
+	// mu protects state and startErr from concurrent access.
+	mu sync.RWMutex
+
+	// state is the current lifecycle state of the service.
+	state State
+
+	// healthyC is closed when the service transitions to StateRunning.
+	healthyC chan struct{}
+
+	// startReturnedC is closed when Start() returns, whether with nil or an error.
+	startReturnedC chan struct{}
+
+	// startErr is the error returned by Start(), or nil if it returned successfully.
+	startErr error
+}
+
+func newServiceWithState(service NamedService) *serviceWithState {
+	return &serviceWithState{
+		service:        service,
+		state:          StateStarting,
+		healthyC:       make(chan struct{}),
+		startReturnedC: make(chan struct{}),
+	}
+}
+
+func (ss *serviceWithState) setState(state State) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
+	ss.state = state
+	if state == StateRunning {
+		select {
+		case <-ss.healthyC:
+		default:
+			close(ss.healthyC)
+		}
+	}
+}
+
+func (ss *serviceWithState) getState() State {
+	ss.mu.RLock()
+	defer ss.mu.RUnlock()
+	return ss.state
+}

pkg/modules/rawdataexport/implrawdataexport/handler.go

@@ -6,20 +6,19 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
+	"slices"
 	"strconv"
-	"strings"
 	"time"
 	"unicode"
 	"unicode/utf8"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/exporttypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -31,129 +30,31 @@ func NewHandler(module rawdataexport.Module) rawdataexport.Handler {
 	return &handler{module: module}
 }
 
-// ExportRawData handles data export requests.
-//
-// API Documentation:
-// Endpoint: GET /api/v1/export_raw_data
-//
-// Query Parameters:
-//
-//   - source (optional): Type of data to export ["logs" (default), "metrics", "traces"]
-//     Note: Currently only "logs" is fully supported
-//
-//   - format (optional): Output format ["csv" (default), "jsonl"]
-//
-//   - start (required): Start time for query (Unix timestamp in nanoseconds)
-//
-//   - end (required): End time for query (Unix timestamp in nanoseconds)
-//
-//   - limit (optional): Maximum number of rows to export
-//     Constraints: Must be positive and cannot exceed MAX_EXPORT_ROW_COUNT_LIMIT
-//
-//   - filter (optional): Filter expression to apply to the query
-//
-//   - columns (optional): Specific columns to include in export
-//     Default: all columns are returned
-//     Format: ["context.field:type", "context.field", "field"]
-//
-//   - order_by (optional): Sorting specification ["column:direction" or "context.field:type:direction"]
-//     Direction: "asc" or "desc"
-//     Default: ["timestamp:desc", "id:desc"]
-//
-// Response Headers:
-//   - Content-Type: "text/csv" or "application/x-ndjson"
-//   - Content-Encoding: "gzip" (handled by HTTP middleware)
-//   - Content-Disposition: "attachment; filename=\"data_exported.[format]\""
-//   - Cache-Control: "no-cache"
-//   - Vary: "Accept-Encoding"
-//   - Transfer-Encoding: "chunked"
-//   - Trailers: X-Response-Complete
-//
-// Response Format:
-//
-//	CSV: Headers in first row, data in subsequent rows
-//	JSONL: One JSON object per line
-//
-// Example Usage:
-//
-//	Basic CSV export:
-//	  GET /api/v1/export_raw_data?start=1693612800000000000&end=1693699199000000000
-//
-//	Export with columns and format:
-//	  GET /api/v1/export_raw_data?start=1693612800000000000&end=1693699199000000000&format=jsonl
-//	      &columns=timestamp&columns=severity&columns=message
-//
-//	Export with filter and ordering:
-//	  GET /api/v1/export_raw_data?start=1693612800000000000&end=1693699199000000000
-//	      &filter=severity="error"&order_by=timestamp:desc&limit=1000
 func (handler *handler) ExportRawData(rw http.ResponseWriter, r *http.Request) {
-	source, err := getExportQuerySource(r.URL.Query())
-	if err != nil {
+	var queryRangeRequest qbtypes.QueryRangeRequest
+
+	var formatParam exporttypes.ExportRawDataFormatQueryParam
+	if err := binding.Query.BindQuery(r.URL.Query(), &formatParam); err != nil {
+		render.Error(rw, err)
+		return
+	}
+	format := formatParam.Format
+	if err := binding.JSON.BindBody(r.Body, &queryRangeRequest); err != nil {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+
+	if err := validateSpecForExport(&queryRangeRequest); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
-	switch source {
-	case "logs":
-		handler.exportLogs(rw, r)
-	case "traces":
-		handler.exportTraces(rw, r)
-	case "metrics":
-		handler.exportMetrics(rw, r)
-	default:
-		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid source: must be logs"))
-	}
-}
-
-func (handler *handler) exportMetrics(rw http.ResponseWriter, r *http.Request) {
-	render.Error(rw, errors.Newf(errors.TypeUnsupported, errors.CodeUnsupported, "metrics export is not yet supported"))
-}
-
-func (handler *handler) exportTraces(rw http.ResponseWriter, r *http.Request) {
-	render.Error(rw, errors.Newf(errors.TypeUnsupported, errors.CodeUnsupported, "traces export is not yet supported"))
-}
-
-func (handler *handler) exportLogs(rw http.ResponseWriter, r *http.Request) {
-	// Set up response headers
-	rw.Header().Set("Cache-Control", "no-cache")
-	rw.Header().Set("Vary", "Accept-Encoding") // Indicate that response varies based on Accept-Encoding
-	rw.Header().Set("Access-Control-Expose-Headers", "Content-Disposition, X-Response-Complete")
-	rw.Header().Set("Trailer", "X-Response-Complete")
-	rw.Header().Set("Transfer-Encoding", "chunked")
-
-	queryParams := r.URL.Query()
-
-	startTime, endTime, err := getExportQueryTimeRange(queryParams)
-	if err != nil {
+	if err := validateAndApplyDefaultExportLimits(queryRangeRequest.CompositeQuery.Queries); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
-	limit, err := getExportQueryLimit(queryParams)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	format, err := getExportQueryFormat(queryParams)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	// Set appropriate content type and filename
-	filename := fmt.Sprintf("data_exported_%s.%s", time.Now().Format("2006-01-02_150405"), format)
-	rw.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-
-	filterExpression := queryParams.Get("filter")
-
-	orderByExpression, err := getExportQueryOrderBy(queryParams)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	columns := getExportQueryColumns(queryParams)
+	queryRangeRequest.UseDefaultOrderBy()
 
 	claims, err := authtypes.ClaimsFromContext(r.Context())
 	if err != nil {
@@ -161,76 +62,98 @@ func (handler *handler) exportLogs(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgID is invalid"))
-		return
-	}
+	orgID := valuer.MustNewUUID(claims.OrgID)
 
-	queryRangeRequest := qbtypes.QueryRangeRequest{
-		Start:       startTime,
-		End:         endTime,
-		RequestType: qbtypes.RequestTypeRaw,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: []qbtypes.QueryEnvelope{
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: nil,
-				},
-			},
-		},
-	}
+	setExportResponseHeaders(rw, format)
 
-	spec := qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{
-		Signal: telemetrytypes.SignalLogs,
-		Name:   "raw",
-		Filter: &qbtypes.Filter{
-			Expression: filterExpression,
-		},
-		Limit: limit,
-		Order: orderByExpression,
-	}
-
-	spec.SelectFields = columns
-
-	queryRangeRequest.CompositeQuery.Queries[0].Spec = spec
-
-	// This will signal Export module to stop sending data
 	doneChan := make(chan any)
 	defer close(doneChan)
 	rowChan, errChan := handler.module.ExportRawData(r.Context(), orgID, &queryRangeRequest, doneChan)
 
-	var isComplete bool
+	isComplete, err := handler.executeExport(rowChan, errChan, format, rw)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	rw.Header().Set("X-Response-Complete", strconv.FormatBool(isComplete))
+}
 
+// validateSpecForExport validates query specs
+func validateSpecForExport(req *qbtypes.QueryRangeRequest) error {
+
+	queries := req.CompositeQuery.Queries
+
+	// If the trace operator query is not present, and there are multiple queries, return an error
+	if req.TraceOperatorQueryIndex() == -1 && len(queries) > 1 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "multiple queries not allowed without a trace operator query")
+	}
+
+	for idx := range queries {
+		switch spec := queries[idx].Spec.(type) {
+		case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation],
+			qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation],
+			qbtypes.QueryBuilderTraceOperator:
+			// Supported spec types
+		default:
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported query at index %d type: %T", idx, spec)
+		}
+	}
+
+	opts := append(qbtypes.GetValidationOptions(req.RequestType), qbtypes.WithSkipLimitOffsetValidation())
+	return req.Validate(opts...)
+}
+
+func validateAndApplyDefaultExportLimits(queries []qbtypes.QueryEnvelope) error {
+	for idx := range queries {
+		limit := queries[idx].GetLimit()
+		if limit == 0 {
+			limit = DefaultExportRowCountLimit
+		} else if limit < 0 {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be positive")
+		} else if limit > MaxExportRowCountLimit {
+			return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit cannot be more than %d", MaxExportRowCountLimit)
+		}
+		queries[idx].SetLimit(limit)
+	}
+	return nil
+}
+
+// setExportResponseHeaders sets common HTTP headers for export responses.
+func setExportResponseHeaders(rw http.ResponseWriter, format string) {
+	rw.Header().Set("Cache-Control", "no-cache")
+	rw.Header().Set("Vary", "Accept-Encoding")
+	rw.Header().Set("Access-Control-Expose-Headers", "Content-Disposition, X-Response-Complete")
+	rw.Header().Set("Trailer", "X-Response-Complete")
+	rw.Header().Set("Transfer-Encoding", "chunked")
+	filename := fmt.Sprintf("data_exported_%s.%s", time.Now().Format("2006-01-02_150405"), format)
+	rw.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+}
+
+// executeExport streams data from rowChan to the response writer in the specified format.
+func (handler *handler) executeExport(rowChan <-chan *qbtypes.RawRow, errChan <-chan error, format string, rw http.ResponseWriter) (bool, error) {
 	switch format {
 	case "csv", "":
 		rw.Header().Set("Content-Type", "text/csv")
 		csvWriter := csv.NewWriter(rw)
-		isComplete, err = handler.exportLogsCSV(rowChan, errChan, csvWriter)
+		isComplete, err := handler.exportRawDataCSV(rowChan, errChan, csvWriter)
 		if err != nil {
-			render.Error(rw, err)
-			return
+			return false, err
 		}
 		csvWriter.Flush()
+		return isComplete, nil
 	case "jsonl":
 		rw.Header().Set("Content-Type", "application/x-ndjson")
-		isComplete, err = handler.exportLogsJSONL(rowChan, errChan, rw)
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
+		return handler.exportRawDataJSONL(rowChan, errChan, rw)
 	default:
-		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid format: must be csv or jsonl"))
-		return
+		return false, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid format: must be csv or jsonl")
 	}
-
-	rw.Header().Set("X-Response-Complete", strconv.FormatBool(isComplete))
 }
 
-func (handler *handler) exportLogsCSV(rowChan <-chan *qbtypes.RawRow, errChan <-chan error, csvWriter *csv.Writer) (bool, error) {
-	var header []string
+// exportRawDataCSV is a generic CSV export function that works with any raw data (logs, traces, etc.)
+func (handler *handler) exportRawDataCSV(rowChan <-chan *qbtypes.RawRow, errChan <-chan error, csvWriter *csv.Writer) (bool, error) {
 
-	headerToIndexMapping := make(map[string]int, len(header))
+	var header []string
+	headerToIndexMapping := make(map[string]int)
 
 	totalBytes := uint64(0)
 	for {
@@ -268,8 +191,8 @@ func (handler *handler) exportLogsCSV(rowChan <-chan *qbtypes.RawRow, errChan <-
 	}
 }
 
-func (handler *handler) exportLogsJSONL(rowChan <-chan *qbtypes.RawRow, errChan <-chan error, writer io.Writer) (bool, error) {
-
+// exportRawDataJSONL is a generic JSONL export function that works with any raw data (logs, traces, etc.)
+func (handler *handler) exportRawDataJSONL(rowChan <-chan *qbtypes.RawRow, errChan <-chan error, writer io.Writer) (bool, error) {
 	totalBytes := uint64(0)
 	for {
 		select {
@@ -277,9 +200,11 @@ func (handler *handler) exportLogsJSONL(rowChan <-chan *qbtypes.RawRow, errChan
 			if !ok {
 				return true, nil
 			}
-			// Handle JSON format (JSONL - one object per line)
-			jsonBytes, _ := json.Marshal(row.Data)
-			totalBytes += uint64(len(jsonBytes)) + 1 // +1 for newline
+			jsonBytes, err := json.Marshal(row.Data)
+			if err != nil {
+				return false, errors.NewUnexpectedf(errors.CodeInternal, "error marshaling JSON: %s", err)
+			}
+			totalBytes += uint64(len(jsonBytes)) + 1
 
 			if _, err := writer.Write(jsonBytes); err != nil {
 				return false, errors.NewUnexpectedf(errors.CodeInternal, "error writing JSON: %s", err)
@@ -299,74 +224,33 @@ func (handler *handler) exportLogsJSONL(rowChan <-chan *qbtypes.RawRow, errChan
 	}
 }
 
-func getExportQuerySource(queryParams url.Values) (string, error) {
-	switch queryParams.Get("source") {
-	case "logs", "":
-		return "logs", nil
-	case "metrics":
-		return "metrics", errors.NewInvalidInputf(errors.CodeInvalidInput, "metrics export not yet supported")
-	case "traces":
-		return "traces", errors.NewInvalidInputf(errors.CodeInvalidInput, "traces export not yet supported")
-	default:
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid source: must be logs, metrics or traces")
-	}
-}
-
-func getExportQueryFormat(queryParams url.Values) (string, error) {
-	switch queryParams.Get("format") {
-	case "csv", "":
-		return "csv", nil
-	case "jsonl":
-		return "jsonl", nil
-	default:
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid format: must be csv or jsonl")
-	}
-}
-
-func getExportQueryLimit(queryParams url.Values) (int, error) {
-
-	limitStr := queryParams.Get("limit")
-	if limitStr == "" {
-		return DefaultExportRowCountLimit, nil
-	} else {
-		limit, err := strconv.Atoi(limitStr)
-		if err != nil {
-			return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid limit format: %s", err.Error())
-		}
-		if limit <= 0 {
-			return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be positive")
-		}
-		if limit > MaxExportRowCountLimit {
-			return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "limit cannot be more than %d", MaxExportRowCountLimit)
-		}
-		return limit, nil
-	}
-}
-
-func getExportQueryTimeRange(queryParams url.Values) (uint64, uint64, error) {
-
-	startTimeStr := queryParams.Get("start")
-	endTimeStr := queryParams.Get("end")
-
-	if startTimeStr == "" || endTimeStr == "" {
-		return 0, 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "start and end time are required")
-	}
-	startTime, err := strconv.ParseUint(startTimeStr, 10, 64)
-	if err != nil {
-		return 0, 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid start time format: %s", err.Error())
-	}
-	endTime, err := strconv.ParseUint(endTimeStr, 10, 64)
-	if err != nil {
-		return 0, 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid end time format: %s", err.Error())
-	}
-	return startTime, endTime, nil
-}
+// priorityColumns defines the columns that should appear first in the CSV output, in order.
+var priorityColumns = []string{"timestamp", "id"}
 
 func constructCSVHeaderFromQueryResponse(data map[string]any) []string {
 	header := make([]string, 0, len(data))
 	for key := range data {
 		header = append(header, key)
 	}
+	// This is to ensure CSV output is consistent across multiple queries
+	slices.SortFunc(header, func(a, b string) int {
+		ai, bi := slices.Index(priorityColumns, a), slices.Index(priorityColumns, b)
+		switch {
+		case ai != -1 && bi != -1:
+			return ai - bi
+		case ai != -1:
+			return -1
+		case bi != -1:
+			return 1
+		default:
+			if a < b {
+				return -1
+			} else if a > b {
+				return 1
+			}
+			return 0
+		}
+	})
 	return header
 }
 
@@ -427,9 +311,12 @@ func constructCSVRecordFromQueryResponse(data map[string]any, headerToIndexMappi
 				valueStr = v.String()
 
 			default:
-				// For all other complex types (maps, structs, etc.)
-				jsonBytes, _ := json.Marshal(v)
-				valueStr = string(jsonBytes)
+				jsonBytes, err := json.Marshal(v)
+				if err != nil {
+					valueStr = fmt.Sprintf("%v", v)
+				} else {
+					valueStr = string(jsonBytes)
+				}
 			}
 
 			record[index] = sanitizeForCSV(valueStr)
@@ -438,26 +325,6 @@ func constructCSVRecordFromQueryResponse(data map[string]any, headerToIndexMappi
 	return record
 }
 
-// getExportQueryColumns parses the "columns" query parameters and returns a slice of TelemetryFieldKey structs.
-// Each column should be a valid telemetry field key in the format "context.field:type" or "context.field" or "field"
-func getExportQueryColumns(queryParams url.Values) []telemetrytypes.TelemetryFieldKey {
-	columnParams := queryParams["columns"]
-
-	columns := make([]telemetrytypes.TelemetryFieldKey, 0, len(columnParams))
-
-	for _, columnStr := range columnParams {
-		// Skip empty strings
-		columnStr = strings.TrimSpace(columnStr)
-		if columnStr == "" {
-			continue
-		}
-
-		columns = append(columns, telemetrytypes.GetFieldKeyFromKeyText(columnStr))
-	}
-
-	return columns
-}
-
 func getsizeOfStringSlice(slice []string) uint64 {
 	var totalBytes uint64
 	for _, str := range slice {
@@ -465,52 +332,3 @@ func getsizeOfStringSlice(slice []string) uint64 {
 	}
 	return totalBytes
 }
-
-// getExportQueryOrderBy parses the "order_by" query parameters and returns a slice of OrderBy structs.
-// Each "order_by" parameter should be in the format "column:direction"
-// Each "column" should be a valid telemetry field key in the format "context.field:type" or "context.field" or "field"
-func getExportQueryOrderBy(queryParams url.Values) ([]qbtypes.OrderBy, error) {
-	orderByParam := queryParams.Get("order_by")
-
-	orderByParam = strings.TrimSpace(orderByParam)
-	if orderByParam == "" {
-		return telemetrylogs.DefaultLogsV2SortingOrder, nil
-	}
-
-	parts := strings.Split(orderByParam, ":")
-	if len(parts) != 2 && len(parts) != 3 {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order_by format: %s, should be <column>:<direction>", orderByParam)
-	}
-
-	column := strings.Join(parts[:len(parts)-1], ":")
-	direction := parts[len(parts)-1]
-
-	orderDirection, ok := qbtypes.OrderDirectionMap[direction]
-	if !ok {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order_by direction: %s, should be one of %s, %s", direction, qbtypes.OrderDirectionAsc, qbtypes.OrderDirectionDesc)
-	}
-
-	orderByKey := telemetrytypes.GetFieldKeyFromKeyText(column)
-
-	orderBy := []qbtypes.OrderBy{
-		{
-			Key: qbtypes.OrderByKey{
-				TelemetryFieldKey: orderByKey,
-			},
-			Direction: orderDirection,
-		},
-	}
-
-	// If we are ordering by the timestamp column, also order by the ID column
-	if orderByKey.Name == telemetrylogs.LogsV2TimestampColumn {
-		orderBy = append(orderBy, qbtypes.OrderBy{
-			Key: qbtypes.OrderByKey{
-				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-					Name: telemetrylogs.LogsV2IDColumn,
-				},
-			},
-			Direction: orderDirection,
-		})
-	}
-	return orderBy, nil
-}

pkg/modules/rawdataexport/implrawdataexport/handler_test.go

@@ -2,162 +2,84 @@ package implrawdataexport
 
 import (
 	"net/url"
-	"strconv"
 	"testing"
 
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/http/binding"
+	"github.com/SigNoz/signoz/pkg/types/exporttypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestGetExportQuerySource(t *testing.T) {
-	tests := []struct {
-		name           string
-		queryParams    url.Values
-		expectedSource string
-		expectedError  bool
-	}{
-		{
-			name:           "default logs source",
-			queryParams:    url.Values{},
-			expectedSource: "logs",
-			expectedError:  false,
-		},
-		{
-			name:           "explicit logs source",
-			queryParams:    url.Values{"source": {"logs"}},
-			expectedSource: "logs",
-			expectedError:  false,
-		},
-		{
-			name:           "metrics source - not supported",
-			queryParams:    url.Values{"source": {"metrics"}},
-			expectedSource: "metrics",
-			expectedError:  true,
-		},
-		{
-			name:           "traces source - not supported",
-			queryParams:    url.Values{"source": {"traces"}},
-			expectedSource: "traces",
-			expectedError:  true,
-		},
-		{
-			name:           "invalid source",
-			queryParams:    url.Values{"source": {"invalid"}},
-			expectedSource: "",
-			expectedError:  true,
-		},
-	}
+func TestExportRawDataFormatQueryParam_BindingDefaults(t *testing.T) {
+	var params exporttypes.ExportRawDataFormatQueryParam
+	err := binding.Query.BindQuery(url.Values{}, &params)
+	assert.NoError(t, err)
+	assert.Equal(t, "csv", params.Format)
+}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			source, err := getExportQuerySource(tt.queryParams)
-			assert.Equal(t, tt.expectedSource, source)
-			if tt.expectedError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
+func logQuery(limit int) qbtypes.QueryEnvelope {
+	return qbtypes.QueryEnvelope{
+		Type: qbtypes.QueryTypeBuilder,
+		Spec: qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{Limit: limit},
 	}
 }
 
-func TestGetExportQueryFormat(t *testing.T) {
-	tests := []struct {
-		name           string
-		queryParams    url.Values
-		expectedFormat string
-		expectedError  bool
-	}{
-		{
-			name:           "default csv format",
-			queryParams:    url.Values{},
-			expectedFormat: "csv",
-			expectedError:  false,
-		},
-		{
-			name:           "explicit csv format",
-			queryParams:    url.Values{"format": {"csv"}},
-			expectedFormat: "csv",
-			expectedError:  false,
-		},
-		{
-			name:           "jsonl format",
-			queryParams:    url.Values{"format": {"jsonl"}},
-			expectedFormat: "jsonl",
-			expectedError:  false,
-		},
-		{
-			name:           "invalid format",
-			queryParams:    url.Values{"format": {"xml"}},
-			expectedFormat: "",
-			expectedError:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			format, err := getExportQueryFormat(tt.queryParams)
-			assert.Equal(t, tt.expectedFormat, format)
-			if tt.expectedError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
+func traceQuery(limit int) qbtypes.QueryEnvelope {
+	return qbtypes.QueryEnvelope{
+		Type: qbtypes.QueryTypeBuilder,
+		Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{Limit: limit},
 	}
 }
 
-func TestGetExportQueryLimit(t *testing.T) {
+func traceOperatorQuery(limit int) qbtypes.QueryEnvelope {
+	return qbtypes.QueryEnvelope{
+		Type: qbtypes.QueryTypeTraceOperator,
+		Spec: qbtypes.QueryBuilderTraceOperator{Limit: limit, Expression: "A"},
+	}
+}
+
+func makeRequest(queries ...qbtypes.QueryEnvelope) qbtypes.QueryRangeRequest {
+	return qbtypes.QueryRangeRequest{
+		Start:          1000000000000,
+		End:            1000003600000,
+		RequestType:    qbtypes.RequestTypeRaw,
+		CompositeQuery: qbtypes.CompositeQuery{Queries: queries},
+	}
+}
+
+func TestValidateSpecForExport(t *testing.T) {
 	tests := []struct {
 		name          string
-		queryParams   url.Values
-		expectedLimit int
+		req           qbtypes.QueryRangeRequest
 		expectedError bool
 	}{
 		{
-			name:          "default limit",
-			queryParams:   url.Values{},
-			expectedLimit: DefaultExportRowCountLimit,
-			expectedError: false,
+			name: "single log query",
+			req:  makeRequest(logQuery(0)),
 		},
 		{
-			name:          "valid limit",
-			queryParams:   url.Values{"limit": {"5000"}},
-			expectedLimit: 5000,
-			expectedError: false,
+			name: "single trace query",
+			req:  makeRequest(traceQuery(0)),
 		},
 		{
-			name:          "maximum limit",
-			queryParams:   url.Values{"limit": {strconv.Itoa(MaxExportRowCountLimit)}},
-			expectedLimit: MaxExportRowCountLimit,
-			expectedError: false,
+			name: "trace operator alone",
+			req:  makeRequest(traceOperatorQuery(0)),
 		},
 		{
-			name:          "limit exceeds maximum",
-			queryParams:   url.Values{"limit": {"100000"}},
-			expectedLimit: 0,
+			name:          "multiple queries without trace operator",
+			req:           makeRequest(logQuery(0), traceQuery(0)),
 			expectedError: true,
 		},
 		{
-			name:          "invalid limit format",
-			queryParams:   url.Values{"limit": {"invalid"}},
-			expectedLimit: 0,
-			expectedError: true,
-		},
-		{
-			name:          "negative limit",
-			queryParams:   url.Values{"limit": {"-100"}},
-			expectedLimit: 0,
+			name:          "unsupported query type",
+			req:           makeRequest(qbtypes.QueryEnvelope{Type: qbtypes.QueryTypeBuilder, Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{}}),
 			expectedError: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			limit, err := getExportQueryLimit(tt.queryParams)
-			assert.Equal(t, tt.expectedLimit, limit)
+			err := validateSpecForExport(&tt.req)
 			if tt.expectedError {
 				assert.Error(t, err)
 			} else {
@@ -167,352 +89,69 @@ func TestGetExportQueryLimit(t *testing.T) {
 	}
 }
 
-func TestGetExportQueryTimeRange(t *testing.T) {
-	tests := []struct {
-		name              string
-		queryParams       url.Values
-		expectedStartTime uint64
-		expectedEndTime   uint64
-		expectedError     bool
-	}{
-		{
-			name: "valid time range",
-			queryParams: url.Values{
-				"start": {"1640995200"},
-				"end":   {"1641081600"},
-			},
-			expectedStartTime: 1640995200,
-			expectedEndTime:   1641081600,
-			expectedError:     false,
-		},
-		{
-			name:          "missing start time",
-			queryParams:   url.Values{"end": {"1641081600"}},
-			expectedError: true,
-		},
-		{
-			name:          "missing end time",
-			queryParams:   url.Values{"start": {"1640995200"}},
-			expectedError: true,
-		},
-		{
-			name:          "missing both times",
-			queryParams:   url.Values{},
-			expectedError: true,
-		},
-		{
-			name: "invalid start time format",
-			queryParams: url.Values{
-				"start": {"invalid"},
-				"end":   {"1641081600"},
-			},
-			expectedError: true,
-		},
-		{
-			name: "invalid end time format",
-			queryParams: url.Values{
-				"start": {"1640995200"},
-				"end":   {"invalid"},
-			},
-			expectedError: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			startTime, endTime, err := getExportQueryTimeRange(tt.queryParams)
-			if tt.expectedError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expectedStartTime, startTime)
-				assert.Equal(t, tt.expectedEndTime, endTime)
-			}
-		})
-	}
-}
-
-func TestGetExportQueryColumns(t *testing.T) {
-	tests := []struct {
-		name            string
-		queryParams     url.Values
-		expectedColumns []telemetrytypes.TelemetryFieldKey
-	}{
-		{
-			name:            "no columns specified",
-			queryParams:     url.Values{},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{},
-		},
-		{
-			name: "single column",
-			queryParams: url.Values{
-				"columns": {"timestamp"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-			},
-		},
-		{
-			name: "multiple columns",
-			queryParams: url.Values{
-				"columns": {"timestamp", "message", "level"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-				{Name: "message"},
-				{Name: "level"},
-			},
-		},
-		{
-			name: "empty column name (should be skipped)",
-			queryParams: url.Values{
-				"columns": {"timestamp", "", "level"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-				{Name: "level"},
-			},
-		},
-		{
-			name: "whitespace column name (should be skipped)",
-			queryParams: url.Values{
-				"columns": {"timestamp", "   ", "level"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-				{Name: "level"},
-			},
-		},
-		{
-			name: "valid column name with data type",
-			queryParams: url.Values{
-				"columns": {"timestamp", "attribute.user:string", "level"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-				{Name: "user", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
-				{Name: "level"},
-			},
-		},
-		{
-			name: "valid column name with dot notation",
-			queryParams: url.Values{
-				"columns": {"timestamp", "attribute.user.string", "level"},
-			},
-			expectedColumns: []telemetrytypes.TelemetryFieldKey{
-				{Name: "timestamp"},
-				{Name: "user.string", FieldContext: telemetrytypes.FieldContextAttribute},
-				{Name: "level"},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			columns := getExportQueryColumns(tt.queryParams)
-			assert.Equal(t, len(tt.expectedColumns), len(columns))
-			for i, expectedCol := range tt.expectedColumns {
-				assert.Equal(t, expectedCol, columns[i])
-			}
-		})
-	}
-}
-
-func TestGetExportQueryOrderBy(t *testing.T) {
+func TestValidateAndApplyDefaultExportLimits(t *testing.T) {
 	tests := []struct {
 		name          string
-		queryParams   url.Values
-		expectedOrder []qbtypes.OrderBy
+		queries       []qbtypes.QueryEnvelope
 		expectedError bool
+		checkQueries  func(t *testing.T, queries []qbtypes.QueryEnvelope)
 	}{
 		{
-			name:        "no order specified",
-			queryParams: url.Values{},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionDesc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2TimestampColumn,
-						},
-					},
-				},
-				{
-					Direction: qbtypes.OrderDirectionDesc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2IDColumn,
-						},
-					},
-				},
+			name:    "single log query, zero limit gets default",
+			queries: makeRequest(logQuery(0)).CompositeQuery.Queries,
+			checkQueries: func(t *testing.T, q []qbtypes.QueryEnvelope) {
+				assert.Equal(t, DefaultExportRowCountLimit, q[0].GetLimit())
 			},
-			expectedError: false,
 		},
 		{
-			name: "single order error, direction not specified",
-			queryParams: url.Values{
-				"order_by": {"timestamp"},
+			name:    "single log query, valid limit kept",
+			queries: makeRequest(logQuery(1000)).CompositeQuery.Queries,
+			checkQueries: func(t *testing.T, q []qbtypes.QueryEnvelope) {
+				assert.Equal(t, 1000, q[0].GetLimit())
 			},
-			expectedOrder: nil,
+		},
+		{
+			name:    "single log query, max limit kept",
+			queries: makeRequest(logQuery(MaxExportRowCountLimit)).CompositeQuery.Queries,
+			checkQueries: func(t *testing.T, q []qbtypes.QueryEnvelope) {
+				assert.Equal(t, MaxExportRowCountLimit, q[0].GetLimit())
+			},
+		},
+		{
+			name:          "single log query, limit exceeds max",
+			queries:       makeRequest(logQuery(MaxExportRowCountLimit + 1)).CompositeQuery.Queries,
 			expectedError: true,
 		},
 		{
-			name: "single order no error",
-			queryParams: url.Values{
-				"order_by": {"timestamp:asc"},
-			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2TimestampColumn,
-						},
-					},
-				},
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2IDColumn,
-						},
-					},
-				},
-			},
-			expectedError: false,
-		},
-		{
-			name: "multiple orders",
-			queryParams: url.Values{
-				"order_by": {"timestamp:asc", "body:desc", "id:asc"},
-			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2TimestampColumn,
-						},
-					},
-				},
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2IDColumn,
-						},
-					},
-				},
-			},
-			expectedError: false,
-		},
-		{
-			name: "empty order name (should be skipped)",
-			queryParams: url.Values{
-				"order_by": {"timestamp:asc", "", "id:asc"},
-			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2TimestampColumn,
-						},
-					},
-				},
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2IDColumn,
-						},
-					},
-				},
-			},
-			expectedError: false,
-		},
-		{
-			name: "whitespace order name (should be skipped)",
-			queryParams: url.Values{
-				"order_by": {"timestamp:asc", "   ", "id:asc"},
-			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2TimestampColumn,
-						},
-					},
-				},
-				{
-					Direction: qbtypes.OrderDirectionAsc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: telemetrylogs.LogsV2IDColumn,
-						},
-					},
-				},
-			},
-			expectedError: false,
-		},
-		{
-			name: "invalid order name (should error out)",
-			queryParams: url.Values{
-				"order_by": {"attributes.user:", "id:asc"},
-			},
-			expectedOrder: nil,
+			name:          "single log query, negative limit",
+			queries:       makeRequest(logQuery(-1)).CompositeQuery.Queries,
 			expectedError: true,
 		},
 		{
-			name: "valid order name (should be included)",
-			queryParams: url.Values{
-				"order_by": {"attribute.user:string:desc", "id:asc"},
+			name:    "single trace query, zero limit gets default",
+			queries: makeRequest(traceQuery(0)).CompositeQuery.Queries,
+			checkQueries: func(t *testing.T, q []qbtypes.QueryEnvelope) {
+				assert.Equal(t, DefaultExportRowCountLimit, q[0].GetLimit())
 			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionDesc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name:          "user",
-							FieldContext:  telemetrytypes.FieldContextAttribute,
-							FieldDataType: telemetrytypes.FieldDataTypeString,
-						},
-					},
-				},
-			},
-			expectedError: false,
 		},
 		{
-			name: "valid order name (should be included)",
-			queryParams: url.Values{
-				"order_by": {"attribute.user.string:desc", "id:asc"},
+			name:    "trace operator alone, zero limit gets default",
+			queries: makeRequest(traceOperatorQuery(0)).CompositeQuery.Queries,
+			checkQueries: func(t *testing.T, q []qbtypes.QueryEnvelope) {
+				assert.Equal(t, DefaultExportRowCountLimit, q[0].GetLimit())
 			},
-			expectedOrder: []qbtypes.OrderBy{
-				{
-					Direction: qbtypes.OrderDirectionDesc,
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name:         "user.string",
-							FieldContext: telemetrytypes.FieldContextAttribute,
-						},
-					},
-				},
-			},
-			expectedError: false,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			order, err := getExportQueryOrderBy(tt.queryParams)
+			err := validateAndApplyDefaultExportLimits(tt.queries)
 			if tt.expectedError {
 				assert.Error(t, err)
 			} else {
 				assert.NoError(t, err)
-				assert.Equal(t, len(tt.expectedOrder), len(order))
-				for i, expectedOrd := range tt.expectedOrder {
-					assert.Equal(t, expectedOrd, order[i])
+				if tt.checkQueries != nil {
+					tt.checkQueries(t, tt.queries)
 				}
 			}
 		})
@@ -529,13 +168,8 @@ func TestConstructCSVHeaderFromQueryResponse(t *testing.T) {
 
 	header := constructCSVHeaderFromQueryResponse(data)
 
-	// Since map iteration order is not guaranteed, check that all expected keys are present
-	expectedKeys := []string{"timestamp", "message", "level", "id"}
-	assert.Equal(t, len(expectedKeys), len(header))
-
-	for _, key := range expectedKeys {
-		assert.Contains(t, header, key)
-	}
+	// Priority columns come first in order, then the rest alphabetically.
+	assert.Equal(t, []string{"timestamp", "id", "level", "message"}, header)
 }
 
 func TestConstructCSVRecordFromQueryResponse(t *testing.T) {

pkg/modules/rawdataexport/implrawdataexport/module.go

@@ -28,8 +28,18 @@ func (m *Module) ExportRawData(ctx context.Context, orgID valuer.UUID, rangeRequ
 		instrumentationtypes.CodeFunctionName: "ExportRawData",
 	})
 
-	spec := rangeRequest.CompositeQuery.Queries[0].Spec.(qbtypes.QueryBuilderQuery[qbtypes.LogAggregation])
-	rowCountLimit := spec.Limit
+	traceOperatorQueryIndex := rangeRequest.TraceOperatorQueryIndex()
+
+	queries := rangeRequest.CompositeQuery.Queries
+
+	// If the trace operator query is present, mark the queries other than trace operator as disabled
+	if traceOperatorQueryIndex > -1 {
+		for idx := range len(queries) {
+			if idx != traceOperatorQueryIndex {
+				queries[idx].SetDisabled(true)
+			}
+		}
+	}
 
 	rowChan := make(chan *qbtypes.RawRow, 1)
 	errChan := make(chan error, 1)
@@ -43,52 +53,62 @@ func (m *Module) ExportRawData(ctx context.Context, orgID valuer.UUID, rangeRequ
 		defer close(errChan)
 		defer close(rowChan)
 
-		rowCount := 0
-
-		for rowCount < rowCountLimit {
-			spec.Limit = min(ChunkSize, rowCountLimit-rowCount)
-			spec.Offset = rowCount
-
-			rangeRequest.CompositeQuery.Queries[0].Spec = spec
-
-			response, err := m.querier.QueryRange(contextWithTimeout, orgID, rangeRequest)
-			if err != nil {
-				errChan <- err
-				return
-			}
-
-			newRowsCount := 0
-			for _, result := range response.Data.Results {
-				resultData, ok := result.(*qbtypes.RawData)
-				if !ok {
-					errChan <- errors.NewInternalf(errors.CodeInternal, "expected RawData, got %T", result)
-					return
-				}
-
-				newRowsCount += len(resultData.Rows)
-				for _, row := range resultData.Rows {
-					select {
-					case rowChan <- row:
-					case <-doneChan:
-						return
-					case <-ctx.Done():
-						errChan <- ctx.Err()
-						return
-					}
-				}
-
-			}
-
-			// Break if we did not receive any new rows
-			if newRowsCount == 0 {
-				return
-			}
-
-			rowCount += newRowsCount
-
+		if traceOperatorQueryIndex > -1 {
+			// If the trace operator query is present, we need to export the data for the trace operator query only
+			exportRawDataForSingleQuery(m.querier, contextWithTimeout, orgID, rangeRequest, rowChan, errChan, doneChan, traceOperatorQueryIndex)
+		} else {
+			// If the trace operator query is not present, we need to export the data for the first query only
+			exportRawDataForSingleQuery(m.querier, contextWithTimeout, orgID, rangeRequest, rowChan, errChan, doneChan, 0)
 		}
 	}()
 
 	return rowChan, errChan
 
 }
+
+func exportRawDataForSingleQuery(querier querier.Querier, ctx context.Context, orgID valuer.UUID, rangeRequest *qbtypes.QueryRangeRequest, rowChan chan *qbtypes.RawRow, errChan chan error, doneChan chan any, queryIndex int) {
+
+	queries := rangeRequest.CompositeQuery.Queries
+	rowCountLimit := queries[queryIndex].GetLimit()
+	rowCount := 0
+
+	for rowCount < rowCountLimit {
+		chunkSize := min(ChunkSize, rowCountLimit-rowCount)
+		queries[queryIndex].SetLimit(chunkSize)
+		queries[queryIndex].SetOffset(rowCount)
+
+		response, err := querier.QueryRange(ctx, orgID, rangeRequest)
+		if err != nil {
+			errChan <- err
+			return
+		}
+
+		newRowsCount := 0
+		for _, result := range response.Data.Results {
+			resultData, ok := result.(*qbtypes.RawData)
+			if !ok {
+				errChan <- errors.NewInternalf(errors.CodeInternal, "expected RawData, got %T", result)
+				return
+			}
+
+			newRowsCount += len(resultData.Rows)
+			for _, row := range resultData.Rows {
+				select {
+				case rowChan <- row:
+				case <-doneChan:
+					return
+				case <-ctx.Done():
+					errChan <- ctx.Err()
+					return
+				}
+			}
+		}
+
+		rowCount += newRowsCount
+
+		// Stop if we received fewer rows than requested — no more data available
+		if newRowsCount < chunkSize {
+			return
+		}
+	}
+}

pkg/modules/user/impluser/service.go

@@ -23,6 +23,7 @@ type service struct {
 	authz     authz.AuthZ
 	config    user.RootConfig
 	stopC     chan struct{}
+	healthyC  chan struct{}
 }
 
 func NewService(
@@ -42,12 +43,14 @@ func NewService(
 		orgGetter: orgGetter,
 		authz:     authz,
 		config:    config,
-		stopC:     make(chan struct{}),
+		stopC:    make(chan struct{}),
+		healthyC: make(chan struct{}),
 	}
 }
 
 func (s *service) Start(ctx context.Context) error {
 	if !s.config.Enabled {
+		close(s.healthyC)
 		<-s.stopC
 		return nil
 	}
@@ -59,6 +62,7 @@ func (s *service) Start(ctx context.Context) error {
 		err := s.reconcile(ctx)
 		if err == nil {
 			s.settings.Logger().InfoContext(ctx, "root user reconciliation completed successfully")
+			close(s.healthyC)
 			<-s.stopC
 			return nil
 		}
@@ -74,6 +78,10 @@ func (s *service) Start(ctx context.Context) error {
 	}
 }
 
+func (s *service) Healthy() <-chan struct{} {
+	return s.healthyC
+}
+
 func (s *service) Stop(ctx context.Context) error {
 	close(s.stopC)
 	return nil

pkg/modules/user/service.go

@@ -3,5 +3,5 @@ package user
 import "github.com/SigNoz/signoz/pkg/factory"
 
 type Service interface {
-	factory.Service
+	factory.ServiceWithHealthy
 }

pkg/query-service/app/http_handler.go

@@ -576,9 +576,6 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 		aH.LicensingAPI.Activate(rw, req)
 	})).Methods(http.MethodGet)
 
-	// Export
-	router.HandleFunc("/api/v1/export_raw_data", am.ViewAccess(aH.Signoz.Handlers.RawDataExport.ExportRawData)).Methods(http.MethodGet)
-
 	router.HandleFunc("/api/v1/span_percentile", am.ViewAccess(aH.Signoz.Handlers.SpanPercentile.GetSpanPercentileDetails)).Methods(http.MethodPost)
 
 	// Query Filter Analyzer api used to extract metric names and grouping columns from a query

pkg/query-service/app/logparsingpipeline/controller.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"maps"
 	"slices"
 	"strings"
 
@@ -12,6 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
@@ -34,19 +36,101 @@ type LogParsingPipelineController struct {
 	Repo
 
 	GetIntegrationPipelines func(context.Context, string) ([]pipelinetypes.GettablePipeline, error)
+	// TODO(Piyush): remove with qbv5 migration
+	reader interfaces.Reader
 }
 
 func NewLogParsingPipelinesController(
 	sqlStore sqlstore.SQLStore,
 	getIntegrationPipelines func(context.Context, string) ([]pipelinetypes.GettablePipeline, error),
+	reader interfaces.Reader,
 ) (*LogParsingPipelineController, error) {
 	repo := NewRepo(sqlStore)
 	return &LogParsingPipelineController{
 		Repo:                    repo,
 		GetIntegrationPipelines: getIntegrationPipelines,
+		reader:                  reader,
 	}, nil
 }
 
+// enrichPipelinesFilters resolves the type (tag vs resource) for filter keys that are
+// missing type info, by looking them up in the store.
+//
+// TODO(Piyush): remove with qbv5 migration
+func (pc *LogParsingPipelineController) enrichPipelinesFilters(
+	ctx context.Context, pipelines []pipelinetypes.GettablePipeline,
+) ([]pipelinetypes.GettablePipeline, error) {
+	// Collect names of non-static keys that are missing type info.
+	// Static fields (body, trace_id, etc.) are intentionally Unspecified and map
+	// to top-level OTEL fields — they do not need enrichment.
+	unspecifiedNames := map[string]bool{}
+	for _, p := range pipelines {
+		if p.Filter != nil {
+			for _, item := range p.Filter.Items {
+				if item.Key.Type == v3.AttributeKeyTypeUnspecified {
+					// Skip static fields
+					if _, isStatic := constants.StaticFieldsLogsV3[item.Key.Key]; isStatic {
+						continue
+					}
+					// Skip enrich body.* fields
+					if strings.HasPrefix(item.Key.Key, "body.") {
+						continue
+					}
+					unspecifiedNames[item.Key.Key] = true
+				}
+			}
+		}
+	}
+	if len(unspecifiedNames) == 0 {
+		return pipelines, nil
+	}
+
+	logFields, apiErr := pc.reader.GetLogFieldsFromNames(ctx, slices.Collect(maps.Keys(unspecifiedNames)))
+	if apiErr != nil {
+		slog.ErrorContext(ctx, "failed to fetch log fields for pipeline filter enrichment", "error", apiErr)
+		return pipelines, apiErr
+	}
+
+	// Build a simple name → AttributeKeyType map from the response.
+	fieldTypes := map[string]v3.AttributeKeyType{}
+	for _, f := range append(logFields.Selected, logFields.Interesting...) {
+		switch f.Type {
+		case constants.Resources:
+			fieldTypes[f.Name] = v3.AttributeKeyTypeResource
+		case constants.Attributes:
+			fieldTypes[f.Name] = v3.AttributeKeyTypeTag
+		}
+	}
+
+	// Set the resolved type on each untyped filter key in-place.
+	for i := range pipelines {
+		if pipelines[i].Filter != nil {
+			for j := range pipelines[i].Filter.Items {
+				key := &pipelines[i].Filter.Items[j].Key
+				if key.Type == v3.AttributeKeyTypeUnspecified {
+					// Skip static fields
+					if _, isStatic := constants.StaticFieldsLogsV3[key.Key]; isStatic {
+						continue
+					}
+					// Skip enrich body.* fields
+					if strings.HasPrefix(key.Key, "body.") {
+						continue
+					}
+
+					if t, ok := fieldTypes[key.Key]; ok {
+						key.Type = t
+					} else {
+						// default to attribute
+						key.Type = v3.AttributeKeyTypeTag
+					}
+				}
+			}
+		}
+	}
+
+	return pipelines, nil
+}
+
 // PipelinesResponse is used to prepare http response for pipelines config related requests
 type PipelinesResponse struct {
 	*opamptypes.AgentConfigVersion
@@ -256,7 +340,12 @@ func (ic *LogParsingPipelineController) PreviewLogsPipelines(
 	ctx context.Context,
 	request *PipelinesPreviewRequest,
 ) (*PipelinesPreviewResponse, error) {
-	result, collectorLogs, err := SimulatePipelinesProcessing(ctx, request.Pipelines, request.Logs)
+	pipelines, err := ic.enrichPipelinesFilters(ctx, request.Pipelines)
+	if err != nil {
+		return nil, err
+	}
+
+	result, collectorLogs, err := SimulatePipelinesProcessing(ctx, pipelines, request.Logs)
 	if err != nil {
 		return nil, err
 	}
@@ -293,10 +382,8 @@ func (pc *LogParsingPipelineController) RecommendAgentConfig(
 	if configVersion != nil {
 		pipelinesVersion = configVersion.Version
 	}
-
-	pipelinesResp, err := pc.GetPipelinesByVersion(
-		context.Background(), orgId, pipelinesVersion,
-	)
+	ctx := context.Background()
+	pipelinesResp, err := pc.GetPipelinesByVersion(ctx, orgId, pipelinesVersion)
 	if err != nil {
 		return nil, "", err
 	}
@@ -306,12 +393,17 @@ func (pc *LogParsingPipelineController) RecommendAgentConfig(
 		return nil, "", errors.WrapInternalf(err, CodeRawPipelinesMarshalFailed, "could not serialize pipelines to JSON")
 	}
 
-	if querybuilder.BodyJSONQueryEnabled {
-		// add default normalize pipeline at the beginning, only for sending to collector
-		pipelinesResp.Pipelines = append([]pipelinetypes.GettablePipeline{pc.getNormalizePipeline()}, pipelinesResp.Pipelines...)
+	enrichedPipelines, err := pc.enrichPipelinesFilters(ctx, pipelinesResp.Pipelines)
+	if err != nil {
+		return nil, "", err
 	}
 
-	updatedConf, err := GenerateCollectorConfigWithPipelines(currentConfYaml, pipelinesResp.Pipelines)
+	if querybuilder.BodyJSONQueryEnabled {
+		// add default normalize pipeline at the beginning, only for sending to collector
+		enrichedPipelines = append([]pipelinetypes.GettablePipeline{pc.getNormalizePipeline()}, enrichedPipelines...)
+	}
+
+	updatedConf, err := GenerateCollectorConfigWithPipelines(currentConfYaml, enrichedPipelines)
 	if err != nil {
 		return nil, "", err
 	}

pkg/query-service/app/server.go

@@ -121,6 +121,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
 		signoz.SQLStore,
 		integrationsController.GetPipelinesForInstalledIntegrations,
+		reader,
 	)
 	if err != nil {
 		return nil, err

pkg/signoz/handler.go

@@ -55,6 +55,7 @@ type Handlers struct {
 	ZeusHandler           zeus.Handler
 	QuerierHandler        querier.Handler
 	ServiceAccountHandler serviceaccount.Handler
+	RegistryHandler       factory.Handler
 }
 
 func NewHandlers(
@@ -69,6 +70,7 @@ func NewHandlers(
 	telemetryMetadataStore telemetrytypes.MetadataStore,
 	authz authz.AuthZ,
 	zeusService zeus.Zeus,
+	registryHandler factory.Handler,
 ) Handlers {
 	return Handlers{
 		SavedView:             implsavedview.NewHandler(modules.SavedView),
@@ -88,5 +90,6 @@ func NewHandlers(
 		ZeusHandler:           zeus.NewHandler(zeusService, licensing),
 		QuerierHandler:        querierHandler,
 		ServiceAccountHandler: implserviceaccount.NewHandler(modules.ServiceAccount),
+		RegistryHandler:       registryHandler,
 	}
 }

pkg/signoz/handler_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/emailing/emailingtest"
+	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/factory/factorytest"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
@@ -55,7 +56,8 @@ func TestNewHandlers(t *testing.T) {
 	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, userGetter, userRoleStore)
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
-	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil)
+	registryHandler := factory.NewHandler(nil)
+	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler)
 	reflectVal := reflect.ValueOf(handlers)
 	for i := 0; i < reflectVal.NumField(); i++ {
 		f := reflectVal.Field(i)

pkg/signoz/openapi.go

@@ -10,6 +10,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
 	"github.com/SigNoz/signoz/pkg/authz"
+	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/global"
@@ -22,6 +23,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
@@ -58,9 +60,11 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ gateway.Handler }{},
 		struct{ fields.Handler }{},
 		struct{ authz.Handler }{},
+		struct{ rawdataexport.Handler }{},
 		struct{ zeus.Handler }{},
 		struct{ querier.Handler }{},
 		struct{ serviceaccount.Handler }{},
+		struct{ factory.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -274,9 +274,11 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.GatewayHandler,
 			handlers.Fields,
 			handlers.AuthzHandler,
+			handlers.RawDataExport,
 			handlers.ZeusHandler,
 			handlers.QuerierHandler,
 			handlers.ServiceAccountHandler,
+			handlers.RegistryHandler,
 		),
 	)
 }

pkg/signoz/signoz.go

@@ -422,21 +422,6 @@ func New(
 	// Initialize the querier handler via callback (allows EE to decorate with anomaly detection)
 	querierHandler := querierHandlerCallback(providerSettings, querier, analytics)
 
-	// Initialize all handlers for the modules
-	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus)
-
-	// Initialize the API server
-	apiserver, err := factory.NewProviderFromNamedMap(
-		ctx,
-		providerSettings,
-		config.APIServer,
-		NewAPIServerProviderFactories(orgGetter, authz, modules, handlers),
-		"signoz",
-	)
-	if err != nil {
-		return nil, err
-	}
-
 	// Create a list of all stats collectors
 	statsCollectors := []statsreporter.StatsCollector{
 		alertmanager,
@@ -463,6 +448,7 @@ func New(
 	}
 
 	registry, err := factory.NewRegistry(
+		ctx,
 		instrumentation.Logger(),
 		factory.NewNamedService(factory.MustNewName("instrumentation"), instrumentation),
 		factory.NewNamedService(factory.MustNewName("pprof"), pprofService),
@@ -472,7 +458,23 @@ func New(
 		factory.NewNamedService(factory.MustNewName("statsreporter"), statsReporter),
 		factory.NewNamedService(factory.MustNewName("tokenizer"), tokenizer),
 		factory.NewNamedService(factory.MustNewName("authz"), authz),
-		factory.NewNamedService(factory.MustNewName("user"), userService),
+		factory.NewNamedService(factory.MustNewName("user"), userService, factory.MustNewName("authz")),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize all handlers for the modules
+	registryHandler := factory.NewHandler(registry)
+	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler)
+
+	// Initialize the API server (after registry so it can access service health)
+	apiserverInstance, err := factory.NewProviderFromNamedMap(
+		ctx,
+		providerSettings,
+		config.APIServer,
+		NewAPIServerProviderFactories(orgGetter, authz, modules, handlers),
+		"signoz",
 	)
 	if err != nil {
 		return nil, err
@@ -490,7 +492,7 @@ func New(
 		Prometheus:             prometheus,
 		Alertmanager:           alertmanager,
 		Querier:                querier,
-		APIServer:              apiserver,
+		APIServer:              apiserverInstance,
 		Zeus:                   zeus,
 		Licensing:              licensing,
 		Emailing:               emailing,

pkg/types/exporttypes/rawdataexport.go

@@ -0,0 +1,6 @@
+package exporttypes
+
+type ExportRawDataFormatQueryParam struct {
+	// Format specifies the output format: "csv" or "jsonl"
+	Format string `query:"format,default=csv" default:"csv" enum:"csv,jsonl" description:"The output format for the export."`
+}

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -393,6 +393,77 @@ func (r *QueryRangeRequest) HasOrderSpecified() bool {
 	return false
 }
 
+// UseDefaultOrderBy applies UseDefaultOrderByForListQuery to every query in the
+// composite query when the request type is a list query (raw, raw_stream, trace).
+func (r *QueryRangeRequest) UseDefaultOrderBy() {
+
+	// Based on the request type, handle default order-bys
+	switch r.RequestType {
+	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace:
+		for idx := range r.CompositeQuery.Queries {
+			r.CompositeQuery.Queries[idx].UseDefaultOrderByForListQuery()
+		}
+	}
+
+}
+
+// UseDefaultOrderByForListQuery applies a default timestamp-descending order
+// for list/raw queries when no explicit order is specified. This is intended
+// for raw data listing endpoints (e.g. export, list views) where a sensible
+// default sort is needed, not for aggregation or timeseries queries.
+func (q *QueryEnvelope) UseDefaultOrderByForListQuery() {
+	if len(q.GetOrder()) > 0 {
+		return
+	}
+
+	switch q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation],
+		QueryBuilderTraceOperator:
+		q.SetOrder(
+			[]OrderBy{
+				{
+					Key: OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name:          "timestamp",
+							Signal:        telemetrytypes.SignalTraces,
+							FieldContext:  telemetrytypes.FieldContextSpan,
+							FieldDataType: telemetrytypes.FieldDataTypeNumber,
+						},
+					},
+					Direction: OrderDirectionDesc,
+				},
+			},
+		)
+	case QueryBuilderQuery[LogAggregation]:
+		q.SetOrder(
+			[]OrderBy{
+				{
+					Key: OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name:          "timestamp",
+							Signal:        telemetrytypes.SignalLogs,
+							FieldContext:  telemetrytypes.FieldContextLog,
+							FieldDataType: telemetrytypes.FieldDataTypeNumber,
+						},
+					},
+					Direction: OrderDirectionDesc,
+				},
+				{
+					Key: OrderByKey{
+						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+							Name:          "id",
+							Signal:        telemetrytypes.SignalLogs,
+							FieldContext:  telemetrytypes.FieldContextLog,
+							FieldDataType: telemetrytypes.FieldDataTypeString,
+						},
+					},
+					Direction: OrderDirectionDesc,
+				},
+			},
+		)
+	}
+}
+
 func (r *QueryRangeRequest) FuncsForQuery(name string) []Function {
 	funcs := []Function{}
 	for _, query := range r.CompositeQuery.Queries {
@@ -437,6 +508,16 @@ func (r *QueryRangeRequest) IsAnomalyRequest() (*QueryBuilderQuery[MetricAggrega
 	return &q, hasAnomaly
 }
 
+func (r *QueryRangeRequest) TraceOperatorQueryIndex() int {
+	for idx, query := range r.CompositeQuery.Queries {
+		switch query.Spec.(type) {
+		case QueryBuilderTraceOperator:
+			return idx
+		}
+	}
+	return -1
+}
+
 // We do not support fill gaps for these queries. Maybe support in future?
 func (r *QueryRangeRequest) SkipFillGaps(name string) bool {
 	for _, query := range r.CompositeQuery.Queries {

pkg/types/querybuildertypes/querybuildertypesv5/req_getters.go

@@ -0,0 +1,379 @@
+package querybuildertypesv5
+
+import "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+
+// GetExpression returns the expression string.
+func (q *QueryEnvelope) GetExpression() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Expression
+	case QueryBuilderFormula:
+		return spec.Expression
+	}
+	return ""
+}
+
+// GetReturnSpansFrom returns the return-spans-from value.
+func (q *QueryEnvelope) GetReturnSpansFrom() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.ReturnSpansFrom
+	}
+	return ""
+}
+
+// GetSignal returns the signal.
+func (q *QueryEnvelope) GetSignal() telemetrytypes.Signal {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Signal
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Signal
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Signal
+	}
+	return telemetrytypes.SignalUnspecified
+}
+
+// GetSource returns the source.
+func (q *QueryEnvelope) GetSource() telemetrytypes.Source {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Source
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Source
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Source
+	}
+	return telemetrytypes.SourceUnspecified
+}
+
+// GetQuery returns the raw query string.
+func (q *QueryEnvelope) GetQuery() string {
+	switch spec := q.Spec.(type) {
+	case PromQuery:
+		return spec.Query
+	case ClickHouseQuery:
+		return spec.Query
+	}
+	return ""
+}
+
+// GetStats returns the PromQL stats flag.
+func (q *QueryEnvelope) GetStats() bool {
+	switch spec := q.Spec.(type) {
+	case PromQuery:
+		return spec.Stats
+	}
+	return false
+}
+
+// GetLeft returns the left query reference of a join.
+func (q *QueryEnvelope) GetLeft() QueryRef {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		return spec.Left
+	}
+	return QueryRef{}
+}
+
+// GetRight returns the right query reference of a join.
+func (q *QueryEnvelope) GetRight() QueryRef {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		return spec.Right
+	}
+	return QueryRef{}
+}
+
+// GetJoinType returns the join type.
+func (q *QueryEnvelope) GetJoinType() JoinType {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		return spec.Type
+	}
+	return JoinType{}
+}
+
+// GetOn returns the join ON condition.
+func (q *QueryEnvelope) GetOn() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		return spec.On
+	}
+	return ""
+}
+
+// GetQueryName returns the name of the spec.
+func (q *QueryEnvelope) GetQueryName() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Name
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Name
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Name
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Name
+	case QueryBuilderFormula:
+		return spec.Name
+	case QueryBuilderJoin:
+		return spec.Name
+	case PromQuery:
+		return spec.Name
+	case ClickHouseQuery:
+		return spec.Name
+	}
+	return ""
+}
+
+// IsDisabled returns whether the spec is disabled.
+func (q *QueryEnvelope) IsDisabled() bool {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Disabled
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Disabled
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Disabled
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Disabled
+	case QueryBuilderFormula:
+		return spec.Disabled
+	case QueryBuilderJoin:
+		return spec.Disabled
+	case PromQuery:
+		return spec.Disabled
+	case ClickHouseQuery:
+		return spec.Disabled
+	}
+	return false
+}
+
+// GetLimit returns the row limit.
+func (q *QueryEnvelope) GetLimit() int {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Limit
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Limit
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Limit
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Limit
+	case QueryBuilderFormula:
+		return spec.Limit
+	case QueryBuilderJoin:
+		return spec.Limit
+	}
+	return 0
+}
+
+// GetOffset returns the row offset.
+func (q *QueryEnvelope) GetOffset() int {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Offset
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Offset
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Offset
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Offset
+	}
+	return 0
+}
+
+// GetType returns the QueryType of the envelope.
+func (q *QueryEnvelope) GetType() QueryType {
+	return q.Type
+}
+
+// GetOrder returns the order-by clauses.
+func (q *QueryEnvelope) GetOrder() []OrderBy {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Order
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Order
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Order
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Order
+	case QueryBuilderFormula:
+		return spec.Order
+	case QueryBuilderJoin:
+		return spec.Order
+	}
+	return nil
+}
+
+// GetGroupBy returns the group-by keys.
+func (q *QueryEnvelope) GetGroupBy() []GroupByKey {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.GroupBy
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.GroupBy
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.GroupBy
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.GroupBy
+	case QueryBuilderJoin:
+		return spec.GroupBy
+	}
+	return nil
+}
+
+// GetFilter returns the filter.
+func (q *QueryEnvelope) GetFilter() *Filter {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Filter
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Filter
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Filter
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Filter
+	case QueryBuilderJoin:
+		return spec.Filter
+	}
+	return nil
+}
+
+// GetHaving returns the having clause.
+func (q *QueryEnvelope) GetHaving() *Having {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Having
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Having
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Having
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Having
+	case QueryBuilderFormula:
+		return spec.Having
+	case QueryBuilderJoin:
+		return spec.Having
+	}
+	return nil
+}
+
+// GetFunctions returns the post-processing functions.
+func (q *QueryEnvelope) GetFunctions() []Function {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Functions
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Functions
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Functions
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Functions
+	case QueryBuilderFormula:
+		return spec.Functions
+	case QueryBuilderJoin:
+		return spec.Functions
+	}
+	return nil
+}
+
+// GetSelectFields returns the selected fields.
+func (q *QueryEnvelope) GetSelectFields() []telemetrytypes.TelemetryFieldKey {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.SelectFields
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.SelectFields
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.SelectFields
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.SelectFields
+	case QueryBuilderJoin:
+		return spec.SelectFields
+	}
+	return nil
+}
+
+// GetLegend returns the legend label.
+func (q *QueryEnvelope) GetLegend() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Legend
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Legend
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Legend
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Legend
+	case QueryBuilderFormula:
+		return spec.Legend
+	case PromQuery:
+		return spec.Legend
+	case ClickHouseQuery:
+		return spec.Legend
+	}
+	return ""
+}
+
+// GetCursor returns the pagination cursor.
+func (q *QueryEnvelope) GetCursor() string {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.Cursor
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.Cursor
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.Cursor
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.Cursor
+	}
+	return ""
+}
+
+// GetStepInterval returns the step interval.
+func (q *QueryEnvelope) GetStepInterval() Step {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		return spec.StepInterval
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.StepInterval
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.StepInterval
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.StepInterval
+	case PromQuery:
+		return spec.Step
+	}
+	return Step{}
+}
+
+// GetSecondaryAggregations returns the secondary aggregations.
+func (q *QueryEnvelope) GetSecondaryAggregations() []SecondaryAggregation {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.SecondaryAggregations
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.SecondaryAggregations
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.SecondaryAggregations
+	case QueryBuilderJoin:
+		return spec.SecondaryAggregations
+	}
+	return nil
+}
+
+// GetLimitBy returns the limit-by configuration.
+func (q *QueryEnvelope) GetLimitBy() *LimitBy {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		return spec.LimitBy
+	case QueryBuilderQuery[LogAggregation]:
+		return spec.LimitBy
+	case QueryBuilderQuery[MetricAggregation]:
+		return spec.LimitBy
+	}
+	return nil
+}

pkg/types/querybuildertypes/querybuildertypesv5/req_setters.go

@@ -0,0 +1,452 @@
+package querybuildertypesv5
+
+import "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+
+// SetExpression sets the expression string of the spec, if applicable.
+func (q *QueryEnvelope) SetExpression(expression string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Expression = expression
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Expression = expression
+		q.Spec = spec
+	}
+}
+
+// SetReturnSpansFrom sets the return-spans-from value, if applicable.
+func (q *QueryEnvelope) SetReturnSpansFrom(returnSpansFrom string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.ReturnSpansFrom = returnSpansFrom
+		q.Spec = spec
+	}
+}
+
+// SetSignal sets the signal of the spec, if applicable.
+func (q *QueryEnvelope) SetSignal(signal telemetrytypes.Signal) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Signal = signal
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Signal = signal
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Signal = signal
+		q.Spec = spec
+	}
+}
+
+// SetSource sets the source of the spec, if applicable.
+func (q *QueryEnvelope) SetSource(source telemetrytypes.Source) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Source = source
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Source = source
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Source = source
+		q.Spec = spec
+	}
+}
+
+// SetQuery sets the raw query string of the spec, if applicable.
+func (q *QueryEnvelope) SetQuery(query string) {
+	switch spec := q.Spec.(type) {
+	case PromQuery:
+		spec.Query = query
+		q.Spec = spec
+	case ClickHouseQuery:
+		spec.Query = query
+		q.Spec = spec
+	}
+}
+
+// SetStats sets the PromQL stats flag, if applicable.
+func (q *QueryEnvelope) SetStats(stats bool) {
+	switch spec := q.Spec.(type) {
+	case PromQuery:
+		spec.Stats = stats
+		q.Spec = spec
+	}
+}
+
+// SetLeft sets the left query reference of a join, if applicable.
+func (q *QueryEnvelope) SetLeft(left QueryRef) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		spec.Left = left
+		q.Spec = spec
+	}
+}
+
+// SetRight sets the right query reference of a join, if applicable.
+func (q *QueryEnvelope) SetRight(right QueryRef) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		spec.Right = right
+		q.Spec = spec
+	}
+}
+
+// SetJoinType sets the join type, if applicable.
+func (q *QueryEnvelope) SetJoinType(joinType JoinType) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		spec.Type = joinType
+		q.Spec = spec
+	}
+}
+
+// SetOn sets the join ON condition, if applicable.
+func (q *QueryEnvelope) SetOn(on string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderJoin:
+		spec.On = on
+		q.Spec = spec
+	}
+}
+
+// SetQueryName sets the name of the spec, if applicable.
+func (q *QueryEnvelope) SetQueryName(name string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Name = name
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Name = name
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Name = name
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Name = name
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Name = name
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Name = name
+		q.Spec = spec
+	case PromQuery:
+		spec.Name = name
+		q.Spec = spec
+	case ClickHouseQuery:
+		spec.Name = name
+		q.Spec = spec
+	}
+}
+
+// SetDisabled sets the disabled flag of the spec, if applicable.
+func (q *QueryEnvelope) SetDisabled(disabled bool) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case PromQuery:
+		spec.Disabled = disabled
+		q.Spec = spec
+	case ClickHouseQuery:
+		spec.Disabled = disabled
+		q.Spec = spec
+	}
+}
+
+// SetLimit sets the row limit of the spec, if applicable.
+func (q *QueryEnvelope) SetLimit(limit int) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Limit = limit
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Limit = limit
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Limit = limit
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Limit = limit
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Limit = limit
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Limit = limit
+		q.Spec = spec
+	}
+}
+
+// SetOffset sets the row offset of the spec, if applicable.
+func (q *QueryEnvelope) SetOffset(offset int) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Offset = offset
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Offset = offset
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Offset = offset
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Offset = offset
+		q.Spec = spec
+	}
+}
+
+// SetType sets the QueryType of the envelope.
+func (q *QueryEnvelope) SetType(t QueryType) {
+	q.Type = t
+}
+
+// SetOrder sets the order-by clauses of the spec, if applicable.
+func (q *QueryEnvelope) SetOrder(order []OrderBy) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Order = order
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Order = order
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Order = order
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Order = order
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Order = order
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Order = order
+		q.Spec = spec
+	}
+}
+
+// SetGroupBy sets the group-by keys of the spec, if applicable.
+func (q *QueryEnvelope) SetGroupBy(groupBy []GroupByKey) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.GroupBy = groupBy
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.GroupBy = groupBy
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.GroupBy = groupBy
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.GroupBy = groupBy
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.GroupBy = groupBy
+		q.Spec = spec
+	}
+}
+
+// SetFilter sets the filter of the spec, if applicable.
+func (q *QueryEnvelope) SetFilter(filter *Filter) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Filter = filter
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Filter = filter
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Filter = filter
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Filter = filter
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Filter = filter
+		q.Spec = spec
+	}
+}
+
+// SetHaving sets the having clause of the spec, if applicable.
+func (q *QueryEnvelope) SetHaving(having *Having) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Having = having
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Having = having
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Having = having
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Having = having
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Having = having
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Having = having
+		q.Spec = spec
+	}
+}
+
+// SetFunctions sets the post-processing functions of the spec, if applicable.
+func (q *QueryEnvelope) SetFunctions(functions []Function) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Functions = functions
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Functions = functions
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Functions = functions
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Functions = functions
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Functions = functions
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.Functions = functions
+		q.Spec = spec
+	}
+}
+
+// SetSelectFields sets the selected fields of the spec, if applicable.
+func (q *QueryEnvelope) SetSelectFields(fields []telemetrytypes.TelemetryFieldKey) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.SelectFields = fields
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.SelectFields = fields
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.SelectFields = fields
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.SelectFields = fields
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.SelectFields = fields
+		q.Spec = spec
+	}
+}
+
+// SetLegend sets the legend label of the spec, if applicable.
+func (q *QueryEnvelope) SetLegend(legend string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Legend = legend
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Legend = legend
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Legend = legend
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Legend = legend
+		q.Spec = spec
+	case QueryBuilderFormula:
+		spec.Legend = legend
+		q.Spec = spec
+	case PromQuery:
+		spec.Legend = legend
+		q.Spec = spec
+	case ClickHouseQuery:
+		spec.Legend = legend
+		q.Spec = spec
+	}
+}
+
+// SetCursor sets the pagination cursor of the spec, if applicable.
+func (q *QueryEnvelope) SetCursor(cursor string) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.Cursor = cursor
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.Cursor = cursor
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.Cursor = cursor
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.Cursor = cursor
+		q.Spec = spec
+	}
+}
+
+// SetStepInterval sets the step interval of the spec, if applicable.
+func (q *QueryEnvelope) SetStepInterval(step Step) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderTraceOperator:
+		spec.StepInterval = step
+		q.Spec = spec
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.StepInterval = step
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.StepInterval = step
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.StepInterval = step
+		q.Spec = spec
+	case PromQuery:
+		spec.Step = step
+		q.Spec = spec
+	}
+}
+
+// SetSecondaryAggregations sets the secondary aggregations of the spec, if applicable.
+func (q *QueryEnvelope) SetSecondaryAggregations(secondaryAggregations []SecondaryAggregation) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.SecondaryAggregations = secondaryAggregations
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.SecondaryAggregations = secondaryAggregations
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.SecondaryAggregations = secondaryAggregations
+		q.Spec = spec
+	case QueryBuilderJoin:
+		spec.SecondaryAggregations = secondaryAggregations
+		q.Spec = spec
+	}
+}
+
+// SetLimitBy sets the limit-by configuration of the spec, if applicable.
+func (q *QueryEnvelope) SetLimitBy(limitBy *LimitBy) {
+	switch spec := q.Spec.(type) {
+	case QueryBuilderQuery[TraceAggregation]:
+		spec.LimitBy = limitBy
+		q.Spec = spec
+	case QueryBuilderQuery[LogAggregation]:
+		spec.LimitBy = limitBy
+		q.Spec = spec
+	case QueryBuilderQuery[MetricAggregation]:
+		spec.LimitBy = limitBy
+		q.Spec = spec
+	}
+}

pkg/types/querybuildertypes/querybuildertypesv5/validation.go

@@ -10,55 +10,9 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
-// queryName returns the name from any query envelope spec type.
-func (e QueryEnvelope) queryName() string {
-	switch spec := e.Spec.(type) {
-	case QueryBuilderQuery[TraceAggregation]:
-		return spec.Name
-	case QueryBuilderQuery[LogAggregation]:
-		return spec.Name
-	case QueryBuilderQuery[MetricAggregation]:
-		return spec.Name
-	case QueryBuilderFormula:
-		return spec.Name
-	case QueryBuilderTraceOperator:
-		return spec.Name
-	case QueryBuilderJoin:
-		return spec.Name
-	case PromQuery:
-		return spec.Name
-	case ClickHouseQuery:
-		return spec.Name
-	}
-	return ""
-}
-
-// isDisabled returns the disabled status from any query envelope spec type.
-func (e QueryEnvelope) isDisabled() bool {
-	switch spec := e.Spec.(type) {
-	case QueryBuilderQuery[TraceAggregation]:
-		return spec.Disabled
-	case QueryBuilderQuery[LogAggregation]:
-		return spec.Disabled
-	case QueryBuilderQuery[MetricAggregation]:
-		return spec.Disabled
-	case QueryBuilderFormula:
-		return spec.Disabled
-	case QueryBuilderTraceOperator:
-		return spec.Disabled
-	case QueryBuilderJoin:
-		return spec.Disabled
-	case PromQuery:
-		return spec.Disabled
-	case ClickHouseQuery:
-		return spec.Disabled
-	}
-	return false
-}
-
 // getQueryIdentifier returns a friendly identifier for a query based on its type and name/content
 func getQueryIdentifier(envelope QueryEnvelope, index int) string {
-	name := envelope.queryName()
+	name := envelope.GetQueryName()
 
 	var typeLabel string
 	switch envelope.Type {
@@ -89,50 +43,115 @@ const (
 	MaxQueryLimit = 10000
 )
 
-// Validate performs preliminary validation on QueryBuilderQuery
-func (q *QueryBuilderQuery[T]) Validate(requestType RequestType) error {
-	// Validate signal
+// ValidationOption is a functional option for configuring validation behaviour.
+type ValidationOption func(*validationConfig)
+
+type validationConfig struct {
+	skipLimitOffsetValidation bool
+	skipAggregationValidation bool
+	skipHavingValidation      bool
+	skipAggregationOrderBy    bool
+	skipSelectFieldValidation bool
+	skipGroupByValidation     bool
+}
+
+func applyValidationOptions(opts []ValidationOption) validationConfig {
+	cfg := validationConfig{}
+	for _, opt := range opts {
+		opt(&cfg)
+	}
+	return cfg
+}
+
+// SkipLimitOffsetValidation returns a ValidationOption that skips the limit and offset range checks.
+// Use this when the caller has already validated limits and offsets with different constraints.
+func WithSkipLimitOffsetValidation() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipLimitOffsetValidation = true
+	}
+}
+
+// SkipAggregationValidation skips aggregation validation.
+// Used for raw/trace request types where aggregations are not required.
+func WithSkipAggregationValidation() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipAggregationValidation = true
+	}
+}
+
+// SkipHavingValidation skips having-clause validation.
+// Used for raw/trace request types where having clauses do not apply.
+func WithSkipHavingValidation() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipHavingValidation = true
+	}
+}
+
+// SkipAggregationOrderBy skips the aggregation-specific order-by key validation.
+// Used for raw/trace request types where order-by keys are not restricted to group-by or aggregation keys.
+func WithSkipAggregationOrderBy() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipAggregationOrderBy = true
+	}
+}
+
+// SkipSelectFieldValidation skips select-field validation.
+// Used for aggregation request types where select fields do not apply.
+func WithSkipSelectFieldValidation() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipSelectFieldValidation = true
+	}
+}
+
+// SkipGroupByValidation skips group-by validation.
+// Used for raw/trace request types where group-by does not apply.
+func WithSkipGroupByValidation() ValidationOption {
+	return func(cfg *validationConfig) {
+		cfg.skipGroupByValidation = true
+	}
+}
+
+// Validate performs preliminary validation on QueryBuilderQuery.
+func (q *QueryBuilderQuery[T]) Validate(opts ...ValidationOption) error {
+	cfg := applyValidationOptions(opts)
+
 	if err := q.validateSignal(); err != nil {
 		return err
 	}
 
-	if err := q.validateAggregations(requestType); err != nil {
+	if err := q.validateAggregations(cfg); err != nil {
 		return err
 	}
 
-	if err := q.validateGroupBy(requestType); err != nil {
+	if err := q.validateGroupBy(cfg); err != nil {
 		return err
 	}
 
-	// Validate limit and pagination
-	if err := q.validateLimitAndPagination(); err != nil {
+	if err := q.validateLimitAndPagination(cfg); err != nil {
 		return err
 	}
 
-	// Validate functions
 	if err := q.validateFunctions(); err != nil {
 		return err
 	}
 
-	// Validate secondary aggregations
 	if err := q.validateSecondaryAggregations(); err != nil {
 		return err
 	}
 
-	if err := q.validateOrderBy(requestType); err != nil {
+	if err := q.validateOrderBy(cfg); err != nil {
 		return err
 	}
 
-	if err := q.validateSelectFields(requestType); err != nil {
+	if err := q.validateSelectFields(cfg); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (q *QueryBuilderQuery[T]) validateSelectFields(requestType RequestType) error {
-	// selectFields don't apply to aggregation queries, skip validation
-	if requestType.IsAggregation() {
+func (q *QueryBuilderQuery[T]) validateSelectFields(cfg validationConfig) error {
+	if cfg.skipSelectFieldValidation {
 		return nil
 	}
 
@@ -148,9 +167,8 @@ func (q *QueryBuilderQuery[T]) validateSelectFields(requestType RequestType) err
 	return nil
 }
 
-func (q *QueryBuilderQuery[T]) validateGroupBy(requestType RequestType) error {
-	// groupBy doesn't apply to non-aggregation queries, skip validation
-	if !requestType.IsAggregation() {
+func (q *QueryBuilderQuery[T]) validateGroupBy(cfg validationConfig) error {
+	if cfg.skipGroupByValidation {
 		return nil
 	}
 	for idx, item := range q.GroupBy {
@@ -183,9 +201,8 @@ func (q *QueryBuilderQuery[T]) validateSignal() error {
 	}
 }
 
-func (q *QueryBuilderQuery[T]) validateAggregations(requestType RequestType) error {
-	// aggregations don't apply to non-aggregation queries, skip validation
-	if !requestType.IsAggregation() {
+func (q *QueryBuilderQuery[T]) validateAggregations(cfg validationConfig) error {
+	if cfg.skipAggregationValidation {
 		return nil
 	}
 
@@ -272,8 +289,11 @@ func (q *QueryBuilderQuery[T]) validateAggregations(requestType RequestType) err
 	return nil
 }
 
-func (q *QueryBuilderQuery[T]) validateLimitAndPagination() error {
-	// Validate limit
+func (q *QueryBuilderQuery[T]) validateLimitAndPagination(cfg validationConfig) error {
+	if cfg.skipLimitOffsetValidation {
+		return nil
+	}
+
 	if q.Limit < 0 {
 		return errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
@@ -336,7 +356,7 @@ func (q *QueryBuilderQuery[T]) validateSecondaryAggregations() error {
 	return nil
 }
 
-func (q *QueryBuilderQuery[T]) validateOrderBy(requestType RequestType) error {
+func (q *QueryBuilderQuery[T]) validateOrderBy(cfg validationConfig) error {
 	for i, order := range q.Order {
 		// Direction validation is handled by the OrderDirection type
 		if order.Direction != OrderDirectionAsc && order.Direction != OrderDirectionDesc {
@@ -355,8 +375,7 @@ func (q *QueryBuilderQuery[T]) validateOrderBy(requestType RequestType) error {
 		}
 	}
 
-	// aggregation-specific order key validation only applies to aggregation queries
-	if requestType.IsAggregation() {
+	if !cfg.skipAggregationOrderBy {
 		return q.validateOrderByForAggregation()
 	}
 
@@ -438,8 +457,8 @@ func (q *QueryBuilderQuery[T]) validateOrderByForAggregation() error {
 	return nil
 }
 
-// ValidateQueryRangeRequest validates the entire query range request
-func (r *QueryRangeRequest) Validate() error {
+// Validate validates the entire query range request.
+func (r *QueryRangeRequest) Validate(opts ...ValidationOption) error {
 	// Validate time range
 	if r.RequestType != RequestTypeRawStream && r.Start >= r.End {
 		return errors.NewInvalidInputf(
@@ -450,8 +469,8 @@ func (r *QueryRangeRequest) Validate() error {
 
 	// Validate request type
 	switch r.RequestType {
-	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTimeSeries, RequestTypeScalar, RequestTypeTrace:
-		// Valid request types
+	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace, RequestTypeTimeSeries, RequestTypeScalar:
+		opts = append(opts, GetValidationOptions(r.RequestType)...)
 	default:
 		return errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
@@ -463,7 +482,7 @@ func (r *QueryRangeRequest) Validate() error {
 	}
 
 	// Validate composite query
-	if err := r.validateCompositeQuery(); err != nil {
+	if err := r.CompositeQuery.Validate(opts...); err != nil {
 		return err
 	}
 
@@ -478,7 +497,7 @@ func (r *QueryRangeRequest) Validate() error {
 // validateAllQueriesNotDisabled validates that at least one query in the composite query is enabled
 func (r *QueryRangeRequest) validateAllQueriesNotDisabled() error {
 	for _, envelope := range r.CompositeQuery.Queries {
-		if !envelope.isDisabled() {
+		if !envelope.IsDisabled() {
 			return nil
 		}
 	}
@@ -489,12 +508,8 @@ func (r *QueryRangeRequest) validateAllQueriesNotDisabled() error {
 	)
 }
 
-func (r *QueryRangeRequest) validateCompositeQuery() error {
-	return r.CompositeQuery.Validate(r.RequestType)
-}
-
 // Validate performs validation on CompositeQuery
-func (c *CompositeQuery) Validate(requestType RequestType) error {
+func (c *CompositeQuery) Validate(opts ...ValidationOption) error {
 	if len(c.Queries) == 0 {
 		return errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
@@ -506,14 +521,14 @@ func (c *CompositeQuery) Validate(requestType RequestType) error {
 	queryNames := make(map[string]bool)
 
 	for i, envelope := range c.Queries {
-		if err := validateQueryEnvelope(envelope, requestType); err != nil {
+		if err := validateQueryEnvelope(envelope, opts...); err != nil {
 			queryId := getQueryIdentifier(envelope, i)
 			return wrapValidationError(err, queryId, "invalid %s: %s")
 		}
 
 		// Check name uniqueness for builder queries
 		if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery {
-			name := envelope.queryName()
+			name := envelope.GetQueryName()
 			if name != "" {
 				if queryNames[name] {
 					return errors.NewInvalidInputf(
@@ -530,16 +545,16 @@ func (c *CompositeQuery) Validate(requestType RequestType) error {
 	return nil
 }
 
-func validateQueryEnvelope(envelope QueryEnvelope, requestType RequestType) error {
+func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) error {
 	switch envelope.Type {
 	case QueryTypeBuilder, QueryTypeSubQuery:
 		switch spec := envelope.Spec.(type) {
 		case QueryBuilderQuery[TraceAggregation]:
-			return spec.Validate(requestType)
+			return spec.Validate(opts...)
 		case QueryBuilderQuery[LogAggregation]:
-			return spec.Validate(requestType)
+			return spec.Validate(opts...)
 		case QueryBuilderQuery[MetricAggregation]:
-			return spec.Validate(requestType)
+			return spec.Validate(opts...)
 		default:
 			return errors.NewInvalidInputf(
 				errors.CodeInvalidInput,
@@ -625,3 +640,14 @@ func validateQueryEnvelope(envelope QueryEnvelope, requestType RequestType) erro
 		)
 	}
 }
+
+func GetValidationOptions(requestType RequestType) []ValidationOption {
+	switch requestType {
+	case RequestTypeTimeSeries, RequestTypeScalar:
+		return []ValidationOption{WithSkipSelectFieldValidation()}
+	case RequestTypeRaw, RequestTypeRawStream, RequestTypeTrace:
+		return []ValidationOption{WithSkipAggregationValidation(), WithSkipHavingValidation(), WithSkipAggregationOrderBy(), WithSkipGroupByValidation()}
+	default:
+		return []ValidationOption{}
+	}
+}

pkg/types/querybuildertypes/querybuildertypesv5/validation_test.go

@@ -743,7 +743,7 @@ func TestValidateQueryEnvelope(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := validateQueryEnvelope(tt.envelope, tt.requestType)
+			err := validateQueryEnvelope(tt.envelope)
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("validateQueryEnvelope() expected error but got none")
@@ -816,7 +816,7 @@ func TestQueryEnvelope_Helpers(t *testing.T) {
 		}
 		for _, tt := range tests {
 			t.Run(tt.name, func(t *testing.T) {
-				got := tt.envelope.queryName()
+				got := tt.envelope.GetQueryName()
 				if got != tt.want {
 					t.Errorf("queryName() = %q, want %q", got, tt.want)
 				}
@@ -868,7 +868,7 @@ func TestQueryEnvelope_Helpers(t *testing.T) {
 		}
 		for _, tt := range tests {
 			t.Run(tt.name, func(t *testing.T) {
-				got := tt.envelope.isDisabled()
+				got := tt.envelope.IsDisabled()
 				if got != tt.want {
 					t.Errorf("isDisabled() = %v, want %v", got, tt.want)
 				}
@@ -1107,7 +1107,7 @@ func TestQueryRangeRequest_ValidateOrderByForAggregation(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := tt.query.Validate(RequestTypeTimeSeries)
+			err := tt.query.Validate(GetValidationOptions(RequestTypeTimeSeries)...)
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("validateOrderByForAggregation() expected error but got none")
@@ -1161,7 +1161,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 				{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "service.name"}},
 			},
 		}
-		err := query.Validate(RequestTypeRaw)
+		err := query.Validate(GetValidationOptions(RequestTypeRaw)...)
 		if err != nil {
 			t.Errorf("expected no error for groupBy with raw request type, got: %v", err)
 		}
@@ -1178,7 +1178,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 				{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: ""}},
 			},
 		}
-		err := query.Validate(RequestTypeTimeSeries)
+		err := query.Validate(GetValidationOptions(RequestTypeTimeSeries)...)
 		if err == nil {
 			t.Errorf("expected error for empty groupBy key with timeseries request type")
 		}
@@ -1190,7 +1190,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 			Signal: telemetrytypes.SignalLogs,
 			Having: &Having{Expression: "count() > 10"},
 		}
-		err := query.Validate(RequestTypeRaw)
+		err := query.Validate(GetValidationOptions(RequestTypeRaw)...)
 		if err != nil {
 			t.Errorf("expected no error for having with raw request type, got: %v", err)
 		}
@@ -1202,7 +1202,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 			Signal: telemetrytypes.SignalTraces,
 			Having: &Having{Expression: "count() > 10"},
 		}
-		err := query.Validate(RequestTypeTrace)
+		err := query.Validate(GetValidationOptions(RequestTypeTrace)...)
 		if err != nil {
 			t.Errorf("expected no error for having with trace request type, got: %v", err)
 		}
@@ -1216,7 +1216,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 				{Expression: "count()"},
 			},
 		}
-		err := query.Validate(RequestTypeRaw)
+		err := query.Validate(GetValidationOptions(RequestTypeRaw)...)
 		if err != nil {
 			t.Errorf("expected no error for aggregations with raw request type, got: %v", err)
 		}
@@ -1230,7 +1230,7 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 				{Expression: "count()"},
 			},
 		}
-		err := query.Validate(RequestTypeRawStream)
+		err := query.Validate(GetValidationOptions(RequestTypeRawStream)...)
 		if err != nil {
 			t.Errorf("expected no error for aggregations with raw_stream request type, got: %v", err)
 		}
@@ -1248,12 +1248,12 @@ func TestNonAggregationFieldsSkipped(t *testing.T) {
 			},
 		}
 		// Should error for raw (selectFields are validated)
-		err := query.Validate(RequestTypeRaw)
+		err := query.Validate(GetValidationOptions(RequestTypeRaw)...)
 		if err == nil {
 			t.Errorf("expected error for isRoot in selectFields with raw request type")
 		}
 		// Should pass for timeseries (selectFields skipped)
-		err = query.Validate(RequestTypeTimeSeries)
+		err = query.Validate(GetValidationOptions(RequestTypeTimeSeries)...)
 		if err != nil {
 			t.Errorf("expected no error for isRoot in selectFields with timeseries request type, got: %v", err)
 		}

tests/integration/fixtures/querier.py

@@ -1,5 +1,6 @@
+from dataclasses import dataclass
 from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import requests
 
@@ -10,6 +11,95 @@ DEFAULT_TOLERANCE = 1e-9
 QUERY_TIMEOUT = 30  # seconds
 
 
+@dataclass
+class TelemetryFieldKey:
+    name: str
+    field_data_type: str
+    field_context: str
+
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "fieldDataType": self.field_data_type,
+            "fieldContext": self.field_context,
+        }
+
+
+@dataclass
+class OrderBy:
+    key: TelemetryFieldKey
+    direction: str = "asc"
+
+    def to_dict(self) -> Dict:
+        return {"key": self.key.to_dict(), "direction": self.direction}
+
+
+@dataclass
+class BuilderQuery:
+    signal: str
+    name: str = "A"
+    limit: Optional[int] = None
+    filter_expression: Optional[str] = None
+    select_fields: Optional[List[TelemetryFieldKey]] = None
+    order: Optional[List[OrderBy]] = None
+
+    def to_dict(self) -> Dict:
+        spec: Dict[str, Any] = {
+            "signal": self.signal,
+            "name": self.name,
+        }
+        if self.limit is not None:
+            spec["limit"] = self.limit
+        if self.filter_expression:
+            spec["filter"] = {"expression": self.filter_expression}
+        if self.select_fields:
+            spec["selectFields"] = [f.to_dict() for f in self.select_fields]
+        if self.order:
+            spec["order"] = [o.to_dict() for o in self.order]
+        return {"type": "builder_query", "spec": spec}
+
+
+@dataclass
+class TraceOperatorQuery:
+    name: str
+    expression: str
+    return_spans_from: str
+    limit: Optional[int] = None
+    order: Optional[List[OrderBy]] = None
+
+    def to_dict(self) -> Dict:
+        spec: Dict[str, Any] = {
+            "name": self.name,
+            "expression": self.expression,
+            "returnSpansFrom": self.return_spans_from,
+        }
+        if self.limit is not None:
+            spec["limit"] = self.limit
+        if self.order:
+            spec["order"] = [o.to_dict() for o in self.order]
+        return {"type": "builder_trace_operator", "spec": spec}
+
+
+@dataclass
+class QueryRangeRequest:
+    start: int  # nanoseconds
+    end: int  # nanoseconds
+    queries: List[Union[BuilderQuery, TraceOperatorQuery]]
+    request_type: Optional[str] = "raw"
+
+    def to_dict(self) -> Dict:
+        body: Dict[str, Any] = {
+            "start": self.start,
+            "end": self.end,
+            "compositeQuery": {
+                "queries": [q.to_dict() for q in self.queries],
+            },
+        }
+        if self.request_type is not None:
+            body["requestType"] = self.request_type
+        return body
+
+
 def make_query_request(
     signoz: types.SigNoz,
     token: str,

tests/integration/fixtures/signoz.py

@@ -108,16 +108,24 @@ def create_signoz(
             for attempt in range(10):
                 try:
                     response = requests.get(
-                        f"http://{container.get_container_host_ip()}:{container.get_exposed_port(8080)}/api/v1/health",
+                        f"http://{container.get_container_host_ip()}:{container.get_exposed_port(8080)}/api/v2/healthz",
                         timeout=2,
                     )
                     if response.status_code == HTTPStatus.OK:
                         return
-                except Exception:  # pylint: disable=broad-exception-caught
-                    logger.info(
-                        "Attempt %s at readiness check for SigNoz container %s failed, going to retry ...",
+                    if response.status_code == HTTPStatus.SERVICE_UNAVAILABLE:
+                        logger.error(
+                            "Attempt %s: SigNoz container %s not ready yet:\n%s",
+                            attempt + 1,
+                            container,
+                            response.text,
+                        )
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    logger.error(
+                        "Attempt %s at readiness check for SigNoz container %s failed: %s",
                         attempt + 1,
                         container,
+                        e,
                     )
                 time.sleep(2)
             raise TimeoutError("timeout exceeded while waiting")

tests/integration/src/bootstrap/setup.py

@@ -1,3 +1,4 @@
+import logging
 from http import HTTPStatus
 
 import numpy as np
@@ -5,14 +6,21 @@ import requests
 
 from fixtures import types
 
+logger = logging.getLogger(__name__)
+
 
 def test_setup(signoz: types.SigNoz) -> None:
     response = requests.get(
         signoz.self.host_configs["8080"].get("/api/v1/version"), timeout=2
     )
-
     assert response.status_code == HTTPStatus.OK
 
+    healthz = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v2/healthz"), timeout=2
+    )
+    logger.info("healthz response: %s", healthz.json())
+    assert healthz.status_code == HTTPStatus.OK
+
 
 def test_telemetry_databases_exist(signoz: types.SigNoz) -> None:
     arr: np.ndarray = signoz.telemetrystore.conn.query_np("SHOW DATABASES")