Merge branch 'main' into nv/dashboard-ai-builder-query-plugin

Keeps the AI builder query kind on every panel's allowed query kinds
alongside main's new Text panel, and regenerates both specs: the trace
builder query picked up bucketOptions, which AIBuilderQuerySpec aliases.

Assisted-by: Claude Opus 5

.github/workflows/integrationci.yaml

@@ -67,7 +67,6 @@ jobs:
           - semconvfamilies
           - serviceaccount
           - spanmapper
-          - tracedetail
           - querier_json_body
           - querier_skip_resource_fingerprint
           - ttl

conf/example.yaml

@@ -202,6 +202,7 @@ telemetrystore:
       max_bytes_to_read: 0
       max_result_rows: 0
       ignore_data_skipping_indices: ""
+      secondary_indices_enable_bulk_filtering: false
 
 ##################### Prometheus #####################
 prometheus:

docs/api/openapi.yml

@@ -3210,6 +3210,69 @@ components:
         repeatVariable:
           type: string
       type: object
+    DashboardtypesAIBuilderQuerySpec:
+      properties:
+        aggregations:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5TraceAggregation'
+          nullable: true
+          type: array
+        bucketOptions:
+          $ref: '#/components/schemas/Querybuildertypesv5BucketOptions'
+        cursor:
+          type: string
+        disabled:
+          type: boolean
+        filter:
+          $ref: '#/components/schemas/Querybuildertypesv5Filter'
+        functions:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5Function'
+          nullable: true
+          type: array
+        groupBy:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5GroupByKey'
+          nullable: true
+          type: array
+        having:
+          $ref: '#/components/schemas/Querybuildertypesv5Having'
+        legend:
+          type: string
+        limit:
+          type: integer
+        limitBy:
+          $ref: '#/components/schemas/Querybuildertypesv5LimitBy'
+        name:
+          type: string
+        offset:
+          type: integer
+        order:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5OrderBy'
+          nullable: true
+          type: array
+        secondaryAggregations:
+          items:
+            $ref: '#/components/schemas/Querybuildertypesv5SecondaryAggregation'
+          nullable: true
+          type: array
+        selectFields:
+          items:
+            $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
+          nullable: true
+          type: array
+        signal:
+          enum:
+          - traces
+          type: string
+        source:
+          $ref: '#/components/schemas/TelemetrytypesSource'
+        stepInterval:
+          $ref: '#/components/schemas/Querybuildertypesv5Step'
+      required:
+      - signal
+      type: object
     DashboardtypesAxes:
       properties:
         isLogScale:
@@ -4133,6 +4196,7 @@ components:
     DashboardtypesQueryPlugin:
       discriminator:
         mapping:
+          signoz/AIBuilderQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec'
           signoz/BuilderQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
           signoz/ClickHouseSQL: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5ClickHouseQuery'
           signoz/CompositeQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
@@ -4142,6 +4206,7 @@ components:
         propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
+      - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormula'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery'
@@ -4151,12 +4216,25 @@ components:
     DashboardtypesQueryPluginKind:
       enum:
       - signoz/BuilderQuery
+      - signoz/AIBuilderQuery
       - signoz/CompositeQuery
       - signoz/Formula
       - signoz/PromQLQuery
       - signoz/ClickHouseSQL
       - signoz/TraceOperator
       type: string
+    DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec:
+      properties:
+        kind:
+          enum:
+          - signoz/AIBuilderQuery
+          type: string
+        spec:
+          $ref: '#/components/schemas/DashboardtypesAIBuilderQuerySpec'
+      required:
+      - kind
+      - spec
+      type: object
     DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec:
       properties:
         kind:
@@ -9439,29 +9517,6 @@ components:
       required:
       - aggregations
       type: object
-    SpantypesGettableTraceSummary:
-      properties:
-        ai:
-          $ref: '#/components/schemas/SpantypesTraceAISummary'
-        endTimestampMillis:
-          minimum: 0
-          type: integer
-        hasMissingSpans:
-          type: boolean
-        rootServiceEntryPoint:
-          type: string
-        rootServiceName:
-          type: string
-        startTimestampMillis:
-          minimum: 0
-          type: integer
-        totalErrorSpansCount:
-          minimum: 0
-          type: integer
-        totalSpansCount:
-          minimum: 0
-          type: integer
-      type: object
     SpantypesGettableWaterfallTrace:
       properties:
         endTimestampMillis:
@@ -9745,32 +9800,6 @@ components:
           nullable: true
           type: object
       type: object
-    SpantypesTraceAISummary:
-      properties:
-        tokens:
-          $ref: '#/components/schemas/SpantypesTraceAITokens'
-        totalCost:
-          nullable: true
-          type: number
-      type: object
-    SpantypesTraceAITokens:
-      properties:
-        cacheRead:
-          minimum: 0
-          type: integer
-        cacheWrite:
-          minimum: 0
-          type: integer
-        input:
-          minimum: 0
-          type: integer
-        output:
-          minimum: 0
-          type: integer
-        reasoning:
-          minimum: 0
-          type: integer
-      type: object
     SpantypesUpdatableSpanMapper:
       properties:
         config:
@@ -15509,66 +15538,6 @@ paths:
       summary: Get aggregations for a trace
       tags:
       - tracedetail
-  /api/v1/traces/{traceID}/summary:
-    get:
-      deprecated: false
-      description: Returns the trace-level fields of the waterfall (time range, root,
-        span counts, missing spans) and, when the trace has gen_ai spans, its token
-        and cost totals. Computed in one aggregate query.
-      operationId: GetTraceSummary
-      parameters:
-      - in: path
-        name: traceID
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableTraceSummary'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get summary for a trace
-      tags:
-      - tracedetail
   /api/v1/user/me:
     get:
       deprecated: true

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

@@ -4009,123 +4009,10 @@ export interface DashboardGridLayoutSpecDTO {
 	repeatVariable?: string;
 }
 
-export interface DashboardtypesAxesDTO {
-	/**
-	 * @type boolean
-	 */
-	isLogScale?: boolean;
-	/**
-	 * @type number,null
-	 */
-	softMax?: number | null;
-	/**
-	 * @type number,null
-	 */
-	softMin?: number | null;
+export enum DashboardtypesAIBuilderQuerySpecDTOSignal {
+	traces = 'traces',
 }
-
-export enum DashboardtypesPrecisionOptionDTO {
-	NUMBER_0 = '0',
-	NUMBER_1 = '1',
-	NUMBER_2 = '2',
-	NUMBER_3 = '3',
-	NUMBER_4 = '4',
-	full = 'full',
-}
-export interface DashboardtypesPanelFormattingDTO {
-	decimalPrecision?: DashboardtypesPrecisionOptionDTO;
-	/**
-	 * @type string
-	 */
-	unit?: string;
-}
-
-export enum DashboardtypesLegendModeDTO {
-	list = 'list',
-}
-export enum DashboardtypesLegendPositionDTO {
-	bottom = 'bottom',
-	right = 'right',
-}
-export type DashboardtypesLegendDTOCustomColorsAnyOf = {
-	[key: string]: string;
-};
-
-/**
- * @nullable
- */
-export type DashboardtypesLegendDTOCustomColors =
-	DashboardtypesLegendDTOCustomColorsAnyOf | null;
-
-export interface DashboardtypesLegendDTO {
-	/**
-	 * @type object,null
-	 */
-	customColors?: DashboardtypesLegendDTOCustomColors;
-	mode?: DashboardtypesLegendModeDTO;
-	position?: DashboardtypesLegendPositionDTO;
-}
-
-export interface DashboardtypesThresholdWithLabelDTO {
-	/**
-	 * @type string
-	 */
-	color: string;
-	/**
-	 * @type string
-	 */
-	label?: string;
-	/**
-	 * @type string
-	 */
-	unit?: string;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	value: number;
-}
-
-export enum DashboardtypesTimePreferenceDTO {
-	global_time = 'global_time',
-	last_5_min = 'last_5_min',
-	last_15_min = 'last_15_min',
-	last_30_min = 'last_30_min',
-	last_1_hr = 'last_1_hr',
-	last_6_hr = 'last_6_hr',
-	last_1_day = 'last_1_day',
-	last_3_days = 'last_3_days',
-	last_1_week = 'last_1_week',
-	last_1_month = 'last_1_month',
-}
-export interface DashboardtypesBarChartVisualizationDTO {
-	/**
-	 * @type boolean
-	 */
-	fillSpans?: boolean;
-	/**
-	 * @type boolean
-	 */
-	stackedBarChart?: boolean;
-	timePreference?: DashboardtypesTimePreferenceDTO;
-}
-
-export interface DashboardtypesBarChartPanelSpecDTO {
-	axes?: DashboardtypesAxesDTO;
-	formatting?: DashboardtypesPanelFormattingDTO;
-	legend?: DashboardtypesLegendDTO;
-	/**
-	 * @type array,null
-	 */
-	thresholds?: DashboardtypesThresholdWithLabelDTO[] | null;
-	visualization?: DashboardtypesBarChartVisualizationDTO;
-}
-
-export interface DashboardtypesBasicVisualizationDTO {
-	timePreference?: DashboardtypesTimePreferenceDTO;
-}
-
-export interface Querybuildertypesv5LogAggregationDTO {
+export interface Querybuildertypesv5TraceAggregationDTO {
 	/**
 	 * @type string
 	 */
@@ -4364,13 +4251,202 @@ export interface TelemetrytypesTelemetryFieldKeyDTO {
 	unit?: string;
 }
 
-export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTOSignal {
-	logs = 'logs',
-}
 export enum TelemetrytypesSourceDTO {
 	meter = 'meter',
 	'' = '',
 }
+export interface DashboardtypesAIBuilderQuerySpecDTO {
+	/**
+	 * @type array,null
+	 */
+	aggregations?: Querybuildertypesv5TraceAggregationDTO[] | null;
+	bucketOptions?: Querybuildertypesv5BucketOptionsDTO;
+	/**
+	 * @type string
+	 */
+	cursor?: string;
+	/**
+	 * @type boolean
+	 */
+	disabled?: boolean;
+	filter?: Querybuildertypesv5FilterDTO;
+	/**
+	 * @type array,null
+	 */
+	functions?: Querybuildertypesv5FunctionDTO[] | null;
+	/**
+	 * @type array,null
+	 */
+	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
+	having?: Querybuildertypesv5HavingDTO;
+	/**
+	 * @type string
+	 */
+	legend?: string;
+	/**
+	 * @type integer
+	 */
+	limit?: number;
+	limitBy?: Querybuildertypesv5LimitByDTO;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type integer
+	 */
+	offset?: number;
+	/**
+	 * @type array,null
+	 */
+	order?: Querybuildertypesv5OrderByDTO[] | null;
+	/**
+	 * @type array,null
+	 */
+	secondaryAggregations?: Querybuildertypesv5SecondaryAggregationDTO[] | null;
+	/**
+	 * @type array,null
+	 */
+	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[] | null;
+	/**
+	 * @enum traces
+	 * @type string
+	 */
+	signal: DashboardtypesAIBuilderQuerySpecDTOSignal;
+	source?: TelemetrytypesSourceDTO;
+	stepInterval?: Querybuildertypesv5StepDTO;
+}
+
+export interface DashboardtypesAxesDTO {
+	/**
+	 * @type boolean
+	 */
+	isLogScale?: boolean;
+	/**
+	 * @type number,null
+	 */
+	softMax?: number | null;
+	/**
+	 * @type number,null
+	 */
+	softMin?: number | null;
+}
+
+export enum DashboardtypesPrecisionOptionDTO {
+	NUMBER_0 = '0',
+	NUMBER_1 = '1',
+	NUMBER_2 = '2',
+	NUMBER_3 = '3',
+	NUMBER_4 = '4',
+	full = 'full',
+}
+export interface DashboardtypesPanelFormattingDTO {
+	decimalPrecision?: DashboardtypesPrecisionOptionDTO;
+	/**
+	 * @type string
+	 */
+	unit?: string;
+}
+
+export enum DashboardtypesLegendModeDTO {
+	list = 'list',
+}
+export enum DashboardtypesLegendPositionDTO {
+	bottom = 'bottom',
+	right = 'right',
+}
+export type DashboardtypesLegendDTOCustomColorsAnyOf = {
+	[key: string]: string;
+};
+
+/**
+ * @nullable
+ */
+export type DashboardtypesLegendDTOCustomColors =
+	DashboardtypesLegendDTOCustomColorsAnyOf | null;
+
+export interface DashboardtypesLegendDTO {
+	/**
+	 * @type object,null
+	 */
+	customColors?: DashboardtypesLegendDTOCustomColors;
+	mode?: DashboardtypesLegendModeDTO;
+	position?: DashboardtypesLegendPositionDTO;
+}
+
+export interface DashboardtypesThresholdWithLabelDTO {
+	/**
+	 * @type string
+	 */
+	color: string;
+	/**
+	 * @type string
+	 */
+	label?: string;
+	/**
+	 * @type string
+	 */
+	unit?: string;
+	/**
+	 * @type number
+	 * @format double
+	 */
+	value: number;
+}
+
+export enum DashboardtypesTimePreferenceDTO {
+	global_time = 'global_time',
+	last_5_min = 'last_5_min',
+	last_15_min = 'last_15_min',
+	last_30_min = 'last_30_min',
+	last_1_hr = 'last_1_hr',
+	last_6_hr = 'last_6_hr',
+	last_1_day = 'last_1_day',
+	last_3_days = 'last_3_days',
+	last_1_week = 'last_1_week',
+	last_1_month = 'last_1_month',
+}
+export interface DashboardtypesBarChartVisualizationDTO {
+	/**
+	 * @type boolean
+	 */
+	fillSpans?: boolean;
+	/**
+	 * @type boolean
+	 */
+	stackedBarChart?: boolean;
+	timePreference?: DashboardtypesTimePreferenceDTO;
+}
+
+export interface DashboardtypesBarChartPanelSpecDTO {
+	axes?: DashboardtypesAxesDTO;
+	formatting?: DashboardtypesPanelFormattingDTO;
+	legend?: DashboardtypesLegendDTO;
+	/**
+	 * @type array,null
+	 */
+	thresholds?: DashboardtypesThresholdWithLabelDTO[] | null;
+	visualization?: DashboardtypesBarChartVisualizationDTO;
+}
+
+export interface DashboardtypesBasicVisualizationDTO {
+	timePreference?: DashboardtypesTimePreferenceDTO;
+}
+
+export interface Querybuildertypesv5LogAggregationDTO {
+	/**
+	 * @type string
+	 */
+	alias?: string;
+	/**
+	 * @type string
+	 */
+	expression?: string;
+}
+
+export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTOSignal {
+	logs = 'logs',
+}
 export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTO {
 	/**
 	 * @type array,null
@@ -4561,17 +4637,6 @@ export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTyp
 	stepInterval?: Querybuildertypesv5StepDTO;
 }
 
-export interface Querybuildertypesv5TraceAggregationDTO {
-	/**
-	 * @type string
-	 */
-	alias?: string;
-	/**
-	 * @type string
-	 */
-	expression?: string;
-}
-
 export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregationDTOSignal {
 	traces = 'traces',
 }
@@ -5102,6 +5167,18 @@ export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDa
 	spec: DashboardtypesBuilderQuerySpecDTO;
 }
 
+export enum DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTOKind {
+	'signoz/AIBuilderQuery' = 'signoz/AIBuilderQuery',
+}
+export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTO {
+	/**
+	 * @enum signoz/AIBuilderQuery
+	 * @type string
+	 */
+	kind: DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTOKind;
+	spec: DashboardtypesAIBuilderQuerySpecDTO;
+}
+
 export enum DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTOKind {
 	'signoz/CompositeQuery' = 'signoz/CompositeQuery',
 }
@@ -5393,6 +5470,7 @@ export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQu
 
 export type DashboardtypesQueryPluginDTO =
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpecDTO
+	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormulaDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQueryDTO
@@ -6069,6 +6147,7 @@ export interface DashboardtypesPostablePublicDashboardDTO {
 
 export enum DashboardtypesQueryPluginKindDTO {
 	'signoz/BuilderQuery' = 'signoz/BuilderQuery',
+	'signoz/AIBuilderQuery' = 'signoz/AIBuilderQuery',
 	'signoz/CompositeQuery' = 'signoz/CompositeQuery',
 	'signoz/Formula' = 'signoz/Formula',
 	'signoz/PromQLQuery' = 'signoz/PromQLQuery',
@@ -10884,78 +10963,6 @@ export interface SpantypesGettableTraceAggregationsDTO {
 	aggregations: SpantypesSpanAggregationResultDTO[];
 }
 
-export interface SpantypesTraceAITokensDTO {
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	cacheRead?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	cacheWrite?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	input?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	output?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	reasoning?: number;
-}
-
-export interface SpantypesTraceAISummaryDTO {
-	tokens?: SpantypesTraceAITokensDTO;
-	/**
-	 * @type number,null
-	 */
-	totalCost?: number | null;
-}
-
-export interface SpantypesGettableTraceSummaryDTO {
-	ai?: SpantypesTraceAISummaryDTO;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	endTimestampMillis?: number;
-	/**
-	 * @type boolean
-	 */
-	hasMissingSpans?: boolean;
-	/**
-	 * @type string
-	 */
-	rootServiceEntryPoint?: string;
-	/**
-	 * @type string
-	 */
-	rootServiceName?: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	startTimestampMillis?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalErrorSpansCount?: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalSpansCount?: number;
-}
-
 export interface SpantypesOtelSpanRefDTO {
 	/**
 	 * @type string
@@ -12667,17 +12674,6 @@ export type GetTraceAggregations200 = {
 	status: string;
 };
 
-export type GetTraceSummaryPathParameters = {
-	traceID: string;
-};
-export type GetTraceSummary200 = {
-	data: SpantypesGettableTraceSummaryDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListUserPreferences200 = {
 	/**
 	 * @type array

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

@@ -4,17 +4,11 @@
  * * regenerate with 'pnpm generate:api'
  * SigNoz
  */
-import { useMutation, useQuery } from 'react-query';
+import { useMutation } from 'react-query';
 import type {
-	InvalidateOptions,
 	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
 	UseMutationOptions,
 	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
 } from 'react-query';
 
 import type {
@@ -22,8 +16,6 @@ import type {
 	GetFlamegraphPathParameters,
 	GetTraceAggregations200,
 	GetTraceAggregationsPathParameters,
-	GetTraceSummary200,
-	GetTraceSummaryPathParameters,
 	GetWaterfallV4200,
 	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
@@ -35,26 +27,6 @@ import type {
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
-const withQueryKey = <T extends object, K>(
-	query: T,
-	queryKey: K,
-): T & { queryKey: K } => {
-	const result = { queryKey } as T & { queryKey: K };
-	for (const key of Object.keys(query)) {
-		// The explicit queryKey always wins, matching the previous
-		// `{ ...query, queryKey }` spread where it was set last.
-		if (key === 'queryKey') {
-			continue;
-		}
-		Object.defineProperty(result, key, {
-			enumerable: true,
-			configurable: true,
-			get: () => (query as Record<string, unknown>)[key],
-		});
-	}
-	return result;
-};
-
 /**
  * Computes span aggregations grouped by requested field.
  * @summary Get aggregations for a trace
@@ -155,108 +127,6 @@ export const useGetTraceAggregations = <
 > => {
 	return useMutation(getGetTraceAggregationsMutationOptions(options));
 };
-/**
- * Returns the trace-level fields of the waterfall (time range, root, span counts, missing spans) and, when the trace has gen_ai spans, its token and cost totals. Computed in one aggregate query.
- * @summary Get summary for a trace
- */
-export const getTraceSummary = (
-	{ traceID }: GetTraceSummaryPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetTraceSummary200>({
-		url: `/api/v1/traces/${traceID}/summary`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetTraceSummaryQueryKey = ({
-	traceID,
-}: GetTraceSummaryPathParameters) => {
-	return [`/api/v1/traces/${traceID}/summary`] as const;
-};
-
-export const getGetTraceSummaryQueryOptions = <
-	TData = Awaited<ReturnType<typeof getTraceSummary>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ traceID }: GetTraceSummaryPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getTraceSummary>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetTraceSummaryQueryKey({ traceID });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getTraceSummary>>> = ({
-		signal,
-	}) => getTraceSummary({ traceID }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: traceID !== null && traceID !== undefined,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getTraceSummary>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetTraceSummaryQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getTraceSummary>>
->;
-export type GetTraceSummaryQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get summary for a trace
- */
-
-export function useGetTraceSummary<
-	TData = Awaited<ReturnType<typeof getTraceSummary>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ traceID }: GetTraceSummaryPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getTraceSummary>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetTraceSummaryQueryOptions({ traceID }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return withQueryKey(query, queryOptions.queryKey);
-}
-
-/**
- * @summary Get summary for a trace
- */
-export const invalidateGetTraceSummary = async (
-	queryClient: QueryClient,
-	{ traceID }: GetTraceSummaryPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetTraceSummaryQueryKey({ traceID }) },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * Returns the flamegraph view of spans for a given trace ID.
  * @summary Get flamegraph view for a trace

frontend/src/api/querySuggestions/__tests__/getFieldKeySuggestions.test.ts

@@ -37,13 +37,12 @@ describe('getFieldKeySuggestions', () => {
 		const response = keysResponse();
 		mockedAIKeys.mockResolvedValue(response);
 
-		const fieldKeysConfig = { searchText: 'llm' };
-		const abortSignal = new AbortController().signal;
+		const filterConfig = { searchText: 'llm' };
 
 		await expect(
-			getFieldKeySuggestions(fieldKeysConfig, 'builder_ai_query', abortSignal),
+			getFieldKeySuggestions(filterConfig, 'builder_ai_query'),
 		).resolves.toBe(response);
-		expect(mockedAIKeys).toHaveBeenCalledWith(fieldKeysConfig, abortSignal);
+		expect(mockedAIKeys).toHaveBeenCalledWith(filterConfig);
 		expect(mockedGenericKeys).not.toHaveBeenCalled();
 	});
 
@@ -59,16 +58,15 @@ describe('getFieldKeySuggestions', () => {
 		const response = keysResponse();
 		mockedGenericKeys.mockResolvedValue(response);
 
-		const fieldKeysConfig = {
+		const filterConfig = {
 			signal: TelemetrytypesSignalDTO.traces,
 			searchText: 'svc',
 		};
-		const abortSignal = new AbortController().signal;
 
 		await expect(
-			getFieldKeySuggestions(fieldKeysConfig, builderQueryType, abortSignal),
+			getFieldKeySuggestions(filterConfig, builderQueryType),
 		).resolves.toBe(response);
-		expect(mockedGenericKeys).toHaveBeenCalledWith(fieldKeysConfig, abortSignal);
+		expect(mockedGenericKeys).toHaveBeenCalledWith(filterConfig);
 		expect(mockedAIKeys).not.toHaveBeenCalled();
 	});
 });

frontend/src/api/querySuggestions/__tests__/getFieldValueSuggestions.test.ts

@@ -34,13 +34,12 @@ describe('getFieldValueSuggestions', () => {
 		const response = valuesResponse();
 		mockedAIValues.mockResolvedValue(response);
 
-		const fieldValuesConfig = { name: 'gen_ai.request.model', searchText: 'gpt' };
-		const abortSignal = new AbortController().signal;
+		const filterConfig = { name: 'gen_ai.request.model', searchText: 'gpt' };
 
 		await expect(
-			getFieldValueSuggestions(fieldValuesConfig, 'builder_ai_query', abortSignal),
+			getFieldValueSuggestions(filterConfig, 'builder_ai_query'),
 		).resolves.toBe(response);
-		expect(mockedAIValues).toHaveBeenCalledWith(fieldValuesConfig, abortSignal);
+		expect(mockedAIValues).toHaveBeenCalledWith(filterConfig);
 		expect(mockedGenericValues).not.toHaveBeenCalled();
 	});
 
@@ -56,20 +55,16 @@ describe('getFieldValueSuggestions', () => {
 		const response = valuesResponse();
 		mockedGenericValues.mockResolvedValue(response);
 
-		const fieldValuesConfig = {
+		const filterConfig = {
 			signal: TelemetrytypesSignalDTO.traces,
 			name: 'service.name',
 			searchText: 'front',
 		};
-		const abortSignal = new AbortController().signal;
 
 		await expect(
-			getFieldValueSuggestions(fieldValuesConfig, builderQueryType, abortSignal),
+			getFieldValueSuggestions(filterConfig, builderQueryType),
 		).resolves.toBe(response);
-		expect(mockedGenericValues).toHaveBeenCalledWith(
-			fieldValuesConfig,
-			abortSignal,
-		);
+		expect(mockedGenericValues).toHaveBeenCalledWith(filterConfig);
 		expect(mockedAIValues).not.toHaveBeenCalled();
 	});
 });

frontend/src/api/querySuggestions/getFieldKeySuggestions.ts

@@ -2,13 +2,12 @@ import { getAIObservabilityFieldsKeys } from 'api/generated/services/ai-observab
 import { getFieldsKeys } from 'api/generated/services/fields';
 import type { BuilderQueryType } from 'types/api/v5/queryRange';
 
-import { FieldKeysConfig, FieldKeysResponse } from './types';
+import { FieldKeysFilterConfig, FieldKeysResponse } from './types';
 
 export const getFieldKeySuggestions = (
-	fieldKeysConfig: FieldKeysConfig,
+	filterConfig: FieldKeysFilterConfig,
 	builderQueryType?: BuilderQueryType,
-	abortSignal?: AbortSignal,
 ): Promise<FieldKeysResponse> =>
 	builderQueryType === 'builder_ai_query'
-		? getAIObservabilityFieldsKeys(fieldKeysConfig, abortSignal)
-		: getFieldsKeys(fieldKeysConfig, abortSignal);
+		? getAIObservabilityFieldsKeys(filterConfig)
+		: getFieldsKeys(filterConfig);

frontend/src/api/querySuggestions/getFieldValueSuggestions.ts

@@ -2,13 +2,12 @@ import { getAIObservabilityFieldsValues } from 'api/generated/services/ai-observ
 import { getFieldsValues } from 'api/generated/services/fields';
 import type { BuilderQueryType } from 'types/api/v5/queryRange';
 
-import { FieldValuesConfig, FieldValuesResponse } from './types';
+import { FieldValuesFilterConfig, FieldValuesResponse } from './types';
 
 export const getFieldValueSuggestions = (
-	fieldValuesConfig: FieldValuesConfig,
+	filterConfig: FieldValuesFilterConfig,
 	builderQueryType?: BuilderQueryType,
-	abortSignal?: AbortSignal,
 ): Promise<FieldValuesResponse> =>
 	builderQueryType === 'builder_ai_query'
-		? getAIObservabilityFieldsValues(fieldValuesConfig, abortSignal)
-		: getFieldsValues(fieldValuesConfig, abortSignal);
+		? getAIObservabilityFieldsValues(filterConfig)
+		: getFieldsValues(filterConfig);

frontend/src/api/querySuggestions/types.ts

@@ -1,7 +1,7 @@
 import type {
 	GetAIObservabilityFieldsKeys200,
-	GetAIObservabilityFieldsValues200,
 	GetAIObservabilityFieldsKeysParams,
+	GetAIObservabilityFieldsValues200,
 	GetAIObservabilityFieldsValuesParams,
 	GetFieldsKeys200,
 	GetFieldsKeysParams,
@@ -9,19 +9,14 @@ import type {
 	GetFieldsValuesParams,
 } from 'api/generated/services/sigNoz.schemas';
 
-export type FieldKeysConfig =
+export type FieldKeysFilterConfig =
 	| GetFieldsKeysParams
 	| GetAIObservabilityFieldsKeysParams;
 
-export type FieldValuesConfig =
+export type FieldValuesFilterConfig =
 	| GetFieldsValuesParams
 	| GetAIObservabilityFieldsValuesParams;
 
-export type FieldKeysConfigProp = Omit<
-	FieldKeysConfig,
-	'signal' | 'searchText'
->;
-
 export type FieldKeysResponse =
 	| GetFieldsKeys200
 	| GetAIObservabilityFieldsKeys200;

frontend/src/components/FieldsSelector/FieldsSelector.tsx

@@ -6,8 +6,7 @@ import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { Check, TableColumnsSplit, X } from '@signozhq/icons';
 import { FloatingPanel } from 'periscope/components/FloatingPanel';
 import { buildCompositeKey } from 'container/OptionsMenu/utils';
-import { FieldKeysConfigProp } from 'api/querySuggestions/types';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
+import { TelemetryFieldKey } from 'types/api/v5/queryRange';
 import { DataSource } from 'types/common/queryBuilder';
 
 import AddedFields from './AddedFields';
@@ -32,9 +31,6 @@ interface FieldsSelectorProps {
 	// Lets users add a free-typed field which
 	// does not show up in the suggestions
 	allowCustomFields?: boolean;
-	fieldKeysConfig?: FieldKeysConfigProp;
-	builderQueryType?: BuilderQueryType;
-	extraFields?: TelemetryFieldKey[];
 	width?: number;
 	height?: number;
 	defaultPosition?: { x: number; y: number };
@@ -54,9 +50,6 @@ function FieldsSelectorContent({
 	maxFields,
 	requiredFields,
 	allowCustomFields,
-	fieldKeysConfig,
-	builderQueryType,
-	extraFields,
 	width = DEFAULT_PANEL_WIDTH,
 	height,
 	defaultPosition,
@@ -165,9 +158,6 @@ function FieldsSelectorContent({
 					onAdd={handleAdd}
 					isAtLimit={isAtLimit}
 					allowCustomFields={allowCustomFields}
-					fieldKeysConfig={fieldKeysConfig}
-					builderQueryType={builderQueryType}
-					extraFields={extraFields}
 				/>
 
 				{hasUnsavedChanges && (

frontend/src/components/FieldsSelector/OtherFields.tsx

@@ -3,22 +3,18 @@ import { Button } from '@signozhq/ui/button';
 import { Skeleton } from 'antd';
 import cx from 'classnames';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { buildCompositeKey } from 'container/OptionsMenu/utils';
-import { FieldKeysConfigProp } from 'api/querySuggestions/types';
-import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
+import { useGetQueryKeySuggestions } from 'hooks/querySuggestions/useGetQueryKeySuggestions';
 import {
-	BuilderQueryType,
 	FieldContext,
 	SignalType,
 	TelemetryFieldKey,
 } from 'types/api/v5/queryRange';
-import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
-import { mergeExtraFields } from 'utils/extraFields';
+import { DataSource } from 'types/common/queryBuilder';
 
 import styles from './FieldsSelector.module.scss';
 
-const EMPTY_EXTRA_FIELDS: TelemetryFieldKey[] = [];
-
 interface OtherFieldsProps {
 	signal: DataSource;
 	debouncedInputValue: string;
@@ -26,9 +22,6 @@ interface OtherFieldsProps {
 	onAdd: (field: TelemetryFieldKey) => void;
 	isAtLimit: boolean;
 	allowCustomFields?: boolean;
-	fieldKeysConfig?: FieldKeysConfigProp;
-	builderQueryType?: BuilderQueryType;
-	extraFields?: TelemetryFieldKey[];
 }
 
 function OtherFields({
@@ -38,26 +31,26 @@ function OtherFields({
 	onAdd,
 	isAtLimit,
 	allowCustomFields,
-	fieldKeysConfig,
-	builderQueryType,
-	extraFields = EMPTY_EXTRA_FIELDS,
 }: OtherFieldsProps): JSX.Element {
-	const { data: fetchedFields, isFetching } = useFieldKeysSuggestion(
+	const { data, isFetching } = useGetQueryKeySuggestions(
 		{
-			...fieldKeysConfig,
-			signal: DATA_SOURCE_TO_SIGNAL[signal],
+			signal,
 			searchText: debouncedInputValue,
 		},
-		builderQueryType,
+		{
+			queryKey: [
+				REACT_QUERY_KEY.GET_FIELDS_SELECTOR_SUGGESTIONS,
+				signal,
+				debouncedInputValue,
+			],
+			enabled: true,
+		},
 	);
 
 	const otherFields = useMemo<TelemetryFieldKey[]>(() => {
-		const search = debouncedInputValue.trim().toLowerCase();
+		const rawSuggestions = Object.values(data?.data.data.keys || {}).flat();
 		// Normalize: synthesize `key` once so downstream reads can trust it.
-		const suggestions: TelemetryFieldKey[] = mergeExtraFields(
-			extraFields.filter((field) => field.name.toLowerCase().includes(search)),
-			fetchedFields ?? [],
-		).map((attr) => ({
+		const suggestions: TelemetryFieldKey[] = rawSuggestions.map((attr) => ({
 			...attr,
 			key: buildCompositeKey(attr.name, attr.fieldContext, attr.fieldDataType),
 			signal: attr.signal as SignalType,
@@ -94,13 +87,7 @@ function OtherFields({
 			key: buildCompositeKey(typed, ''),
 		};
 		return [customField, ...available];
-	}, [
-		extraFields,
-		fetchedFields,
-		addedFields,
-		allowCustomFields,
-		debouncedInputValue,
-	]);
+	}, [data, addedFields, allowCustomFields, debouncedInputValue]);
 
 	if (isFetching) {
 		return (

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

@@ -1,17 +1,11 @@
 import { act, fireEvent, render, screen } from 'tests/test-utils';
+import { useGetQueryKeySuggestions } from 'hooks/querySuggestions/useGetQueryKeySuggestions';
 import { TelemetryFieldKey } from 'types/api/v5/queryRange';
 import { DataSource } from 'types/common/queryBuilder';
 
 import FieldsSelector from '../FieldsSelector';
-import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
 
-jest.mock('hooks/querySuggestions/useFieldKeysSuggestion', () => ({
-	useFieldKeysSuggestion: jest.fn(() => ({
-		data: undefined,
-		isFetching: false,
-		isFetched: true,
-	})),
-}));
+jest.mock('hooks/querySuggestions/useGetQueryKeySuggestions');
 
 jest.mock('@signozhq/ui/sonner', () => ({
 	...jest.requireActual('@signozhq/ui/sonner'),
@@ -27,15 +21,22 @@ jest.mock('periscope/components/FloatingPanel', () => ({
 }));
 
 const mockSuggestions = (names: string[]): void => {
-	(useFieldKeysSuggestion as jest.Mock).mockReturnValue({
-		data: names.map((name) => ({
-			name,
-			signal: 'logs',
-			fieldDataType: 'string',
-			fieldContext: '',
-		})),
+	(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+		data: {
+			data: {
+				data: {
+					keys: {
+						attributeKeys: names.map((name) => ({
+							name,
+							signal: 'logs',
+							fieldDataType: 'string',
+							fieldContext: '',
+						})),
+					},
+				},
+			},
+		},
 		isFetching: false,
-		isFetched: true,
 	});
 };
 

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

@@ -1,30 +1,29 @@
 import { fireEvent, render, screen } from 'tests/test-utils';
-import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
-import { FieldKeysConfigProp } from 'api/querySuggestions/types';
-import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
-import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
+import { useGetQueryKeySuggestions } from 'hooks/querySuggestions/useGetQueryKeySuggestions';
+import { TelemetryFieldKey } from 'types/api/v5/queryRange';
+import { DataSource } from 'types/common/queryBuilder';
 
 import OtherFields from '../OtherFields';
 
-jest.mock('hooks/querySuggestions/useFieldKeysSuggestion', () => ({
-	useFieldKeysSuggestion: jest.fn(() => ({
-		data: undefined,
-		isFetching: false,
-		isFetched: true,
-	})),
-}));
+jest.mock('hooks/querySuggestions/useGetQueryKeySuggestions');
 
 const mockSuggestions = (names: string[]): void => {
-	(useFieldKeysSuggestion as jest.Mock).mockReturnValue({
-		data: names.map((name) => ({
-			name,
-			signal: 'logs',
-			fieldDataType: 'string',
-			fieldContext: '',
-		})),
+	(useGetQueryKeySuggestions as jest.Mock).mockReturnValue({
+		data: {
+			data: {
+				data: {
+					keys: {
+						attributeKeys: names.map((name) => ({
+							name,
+							signal: 'logs',
+							fieldDataType: 'string',
+							fieldContext: '',
+						})),
+					},
+				},
+			},
+		},
 		isFetching: false,
-		isFetched: true,
 	});
 };
 
@@ -83,6 +82,7 @@ describe('OtherFields — custom (free-typed) option', () => {
 		mockSuggestions(['orderId']);
 		renderOtherFields({ debouncedInputValue: 'orderid' });
 
+		// the real suggestion shows, the lowercased custom name does not
 		expect(screen.getByText('orderId')).toBeInTheDocument();
 		expect(screen.queryByText('orderid')).not.toBeInTheDocument();
 	});
@@ -116,126 +116,10 @@ describe('OtherFields — custom (free-typed) option', () => {
 	it('shows the custom option at the field limit but hides its Add button', () => {
 		renderOtherFields({ debouncedInputValue: 'unknown.a.b.c', isAtLimit: true });
 
+		// same as every other row at the limit: name shown, no Add button
 		expect(screen.getByText('unknown.a.b.c')).toBeInTheDocument();
 		expect(
 			screen.queryByRole('button', { name: /add/i }),
 		).not.toBeInTheDocument();
 	});
 });
-
-describe('OtherFields — field keys config', () => {
-	const pool: TelemetryFieldKey[] = [
-		{ name: 'total_tokens', fieldContext: 'trace', fieldDataType: 'float64' },
-		{ name: 'llm_call_count', fieldContext: 'trace', fieldDataType: 'float64' },
-	];
-
-	const fieldKeysConfig: FieldKeysConfigProp = {
-		fieldContext: TelemetrytypesFieldContextDTO.trace,
-	};
-	const builderQueryType: BuilderQueryType = 'builder_ai_query';
-
-	const mockPool = (fields: TelemetryFieldKey[]): void => {
-		(useFieldKeysSuggestion as jest.Mock).mockReturnValue({
-			data: fields,
-			isFetching: false,
-			isFetched: true,
-		});
-	};
-
-	beforeEach(() => {
-		mockPool(pool);
-	});
-
-	it('lists the pool it is handed', () => {
-		renderOtherFields({
-			fieldKeysConfig,
-			builderQueryType,
-			allowCustomFields: false,
-		});
-
-		expect(screen.getByText('total_tokens')).toBeInTheDocument();
-		expect(screen.getByText('llm_call_count')).toBeInTheDocument();
-	});
-
-	it('forwards the fetch params and search to the shared keys hook', () => {
-		renderOtherFields({
-			fieldKeysConfig,
-			builderQueryType,
-			allowCustomFields: false,
-			debouncedInputValue: 'llm',
-		});
-
-		expect(useFieldKeysSuggestion).toHaveBeenCalledWith(
-			{
-				...fieldKeysConfig,
-				signal: DATA_SOURCE_TO_SIGNAL[DataSource.LOGS],
-				searchText: 'llm',
-			},
-			builderQueryType,
-		);
-	});
-
-	it('lists extra fields the keys endpoint never returns', () => {
-		mockPool([{ name: 'total_tokens' } as TelemetryFieldKey]);
-
-		renderOtherFields({
-			fieldKeysConfig,
-			builderQueryType,
-			extraFields: [{ name: 'last_activity_time' } as TelemetryFieldKey],
-			allowCustomFields: false,
-		});
-
-		expect(screen.getByText('last_activity_time')).toBeInTheDocument();
-		expect(screen.getByText('total_tokens')).toBeInTheDocument();
-	});
-
-	it('filters extra fields by search text', () => {
-		mockPool([]);
-
-		renderOtherFields({
-			fieldKeysConfig,
-			builderQueryType,
-			extraFields: [
-				{ name: 'last_activity_time' } as TelemetryFieldKey,
-				{ name: 'timestamp' } as TelemetryFieldKey,
-			],
-			debouncedInputValue: 'activity',
-			allowCustomFields: false,
-		});
-
-		expect(screen.getByText('last_activity_time')).toBeInTheDocument();
-		expect(screen.queryByText('timestamp')).not.toBeInTheDocument();
-	});
-
-	it('keeps a fetched key whose name does not contain the search text', () => {
-		mockPool([
-			{ name: 'service.name', fieldContext: 'resource' } as TelemetryFieldKey,
-		]);
-
-		renderOtherFields({
-			debouncedInputValue: 'resource.service',
-			allowCustomFields: false,
-		});
-
-		expect(screen.getByText('service.name')).toBeInTheDocument();
-	});
-
-	it('omits pool fields that are already added', () => {
-		renderOtherFields({
-			fieldKeysConfig,
-			builderQueryType,
-			allowCustomFields: false,
-			addedFields: [
-				{
-					name: 'total_tokens',
-					fieldContext: 'trace',
-					fieldDataType: 'float64',
-					key: 'trace:total_tokens:float64',
-				},
-			],
-		});
-
-		expect(screen.queryByText('total_tokens')).not.toBeInTheDocument();
-		expect(screen.getByText('llm_call_count')).toBeInTheDocument();
-	});
-});

frontend/src/components/OrderBy/ListViewOrderBy.tsx

@@ -1,23 +1,16 @@
 import { useEffect, useRef, useState } from 'react';
+import { useQuery } from 'react-query';
 import { Select, Spin } from 'antd';
-import { FieldKeysConfigProp } from 'api/querySuggestions/types';
-import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
-import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
+import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
+import { QueryKeyDataSuggestionsProps } from 'types/api/querySuggestions/types';
+import { DataSource } from 'types/common/queryBuilder';
 
 import './ListViewOrderBy.styles.scss';
 
-const DEFAULT_EXTRA_FIELDS: TelemetryFieldKey[] = [
-	{ name: 'timestamp' } as TelemetryFieldKey,
-];
-
 interface ListViewOrderByProps {
 	value: string;
 	onChange: (value: string) => void;
 	dataSource: DataSource;
-	fieldKeysConfig?: FieldKeysConfigProp;
-	builderQueryType?: BuilderQueryType;
-	extraFields?: TelemetryFieldKey[];
 }
 
 // Loader component for the dropdown when loading or no results
@@ -33,9 +26,6 @@ function ListViewOrderBy({
 	value,
 	onChange,
 	dataSource,
-	fieldKeysConfig,
-	builderQueryType,
-	extraFields = DEFAULT_EXTRA_FIELDS,
 }: ListViewOrderByProps): JSX.Element {
 	const [searchInput, setSearchInput] = useState('');
 	const [debouncedInput, setDebouncedInput] = useState('');
@@ -44,14 +34,17 @@ function ListViewOrderBy({
 	>([]);
 	const debounceTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-	const { data, isLoading } = useFieldKeysSuggestion(
-		{
-			...fieldKeysConfig,
-			signal: DATA_SOURCE_TO_SIGNAL[dataSource],
-			searchText: debouncedInput,
+	// Fetch key suggestions based on debounced input
+	const { data, isLoading } = useQuery({
+		queryKey: ['orderByKeySuggestions', dataSource, debouncedInput],
+		queryFn: async () => {
+			const response = await getKeySuggestions({
+				signal: dataSource,
+				searchText: debouncedInput,
+			});
+			return response.data;
 		},
-		builderQueryType,
-	);
+	});
 
 	useEffect(
 		() => (): void => {
@@ -62,24 +55,24 @@ function ListViewOrderBy({
 		[],
 	);
 
-	const extraKeysSignature = extraFields.map((field) => field.name).join(',');
-
 	// Update options when API data changes
 	useEffect(() => {
-		const keyNames = (data ?? []).map((field) => field.name);
-		const search = searchInput.trim().toLowerCase();
-		const extraMatches = extraKeysSignature
-			.split(',')
-			.filter((key) => key.length > 0 && key.toLowerCase().includes(search));
-		const uniqueKeys = [...new Set([...extraMatches, ...keyNames])];
+		const rawKeys: QueryKeyDataSuggestionsProps[] = data?.data?.keys
+			? Object.values(data.data?.keys).flat()
+			: [];
 
-		setSelectOptions(
-			uniqueKeys.flatMap((key) => [
-				{ label: `${key} (desc)`, value: `${key}:desc` },
-				{ label: `${key} (asc)`, value: `${key}:asc` },
-			]),
-		);
-	}, [data, searchInput, extraKeysSignature]);
+		const keyNames = rawKeys.map((key) => key.name);
+		const uniqueKeys = [
+			...new Set(searchInput ? keyNames : ['timestamp', ...keyNames]),
+		];
+
+		const updatedOptions = uniqueKeys.flatMap((key) => [
+			{ label: `${key} (desc)`, value: `${key}:desc` },
+			{ label: `${key} (asc)`, value: `${key}:asc` },
+		]);
+
+		setSelectOptions(updatedOptions);
+	}, [data, searchInput]);
 
 	// Handle search input with debounce
 	const handleSearch = (input: string): void => {

frontend/src/components/OrderBy/__tests__/ListViewOrderBy.test.tsx

@@ -1,169 +0,0 @@
-import { fireEvent, render, screen, waitFor } from 'tests/test-utils';
-import { ENVIRONMENT } from 'constants/env';
-import {
-	TRACE_VIEW_BUILDER_QUERY_TYPE,
-	TRACE_VIEW_FIELD_KEYS,
-	TRACE_VIEW_ORDER_BY_EXTRA_FIELDS,
-} from 'container/LLMObservability/Explorer/constants';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
-import { DataSource } from 'types/common/queryBuilder';
-
-import ListViewOrderBy from '../ListViewOrderBy';
-
-const seenAI: URLSearchParams[] = [];
-const seenGeneric: URLSearchParams[] = [];
-
-const mockAIKeys = (names: string[]): void => {
-	server.use(
-		rest.get(
-			`${ENVIRONMENT.baseURL}/api/v1/ai_observability/fields/keys`,
-			(req, res, ctx) => {
-				seenAI.push(req.url.searchParams);
-				return res(
-					ctx.status(200),
-					ctx.json({
-						status: 'success',
-						data: {
-							complete: true,
-							keys: Object.fromEntries(names.map((name) => [name, [{ name }]])),
-						},
-					}),
-				);
-			},
-		),
-	);
-};
-
-const mockGenericKeys = (names: string[]): void => {
-	server.use(
-		rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/keys`, (req, res, ctx) => {
-			seenGeneric.push(req.url.searchParams);
-			return res(
-				ctx.status(200),
-				ctx.json({
-					status: 'success',
-					data: {
-						complete: true,
-						keys: Object.fromEntries(names.map((name) => [name, [{ name }]])),
-					},
-				}),
-			);
-		}),
-	);
-};
-
-const openDropdown = (): void => {
-	fireEvent.mouseDown(screen.getByRole('combobox'));
-};
-
-const getOptionLabels = (): string[] =>
-	Array.from(document.querySelectorAll('.ant-select-item-option-content')).map(
-		(node) => node.textContent ?? '',
-	);
-
-describe('ListViewOrderBy', () => {
-	beforeEach(() => {
-		seenAI.length = 0;
-		seenGeneric.length = 0;
-	});
-
-	it('reads the ai_observability trace context for an AI query', async () => {
-		mockAIKeys(['total_tokens']);
-
-		render(
-			<ListViewOrderBy
-				value="last_activity_time:desc"
-				onChange={jest.fn()}
-				dataSource={DataSource.TRACES}
-				fieldKeysConfig={TRACE_VIEW_FIELD_KEYS}
-				builderQueryType={TRACE_VIEW_BUILDER_QUERY_TYPE}
-				extraFields={TRACE_VIEW_ORDER_BY_EXTRA_FIELDS}
-			/>,
-		);
-
-		await waitFor(() => {
-			expect(seenAI).toHaveLength(1);
-		});
-		expect(seenAI[0]?.get('searchText')).toBe('');
-		expect(seenAI[0]?.get('fieldContext')).toBe(
-			TelemetrytypesFieldContextDTO.trace,
-		);
-		expect(seenGeneric).toHaveLength(0);
-	});
-
-	it('offers the extra keys alongside the ones the endpoint reports', async () => {
-		mockAIKeys(['total_tokens']);
-
-		render(
-			<ListViewOrderBy
-				value="last_activity_time:desc"
-				onChange={jest.fn()}
-				dataSource={DataSource.TRACES}
-				fieldKeysConfig={TRACE_VIEW_FIELD_KEYS}
-				builderQueryType={TRACE_VIEW_BUILDER_QUERY_TYPE}
-				extraFields={TRACE_VIEW_ORDER_BY_EXTRA_FIELDS}
-			/>,
-		);
-
-		openDropdown();
-
-		await waitFor(() => {
-			expect(getOptionLabels()).toContain('total_tokens (desc)');
-		});
-		expect(getOptionLabels()).toContain('last_activity_time (asc)');
-	});
-
-	it('keeps a matching extra key while searching', async () => {
-		mockAIKeys([]);
-
-		render(
-			<ListViewOrderBy
-				value="last_activity_time:desc"
-				onChange={jest.fn()}
-				dataSource={DataSource.TRACES}
-				fieldKeysConfig={TRACE_VIEW_FIELD_KEYS}
-				builderQueryType={TRACE_VIEW_BUILDER_QUERY_TYPE}
-				extraFields={TRACE_VIEW_ORDER_BY_EXTRA_FIELDS}
-			/>,
-		);
-
-		await waitFor(() => {
-			expect(seenAI.length).toBeGreaterThan(0);
-		});
-
-		openDropdown();
-		fireEvent.change(screen.getByRole('combobox'), {
-			target: { value: 'activity' },
-		});
-
-		await waitFor(() => {
-			expect(getOptionLabels()).toContain('last_activity_time (desc)');
-		});
-	});
-
-	it('defaults to timestamp and the generic endpoint', async () => {
-		mockGenericKeys(['service.name']);
-
-		render(
-			<ListViewOrderBy
-				value="timestamp:desc"
-				onChange={jest.fn()}
-				dataSource={DataSource.TRACES}
-			/>,
-		);
-
-		await waitFor(() => {
-			expect(seenGeneric).toHaveLength(1);
-		});
-		expect(seenGeneric[0]?.get('signal')).toBe(DataSource.TRACES);
-		expect(seenGeneric[0]?.get('searchText')).toBe('');
-
-		openDropdown();
-
-		await waitFor(() => {
-			expect(getOptionLabels()).toContain('timestamp (desc)');
-		});
-	});
-});

frontend/src/constants/localStorage.ts

@@ -12,8 +12,6 @@ export enum LOCALSTORAGE {
 	GRAPH_VISIBILITY_STATES = 'GRAPH_VISIBILITY_STATES',
 	TRACES_LIST_COLUMNS = 'TRACES_LIST_COLUMNS',
 	TRACES_VIEW_COLUMNS = 'TRACES_VIEW_COLUMNS',
-	AI_OBSERVABILITY_TRACE_VIEW_COLUMNS = 'AI_OBSERVABILITY_TRACE_VIEW_COLUMNS',
-	AI_OBSERVABILITY_LIST_COLUMNS = 'AI_OBSERVABILITY_LIST_COLUMNS',
 	LOGS_LIST_COLUMNS = 'LOGS_LIST_COLUMNS',
 	LOGS_LIST_COLUMN_SIZING = 'LOGS_LIST_COLUMN_SIZING',
 	LOGGED_IN_USER_NAME = 'LOGGED_IN_USER_NAME',

frontend/src/constants/reactQueryKeys.ts

@@ -106,8 +106,8 @@ export const REACT_QUERY_KEY = {
 	// Dashboard Grid Card Query Keys
 	DASHBOARD_GRID_CARD_QUERY_RANGE: 'DASHBOARD_GRID_CARD_QUERY_RANGE',
 
-	// Field Keys Suggestion Query Keys
-	FIELD_KEYS_SUGGESTION: 'FIELD_KEYS_SUGGESTION',
+	// Fields Selector Query Keys
+	GET_FIELDS_SELECTOR_SUGGESTIONS: 'GET_FIELDS_SELECTOR_SUGGESTIONS',
 
 	// AI Assistant Query Keys
 	AI_ASSISTANT_EMPTY_STATE_CHIPS: 'AI_ASSISTANT_EMPTY_STATE_CHIPS',

frontend/src/container/LLMObservability/Explorer/Controls/index.tsx

@@ -1,12 +1,10 @@
 import { memo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Settings } from '@signozhq/icons';
-import { FieldKeysConfigProp } from 'api/querySuggestions/types';
 import FieldsSelector from 'components/FieldsSelector';
 import Controls, { ControlsProps } from 'container/Controls';
 import { OptionsMenuConfig } from 'container/OptionsMenu/types';
 import useQueryPagination from 'hooks/queryPagination/useQueryPagination';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
 import { DataSource } from 'types/common/queryBuilder';
 
 import styles from './Controls.module.scss';
@@ -16,10 +14,7 @@ function TraceExplorerControls({
 	totalCount,
 	perPageOptions,
 	config,
-	fieldKeysConfig,
-	builderQueryType,
-	extraFields,
-	requiredFields,
+	showSizeChanger = true,
 }: TraceExplorerControlsProps): JSX.Element | null {
 	const { t } = useTranslation(['trace']);
 	const [isFieldsSelectorOpen, setIsFieldsSelectorOpen] = useState(false);
@@ -49,10 +44,6 @@ function TraceExplorerControls({
 						onFieldsChange={config.fieldsSelector.onFieldsChange}
 						onClose={(): void => setIsFieldsSelectorOpen(false)}
 						signal={DataSource.TRACES}
-						fieldKeysConfig={fieldKeysConfig}
-						builderQueryType={builderQueryType}
-						extraFields={extraFields}
-						requiredFields={requiredFields}
 					/>
 				</>
 			)}
@@ -66,28 +57,26 @@ function TraceExplorerControls({
 				handleCountItemsPerPageChange={handleCountItemsPerPageChange}
 				handleNavigateNext={handleNavigateNext}
 				handleNavigatePrevious={handleNavigatePrevious}
+				showSizeChanger={showSizeChanger}
 			/>
 		</div>
 	);
 }
 
+TraceExplorerControls.defaultProps = {
+	config: null,
+};
+
 type TraceExplorerControlsProps = Pick<
 	ControlsProps,
 	'isLoading' | 'totalCount' | 'perPageOptions'
 > & {
 	config?: OptionsMenuConfig | null;
-	fieldKeysConfig?: FieldKeysConfigProp;
-	builderQueryType?: BuilderQueryType;
-	extraFields?: TelemetryFieldKey[];
-	requiredFields?: readonly string[];
+	showSizeChanger?: boolean;
 };
 
 TraceExplorerControls.defaultProps = {
-	config: null,
-	fieldKeysConfig: undefined,
-	builderQueryType: undefined,
-	extraFields: undefined,
-	requiredFields: undefined,
+	showSizeChanger: true,
 };
 
 export default memo(TraceExplorerControls);

frontend/src/container/LLMObservability/Explorer/TracesView/TracesView.module.scss

@@ -10,25 +10,6 @@
 
 .actionsContainer {
 	display: flex;
-	justify-content: flex-end;
+	justify-content: space-between;
 	align-items: center;
 }
-
-.orderByContainer {
-	display: flex;
-	align-items: center;
-	gap: var(--spacing-4);
-}
-
-.orderByLabel {
-	color: var(--muted-foreground);
-	// Between --periscope-font-size-small (11px) and -base (13px), so literal.
-	font-size: 12px;
-	font-style: normal;
-	font-weight: 400;
-	line-height: 16px; /* 133.333% */
-
-	display: flex;
-	align-items: center;
-	gap: var(--spacing-2);
-}

frontend/src/container/LLMObservability/Explorer/TracesView/TracesView.tsx

@@ -3,45 +3,35 @@ import {
 	memo,
 	MutableRefObject,
 	SetStateAction,
-	useCallback,
 	useEffect,
 	useMemo,
-	useState,
 } from 'react';
 import { QueryKey } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
-import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
+import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
 import { ENTITY_VERSION_V5 } from 'constants/app';
-import { LOCALSTORAGE } from 'constants/localStorage';
 import { QueryParams } from 'constants/query';
 import { initialQueryAIWithType, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { getTraceLink } from '../ListView/utils';
-import { TracesTableRow } from '../TracesTable/getFieldColumn';
-import TracesTable from '../TracesTable/TracesTable';
+import TraceExplorerControls from 'container/TracesExplorer/Controls';
+import { getTraceLink } from 'container/TracesExplorer/ListView/utils';
+import { TracesTableRow } from 'container/TracesExplorer/TracesTable/getFieldColumn';
+import TracesTable from 'container/TracesExplorer/TracesTable/TracesTable';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { Pagination } from 'hooks/queryPagination';
 import useUrlQueryData from 'hooks/useUrlQueryData';
-import { ArrowUp10, Minus } from '@signozhq/icons';
 import { AppState } from 'store/reducers';
 import { Warning } from 'types/api';
 import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import DOCLINKS from 'utils/docLinks';
 
-import TraceExplorerControls from '../Controls';
-import {
-	TRACE_VIEW_BUILDER_QUERY_TYPE,
-	TRACE_VIEW_COLUMN_EXTRA_FIELDS,
-	TRACE_VIEW_DEFAULT_ORDER_BY,
-	TRACE_VIEW_FIELD_KEYS,
-	TRACE_VIEW_ORDER_BY_EXTRA_FIELDS,
-} from '../constants';
 import { getListViewQuery } from '../explorerUtils';
-import { PER_PAGE_OPTIONS } from './configs';
-import { useTraceViewColumns } from './useTraceViewColumns';
+import { columns, PER_PAGE_OPTIONS } from './configs';
 import styles from './TracesView.module.scss';
 
 interface TracesViewProps {
@@ -59,16 +49,6 @@ function TracesView({
 }: TracesViewProps): JSX.Element {
 	const { stagedQuery, panelType } = useQueryBuilder();
 
-	const [orderBy, setOrderBy] = useState<string>(TRACE_VIEW_DEFAULT_ORDER_BY);
-
-	const {
-		columns,
-		selectedFields,
-		onFieldsChange,
-		requiredFields,
-		isLoading: isColumnsLoading,
-	} = useTraceViewColumns();
-
 	const {
 		selectedTime: globalSelectedTime,
 		maxTime,
@@ -80,8 +60,8 @@ function TracesView({
 	);
 
 	const transformedQuery = useMemo(
-		() => getListViewQuery(stagedQuery || initialQueryAIWithType, orderBy),
-		[stagedQuery, orderBy],
+		() => getListViewQuery(stagedQuery || initialQueryAIWithType),
+		[stagedQuery],
 	);
 
 	const queryKey = useMemo(
@@ -93,7 +73,6 @@ function TracesView({
 			stagedQuery,
 			panelType,
 			paginationQueryData,
-			orderBy,
 		],
 		[
 			globalSelectedTime,
@@ -102,7 +81,6 @@ function TracesView({
 			stagedQuery,
 			panelType,
 			paginationQueryData,
-			orderBy,
 		],
 	);
 
@@ -164,43 +142,27 @@ function TracesView({
 		}
 	}, [isLoading, isFetching, isError, rows.length]);
 
-	const handleOrderChange = useCallback((value: string): void => {
-		setOrderBy(value);
-	}, []);
-
-	const fieldsSelectorConfig = useMemo(
-		() => ({ fieldsSelector: { value: selectedFields, onFieldsChange } }),
-		[selectedFields, onFieldsChange],
-	);
-
 	return (
 		<div className={styles.container}>
 			<div className={styles.actionsContainer}>
-				<div className="trace-explorer-controls">
-					<div className={styles.orderByContainer}>
-						<div className={styles.orderByLabel}>
-							Order by <Minus size={14} /> <ArrowUp10 size={14} />
-						</div>
+				<Typography>
+					This tab only shows Root Spans. More details
+					<Typography.Link href={DOCLINKS.TRACES_DETAILS_LINK} target="_blank">
+						{' '}
+						here
+					</Typography.Link>
+				</Typography>
 
-						<ListViewOrderBy
-							value={orderBy}
-							onChange={handleOrderChange}
-							dataSource={DataSource.TRACES}
-							fieldKeysConfig={TRACE_VIEW_FIELD_KEYS}
-							builderQueryType={TRACE_VIEW_BUILDER_QUERY_TYPE}
-							extraFields={TRACE_VIEW_ORDER_BY_EXTRA_FIELDS}
-						/>
-					</div>
+				<div className="trace-explorer-controls">
+					<DownloadOptionsMenu
+						dataSource={DataSource.TRACES}
+						panelType={PANEL_TYPES.TRACE}
+					/>
 
 					<TraceExplorerControls
 						isLoading={isLoading}
 						totalCount={rows.length}
 						perPageOptions={PER_PAGE_OPTIONS}
-						config={fieldsSelectorConfig}
-						fieldKeysConfig={TRACE_VIEW_FIELD_KEYS}
-						builderQueryType={TRACE_VIEW_BUILDER_QUERY_TYPE}
-						extraFields={TRACE_VIEW_COLUMN_EXTRA_FIELDS}
-						requiredFields={requiredFields}
 					/>
 				</div>
 			</div>
@@ -208,11 +170,10 @@ function TracesView({
 			<TracesTable
 				data={rows}
 				columns={columns}
-				columnStorageKey={LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS}
 				respectColumnOrder
 				panelType="TRACE"
 				getRowHref={getTraceLink}
-				isLoading={isLoading || isColumnsLoading}
+				isLoading={isLoading}
 				isFetching={isFetching}
 				isError={isError}
 				error={error}

frontend/src/container/LLMObservability/Explorer/TracesView/__tests__/useTraceViewColumns.test.tsx

@@ -1,219 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-import { ReactNode } from 'react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { ENVIRONMENT } from 'constants/env';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import {
-	TelemetrytypesFieldContextDTO,
-	TelemetrytypesFieldDataTypeDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { useColumnStore } from 'components/TanStackTableView/useColumnStore';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-
-import { useTraceViewColumns } from '../useTraceViewColumns';
-
-const STORAGE_KEY = LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS;
-
-const AGGREGATE_KEYS = [
-	'llm_call_count',
-	'tool_call_count',
-	'distinct_tool_count',
-	'input_tokens',
-	'output_tokens',
-	'total_tokens',
-	'estimated_total_cost',
-	'max_llm_duration_nano',
-];
-
-const fieldNames = (fields: TelemetryFieldKey[]): string[] =>
-	fields.map((field) => field.name);
-
-const columnNames = (columns: { header?: unknown }[]): string[] =>
-	columns.map((column) => column.header as string);
-
-function wrapper({ children }: { children: ReactNode }): JSX.Element {
-	const queryClient = new QueryClient({
-		defaultOptions: { queries: { retry: false } },
-	});
-	return (
-		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-	);
-}
-
-const seenAI: URLSearchParams[] = [];
-
-const mockAggregateKeys = (names: string[]): void => {
-	server.use(
-		rest.get(
-			`${ENVIRONMENT.baseURL}/api/v1/ai_observability/fields/keys`,
-			(req, res, ctx) => {
-				seenAI.push(req.url.searchParams);
-				return res(
-					ctx.status(200),
-					ctx.json({
-						status: 'success',
-						data: {
-							complete: true,
-							keys: Object.fromEntries(
-								names.map((name) => [
-									name,
-									[
-										{
-											name,
-											fieldContext: TelemetrytypesFieldContextDTO.trace,
-											fieldDataType: TelemetrytypesFieldDataTypeDTO.float64,
-										},
-									],
-								]),
-							),
-						},
-					}),
-				);
-			},
-		),
-	);
-};
-
-const renderColumns = async (): Promise<
-	ReturnType<typeof renderHook<ReturnType<typeof useTraceViewColumns>, unknown>>
-> => {
-	const rendered = renderHook(() => useTraceViewColumns(), { wrapper });
-	await waitFor(() => {
-		expect(rendered.result.current.isLoading).toBe(false);
-	});
-	return rendered;
-};
-
-describe('useTraceViewColumns', () => {
-	beforeEach(() => {
-		seenAI.length = 0;
-		useColumnStore.getState().tables = {};
-		localStorage.clear();
-		mockAggregateKeys(AGGREGATE_KEYS);
-	});
-
-	it('reads the aggregates from the trace context of the keys endpoint', async () => {
-		await renderColumns();
-
-		expect(seenAI).toHaveLength(1);
-		expect(seenAI[0]?.get('searchText')).toBe('');
-		expect(seenAI[0]?.get('fieldContext')).toBe(
-			TelemetrytypesFieldContextDTO.trace,
-		);
-	});
-
-	it('pools the hardcoded display-only columns with the endpoint aggregates', async () => {
-		const { result } = await renderColumns();
-
-		expect(columnNames(result.current.columns)).toStrictEqual([
-			'service.name',
-			'root_span_name',
-			'trace_duration_nano',
-			'span_count',
-			'trace_id',
-			'start_time',
-			'end_time',
-			'error_count',
-			'input',
-			'output',
-			...AGGREGATE_KEYS,
-		]);
-	});
-
-	it('selects only the default-visible columns on first render', async () => {
-		const { result } = await renderColumns();
-
-		expect(fieldNames(result.current.selectedFields)).toStrictEqual([
-			'service.name',
-			'root_span_name',
-			'trace_duration_nano',
-			'span_count',
-			'trace_id',
-			'llm_call_count',
-			'total_tokens',
-			'estimated_total_cost',
-		]);
-	});
-
-	it('keeps a newly reported aggregate hidden until it is picked', async () => {
-		mockAggregateKeys(['brand_new_aggregate']);
-
-		const { result } = await renderColumns();
-
-		expect(columnNames(result.current.columns)).toContain('brand_new_aggregate');
-		expect(fieldNames(result.current.selectedFields)).not.toContain(
-			'brand_new_aggregate',
-		);
-	});
-
-	it('hides the columns dropped from the selection', async () => {
-		const { result } = await renderColumns();
-
-		act(() => {
-			result.current.onFieldsChange([
-				{ name: 'trace_id' },
-				{ name: 'total_tokens', fieldContext: 'trace', fieldDataType: 'float64' },
-			]);
-		});
-
-		expect(fieldNames(result.current.selectedFields)).toStrictEqual([
-			'trace_id',
-			'total_tokens',
-		]);
-	});
-
-	it('shows a column added back from the pool', async () => {
-		const { result } = await renderColumns();
-
-		act(() => {
-			result.current.onFieldsChange([{ name: 'trace_id' }]);
-		});
-		act(() => {
-			result.current.onFieldsChange([{ name: 'trace_id' }, { name: 'input' }]);
-		});
-
-		expect(fieldNames(result.current.selectedFields)).toStrictEqual([
-			'trace_id',
-			'input',
-		]);
-	});
-
-	it('keeps the trace id column even when the selection drops it', async () => {
-		const { result } = await renderColumns();
-
-		act(() => {
-			result.current.onFieldsChange([{ name: 'span_count' }]);
-		});
-
-		expect(fieldNames(result.current.selectedFields)).toContain('trace_id');
-		expect(result.current.requiredFields).toStrictEqual(['trace_id']);
-	});
-
-	it('persists the selection order', async () => {
-		const { result } = await renderColumns();
-
-		act(() => {
-			result.current.onFieldsChange([
-				{ name: 'total_tokens', fieldContext: 'trace', fieldDataType: 'float64' },
-				{ name: 'trace_id' },
-				{ name: 'service.name', fieldContext: 'resource' },
-			]);
-		});
-
-		expect(fieldNames(result.current.selectedFields)).toStrictEqual([
-			'total_tokens',
-			'trace_id',
-			'service.name',
-		]);
-		expect(
-			useColumnStore.getState().tables[STORAGE_KEY].columnOrder,
-		).toStrictEqual([
-			'trace:total_tokens:float64',
-			'trace_id',
-			'resource:service.name',
-		]);
-	});
-});

frontend/src/container/LLMObservability/Explorer/TracesView/configs.tsx

@@ -5,29 +5,18 @@ import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';
 
 export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];
 
-/** Always visible: it is the row's link to the trace. */
-export const TRACE_ID_COLUMN_ID = 'trace_id';
+const TRACE_FIELDS = [
+	{ name: 'service.name', fieldContext: 'resource' },
+	{ name: 'name' },
+	{ name: 'duration_nano' },
+	{ name: 'span_count' },
+	{ name: 'trace_id' },
+] as TelemetryFieldKey[];
 
-/** Everything else starts hidden, including any aggregate the endpoint adds later. */
-const DEFAULT_VISIBLE_FIELDS = new Set([
-	'service.name',
-	'root_span_name',
-	'trace_duration_nano',
-	'span_count',
-	'llm_call_count',
-	'total_tokens',
-	'estimated_total_cost',
-	TRACE_ID_COLUMN_ID,
-]);
-
-export const buildTraceViewColumns = (
-	fields: TelemetryFieldKey[],
-): TableColumnDef<TracesTableRow>[] =>
-	fields.map((field) => ({
+export const columns: TableColumnDef<TracesTableRow>[] = TRACE_FIELDS.map(
+	(field) => ({
 		...getFieldColumn(field),
-		defaultVisibility: DEFAULT_VISIBLE_FIELDS.has(field.name),
-		// The shared column builder pins anything in TIMESTAMP_FIELD_NAMES; these stay movable.
-		enableMove: field.name !== TRACE_ID_COLUMN_ID,
-		enableRemove: field.name !== TRACE_ID_COLUMN_ID,
-		canBeHidden: field.name !== TRACE_ID_COLUMN_ID,
-	}));
+		enableRemove: false,
+		canBeHidden: false,
+	}),
+);

frontend/src/container/LLMObservability/Explorer/TracesView/useTraceViewColumns.ts

@@ -1,109 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react';
-import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
-import { mergeExtraFields } from 'utils/extraFields';
-import type { TableColumnDef } from 'components/TanStackTableView/types';
-import {
-	hideColumn,
-	initializeFromDefaults,
-	setColumnOrder,
-	showColumn,
-	useColumnOrder,
-	useHiddenColumnIds,
-} from 'components/TanStackTableView/useColumnStore';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { buildCompositeKey } from 'container/OptionsMenu/utils';
-import { TracesTableRow } from '../TracesTable/getFieldColumn';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
-
-import {
-	TRACE_VIEW_BUILDER_QUERY_TYPE,
-	TRACE_VIEW_COLUMN_EXTRA_FIELDS,
-	TRACE_VIEW_FIELD_KEYS,
-} from '../constants';
-import { buildTraceViewColumns, TRACE_ID_COLUMN_ID } from './configs';
-
-const STORAGE_KEY = LOCALSTORAGE.AI_OBSERVABILITY_TRACE_VIEW_COLUMNS;
-
-/** Matches the id getFieldColumn derives, so fields and columns address alike. */
-const columnIdOf = (field: TelemetryFieldKey): string =>
-	buildCompositeKey(field.name, field.fieldContext, field.fieldDataType);
-
-interface UseTraceViewColumns {
-	columns: TableColumnDef<TracesTableRow>[];
-	selectedFields: TelemetryFieldKey[];
-	onFieldsChange: (next: TelemetryFieldKey[]) => void;
-	requiredFields: readonly string[];
-	isLoading: boolean;
-}
-
-// TODO(ai-explorer): browser-local only, unlike the list views' `?options=` columns.
-export function useTraceViewColumns(): UseTraceViewColumns {
-	const { data: fetchedFields = [], isFetched } = useFieldKeysSuggestion(
-		{
-			...TRACE_VIEW_FIELD_KEYS,
-			signal: DATA_SOURCE_TO_SIGNAL[DataSource.TRACES],
-			searchText: '',
-		},
-		TRACE_VIEW_BUILDER_QUERY_TYPE,
-	);
-
-	const availableFields = useMemo(
-		() => mergeExtraFields(TRACE_VIEW_COLUMN_EXTRA_FIELDS, fetchedFields),
-		[fetchedFields],
-	);
-
-	const columns = useMemo(
-		() => buildTraceViewColumns(availableFields),
-		[availableFields],
-	);
-
-	// Defaults from a partial column set would persist as the user's own choice.
-	useEffect(() => {
-		if (isFetched) {
-			initializeFromDefaults(STORAGE_KEY, columns);
-		}
-	}, [isFetched, columns]);
-
-	const hiddenColumnIds = useHiddenColumnIds(STORAGE_KEY);
-	const columnOrder = useColumnOrder(STORAGE_KEY);
-
-	const selectedFields = useMemo(() => {
-		const hidden = new Set(hiddenColumnIds);
-		const orderIndex = new Map(columnOrder.map((id, index) => [id, index]));
-
-		return availableFields
-			.filter((field) => !hidden.has(columnIdOf(field)))
-			.sort(
-				(a, b) =>
-					(orderIndex.get(columnIdOf(a)) ?? Infinity) -
-					(orderIndex.get(columnIdOf(b)) ?? Infinity),
-			);
-	}, [availableFields, hiddenColumnIds, columnOrder]);
-
-	const onFieldsChange = useCallback(
-		(next: TelemetryFieldKey[]): void => {
-			const keptIds = new Set(next.map(columnIdOf));
-
-			columns.forEach((column) => {
-				if (keptIds.has(column.id) || column.id === TRACE_ID_COLUMN_ID) {
-					showColumn(STORAGE_KEY, column.id);
-				} else {
-					hideColumn(STORAGE_KEY, column.id);
-				}
-			});
-
-			// Columns missing from the order sort last, so the visible ones suffice.
-			setColumnOrder(STORAGE_KEY, next.map(columnIdOf));
-		},
-		[columns],
-	);
-
-	return {
-		columns,
-		selectedFields,
-		onFieldsChange,
-		requiredFields: [TRACE_ID_COLUMN_ID],
-		isLoading: !isFetched,
-	};
-}

frontend/src/container/LLMObservability/Explorer/constants.ts

@@ -1,6 +1,3 @@
-import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-
 export const TOOLBAR_VIEWS = {
 	list: {
 		name: 'list',
@@ -37,29 +34,3 @@ export const TOOLBAR_VIEWS = {
 		key: 'clickhouse',
 	},
 };
-
-export const TRACE_VIEW_DEFAULT_ORDER_BY = 'last_activity_time:desc';
-
-/** Display-only: ordering or filtering on one is an error, so the keys endpoint omits them. */
-export const TRACE_VIEW_COLUMN_EXTRA_FIELDS: TelemetryFieldKey[] = [
-	{ name: 'service.name', fieldContext: 'resource' },
-	{ name: 'root_span_name' },
-	{ name: 'trace_duration_nano' },
-	{ name: 'span_count' },
-	{ name: 'trace_id' },
-	{ name: 'start_time' },
-	{ name: 'end_time' },
-	{ name: 'error_count' },
-	{ name: 'input' },
-	{ name: 'output' },
-] as TelemetryFieldKey[];
-
-export const TRACE_VIEW_FIELD_KEYS = {
-	fieldContext: TelemetrytypesFieldContextDTO.trace,
-} as const;
-
-export const TRACE_VIEW_BUILDER_QUERY_TYPE = 'builder_ai_query' as const;
-
-export const TRACE_VIEW_ORDER_BY_EXTRA_FIELDS: TelemetryFieldKey[] = [
-	{ name: 'last_activity_time' } as TelemetryFieldKey,
-];

frontend/src/hooks/querySuggestions/__tests__/useFieldKeysSuggestion.test.ts

@@ -1,185 +0,0 @@
-import { QueryClient } from 'react-query';
-import { ENVIRONMENT } from 'constants/env';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
-import { FieldKeysConfig, FieldKeysResponse } from 'api/querySuggestions/types';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
-import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
-
-import {
-	getFieldKeysQueryOptions,
-	toFieldKeys,
-} from '../useFieldKeysSuggestion';
-
-/** Drives the options object the way react-query does, without a client. */
-const fetchKeys = async (
-	fieldKeysConfig: FieldKeysConfig,
-	builderQueryType?: BuilderQueryType,
-): Promise<TelemetryFieldKey[]> => {
-	const { queryFn, select } = getFieldKeysQueryOptions(
-		fieldKeysConfig,
-		builderQueryType,
-	);
-	const response = await (
-		queryFn as (context: { signal: AbortSignal }) => Promise<FieldKeysResponse>
-	)({ signal: new AbortController().signal });
-
-	return select?.(response) ?? [];
-};
-
-const mockKeys = (
-	path: '/api/v1/ai_observability/fields/keys' | '/api/v1/fields/keys',
-	names: string[],
-	onRequest?: (params: URLSearchParams) => void,
-): void => {
-	server.use(
-		rest.get(`${ENVIRONMENT.baseURL}${path}`, (req, res, ctx) => {
-			onRequest?.(req.url.searchParams);
-			return res(
-				ctx.status(200),
-				ctx.json({
-					status: 'success',
-					data: {
-						complete: true,
-						keys: Object.fromEntries(names.map((name) => [name, [{ name }]])),
-					},
-				}),
-			);
-		}),
-	);
-};
-
-describe('useFieldKeysSuggestion', () => {
-	let queryClient: QueryClient;
-
-	beforeEach(() => {
-		queryClient = new QueryClient({
-			defaultOptions: { queries: { retry: false } },
-		});
-	});
-
-	it('reads the ai_observability endpoint for a builder_ai_query', async () => {
-		const seen: URLSearchParams[] = [];
-		mockKeys(
-			'/api/v1/ai_observability/fields/keys',
-			['total_tokens'],
-			(params) => {
-				seen.push(params);
-			},
-		);
-
-		const keys = await fetchKeys(
-			{
-				signal: DATA_SOURCE_TO_SIGNAL[DataSource.TRACES],
-				searchText: 'llm',
-				fieldContext: TelemetrytypesFieldContextDTO.trace,
-			},
-			'builder_ai_query',
-		);
-
-		expect(seen).toHaveLength(1);
-		expect(seen[0]?.get('searchText')).toBe('llm');
-		expect(seen[0]?.get('fieldContext')).toBe(
-			TelemetrytypesFieldContextDTO.trace,
-		);
-		expect(keys.map((key) => key.name)).toStrictEqual(['total_tokens']);
-	});
-
-	it('reads the generic endpoint for an unmarked query', async () => {
-		const seen: URLSearchParams[] = [];
-		mockKeys('/api/v1/fields/keys', ['service.name'], (params) => {
-			seen.push(params);
-		});
-
-		const keys = await fetchKeys({
-			signal: DATA_SOURCE_TO_SIGNAL[DataSource.TRACES],
-			searchText: 'svc',
-		});
-
-		expect(seen).toHaveLength(1);
-		expect(seen[0]?.get('signal')).toBe(DataSource.TRACES);
-		expect(seen[0]?.get('searchText')).toBe('svc');
-		expect(keys.map((key) => key.name)).toStrictEqual(['service.name']);
-	});
-
-	it('reads the trace context of the ai_observability endpoint', async () => {
-		const seen: URLSearchParams[] = [];
-		mockKeys(
-			'/api/v1/ai_observability/fields/keys',
-			['total_tokens'],
-			(params) => {
-				seen.push(params);
-			},
-		);
-
-		const keys = await fetchKeys(
-			{
-				signal: DATA_SOURCE_TO_SIGNAL[DataSource.TRACES],
-				searchText: '',
-				fieldContext: TelemetrytypesFieldContextDTO.trace,
-			},
-			'builder_ai_query',
-		);
-
-		expect(seen[0]?.get('searchText')).toBe('');
-		expect(keys.map((key) => key.name)).toStrictEqual(['total_tokens']);
-	});
-
-	it('reuses the cached keys response for a second empty search', async () => {
-		const seen: URLSearchParams[] = [];
-		mockKeys(
-			'/api/v1/ai_observability/fields/keys',
-			['total_tokens'],
-			(params) => {
-				seen.push(params);
-			},
-		);
-
-		const fieldKeysConfig = {
-			signal: DATA_SOURCE_TO_SIGNAL[DataSource.TRACES],
-			searchText: '',
-			fieldContext: TelemetrytypesFieldContextDTO.trace,
-		};
-
-		// Built twice: equal keys must resolve to one cache entry, not two requests.
-		await queryClient.fetchQuery(
-			getFieldKeysQueryOptions(fieldKeysConfig, 'builder_ai_query'),
-		);
-		await queryClient.fetchQuery(
-			getFieldKeysQueryOptions(fieldKeysConfig, 'builder_ai_query'),
-		);
-
-		expect(seen).toHaveLength(1);
-	});
-
-	it('hands the query signal to the fetcher so a superseded search aborts', async () => {
-		server.use(
-			rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/keys`, (_req, res, ctx) =>
-				res(ctx.delay(500), ctx.status(200), ctx.json({ status: 'success' })),
-			),
-		);
-
-		const controller = new AbortController();
-		const { queryFn } = getFieldKeysQueryOptions({
-			signal: DATA_SOURCE_TO_SIGNAL[DataSource.LOGS],
-			searchText: 'svc',
-		});
-		const pending = (
-			queryFn as (context: { signal: AbortSignal }) => Promise<unknown>
-		)({ signal: controller.signal });
-
-		controller.abort();
-
-		await expect(pending).rejects.toBeDefined();
-	});
-
-	it('treats a null keys map as empty', () => {
-		expect(
-			toFieldKeys({
-				status: 'success',
-				data: { complete: false, keys: null },
-			}),
-		).toStrictEqual([]);
-	});
-});

frontend/src/hooks/querySuggestions/useFieldKeysSuggestion.ts

@@ -1,50 +0,0 @@
-import {
-	QueryKey,
-	useQuery,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { ErrorType } from 'api/generatedAPIInstance';
-import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
-import { getFieldKeySuggestions } from 'api/querySuggestions/getFieldKeySuggestions';
-import { FIELD_API_CACHE_TIME } from 'constants/queryCacheTime';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { FieldKeysConfig, FieldKeysResponse } from 'api/querySuggestions/types';
-import { BuilderQueryType, TelemetryFieldKey } from 'types/api/v5/queryRange';
-
-export type FieldKeysQueryOptions = UseQueryOptions<
-	FieldKeysResponse,
-	ErrorType<RenderErrorResponseDTO>,
-	TelemetryFieldKey[]
-> & { queryKey: QueryKey };
-
-export const toFieldKeys = (
-	res: FieldKeysResponse | undefined,
-): TelemetryFieldKey[] =>
-	Object.values(res?.data?.keys ?? {})
-		.flat()
-		.map((key) => ({ ...key }) as TelemetryFieldKey);
-
-export const getFieldKeysQueryOptions = (
-	fieldKeysConfig: FieldKeysConfig,
-	builderQueryType?: BuilderQueryType,
-): FieldKeysQueryOptions => ({
-	queryKey: [
-		REACT_QUERY_KEY.FIELD_KEYS_SUGGESTION,
-		builderQueryType,
-		fieldKeysConfig,
-	],
-	queryFn: ({ signal }): Promise<FieldKeysResponse> =>
-		getFieldKeySuggestions(fieldKeysConfig, builderQueryType, signal),
-	select: toFieldKeys,
-	staleTime: FIELD_API_CACHE_TIME,
-	cacheTime: FIELD_API_CACHE_TIME,
-	refetchOnMount: false,
-	refetchOnWindowFocus: false,
-});
-
-export const useFieldKeysSuggestion = (
-	fieldKeysConfig: FieldKeysConfig,
-	builderQueryType?: BuilderQueryType,
-): UseQueryResult<TelemetryFieldKey[], ErrorType<RenderErrorResponseDTO>> =>
-	useQuery(getFieldKeysQueryOptions(fieldKeysConfig, builderQueryType));

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

@@ -1,44 +0,0 @@
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-
-import { mergeExtraFields } from '../extraFields';
-
-describe('mergeExtraFields', () => {
-	it('drops fetched keys that share a composite key with an extra field', () => {
-		expect(
-			mergeExtraFields(
-				[{ name: 'trace_id' } as TelemetryFieldKey],
-				[
-					{ name: 'trace_id' } as TelemetryFieldKey,
-					{ name: 'total_tokens' } as TelemetryFieldKey,
-				],
-			).map((key) => key.name),
-		).toStrictEqual(['trace_id', 'total_tokens']);
-	});
-
-	it('keeps extra and fetched keys that share a name but differ in context', () => {
-		expect(
-			mergeExtraFields(
-				[{ name: 'service.name', fieldContext: 'resource' } as TelemetryFieldKey],
-				[
-					{
-						name: 'service.name',
-						fieldContext: 'attribute',
-					} as TelemetryFieldKey,
-					{ name: 'total_tokens' } as TelemetryFieldKey,
-				],
-			),
-		).toStrictEqual([
-			{ name: 'service.name', fieldContext: 'resource' },
-			{ name: 'service.name', fieldContext: 'attribute' },
-			{ name: 'total_tokens' },
-		]);
-	});
-
-	it('returns the fetched keys when there are no extra fields', () => {
-		expect(
-			mergeExtraFields(undefined, [
-				{ name: 'total_tokens' } as TelemetryFieldKey,
-			]).map((key) => key.name),
-		).toStrictEqual(['total_tokens']);
-	});
-});

frontend/src/utils/extraFields.ts

@@ -1,23 +0,0 @@
-import { buildCompositeKey } from 'container/OptionsMenu/utils';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-
-export const mergeExtraFields = (
-	extra: TelemetryFieldKey[] = [],
-	fetched: TelemetryFieldKey[],
-): TelemetryFieldKey[] => {
-	const extraKeys = new Set(
-		extra.map((field) =>
-			buildCompositeKey(field.name, field.fieldContext, field.fieldDataType),
-		),
-	);
-
-	return [
-		...extra,
-		...fetched.filter(
-			(field) =>
-				!extraKeys.has(
-					buildCompositeKey(field.name, field.fieldContext, field.fieldDataType),
-				),
-		),
-	];
-};

pkg/apiserver/signozapiserver/tracedetail.go

@@ -10,23 +10,6 @@ import (
 )
 
 func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/traces/{traceID}/summary", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetTraceSummary),
-		handler.OpenAPIDef{
-			ID:                  "GetTraceSummary",
-			Tags:                []string{"tracedetail"},
-			Summary:             "Get summary for a trace",
-			Description:         "Returns the trace-level fields of the waterfall (time range, root, span counts, missing spans) and, when the trace has gen_ai spans, its token and cost totals. Computed in one aggregate query.",
-			Response:            new(spantypes.GettableTraceSummary),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v4/traces/{traceID}/waterfall", handler.New(
 		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfallV4),
 		handler.OpenAPIDef{

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -6,9 +6,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/gorilla/mux"
 )
 
@@ -20,27 +18,6 @@ func NewHandler(module tracedetail.Module) tracedetail.Handler {
 	return &handler{module: module}
 }
 
-func (h *handler) GetTraceSummary(rw http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	stats, err := h.module.GetTraceStats(r.Context(), orgID, mux.Vars(r)["traceID"])
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spantypes.NewGettableTraceSummary(stats))
-}
-
 func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
 	req := new(spantypes.PostableWaterfall)
 	if err := binding.JSON.BindBody(r.Body, req); err != nil {

pkg/modules/tracedetail/impltracedetail/module.go

@@ -8,7 +8,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"go.opentelemetry.io/otel/metric"
 )
 
@@ -40,21 +39,6 @@ func NewModule(traceStore spantypes.TraceStore, providerSettings factory.Provide
 	return m
 }
 
-func (m *module) GetTraceStats(ctx context.Context, orgID valuer.UUID, traceID string) (*spantypes.TraceStats, error) {
-	summary, err := m.store.GetTraceSummary(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-	stats, err := m.store.GetTraceStats(ctx, orgID, traceID, summary)
-	if err != nil {
-		return nil, err
-	}
-	if stats.TotalSpans == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-	return stats, nil
-}
-
 // GetWaterfallV4 is the OOM-safe V4 waterfall.
 // For large traces (NumSpans > effectiveLimit) it uses a two-step fetch:
 // minimal fields for all spans to build the tree, then full fields for the

pkg/modules/tracedetail/impltracedetail/store.go

@@ -10,15 +10,9 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/clickhousesql"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 const colServiceName = `resource_string_service$$$$name` // $ gets escaped so $$$$ converts to $$.
@@ -44,18 +38,10 @@ type spanDurationRow struct {
 
 type traceStore struct {
 	telemetryStore telemetrystore.TelemetryStore
-	metadataStore  telemetrytypes.MetadataStore
-	storage        qbtypes.Storage
-	flagger        flagger.Flagger
 }
 
-func NewTraceStore(ts telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, fl flagger.Flagger) *traceStore {
-	return &traceStore{
-		telemetryStore: ts,
-		metadataStore:  metadataStore,
-		storage:        tracestelemetryschema.NewStorage(),
-		flagger:        fl,
-	}
+func NewTraceStore(ts telemetrystore.TelemetryStore) *traceStore {
+	return &traceStore{telemetryStore: ts}
 }
 
 func (s *traceStore) GetTraceSummary(ctx context.Context, traceID string) (*spantypes.TraceSummary, error) {
@@ -79,131 +65,6 @@ func (s *traceStore) GetTraceSummary(ctx context.Context, traceID string) (*span
 	return &summary, nil
 }
 
-func (s *traceStore) GetTraceStats(ctx context.Context, orgID valuer.UUID, traceID string, summary *spantypes.TraceSummary) (*spantypes.TraceStats, error) {
-	table := fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable)
-	spans := sqlbuilder.NewSelectBuilder()
-
-	genAIColumns, err := s.genAISpanColumns(ctx, orgID, summary, spans)
-	if err != nil {
-		return nil, err
-	}
-
-	// A span whose parent was never recorded hangs off a synthetic "Missing Span" root in the waterfall.
-	ids := sqlbuilder.NewSelectBuilder()
-	ids.Select("span_id")
-	ids.From(table)
-	ids.Where(
-		ids.E("trace_id", traceID),
-		ids.GE("ts_bucket_start", summary.Start.Unix()-1800),
-		ids.LE("ts_bucket_start", summary.End.Unix()),
-	)
-	missingParent := fmt.Sprintf("parent_span_id <> '' AND parent_span_id GLOBAL NOT IN (%s)", spans.Var(ids))
-
-	spans.Select(
-		"toUnixTimestamp64Nano(timestamp) AS span_start_ns",
-		"span_start_ns + duration_nano AS span_end_ns",
-		"span_id",
-		"has_error",
-		"("+missingParent+") AS has_missing_parent",
-		"(parent_span_id = '' OR has_missing_parent) AS is_root",
-		"if(parent_span_id = '', name, 'Missing Span') AS root_name",
-		"if(parent_span_id = '', "+colServiceName+", '') AS root_service",
-	)
-	spans.SelectMore(genAIColumns...)
-	spans.From(table)
-	spans.Where(
-		spans.E("trace_id", traceID),
-		spans.GE("ts_bucket_start", summary.Start.Unix()-1800),
-		spans.LE("ts_bucket_start", summary.End.Unix()),
-	)
-	spans.SQL("LIMIT 1 BY span_id")
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(
-		"toUInt64(min(span_start_ns)) AS start_ns",
-		"toUInt64(max(span_end_ns)) AS end_ns",
-		"count() AS total_spans",
-		"countIf(has_error) AS total_error_spans",
-		"countIf(has_missing_parent) > 0 AS has_missing_spans",
-		"argMinIf(root_service, (span_start_ns, root_name), is_root) AS root_service_name",
-		"argMinIf(root_name, (span_start_ns, root_name), is_root) AS root_entry_point",
-		"countIf(is_gen_ai) AS gen_ai_span_count",
-		"toUInt64(coalesce(sum(input_tokens_value), 0)) AS input_tokens",
-		"toUInt64(coalesce(sum(output_tokens_value), 0)) AS output_tokens",
-		"toUInt64(coalesce(sum(cache_read_tokens_value), 0)) AS cache_read_tokens",
-		"toUInt64(coalesce(sum(cache_write_tokens_value), 0)) AS cache_write_tokens",
-		"toUInt64(coalesce(sum(reasoning_tokens_value), 0)) AS reasoning_tokens",
-		"sum(total_cost_value) AS total_cost",
-	)
-	sb.From(sb.BuilderAs(spans, "spans"))
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	var stats spantypes.TraceStats
-	err = s.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(
-		&stats.StartNs, &stats.EndNs, &stats.TotalSpans, &stats.TotalErrorSpans, &stats.HasMissingSpans,
-		&stats.RootServiceName, &stats.RootEntryPoint, &stats.GenAISpanCount,
-		&stats.Tokens.Input, &stats.Tokens.Output, &stats.Tokens.CacheRead, &stats.Tokens.CacheWrite, &stats.Tokens.Reasoning,
-		&stats.TotalCost,
-	)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying trace stats")
-	}
-	return &stats, nil
-}
-
-// genAISpanColumns renders the per-span gen_ai gate and value reads through the shared
-// traces storage, so each attribute is read from the column its evolutions place it in
-// over the trace's own time window. Exists predicates bind their args into sb.
-func (s *traceStore) genAISpanColumns(ctx context.Context, orgID valuer.UUID, summary *spantypes.TraceSummary, sb *sqlbuilder.SelectBuilder) ([]string, error) {
-	// no data type: metadata reports token counts as number, so a float64 request would
-	// miss them and fall back to a map read without evolutions
-	attributeKey := func(name string) *telemetrytypes.TelemetryFieldKey {
-		return &telemetrytypes.TelemetryFieldKey{Name: name, Signal: telemetrytypes.SignalTraces, FieldContext: telemetrytypes.FieldContextAttribute}
-	}
-
-	selectors := make([]*telemetrytypes.FieldKeySelector, 0, len(aiobservabilitytypes.GenAISpanGateKeys)+len(spantypes.TraceStatsGenAIColumns))
-	addSelector := func(name string) {
-		selectors = append(selectors, &telemetrytypes.FieldKeySelector{
-			Name:              name,
-			Signal:            telemetrytypes.SignalTraces,
-			FieldContext:      telemetrytypes.FieldContextAttribute,
-			SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact,
-		})
-	}
-	for _, name := range aiobservabilitytypes.GenAISpanGateKeys {
-		addSelector(name)
-	}
-	for _, col := range spantypes.TraceStatsGenAIColumns {
-		addSelector(col.Key)
-	}
-	keys, _, err := s.metadataStore.GetKeysMulti(ctx, orgID, querybuilder.ExpandKeySelectorsForFamilies(ctx, orgID, s.flagger, selectors))
-	if err != nil {
-		return nil, err
-	}
-
-	q := querybuilder.NewQueryInfo(ctx, orgID, s.flagger, telemetrytypes.SignalTraces, nil, uint64(summary.Start.UnixNano()), uint64(summary.End.UnixNano()))
-
-	gate := make([]string, 0, len(aiobservabilitytypes.GenAISpanGateKeys))
-	for _, name := range aiobservabilitytypes.GenAISpanGateKeys {
-		conds, _, err := querybuilder.Conditions(ctx, q, s.storage, attributeKey(name), qbtypes.FilterOperatorExists, nil, keys, false, sb)
-		if err != nil {
-			return nil, err
-		}
-		gate = append(gate, conds...)
-	}
-	columns := []string{sb.Or(gate...) + " AS is_gen_ai"}
-
-	for _, col := range spantypes.TraceStatsGenAIColumns {
-		expr, err := querybuilder.ResolveColumn(ctx, q, s.storage, attributeKey(col.Key), telemetrytypes.FieldDataTypeFloat64, keys)
-		if err != nil {
-			return nil, err
-		}
-		// a materialized column name carries `$$`, which Build would otherwise unescape
-		columns = append(columns, sqlbuilder.Escape(expr)+" AS "+col.Column+"_value")
-	}
-	return columns, nil
-}
-
 func (s *traceStore) GetTraceSpans(ctx context.Context, traceID string, summary *spantypes.TraceSummary) ([]spantypes.StorableSpan, error) {
 	// DISTINCT ON (span_id) is ClickHouse-specific syntax not supported by sqlbuilder
 	query := fmt.Sprintf(`

pkg/modules/tracedetail/tracedetail.go

@@ -6,12 +6,10 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 // Handler exposes HTTP handlers for trace detail APIs.
 type Handler interface {
-	GetTraceSummary(http.ResponseWriter, *http.Request)
 	GetWaterfallV4(http.ResponseWriter, *http.Request)
 	GetTraceAggregations(http.ResponseWriter, *http.Request)
 	GetFlamegraph(http.ResponseWriter, *http.Request)
@@ -19,7 +17,6 @@ type Handler interface {
 
 // Module defines the business logic for trace detail operations.
 type Module interface {
-	GetTraceStats(ctx context.Context, orgID valuer.UUID, traceID string) (*spantypes.TraceStats, error)
 	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error)
 	GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error)
 	GetFlamegraph(ctx context.Context, traceID string, selectedSpanID string, selectFields []telemetrytypes.TelemetryFieldKey) (*spantypes.GettableFlamegraphTrace, error)

pkg/modules/tracefunnel/clickhouse_queries.go

@@ -495,8 +495,8 @@ WITH
     toDateTime64(%[3]d/1e9, 9) AS start_ts,
     toDateTime64(%[4]d/1e9, 9) AS end_ts,
 
-    (%[5]s,%[6]s) AS step1,
-    (%[7]s,%[8]s) AS step2
+    ('%[5]s','%[6]s') AS step1,
+    ('%[7]s','%[8]s') AS step2
 
 SELECT
     trace_id,
@@ -527,10 +527,10 @@ LIMIT 5;
 		containsErrorT2,
 		startTs,
 		endTs,
-		clickhousesql.StringLiteral(serviceNameT1),
-		clickhousesql.StringLiteral(spanNameT1),
-		clickhousesql.StringLiteral(serviceNameT2),
-		clickhousesql.StringLiteral(spanNameT2),
+		serviceNameT1,
+		spanNameT1,
+		serviceNameT2,
+		spanNameT2,
 		clauseStep1,
 		clauseStep2,
 		t1TimeExpr,
@@ -571,8 +571,8 @@ WITH
     toDateTime64(%[3]d/1e9, 9) AS start_ts,
     toDateTime64(%[4]d/1e9, 9) AS end_ts,
 
-    (%[5]s,%[6]s) AS step1,
-    (%[7]s,%[8]s) AS step2
+    ('%[5]s','%[6]s') AS step1,
+    ('%[7]s','%[8]s') AS step2
 
 SELECT
     trace_id,
@@ -607,10 +607,10 @@ LIMIT 5;
 		containsErrorT2,
 		startTs,
 		endTs,
-		clickhousesql.StringLiteral(serviceNameT1),
-		clickhousesql.StringLiteral(spanNameT1),
-		clickhousesql.StringLiteral(serviceNameT2),
-		clickhousesql.StringLiteral(spanNameT2),
+		serviceNameT1,
+		spanNameT1,
+		serviceNameT2,
+		spanNameT2,
 		clauseStep1,
 		clauseStep2,
 		t1TimeExpr,

pkg/signoz/module.go

@@ -161,7 +161,7 @@ func NewModules(
 		LogsPipeline:         impllogspipeline.NewModule(sqlstore),
 		RuleStateHistory:     implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger), ruleStore),
 		CloudIntegration:     cloudIntegrationModule,
-		TraceDetail:          impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore, telemetryMetadataStore, fl), providerSettings, config.TraceDetail),
+		TraceDetail:          impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
 		SpanMapper:           implspanmapper.NewModule(implspanmapper.NewStore(sqlstore), fl),
 		LLMPricingRule:       impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore), fl, querier),
 		Tag:                  tagModule,

pkg/telemetryschema/aitelemetryschema/const.go

@@ -19,7 +19,6 @@ var (
 		aiobservabilitytypes.GenAIUsageOutputTokens:             genAIAttribute(aiobservabilitytypes.GenAIUsageOutputTokens, telemetrytypes.FieldDataTypeFloat64),
 		aiobservabilitytypes.GenAIUsageCacheReadInputTokens:     genAIAttribute(aiobservabilitytypes.GenAIUsageCacheReadInputTokens, telemetrytypes.FieldDataTypeFloat64),
 		aiobservabilitytypes.GenAIUsageCacheCreationInputTokens: genAIAttribute(aiobservabilitytypes.GenAIUsageCacheCreationInputTokens, telemetrytypes.FieldDataTypeFloat64),
-		aiobservabilitytypes.GenAIUsageReasoningOutputTokens:    genAIAttribute(aiobservabilitytypes.GenAIUsageReasoningOutputTokens, telemetrytypes.FieldDataTypeFloat64),
 		aiobservabilitytypes.SignozGenAITotalCost:               genAIAttribute(aiobservabilitytypes.SignozGenAITotalCost, telemetrytypes.FieldDataTypeFloat64),
 
 		aiobservabilitytypes.GenAIInputMessages:  genAIAttribute(aiobservabilitytypes.GenAIInputMessages, telemetrytypes.FieldDataTypeString),

pkg/telemetrystore/config.go

@@ -46,6 +46,7 @@ type QuerySettings struct {
 	MaxBytesToRead                      int    `mapstructure:"max_bytes_to_read"`
 	MaxResultRows                       int    `mapstructure:"max_result_rows"`
 	IgnoreDataSkippingIndices           string `mapstructure:"ignore_data_skipping_indices"`
+	SecondaryIndicesEnableBulkFiltering bool   `mapstructure:"secondary_indices_enable_bulk_filtering"`
 }
 
 func NewConfigFactory() factory.ConfigFactory {

pkg/telemetrystore/telemetrystorehook/settings.go

@@ -72,6 +72,10 @@ func (h *provider) BeforeQuery(ctx context.Context, _ *telemetrystore.QueryEvent
 		settings["result_overflow_mode"] = ctx.Value("result_overflow_mode")
 	}
 
+	// TODO(srikanthccv): enable it when the "Cannot read all data" issue is fixed
+	// https://github.com/ClickHouse/ClickHouse/issues/82283
+	settings["secondary_indices_enable_bulk_filtering"] = false
+
 	ctx = clickhouse.Context(ctx, clickhouse.WithSettings(settings))
 	return ctx
 }

pkg/types/aiobservabilitytypes/keys.go

@@ -15,7 +15,6 @@ const (
 	GenAIUsageOutputTokens             = "gen_ai.usage.output_tokens"
 	GenAIUsageCacheReadInputTokens     = "gen_ai.usage.cache_read.input_tokens"
 	GenAIUsageCacheCreationInputTokens = "gen_ai.usage.cache_creation.input_tokens"
-	GenAIUsageReasoningOutputTokens    = "gen_ai.usage.reasoning.output_tokens"
 
 	GenAIInputMessages  = "gen_ai.input.messages"
 	GenAIOutputMessages = "gen_ai.output.messages"

pkg/types/alertmanagertypes/channelconfig.go

@@ -1014,7 +1014,7 @@ func rejectHTTPBasicAuthBeyondPassword(channelName string, httpConfig *commoncfg
 
 	basicAuth := httpConfig.BasicAuth
 	if *basicAuth != (commoncfg.BasicAuth{Username: basicAuth.Username, Password: basicAuth.Password}) {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.basic_auth with fields other than username and password, which is not supported", channelName)
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.basic_auth, which is not supported", channelName)
 	}
 
 	return nil
@@ -1026,8 +1026,8 @@ func rejectHTTPAuthorizationBeyondBearer(channelName string, httpConfig *commonc
 	}
 
 	authorization := httpConfig.Authorization
-	if !strings.EqualFold(authorization.Type, bearerAuthorizationType) || *authorization != (commoncfg.Authorization{Type: authorization.Type, Credentials: authorization.Credentials}) {
-		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.authorization with fields other than a bearer token, which is not supported", channelName)
+	if *authorization != (commoncfg.Authorization{Type: bearerAuthorizationType, Credentials: authorization.Credentials}) {
+		return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets http_config.authorization, which is not supported", channelName)
 	}
 
 	return nil

pkg/types/alertmanagertypes/channelconvertors_test.go

@@ -542,42 +542,3 @@ func TestChannelToPostableChannelRejectsUnrepresentableChannels(t *testing.T) {
 		})
 	}
 }
-
-// The HTTP auth scheme is case-insensitive (RFC 7235) and Alertmanager sends
-// the stored spelling verbatim, so a hand-written receiver may carry any casing.
-func TestChannelToPostableChannelReadsWebhookBearerSchemeCaseInsensitively(t *testing.T) {
-	sendResolved := config.DefaultWebhookConfig.VSendResolved
-
-	testCases := []struct {
-		name                string
-		storedChannelData   string
-		expectedWebhookSpec *ChannelWebhookConfig
-	}{
-		{
-			name:                "CanonicalBearer",
-			storedChannelData:   `{"name":"hook","webhook_configs":[{"send_resolved":true,"url":"https://a","http_config":{"authorization":{"type":"Bearer","credentials":"tok"},"follow_redirects":true,"enable_http2":true}}]}`,
-			expectedWebhookSpec: &ChannelWebhookConfig{SendResolved: &sendResolved, URL: "https://a", BearerToken: "tok"},
-		},
-		{
-			name:                "LowercaseBearer",
-			storedChannelData:   `{"name":"hook","webhook_configs":[{"send_resolved":true,"url":"https://b","http_config":{"authorization":{"type":"bearer","credentials":"lower"},"follow_redirects":true,"enable_http2":true}}]}`,
-			expectedWebhookSpec: &ChannelWebhookConfig{SendResolved: &sendResolved, URL: "https://b", BearerToken: "lower"},
-		},
-		{
-			name:                "UppercaseBearer",
-			storedChannelData:   `{"name":"hook","webhook_configs":[{"send_resolved":true,"url":"https://c","http_config":{"authorization":{"type":"BEARER","credentials":"upper"},"follow_redirects":true,"enable_http2":true}}]}`,
-			expectedWebhookSpec: &ChannelWebhookConfig{SendResolved: &sendResolved, URL: "https://c", BearerToken: "upper"},
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			channel := Channel{DisplayName: "hook", Data: testCase.storedChannelData}
-
-			postable, err := channel.toPostableNotificationChannel()
-			require.NoError(t, err)
-			assert.Equal(t, ChannelKindWebhook, postable.Config.Kind)
-			assert.Equal(t, testCase.expectedWebhookSpec, postable.Config.Spec)
-		})
-	}
-}

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -157,6 +157,7 @@ func (d *DashboardSpec) validateQuery(qi int, q Query, panelKind PanelPluginKind
 func validateQueryAllowedForPanel(plugin QueryPlugin, allowed []QueryPluginKind, panelKind PanelPluginKind, path string) error {
 	compositeSubQueryTypeToPluginKind := map[qb.QueryType]QueryPluginKind{
 		qb.QueryTypeBuilder:       QueryKindBuilder,
+		qb.QueryTypeBuilderAI:     QueryKindAIBuilder,
 		qb.QueryTypeFormula:       QueryKindFormula,
 		qb.QueryTypeTraceOperator: QueryKindTraceOperator,
 		qb.QueryTypePromQL:        QueryKindPromQL,

pkg/types/dashboardtypes/perses_dashboard_stats_test.go

@@ -117,6 +117,22 @@ func TestNewStatsFromStorableDashboardsCountsCompositeSubQueries(t *testing.T) {
 	assert.Equal(t, int64(1), stats[statKeyPanelLogsCount])
 }
 
+// An AI builder query is always a traces query, so it counts towards traces.
+func TestNewStatsFromStorableDashboardsCountsAIBuilderQueries(t *testing.T) {
+	aiBuilder := `{
+		"kind": "time_series",
+		"spec": {"plugin": {"kind": "signoz/AIBuilderQuery", "spec": {"name": "A", "aggregations": [{"expression": "count()"}]}}}
+	}`
+	dashboard := newStatsStorableV2(t, `"p1": `+statsPanel(aiBuilder))
+
+	stats := NewStatsFromStorableDashboards([]*StorableDashboard{dashboard})
+
+	assert.Equal(t, int64(1), stats[statKeyPanelCount])
+	assert.Equal(t, int64(1), stats[statKeyPanelTracesCount])
+	assert.Equal(t, int64(0), stats[statKeyPanelMetricsCount])
+	assert.Equal(t, int64(0), stats[statKeyPanelLogsCount])
+}
+
 // promql and clickhouse queries carry no signal, so they land in the panel total
 // and nowhere else.
 func TestNewStatsFromStorableDashboardsIgnoresSignallessQueries(t *testing.T) {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1830,6 +1830,8 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {
 		{"TimeSeries+PromQL", mkQuery("signoz/TimeSeriesPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), false},
 		{"Table+ClickHouse", mkQuery("signoz/TablePanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), false},
 		{"List+Builder", mkQuery("signoz/ListPanel", "signoz/BuilderQuery", `{"name":"A","signal":"logs"}`), false},
+		{"TimeSeries+AIBuilder", mkQuery("signoz/TimeSeriesPanel", "signoz/AIBuilderQuery", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},
+		{"List+AIBuilder", mkQuery("signoz/ListPanel", "signoz/AIBuilderQuery", `{"name":"A"}`), false},
 		// Top-level: rejected
 		{"Table+PromQL", mkQuery("signoz/TablePanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},
 		{"List+ClickHouse", mkQuery("signoz/ListPanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), true},
@@ -1839,6 +1841,7 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {
 		// Composite sub-queries
 		{"Table+Composite(promql)", mkComposite("signoz/TablePanel", "promql", `{"name":"A","query":"up"}`), true},
 		{"Table+Composite(clickhouse)", mkComposite("signoz/TablePanel", "clickhouse_sql", `{"name":"A","query":"SELECT 1"}`), false},
+		{"Table+Composite(builder_ai)", mkComposite("signoz/TablePanel", "builder_ai_query", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},
 	}
 
 	for _, tc := range cases {

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -91,6 +91,7 @@ type QueryPlugin struct {
 func (QueryPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {
 	return markDiscriminator(s, "kind", map[string]string{
 		string(QueryKindBuilder):       schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec"),
+		string(QueryKindAIBuilder):     schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec"),
 		string(QueryKindComposite):     schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery"),
 		string(QueryKindFormula):       schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormula"),
 		string(QueryKindPromQL):        schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery"),
@@ -120,6 +121,7 @@ func (p *QueryPlugin) UnmarshalJSON(data []byte) error {
 func (QueryPlugin) JSONSchemaOneOf() []any {
 	return []any{
 		QueryPluginVariant[BuilderQuerySpec]{Kind: string(QueryKindBuilder)},
+		QueryPluginVariant[AIBuilderQuerySpec]{Kind: string(QueryKindAIBuilder)},
 		QueryPluginVariant[CompositeQuerySpec]{Kind: string(QueryKindComposite)},
 		QueryPluginVariant[FormulaSpec]{Kind: string(QueryKindFormula)},
 		QueryPluginVariant[PromQLQuerySpec]{Kind: string(QueryKindPromQL)},
@@ -140,6 +142,11 @@ func (plugin QueryPlugin) buildV5CompositeQueryFromPlugin() (qb.CompositeQuery,
 			return qb.CompositeQuery{}, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "builder query is empty")
 		}
 		return wrapEnvelope(qb.QueryTypeBuilder, spec.Spec), nil
+	case *AIBuilderQuerySpec:
+		if spec == nil {
+			return qb.CompositeQuery{}, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "AI builder query is empty")
+		}
+		return wrapEnvelope(qb.QueryTypeBuilderAI, qb.QueryBuilderQuery[qb.TraceAggregation](*spec)), nil
 	case *qb.PromQuery:
 		return wrapEnvelope(qb.QueryTypePromQL, *spec), nil
 	case *qb.ClickHouseQuery:
@@ -234,6 +241,7 @@ var (
 	}
 	queryPluginSpecs = map[QueryPluginKind]func() any{
 		QueryKindBuilder:       func() any { return new(BuilderQuerySpec) },
+		QueryKindAIBuilder:     func() any { return new(AIBuilderQuerySpec) },
 		QueryKindComposite:     func() any { return new(CompositeQuerySpec) },
 		QueryKindFormula:       func() any { return new(FormulaSpec) },
 		QueryKindPromQL:        func() any { return new(PromQLQuerySpec) },
@@ -246,13 +254,13 @@ var (
 		VariableKindCustom:  func() any { return new(CustomVariableSpec) },
 	}
 	allowedQueryKinds = map[PanelPluginKind][]QueryPluginKind{
-		PanelKindTimeSeries: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindBarChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindNumber:     {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindHistogram:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindTable:      {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindList:       {QueryKindBuilder},
+		PanelKindTimeSeries: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindBarChart:   {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindNumber:     {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindHistogram:  {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindPieChart:   {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
+		PanelKindTable:      {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
+		PanelKindList:       {QueryKindBuilder, QueryKindAIBuilder},
 		PanelKindText:       {},
 	}
 )

pkg/types/dashboardtypes/perses_public_dashboard.go

@@ -106,6 +106,13 @@ func redactQuery(spec any) any {
 			return spec
 		}
 		return &BuilderQuerySpec{Spec: redactLeafQuery(s.Spec)}
+	case *AIBuilderQuerySpec:
+		if s == nil {
+			return spec
+		}
+		redacted := redactLeafQuery(qb.QueryBuilderQuery[qb.TraceAggregation](*s)).(qb.QueryBuilderQuery[qb.TraceAggregation])
+		out := AIBuilderQuerySpec(redacted)
+		return &out
 	case *qb.PromQuery:
 		return redactQueryPtr(s)
 	case *qb.ClickHouseQuery:

pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.go

@@ -159,6 +159,11 @@ func TestDashboardV2GetPanelQuery(t *testing.T) {
 			plugin       QueryPlugin
 			expectedType qb.QueryType
 		}{
+			{
+				description:  "AI builder query",
+				plugin:       QueryPlugin{Kind: QueryKindAIBuilder, Spec: &AIBuilderQuerySpec{Name: "A"}},
+				expectedType: qb.QueryTypeBuilderAI,
+			},
 			{
 				description:  "promql",
 				plugin:       QueryPlugin{Kind: QueryKindPromQL, Spec: &qb.PromQuery{Name: "A", Query: "up"}},

pkg/types/dashboardtypes/perses_public_dashboard_redaction_test.go

@@ -133,6 +133,19 @@ func TestRedactQueryPluginWrappers(t *testing.T) {
 		assert.Equal(t, "A", builder.Name)
 	})
 
+	t.Run("AI builder plugin pointer is redacted and stays a pointer", func(t *testing.T) {
+		plugin := &AIBuilderQuerySpec{
+			Name:   "A",
+			Filter: &qb.Filter{Expression: "body contains 'secret'"},
+		}
+
+		result, ok := redactQuery(plugin).(*AIBuilderQuerySpec)
+		require.True(t, ok)
+
+		assert.Nil(t, result.Filter)
+		assert.Equal(t, "A", result.Name)
+	})
+
 	t.Run("composite plugin redacts every sub-query envelope", func(t *testing.T) {
 		composite := &qb.CompositeQuery{Queries: []qb.QueryEnvelope{
 			{Type: qb.QueryTypeBuilder, Spec: qb.QueryBuilderQuery[qb.MetricAggregation]{Name: "A", Filter: &qb.Filter{Expression: "x = 1"}}},

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -93,6 +93,7 @@ type QueryPluginKind string
 
 const (
 	QueryKindBuilder       QueryPluginKind = "signoz/BuilderQuery"
+	QueryKindAIBuilder     QueryPluginKind = "signoz/AIBuilderQuery"
 	QueryKindComposite     QueryPluginKind = "signoz/CompositeQuery"
 	QueryKindFormula       QueryPluginKind = "signoz/Formula"
 	QueryKindPromQL        QueryPluginKind = "signoz/PromQLQuery"
@@ -101,7 +102,7 @@ const (
 )
 
 func (QueryPluginKind) Enum() []any {
-	return []any{QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL, QueryKindTraceOperator}
+	return []any{QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL, QueryKindTraceOperator}
 }
 
 type (
@@ -159,6 +160,26 @@ func (BuilderQuerySpec) JSONSchemaOneOf() []any {
 	}
 }
 
+// AIBuilderQuerySpec is the spec of a signoz/AIBuilderQuery plugin: a gen_ai-scoped
+// (AI observability) traces builder query, executed as qb.QueryTypeBuilderAI. The
+// signal is implied by the kind and pinned to traces, mirroring the builder_ai_query
+// QueryEnvelope decode.
+type AIBuilderQuerySpec qb.QueryBuilderQuery[qb.TraceAggregation]
+
+func (b *AIBuilderQuerySpec) UnmarshalJSON(data []byte) error {
+	var spec qb.QueryBuilderQuery[qb.TraceAggregation]
+	if err := json.Unmarshal(data, &spec); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid AI builder query spec")
+	}
+	spec.Signal = telemetrytypes.SignalTraces
+	*b = AIBuilderQuerySpec(spec)
+	return nil
+}
+
+func (AIBuilderQuerySpec) PrepareJSONSchema(s *jsonschema.Schema) error {
+	return (qb.QueryBuilderQuery[qb.TraceAggregation]{}).PrepareJSONSchema(s)
+}
+
 // ══════════════════════════════════════════════
 // SigNoz panel plugin specs
 // ══════════════════════════════════════════════

pkg/types/dashboardtypes/perses_signoz_plugins_test.go

@@ -0,0 +1,75 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// An AI builder query is a gen_ai-scoped traces builder query: the signal is
+// implied by the plugin kind and pinned to traces on decode, mirroring the
+// builder_ai_query QueryEnvelope.
+func TestAIBuilderQueryPluginRoundTrip(t *testing.T) {
+	data := []byte(`{
+		"variables": [],
+		"panels": {"p1": {"kind": "Panel", "spec": {
+			"links": [],
+			"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
+			"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/AIBuilderQuery", "spec": {
+				"name": "A", "aggregations": [{"expression": "count()"}]
+			}}}}]
+		}}},
+		"links": [],
+		"layouts": []
+	}`)
+
+	spec, err := unmarshalDashboard(data)
+	require.NoError(t, err)
+
+	plugin := spec.Panels["p1"].Spec.Queries[0].Spec.Plugin
+	assert.Equal(t, QueryKindAIBuilder, plugin.Kind)
+
+	aiSpec, ok := plugin.Spec.(*AIBuilderQuerySpec)
+	require.True(t, ok, "expected *AIBuilderQuerySpec, got %T", plugin.Spec)
+	assert.Equal(t, "A", aiSpec.Name)
+	assert.Equal(t, telemetrytypes.SignalTraces, aiSpec.Signal)
+
+	// Marshal emits the pinned signal and decodes back to the same plugin.
+	out, err := json.Marshal(plugin)
+	require.NoError(t, err)
+	assert.Contains(t, string(out), `"kind":"signoz/AIBuilderQuery"`)
+	assert.Contains(t, string(out), `"signal":"traces"`)
+
+	var roundTripped QueryPlugin
+	require.NoError(t, json.Unmarshal(out, &roundTripped))
+	assert.Equal(t, plugin, roundTripped)
+}
+
+// At query-range time an AI builder query wraps into a single builder_ai_query
+// envelope so the querier routes it to the gen_ai statement builder.
+func TestAIBuilderQueryPluginBuildsBuilderAIEnvelope(t *testing.T) {
+	plugin := QueryPlugin{Kind: QueryKindAIBuilder, Spec: &AIBuilderQuerySpec{Name: "A", Signal: telemetrytypes.SignalTraces}}
+
+	composite, err := plugin.buildV5CompositeQueryFromPlugin()
+	require.NoError(t, err)
+	require.Len(t, composite.Queries, 1)
+	assert.Equal(t, qb.QueryTypeBuilderAI, composite.Queries[0].Type)
+
+	spec, ok := composite.Queries[0].Spec.(qb.QueryBuilderQuery[qb.TraceAggregation])
+	require.True(t, ok, "expected traces builder query, got %T", composite.Queries[0].Spec)
+	assert.Equal(t, "A", spec.Name)
+	assert.Equal(t, telemetrytypes.SignalTraces, spec.Signal)
+}
+
+func TestAIBuilderQueryPluginNilSpec(t *testing.T) {
+	plugin := QueryPlugin{Kind: QueryKindAIBuilder, Spec: (*AIBuilderQuerySpec)(nil)}
+
+	_, err := plugin.buildV5CompositeQueryFromPlugin()
+	require.Error(t, err)
+	assert.True(t, errors.Ast(err, errors.TypeInvalidInput))
+}

pkg/types/spantypes/store.go

@@ -27,7 +27,6 @@ type SpanMapperStore interface {
 // TraceStore defines the data access interface for trace detail queries.
 type TraceStore interface {
 	GetTraceSummary(ctx context.Context, traceID string) (*TraceSummary, error)
-	GetTraceStats(ctx context.Context, orgID valuer.UUID, traceID string, summary *TraceSummary) (*TraceStats, error)
 	GetTraceSpans(ctx context.Context, traceID string, summary *TraceSummary) ([]StorableSpan, error)
 	GetMinimalSpans(ctx context.Context, traceID string, start, end time.Time) ([]MinimalSpan, error)
 	GetTraceSpansByIDs(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]StorableSpan, error)

pkg/types/spantypes/trace_summary.go

@@ -1,76 +0,0 @@
-package spantypes
-
-import "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
-
-// TraceStatsGenAIColumns pairs each summed TraceStats column with the gen_ai attribute it sums.
-var TraceStatsGenAIColumns = []TraceStatsGenAIColumn{
-	{Column: "input_tokens", Key: aiobservabilitytypes.GenAIUsageInputTokens},
-	{Column: "output_tokens", Key: aiobservabilitytypes.GenAIUsageOutputTokens},
-	{Column: "cache_read_tokens", Key: aiobservabilitytypes.GenAIUsageCacheReadInputTokens},
-	{Column: "cache_write_tokens", Key: aiobservabilitytypes.GenAIUsageCacheCreationInputTokens},
-	{Column: "reasoning_tokens", Key: aiobservabilitytypes.GenAIUsageReasoningOutputTokens},
-	{Column: "total_cost", Key: aiobservabilitytypes.SignozGenAITotalCost},
-}
-
-type TraceStatsGenAIColumn struct {
-	Column string
-	Key    string
-}
-
-// TraceStats is the single-row result of the trace summary aggregate query.
-type TraceStats struct {
-	StartNs         uint64
-	EndNs           uint64
-	RootServiceName string
-	RootEntryPoint  string
-	TotalSpans      uint64
-	TotalErrorSpans uint64
-	HasMissingSpans bool
-	GenAISpanCount  uint64
-	Tokens          TraceAITokens
-	TotalCost       *float64
-}
-
-// GettableTraceSummary is the response for the trace summary API; the trace-level
-// fields match the waterfall response.
-type GettableTraceSummary struct {
-	StartTimestampMillis  uint64          `json:"startTimestampMillis"`
-	EndTimestampMillis    uint64          `json:"endTimestampMillis"`
-	RootServiceName       string          `json:"rootServiceName"`
-	RootServiceEntryPoint string          `json:"rootServiceEntryPoint"`
-	TotalSpansCount       uint64          `json:"totalSpansCount"`
-	TotalErrorSpansCount  uint64          `json:"totalErrorSpansCount"`
-	HasMissingSpans       bool            `json:"hasMissingSpans"`
-	AI                    *TraceAISummary `json:"ai,omitempty"`
-}
-
-// TraceAISummary is present when any span carries a gen_ai gate key.
-type TraceAISummary struct {
-	Tokens TraceAITokens `json:"tokens"`
-	// TotalCost is null when no span carries a cost attribute.
-	TotalCost *float64 `json:"totalCost" nullable:"true"`
-}
-
-type TraceAITokens struct {
-	Input      uint64 `json:"input"`
-	Output     uint64 `json:"output"`
-	CacheRead  uint64 `json:"cacheRead"`
-	CacheWrite uint64 `json:"cacheWrite"`
-	Reasoning  uint64 `json:"reasoning"`
-}
-
-func NewGettableTraceSummary(stats *TraceStats) *GettableTraceSummary {
-	summary := &GettableTraceSummary{
-		StartTimestampMillis:  stats.StartNs / 1_000_000,
-		EndTimestampMillis:    stats.EndNs / 1_000_000,
-		RootServiceName:       stats.RootServiceName,
-		RootServiceEntryPoint: stats.RootEntryPoint,
-		TotalSpansCount:       stats.TotalSpans,
-		TotalErrorSpansCount:  stats.TotalErrorSpans,
-		HasMissingSpans:       stats.HasMissingSpans,
-	}
-	if stats.GenAISpanCount > 0 {
-		summary.AI = &TraceAISummary{Tokens: stats.Tokens, TotalCost: stats.TotalCost}
-	}
-	return summary
-}

tests/fixtures/traces.py

@@ -895,7 +895,6 @@ _TRACES_TABLES_TO_TRUNCATE = [
     "span_attributes_keys",
     "signoz_error_index_v2",
     "top_level_operations",
-    "trace_summary",
 ]
 
 

tests/integration/tests/tracedetail/01_summary.py

@@ -1,280 +0,0 @@
-from collections.abc import Callable
-from datetime import UTC, datetime, timedelta
-from http import HTTPStatus
-
-import pytest
-import requests
-
-from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.querierai import root_span
-from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode
-
-WATERFALL_FIELDS = (
-    "startTimestampMillis",
-    "endTimestampMillis",
-    "rootServiceName",
-    "rootServiceEntryPoint",
-    "totalSpansCount",
-    "totalErrorSpansCount",
-    "hasMissingSpans",
-)
-
-
-@pytest.mark.parametrize("attribute_backend", ["map", "json"])
-def test_summary_ai_trace(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-    use_attribute_backend: Callable[[str], None],
-    attribute_backend: str,
-) -> None:
-    """The summary carries the waterfall's trace-level fields and, for a trace with gen_ai
-    spans, token totals over every LLM span and the cost summed over the spans that carry it.
-    Spans are written to one layout only, so a read from the wrong column sums to zero."""
-    use_attribute_backend(attribute_backend)
-    write_mode = "json_only" if attribute_backend == "json" else "legacy_only"
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = f"td-summary-{attribute_backend}"
-    resources = {"service.name": service}
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-
-    insert_traces(
-        [
-            root_span(now=now, trace_id=trace_id, span_id=root_id, resources=resources, duration_s=4),
-            Traces(
-                timestamp=now - timedelta(seconds=4),
-                duration=timedelta(seconds=1),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=root_id,
-                name="chat gpt-4o-mini",
-                kind=TracesKind.SPAN_KIND_CLIENT,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-                attributes={
-                    "gen_ai.request.model": "gpt-4o-mini",
-                    "gen_ai.usage.input_tokens": 100,
-                    "gen_ai.usage.output_tokens": 20,
-                    "gen_ai.usage.cache_read.input_tokens": 7,
-                    "_signoz.gen_ai.total_cost": 0.01,
-                },
-                attribute_write_mode=write_mode,
-            ),
-            # a failed LLM call: counted in tokens and errors, but priced by nobody
-            Traces(
-                timestamp=now - timedelta(seconds=3),
-                duration=timedelta(seconds=0.5),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=root_id,
-                name="chat gpt-4o-mini",
-                kind=TracesKind.SPAN_KIND_CLIENT,
-                status_code=TracesStatusCode.STATUS_CODE_ERROR,
-                resources=resources,
-                attributes={
-                    "gen_ai.request.model": "gpt-4o-mini",
-                    "gen_ai.usage.input_tokens": 50,
-                    "gen_ai.usage.output_tokens": 5,
-                },
-                attribute_write_mode=write_mode,
-            ),
-            Traces(
-                timestamp=now - timedelta(seconds=2),
-                duration=timedelta(seconds=0.5),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=root_id,
-                name="execute_tool",
-                kind=TracesKind.SPAN_KIND_INTERNAL,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-                attributes={"gen_ai.tool.name": "get_weather"},
-                attribute_write_mode=write_mode,
-            ),
-        ]
-    )
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    headers = {"authorization": f"Bearer {token}", "content-type": "application/json"}
-
-    summary = requests.get(signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/summary"), timeout=10, headers=headers)
-    assert summary.status_code == HTTPStatus.OK, summary.text
-    summary = summary.json()["data"]
-
-    waterfall = requests.post(
-        signoz.self.host_configs["8080"].get(f"/api/v4/traces/{trace_id}/waterfall"),
-        timeout=10,
-        headers=headers,
-        json={"selectedSpanId": "", "uncollapsedSpans": []},
-    )
-    assert waterfall.status_code == HTTPStatus.OK, waterfall.text
-    waterfall = waterfall.json()["data"]
-
-    assert {k: summary[k] for k in WATERFALL_FIELDS} == {k: waterfall[k] for k in WATERFALL_FIELDS}
-    assert summary["rootServiceName"] == service
-    assert summary["rootServiceEntryPoint"] == "POST /api/chat"
-    assert summary["totalSpansCount"] == 4
-    assert summary["totalErrorSpansCount"] == 1
-    assert summary["hasMissingSpans"] is False
-
-    assert summary["ai"]["tokens"] == {"input": 150, "output": 25, "cacheRead": 7, "cacheWrite": 0, "reasoning": 0}
-    assert summary["ai"]["totalCost"] == pytest.approx(0.01)
-
-
-def test_summary_ai_trace_across_json_rollout(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-    seed_attribute_evolution: Callable[[str, datetime], None],
-) -> None:
-    """A trace that straddles the attribute JSON rollout has LLM spans written only to the legacy
-    maps before it and to the JSON column after it. The summary window covers both, so the gen_ai
-    reads must fall back across columns and sum every span."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    rollout = now - timedelta(minutes=30)
-    seed_attribute_evolution("traces", rollout)
-
-    service = "td-summary-rollout"
-    resources = {"service.name": service}
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-
-    insert_traces(
-        [
-            Traces(
-                timestamp=rollout - timedelta(minutes=10),
-                duration=timedelta(minutes=15),
-                trace_id=trace_id,
-                span_id=root_id,
-                parent_span_id="",
-                name="long agent run",
-                kind=TracesKind.SPAN_KIND_SERVER,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-                attribute_write_mode="legacy_only",
-            ),
-            Traces(
-                timestamp=rollout - timedelta(minutes=5),
-                duration=timedelta(seconds=1),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=root_id,
-                name="chat gpt-4o-mini",
-                kind=TracesKind.SPAN_KIND_CLIENT,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-                attributes={"gen_ai.request.model": "gpt-4o-mini", "gen_ai.usage.input_tokens": 100, "gen_ai.usage.output_tokens": 20, "_signoz.gen_ai.total_cost": 0.01},
-                attribute_write_mode="legacy_only",
-            ),
-            Traces(
-                timestamp=rollout + timedelta(minutes=4),
-                duration=timedelta(seconds=1),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=root_id,
-                name="chat gpt-4o-mini",
-                kind=TracesKind.SPAN_KIND_CLIENT,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-                attributes={"gen_ai.request.model": "gpt-4o-mini", "gen_ai.usage.input_tokens": 50, "gen_ai.usage.output_tokens": 5, "_signoz.gen_ai.total_cost": 0.02},
-                attribute_write_mode="json_only",
-            ),
-        ]
-    )
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    summary = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/summary"),
-        timeout=10,
-        headers={"authorization": f"Bearer {token}"},
-    )
-    assert summary.status_code == HTTPStatus.OK, summary.text
-    summary = summary.json()["data"]
-
-    assert summary["totalSpansCount"] == 3
-    assert summary["rootServiceEntryPoint"] == "long agent run"
-    assert summary["ai"]["tokens"] == {"input": 150, "output": 25, "cacheRead": 0, "cacheWrite": 0, "reasoning": 0}
-    assert summary["ai"]["totalCost"] == pytest.approx(0.03)
-
-
-def test_summary_non_ai_trace_with_missing_root(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """A trace whose recorded spans all hang off an unrecorded parent reports the synthetic
-    "Missing Span" root exactly as the waterfall does, and a trace without gen_ai spans has
-    no `ai` block."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    resources = {"service.name": "td-summary-orphan"}
-    trace_id = TraceIdGenerator.trace_id()
-    missing_parent_id = TraceIdGenerator.span_id()
-
-    insert_traces(
-        [
-            Traces(
-                timestamp=now - timedelta(seconds=5),
-                duration=timedelta(seconds=2),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=missing_parent_id,
-                name="SELECT users",
-                kind=TracesKind.SPAN_KIND_CLIENT,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-            ),
-            Traces(
-                timestamp=now - timedelta(seconds=4),
-                duration=timedelta(seconds=1),
-                trace_id=trace_id,
-                span_id=TraceIdGenerator.span_id(),
-                parent_span_id=missing_parent_id,
-                name="publish event",
-                kind=TracesKind.SPAN_KIND_PRODUCER,
-                status_code=TracesStatusCode.STATUS_CODE_OK,
-                resources=resources,
-            ),
-        ]
-    )
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    headers = {"authorization": f"Bearer {token}", "content-type": "application/json"}
-
-    summary = requests.get(signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/summary"), timeout=10, headers=headers)
-    assert summary.status_code == HTTPStatus.OK, summary.text
-    summary = summary.json()["data"]
-
-    waterfall = requests.post(
-        signoz.self.host_configs["8080"].get(f"/api/v4/traces/{trace_id}/waterfall"),
-        timeout=10,
-        headers=headers,
-        json={"selectedSpanId": "", "uncollapsedSpans": []},
-    )
-    assert waterfall.status_code == HTTPStatus.OK, waterfall.text
-    waterfall = waterfall.json()["data"]
-
-    assert {k: summary[k] for k in WATERFALL_FIELDS} == {k: waterfall[k] for k in WATERFALL_FIELDS}
-    assert summary["hasMissingSpans"] is True
-    assert summary["rootServiceName"] == ""
-    assert summary["rootServiceEntryPoint"] == "Missing Span"
-    assert summary["totalSpansCount"] == 2
-    assert "ai" not in summary
-
-
-def test_summary_unknown_trace(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-) -> None:
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/traces/{TraceIdGenerator.trace_id()}/summary"),
-        timeout=10,
-        headers={"authorization": f"Bearer {token}"},
-    )
-    assert response.status_code == HTTPStatus.NOT_FOUND, response.text