chore: error on empty title body with non-retryable error and give 429 retryable error due to limit

.github/workflows/integrationci.yaml

@@ -53,7 +53,6 @@ jobs:
           - queriermetrics
           - querierscalar
           - queriercommon
-          - querierai
           - rawexportdata
           - querierauthz
           - role

docs/api/openapi.yml

@@ -6899,7 +6899,6 @@ components:
     Querybuildertypesv5QueryEnvelope:
       discriminator:
         mapping:
-          builder_ai_query: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilderAI'
           builder_formula: '#/components/schemas/Querybuildertypesv5QueryEnvelopeFormula'
           builder_query: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilder'
           builder_trace_operator: '#/components/schemas/Querybuildertypesv5QueryEnvelopeTraceOperator'
@@ -6908,7 +6907,6 @@ components:
         propertyName: type
       oneOf:
       - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilder'
-      - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilderAI'
       - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeFormula'
       - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeTraceOperator'
       - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopePromQL'
@@ -6923,15 +6921,6 @@ components:
       required:
       - type
       type: object
-    Querybuildertypesv5QueryEnvelopeBuilderAI:
-      properties:
-        spec:
-          $ref: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregation'
-        type:
-          $ref: '#/components/schemas/Querybuildertypesv5QueryType'
-      required:
-      - type
-      type: object
     Querybuildertypesv5QueryEnvelopeClickHouseSQL:
       properties:
         spec:
@@ -7045,7 +7034,6 @@ components:
     Querybuildertypesv5QueryType:
       enum:
       - builder_query
-      - builder_ai_query
       - builder_formula
       - builder_trace_operator
       - clickhouse_sql

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

@@ -4298,18 +4298,6 @@ export interface Querybuildertypesv5QueryEnvelopeBuilderDTO {
 	type: Querybuildertypesv5QueryEnvelopeBuilderDTOType;
 }
 
-export enum Querybuildertypesv5QueryEnvelopeBuilderAIDTOType {
-	builder_ai_query = 'builder_ai_query',
-}
-export interface Querybuildertypesv5QueryEnvelopeBuilderAIDTO {
-	spec?: Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregationDTO;
-	/**
-	 * @type string
-	 * @enum builder_ai_query
-	 */
-	type: Querybuildertypesv5QueryEnvelopeBuilderAIDTOType;
-}
-
 export interface Querybuildertypesv5QueryBuilderFormulaDTO {
 	/**
 	 * @type boolean
@@ -4493,7 +4481,6 @@ export interface Querybuildertypesv5QueryEnvelopeClickHouseSQLDTO {
 
 export type Querybuildertypesv5QueryEnvelopeDTO =
 	| Querybuildertypesv5QueryEnvelopeBuilderDTO
-	| Querybuildertypesv5QueryEnvelopeBuilderAIDTO
 	| Querybuildertypesv5QueryEnvelopeFormulaDTO
 	| Querybuildertypesv5QueryEnvelopeTraceOperatorDTO
 	| Querybuildertypesv5QueryEnvelopePromQLDTO
@@ -8297,7 +8284,6 @@ export interface Querybuildertypesv5QueryRangeResponseDTO {
 
 export enum Querybuildertypesv5QueryTypeDTO {
 	builder_query = 'builder_query',
-	builder_ai_query = 'builder_ai_query',
 	builder_formula = 'builder_formula',
 	builder_trace_operator = 'builder_trace_operator',
 	clickhouse_sql = 'clickhouse_sql',

frontend/src/components/FieldsSelector/OtherFields.tsx

@@ -8,6 +8,7 @@ import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import { useGetQueryKeySuggestions } from 'hooks/querySuggestions/useGetQueryKeySuggestions';
 import {
 	FieldContext,
+	FieldDataType,
 	SignalType,
 	TelemetryFieldKey,
 } from 'types/api/v5/queryRange';
@@ -54,7 +55,7 @@ function OtherFields({
 				key: buildCompositeKey(attr.name, attr.fieldContext as string),
 				signal: attr.signal as SignalType,
 				fieldContext: attr.fieldContext as FieldContext,
-				fieldDataType: attr.fieldDataType,
+				fieldDataType: attr.fieldDataType as FieldDataType,
 			}),
 		);
 		const addedIds = new Set(

frontend/src/components/QueryBuilderV2/QueryV2/QueryAggregation/QueryAggregationSelect.tsx

@@ -25,12 +25,12 @@ import CodeMirror, {
 } from '@uiw/react-codemirror';
 import { Button, Popover, Tooltip } from 'antd';
 import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
+import { QUERY_BUILDER_KEY_TYPES } from 'constants/antlrQueryConstants';
 import { QueryBuilderKeys } from 'constants/queryBuilder';
 import { tracesAggregateOperatorOptions } from 'constants/queryBuilderOperators';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { Info, TriangleAlert } from '@signozhq/icons';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { FieldDataType } from 'types/api/v5/queryRange';
 import { TracesAggregatorOperator } from 'types/common/queryBuilder';
 
 import { useQueryBuilderV2Context } from '../../QueryBuilderV2Context';
@@ -323,16 +323,16 @@ function QueryAggregationSelect({
 				TracesAggregatorOperator.RATE,
 			];
 
-			const fieldDataType: FieldDataType | undefined =
+			const fieldDataType =
 				functionContextForFetch &&
 				operatorsWithoutDataType.includes(functionContextForFetch)
 					? undefined
-					: 'number';
+					: QUERY_BUILDER_KEY_TYPES.NUMBER;
 
 			return getKeySuggestions({
 				signal: queryData.dataSource,
 				searchText: '',
-				fieldDataType,
+				fieldDataType: fieldDataType as QUERY_BUILDER_KEY_TYPES,
 			});
 		},
 		{

frontend/src/container/OptionsMenu/useOptionsMenu.ts

@@ -113,7 +113,7 @@ const useOptionsMenu = ({
 					(suggestion) => ({
 						name: suggestion.name,
 						signal: suggestion.signal as SignalType,
-						fieldDataType: suggestion.fieldDataType,
+						fieldDataType: suggestion.fieldDataType as FieldDataType,
 						fieldContext: suggestion.fieldContext as FieldContext,
 					}),
 				);
@@ -192,7 +192,7 @@ const useOptionsMenu = ({
 				name: e.name,
 				signal: e.signal as SignalType,
 				fieldContext: e.fieldContext as FieldContext,
-				fieldDataType: e.fieldDataType,
+				fieldDataType: e.fieldDataType as FieldDataType,
 			}));
 		}
 		if (dataSource === DataSource.TRACES) {

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

@@ -4,11 +4,11 @@ import { Input } from '@signozhq/ui/input';
 import { Skeleton } from 'antd';
 import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { QUERY_BUILDER_KEY_TYPES } from 'constants/antlrQueryConstants';
 import useDebounce from 'hooks/useDebounce';
 import { ContextMenu } from 'periscope/components/ContextMenu';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { MetricAggregation } from 'types/api/v5/queryRange';
-import { fieldDataTypeToDataType } from 'utils/fieldDataType';
 
 import { BreakoutOptionsProps } from './contextConfig';
 import { BreakoutAttributeType } from './types';
@@ -80,7 +80,7 @@ function BreakoutOptions({
 			keyArray.forEach((keyData) => {
 				transformedOptions.push({
 					key: keyData.name,
-					dataType: fieldDataTypeToDataType(keyData.fieldDataType),
+					dataType: keyData.fieldDataType as QUERY_BUILDER_KEY_TYPES,
 					type: '',
 				});
 			});

frontend/src/container/QueryTable/Drilldown/__tests__/Breakout.test.tsx

@@ -238,10 +238,6 @@ describe('TableDrilldown Breakout Functionality', () => {
 		expect(aggregateQueryData.groupBy).toHaveLength(1);
 		expect(aggregateQueryData.groupBy[0].key).toBe('deployment.environment');
 
-		// The picked field's type travels with it — dropping it leaves the breakout query
-		// untyped, so a drilldown on its result can't tell a number from a string.
-		expect(aggregateQueryData.groupBy[0].dataType).toBe('string');
-
 		// Verify that orderBy has been cleared (as per getBreakoutQuery logic)
 		expect(aggregateQueryData.orderBy).toStrictEqual([]);
 

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

@@ -1,5 +1,6 @@
 import { OPERATORS, PANEL_TYPES } from 'constants/queryBuilder';
 import cloneDeep from 'lodash-es/cloneDeep';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import { addFilterToSelectedQuery, FilterData } from './drilldownUtils';
@@ -88,11 +89,7 @@ export const getBreakoutQuery = (
 		.filter((item: IBuilderQuery) => item.queryName === aggregateData.queryName)
 		.map((item: IBuilderQuery) => ({
 			...item,
-			// The picked field's type travels with it: dropped, the breakout query goes out
-			// untyped and a drilldown on its result can't tell a number from a string.
-			groupBy: [
-				{ key: groupBy.key, dataType: groupBy.dataType, type: groupBy.type },
-			],
+			groupBy: [{ key: groupBy.key, type: groupBy.type } as BaseAutocompleteData],
 			orderBy: [],
 			legend: item.legend && groupBy.key ? `{{${groupBy.key}}}` : '',
 		}));

frontend/src/container/QueryTable/Drilldown/types.ts

@@ -1,8 +1,6 @@
 import { ReactNode } from 'react';
-import {
-	BaseAutocompleteData,
-	DataTypes,
-} from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { QUERY_BUILDER_KEY_TYPES } from 'constants/antlrQueryConstants';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
 export type ContextMenuItem = ReactNode;
@@ -33,8 +31,7 @@ export interface AggregateContextMenuConfig {
 
 export interface BreakoutAttributeType {
 	key: string;
-	/** The picked field's type, in the vocabulary the group-by it becomes is read with. */
-	dataType: DataTypes;
+	dataType: QUERY_BUILDER_KEY_TYPES;
 	type: string;
 }
 

frontend/src/types/api/querySuggestions/types.ts

@@ -1,4 +1,4 @@
-import { FieldDataType } from 'types/api/v5/queryRange';
+import { QUERY_BUILDER_KEY_TYPES } from 'constants/antlrQueryConstants';
 
 export interface QueryKeyDataSuggestionsProps {
 	label: string;
@@ -7,12 +7,7 @@ export interface QueryKeyDataSuggestionsProps {
 	apply?: string;
 	detail?: string;
 	fieldContext?: 'resource' | 'scope' | 'attribute' | 'span';
-	/**
-	 * The field's type as the API reports it. Was declared as the antlr key-type enum
-	 * (`string | number | boolean`), which the endpoint never returns — every consumer cast it
-	 * back to `FieldDataType`.
-	 */
-	fieldDataType?: FieldDataType;
+	fieldDataType?: QUERY_BUILDER_KEY_TYPES;
 	name: string;
 	signal: 'traces' | 'logs' | 'metrics';
 }
@@ -31,7 +26,7 @@ export interface QueryKeyRequestProps {
 	signal: 'traces' | 'logs' | 'metrics';
 	searchText: string;
 	fieldContext?: 'resource' | 'scope' | 'attribute' | 'span';
-	fieldDataType?: FieldDataType;
+	fieldDataType?: QUERY_BUILDER_KEY_TYPES;
 	metricName?: string;
 	metricNamespace?: string;
 	signalSource?: 'meter' | '';

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

@@ -1,34 +0,0 @@
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import type { FieldDataType } from 'types/api/v5/queryRange';
-
-import { fieldDataTypeToDataType } from '../fieldDataType';
-
-describe('fieldDataTypeToDataType', () => {
-	it('maps the reported numeric spellings onto the query-builder numerics', () => {
-		expect(fieldDataTypeToDataType('number')).toBe(DataTypes.Float64);
-		expect(fieldDataTypeToDataType('int64')).toBe(DataTypes.Int64);
-		expect(fieldDataTypeToDataType('float64')).toBe(DataTypes.Float64);
-	});
-
-	it('maps the list spellings onto the array types', () => {
-		expect(fieldDataTypeToDataType('[]string')).toBe(DataTypes.ArrayString);
-		expect(fieldDataTypeToDataType('[]bool')).toBe(DataTypes.ArrayBool);
-		expect(fieldDataTypeToDataType('[]int64')).toBe(DataTypes.ArrayInt64);
-		expect(fieldDataTypeToDataType('[]float64')).toBe(DataTypes.ArrayFloat64);
-		expect(fieldDataTypeToDataType('[]number')).toBe(DataTypes.ArrayFloat64);
-	});
-
-	it('passes through the spellings the two vocabularies share', () => {
-		expect(fieldDataTypeToDataType('string')).toBe(DataTypes.String);
-		expect(fieldDataTypeToDataType('bool')).toBe(DataTypes.bool);
-	});
-
-	it('returns EMPTY for empty, missing and not-yet-known types', () => {
-		expect(fieldDataTypeToDataType('')).toBe(DataTypes.EMPTY);
-		expect(fieldDataTypeToDataType(undefined)).toBe(DataTypes.EMPTY);
-		// The backend can store `[]json` / `[]dynamic`, which the API union doesn't list.
-		expect(fieldDataTypeToDataType('[]json' as FieldDataType)).toBe(
-			DataTypes.EMPTY,
-		);
-	});
-});

frontend/src/utils/fieldDataType.ts

@@ -1,31 +0,0 @@
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import type { FieldDataType } from 'types/api/v5/queryRange';
-
-/**
- * The field metadata APIs and the query builder spell field types differently: the metadata
- * collapses the numerics to `number` and writes lists as `[]string`, while `DataTypes` — which
- * keys the operator and attribute-value lookups — uses `float64` and `array(string)`. Convert
- * where a reported type becomes a query-builder one, so those lookups can't miss.
- */
-const TO_DATA_TYPE: Record<FieldDataType, DataTypes> = {
-	'': DataTypes.EMPTY,
-	string: DataTypes.String,
-	bool: DataTypes.bool,
-	int64: DataTypes.Int64,
-	float64: DataTypes.Float64,
-	number: DataTypes.Float64,
-	'[]string': DataTypes.ArrayString,
-	'[]bool': DataTypes.ArrayBool,
-	'[]int64': DataTypes.ArrayInt64,
-	'[]float64': DataTypes.ArrayFloat64,
-	'[]number': DataTypes.ArrayFloat64,
-};
-
-/**
- * Exhaustive over `FieldDataType`, so a type added to the API union fails to compile here
- * rather than going missing at runtime. The fallback is for a spelling the union doesn't know
- * yet — the backend can store `[]json` and `[]dynamic` — not for any of the cases above.
- */
-export const fieldDataTypeToDataType = (
-	fieldDataType?: FieldDataType,
-): DataTypes => TO_DATA_TYPE[fieldDataType ?? ''] ?? DataTypes.EMPTY;

pkg/alertmanager/alertmanagernotify/googlechat/googlechat.go

@@ -0,0 +1,167 @@
+package googlechat
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+)
+
+func New(conf *alertmanagertypes.GoogleChatReceiverConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater) (*Notifier, error) {
+	client, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration)
+	if err != nil {
+		return nil, err
+	}
+	return &Notifier{
+		conf:      conf,
+		tmpl:      t,
+		logger:    l,
+		client:    client,
+		retrier:   &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
+		templater: templater,
+	}, nil
+}
+
+func (n *Notifier) Notify(ctx context.Context, alerts ...*types.Alert) (bool, error) {
+	if n.conf.WebhookURL == nil {
+		return false, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url is empty")
+	}
+
+	key, err := notify.ExtractGroupKey(ctx)
+	if err != nil {
+		return false, err
+	}
+	n.logger.DebugContext(ctx, "sending google chat notification", slog.Any("group_key", key))
+
+	c, err := n.prepareContent(ctx, alerts)
+	if err != nil {
+		return false, err
+	}
+	text := c.title
+	if c.body != "" {
+		text = fmt.Sprintf("%s\n%s", c.title, c.body)
+	}
+	// Google Chat rejects a message with empty text and no cards. An empty
+	// render means a misconfigured title/text template, so fail loudly and
+	// non-retryably instead of sending a placeholder.
+	if text == "" {
+		return false, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat message rendered empty; check the channel title/text templates")
+	}
+
+	msg := Message{Text: text}
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(msg); err != nil {
+		return false, err
+	}
+	// Truncate to Google Chat's byte limit. We measure the serialized buffer and
+	// drop that many text bytes; each removed text byte drops >=1 serialized byte,
+	// so a single pass always lands the payload within the limit.
+	if buf.Len() > maxMessageBytes {
+		over := buf.Len() - maxMessageBytes
+		target := max(len(text)-over, 0)
+		msg.Text = truncateToByteLimit(text, target)
+		buf.Reset()
+		if err := json.NewEncoder(&buf).Encode(msg); err != nil {
+			return false, err
+		}
+	}
+
+	// Thread same-rule alerts together: threadKey is a stable hash of the
+	// alert group key. Changing a rule's grouping starts a new thread.
+	u, err := url.Parse(n.conf.WebhookURL.String())
+	if err != nil {
+		return false, errors.WrapInternalf(err, errors.CodeInternal, "parse google chat webhook url")
+	}
+	q := u.Query()
+	q.Set("threadKey", key.Hash())
+	q.Set("messageReplyOption", "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD")
+	u.RawQuery = q.Encode()
+
+	resp, err := notify.PostJSON(ctx, n.client, u.String(), &buf) //nolint:bodyclose
+	if err != nil {
+		return true, notify.RedactURL(err)
+	}
+	defer notify.Drain(resp)
+
+	shouldRetry, err := n.retrier.Check(resp.StatusCode, resp.Body)
+	if err != nil {
+		return shouldRetry, notify.NewErrorWithReason(notify.GetFailureReasonFromStatusCode(resp.StatusCode), err)
+	}
+	return shouldRetry, err
+}
+
+// prepareContent expands the title and body templates. Custom templates (from
+// alert annotations) override the channel defaults; result.IsDefaultBody tells
+// whether the body came from the default template.
+func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) (content, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Title,
+		DefaultBodyTemplate:  n.conf.Text,
+	}, alerts)
+	if err != nil {
+		return content{}, err
+	}
+
+	title := result.Title
+	body := strings.Join(result.Body, "\n\n")
+
+	// Default templates are already authored in Google Chat dialect. Custom
+	// templates are standard markdown, so convert them. The templater only
+	// reports IsDefaultBody, so the title is gated on the body's default-ness.
+	if !result.IsDefaultBody {
+		if body != "" {
+			if body, err = markdownrenderer.RenderGoogleChatMarkdown(body); err != nil {
+				return content{}, err
+			}
+		}
+		if title != "" {
+			if title, err = markdownrenderer.RenderGoogleChatMarkdown(title); err != nil {
+				return content{}, err
+			}
+		}
+	}
+
+	return content{
+		title:         title,
+		body:          body,
+		isDefaultBody: result.IsDefaultBody,
+	}, nil
+}
+
+// truncateToByteLimit trims s to at most maxBytes bytes on a rune boundary,
+// appending an ellipsis when it truncates.
+func truncateToByteLimit(s string, maxBytes int) string {
+	if len(s) <= maxBytes {
+		return s
+	}
+	const ellipsis = "..."
+	target := maxBytes - len(ellipsis)
+	if target <= 0 {
+		return ellipsis[:maxBytes]
+	}
+	truncated := s
+	for len(truncated) > target {
+		_, size := utf8.DecodeLastRuneInString(truncated)
+		if size == 0 {
+			break
+		}
+		truncated = truncated[:len(truncated)-size]
+	}
+	return truncated + ellipsis
+}

pkg/alertmanager/alertmanagernotify/googlechat/googlechat_test.go

@@ -0,0 +1,281 @@
+package googlechat
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	commoncfg "github.com/prometheus/common/config"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/require"
+
+	"github.com/prometheus/alertmanager/config"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/notify/test"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+)
+
+func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
+	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
+}
+
+func secretURLFromString(t *testing.T, rawURL string) *config.SecretURL {
+	t.Helper()
+	parsed, err := url.Parse(rawURL)
+	require.NoError(t, err)
+	return &config.SecretURL{URL: parsed}
+}
+
+func newTestNotifier(t *testing.T, webhookURL, title, text string) *Notifier {
+	t.Helper()
+	tmpl := test.CreateTmpl(t)
+	n, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		HTTPConfig: &commoncfg.HTTPClientConfig{},
+		WebhookURL: secretURLFromString(t, webhookURL),
+		Title:      title,
+		Text:       text,
+	}, tmpl, slog.New(slog.DiscardHandler), newTestTemplater(tmpl))
+	require.NoError(t, err)
+	return n
+}
+
+func newTestAlerts(alertname string) []*types.Alert {
+	return []*types.Alert{{
+		Alert: model.Alert{
+			Labels:      model.LabelSet{"alertname": model.LabelValue(alertname)},
+			Annotations: model.LabelSet{"summary": model.LabelValue("summary for " + alertname)},
+			StartsAt:    time.Now(),
+			EndsAt:      time.Now().Add(time.Minute),
+		},
+	}}
+}
+
+func newTestContext() context.Context {
+	return notify.WithGroupKey(context.Background(), "test-receiver")
+}
+
+// captureServer starts an httptest server that decodes the posted Google Chat
+// Message into got and replies 200.
+func captureServer(t *testing.T, got *Message) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if got != nil {
+			_ = json.NewDecoder(r.Body).Decode(got)
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+}
+
+func TestGoogleChatSend(t *testing.T) {
+	var got Message
+	server := captureServer(t, &got)
+	defer server.Close()
+
+	n := newTestNotifier(t, server.URL, `[{{ .Status | toUpper }}] {{ .CommonLabels.alertname }}`, "")
+	retry, err := n.Notify(newTestContext(), newTestAlerts("TestAlert")...)
+
+	require.NoError(t, err)
+	require.False(t, retry)
+	require.Contains(t, got.Text, "FIRING")
+	require.Contains(t, got.Text, "TestAlert")
+}
+
+func TestGoogleChatTitleAndBody(t *testing.T) {
+	var got Message
+	server := captureServer(t, &got)
+	defer server.Close()
+
+	// static templates → assert the exact title\nbody join.
+	n := newTestNotifier(t, server.URL, "TITLE", "BODY")
+	retry, err := n.Notify(newTestContext(), newTestAlerts("TestAlert")...)
+
+	require.NoError(t, err)
+	require.False(t, retry)
+	require.Equal(t, "TITLE\nBODY", got.Text)
+}
+
+func TestGoogleChatRetryCodes(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
+	n, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		HTTPConfig: &commoncfg.HTTPClientConfig{},
+		WebhookURL: secretURLFromString(t, "https://chat.googleapis.com/v1/spaces/test/messages"),
+	}, tmpl, slog.New(slog.DiscardHandler), newTestTemplater(tmpl))
+	require.NoError(t, err)
+
+	cases := []struct {
+		code  int
+		retry bool
+	}{
+		{http.StatusOK, false},
+		{http.StatusBadRequest, false},         // 400: malformed payload, permanent
+		{http.StatusTooManyRequests, true},     // 429: rate limited, retry (our RetryCodes)
+		{http.StatusInternalServerError, true}, // 5xx: retry
+		{http.StatusServiceUnavailable, true},
+	}
+	for _, c := range cases {
+		t.Run(http.StatusText(c.code), func(t *testing.T) {
+			actual, _ := n.retrier.Check(c.code, nil)
+			require.Equal(t, c.retry, actual, "retry mismatch on status %d", c.code)
+		})
+	}
+}
+
+func TestGoogleChatRedactedURL(t *testing.T) {
+	ctx, u, fn := test.GetContextWithCancelingURL()
+	defer fn()
+	ctx = notify.WithGroupKey(ctx, "test-receiver")
+
+	tmpl := test.CreateTmpl(t)
+	n, err := New(&alertmanagertypes.GoogleChatReceiverConfig{
+		HTTPConfig: &commoncfg.HTTPClientConfig{},
+		WebhookURL: &config.SecretURL{URL: u},
+		Title:      "alert", // non-empty so it reaches the POST (not the empty-text guard)
+	}, tmpl, slog.New(slog.DiscardHandler), newTestTemplater(tmpl))
+	require.NoError(t, err)
+
+	test.AssertNotifyLeaksNoSecret(ctx, t, n, u.String())
+}
+
+func TestTruncateToByteLimit(t *testing.T) {
+	cases := []struct {
+		name    string
+		in      string
+		max     int
+		wantLen int    // upper bound on byte length of result
+		wantHas string // substring the result must contain (or "")
+	}{
+		{"under limit passthrough", "hello", 100, 5, "hello"},
+		{"over limit trims with ellipsis", strings.Repeat("a", 50), 10, 10, "..."},
+		{"exact limit passthrough", "hello", 5, 5, "hello"},
+		{"tiny limit", "hello", 2, 2, ""},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := truncateToByteLimit(c.in, c.max)
+			require.LessOrEqual(t, len(got), c.wantLen)
+			if c.wantHas != "" {
+				require.Contains(t, got, c.wantHas)
+			}
+		})
+	}
+}
+
+func TestGoogleChatMessageSizeLimit(t *testing.T) {
+	var bodyLen int
+	var valid bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		bodyLen = len(raw)
+		valid = json.Valid(raw)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	// Huge plain-ASCII title so one-time truncation lands deterministically under the limit.
+	n := newTestNotifier(t, server.URL, strings.Repeat("A", 40000), "")
+	retry, err := n.Notify(newTestContext(), newTestAlerts("Big")...)
+
+	require.NoError(t, err)
+	require.False(t, retry)
+	require.True(t, valid, "posted body must be valid JSON")
+	require.LessOrEqual(t, bodyLen, maxMessageBytes, "posted body must be within the size limit")
+}
+
+func TestGoogleChatThreading(t *testing.T) {
+	var query url.Values
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		query = r.URL.Query()
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	cases := []struct{ name, groupKey string }{
+		{"rule a", "{ruleId=\"aaa\"}"},
+		{"rule b", "{ruleId=\"bbb\"}"},
+	}
+	seen := map[string]string{}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			n := newTestNotifier(t, server.URL, "T", "")
+			ctx := notify.WithGroupKey(context.Background(), c.groupKey)
+			_, err := n.Notify(ctx, newTestAlerts("X")...)
+			require.NoError(t, err)
+
+			require.Equal(t, "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD", query.Get("messageReplyOption"))
+			threadKey := query.Get("threadKey")
+			require.Equal(t, notify.Key(c.groupKey).Hash(), threadKey, "threadKey must be the group key hash")
+			seen[c.name] = threadKey
+		})
+	}
+	require.NotEqual(t, seen["rule a"], seen["rule b"], "distinct group keys must yield distinct threadKeys")
+}
+
+func TestGoogleChatCustomTemplateMarkdown(t *testing.T) {
+	var got Message
+	server := captureServer(t, &got)
+	defer server.Close()
+
+	// Custom body template (standard markdown) supplied via annotation → the
+	// !IsDefaultBody path must convert it to Google Chat dialect.
+	alerts := []*types.Alert{{
+		Alert: model.Alert{
+			Labels:      model.LabelSet{"alertname": "X"},
+			Annotations: model.LabelSet{ruletypes.AnnotationBodyTemplate: "**bold** and [link](https://x)"},
+			StartsAt:    time.Now(),
+			EndsAt:      time.Now().Add(time.Minute),
+		},
+	}}
+	n := newTestNotifier(t, server.URL, "Alert", "default body")
+	_, err := n.Notify(newTestContext(), alerts...)
+	require.NoError(t, err)
+
+	require.Contains(t, got.Text, "*bold*", "** should convert to *")
+	require.Contains(t, got.Text, "<https://x|link>", "[t](u) should convert to <u|t>")
+	require.NotContains(t, got.Text, "**bold**", "conversion must have happened")
+}
+
+func TestGoogleChatSerializedSizeUnderLimit(t *testing.T) {
+	var bodyLen int
+	var valid bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		bodyLen = len(raw)
+		valid = json.Valid(raw)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	// Escaping-dense payload: <, >, & and newlines each expand under JSON
+	// encoding, so this is the shape that would push the serialized body over
+	// the limit if we measured the text bytes instead of the marshaled buffer.
+	dense := strings.Repeat("<https://example.com/a?x=1&y=2|link>\n", 2000)
+	n := newTestNotifier(t, server.URL, dense, "")
+	_, err := n.Notify(newTestContext(), newTestAlerts("Dense")...)
+
+	require.NoError(t, err)
+	require.True(t, valid, "posted body must be valid JSON")
+	require.LessOrEqual(t, bodyLen, maxMessageBytes, "serialized body must be within the limit")
+}
+
+func TestGoogleChatEmptyText(t *testing.T) {
+	server := captureServer(t, nil)
+	defer server.Close()
+
+	// Empty title and body templates → must not POST; fail non-retryably.
+	n := newTestNotifier(t, server.URL, "", "")
+	retry, err := n.Notify(newTestContext(), newTestAlerts("X")...)
+
+	require.Error(t, err)
+	require.False(t, retry)
+}

pkg/alertmanager/alertmanagernotify/googlechat/types.go

@@ -0,0 +1,38 @@
+package googlechat
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+)
+
+const (
+	Integration = "googlechat"
+	// maxMessageBytes is the Google Chat message payload limit.
+	// https://developers.google.com/chat/api/guides/message-formats/basic#maximum_size
+	maxMessageBytes = 32000
+)
+
+// Notifier implements notify.Notifier for Google Chat.
+type Notifier struct {
+	conf      *alertmanagertypes.GoogleChatReceiverConfig
+	tmpl      *template.Template
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
+}
+
+// Message is the Google Chat webhook payload.
+type Message struct {
+	Text string `json:"text"`
+}
+
+// content holds the rendered title and body for a Google Chat message.
+type content struct {
+	title, body   string
+	isDefaultBody bool
+}

pkg/alertmanager/alertmanagernotify/receiver.go

@@ -5,6 +5,7 @@ import (
 	"slices"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/email"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/googlechat"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/msteamsv2"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/opsgenie"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/pagerduty"
@@ -24,6 +25,7 @@ var customNotifierIntegrations = []string{
 	opsgenie.Integration,
 	slack.Integration,
 	msteamsv2.Integration,
+	googlechat.Integration,
 }
 
 func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {
@@ -74,6 +76,11 @@ func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Temp
 			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l, templater)
 		})
 	}
+	for i, c := range nc.GoogleChatConfigs {
+		add(googlechat.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
+			return googlechat.New(c, tmpl, l, templater)
+		})
+	}
 
 	if errs.Len() > 0 {
 		return nil, &errs

pkg/modules/llmpricingrule/impllmpricingrule/module.go

@@ -213,18 +213,18 @@ func (module *module) discoverModels(ctx context.Context, orgID valuer.UUID) ([]
 					Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
 						Name:   "A",
 						Signal: telemetrytypes.SignalTraces,
-						Filter: &qbtypes.Filter{Expression: fmt.Sprintf("%s EXISTS", telemetrytypes.GenAIRequestModel)},
+						Filter: &qbtypes.Filter{Expression: fmt.Sprintf("%s EXISTS", llmpricingruletypes.GenAIRequestModel)},
 						Aggregations: []qbtypes.TraceAggregation{
 							{Expression: "count()", Alias: "spanCount"},
 						},
 						GroupBy: []qbtypes.GroupByKey{
 							{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-								Name:          telemetrytypes.GenAIRequestModel,
+								Name:          llmpricingruletypes.GenAIRequestModel,
 								FieldContext:  telemetrytypes.FieldContextSpan,
 								FieldDataType: telemetrytypes.FieldDataTypeString,
 							}},
 							{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-								Name:          telemetrytypes.GenAIProviderName,
+								Name:          llmpricingruletypes.GenAIProviderName,
 								FieldContext:  telemetrytypes.FieldContextSpan,
 								FieldDataType: telemetrytypes.FieldDataTypeString,
 							}},
@@ -254,9 +254,9 @@ func (module *module) discoverModels(ctx context.Context, orgID valuer.UUID) ([]
 		switch c.Type {
 		case qbtypes.ColumnTypeGroup:
 			switch c.Name {
-			case telemetrytypes.GenAIRequestModel:
+			case llmpricingruletypes.GenAIRequestModel:
 				modelIdx = i
-			case telemetrytypes.GenAIProviderName:
+			case llmpricingruletypes.GenAIProviderName:
 				providerIdx = i
 			}
 		case qbtypes.ColumnTypeAggregation:

pkg/querier/api.go

@@ -242,7 +242,7 @@ func (handler *handler) ReplaceVariables(rw http.ResponseWriter, req *http.Reque
 	errs := []error{}
 
 	for idx, item := range queryRangeRequest.CompositeQuery.Queries {
-		if item.Type == qbtypes.QueryTypeBuilder || item.Type == qbtypes.QueryTypeBuilderAI {
+		if item.Type == qbtypes.QueryTypeBuilder {
 			switch spec := item.Spec.(type) {
 			case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
 				if spec.Filter != nil && spec.Filter.Expression != "" {

pkg/querier/preview.go

@@ -249,7 +249,6 @@ func (q *querier) buildPreviewProviders(
 func rendersStandaloneStatement(t qbtypes.QueryType) bool {
 	switch t {
 	case qbtypes.QueryTypeBuilder,
-		qbtypes.QueryTypeBuilderAI,
 		qbtypes.QueryTypePromQL,
 		qbtypes.QueryTypeClickHouseSQL,
 		qbtypes.QueryTypeTraceOperator:

pkg/querier/querier.go

@@ -42,7 +42,6 @@ type querier struct {
 	metadataStore            telemetrytypes.MetadataStore
 	promEngine               prometheus.Prometheus
 	traceStmtBuilder         qbtypes.StatementBuilder[qbtypes.TraceAggregation]
-	aiTraceStmtBuilder       qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	logStmtBuilder           qbtypes.StatementBuilder[qbtypes.LogAggregation]
 	auditStmtBuilder         qbtypes.StatementBuilder[qbtypes.LogAggregation]
 	metricStmtBuilder        qbtypes.StatementBuilder[qbtypes.MetricAggregation]
@@ -62,7 +61,6 @@ func New(
 	metadataStore telemetrytypes.MetadataStore,
 	promEngine prometheus.Prometheus,
 	traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
-	aiTraceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
 	logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
 	auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
 	metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation],
@@ -84,7 +82,6 @@ func New(
 		metadataStore:            metadataStore,
 		promEngine:               promEngine,
 		traceStmtBuilder:         traceStmtBuilder,
-		aiTraceStmtBuilder:       aiTraceStmtBuilder,
 		logStmtBuilder:           logStmtBuilder,
 		auditStmtBuilder:         auditStmtBuilder,
 		metricStmtBuilder:        metricStmtBuilder,
@@ -235,16 +232,6 @@ func (q *querier) buildQueries(
 			}
 			queries[traceOpQuery.Name] = toq
 			steps[traceOpQuery.Name] = traceOpQuery.StepInterval
-		case qbtypes.QueryTypeBuilderAI:
-			spec, ok := query.Spec.(qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation])
-			if !ok {
-				return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid AI builder query spec %T", query.Spec)
-			}
-			spec.ShiftBy = extractShiftFromBuilderQuery(spec)
-			timeRange := adjustTimeRangeForShift(spec, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType)
-			bq := newBuilderQuery(q.logger, q.telemetryStore, orgID, q.aiTraceStmtBuilder, spec, timeRange, req.RequestType, tmplVars, builderConfig{})
-			queries[spec.Name] = bq
-			steps[spec.Name] = spec.StepInterval
 		case qbtypes.QueryTypeBuilder:
 			switch spec := query.Spec.(type) {
 			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:
@@ -311,11 +298,6 @@ func (q *querier) populateQBEvent(event *qbtypes.QBEvent, queries []qbtypes.Quer
 			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
 				event.MetricsUsed = true
 			}
-		case qbtypes.QueryTypeBuilderAI:
-			filter := query.GetFilter()
-			event.FilterApplied = event.FilterApplied || (filter != nil && filter.Expression != "")
-			event.GroupByApplied = event.GroupByApplied || len(query.GetGroupBy()) > 0
-			event.TracesUsed = true
 		case qbtypes.QueryTypePromQL:
 			event.MetricsUsed = true
 		case qbtypes.QueryTypeTraceOperator:
@@ -878,9 +860,7 @@ func (q *querier) createRangedQuery(_ valuer.UUID, originalQuery qbtypes.Query,
 		specCopy := qt.spec.Copy()
 		specCopy.ShiftBy = extractShiftFromBuilderQuery(specCopy)
 		adjustedTimeRange := adjustTimeRangeForShift(specCopy, timeRange, qt.kind)
-		// Reuse the statement builder the original query was created with, so an AI
-		// query keeps its AI builder without re-deriving it from the spec.
-		return newBuilderQuery(q.logger, q.telemetryStore, qt.orgID, qt.stmtBuilder, specCopy, adjustedTimeRange, qt.kind, qt.variables, builderConfig{})
+		return newBuilderQuery(q.logger, q.telemetryStore, qt.orgID, q.traceStmtBuilder, specCopy, adjustedTimeRange, qt.kind, qt.variables, builderConfig{})
 
 	case *builderQuery[qbtypes.LogAggregation]:
 		specCopy := qt.spec.Copy()
@@ -1237,8 +1217,6 @@ func (q *querier) adjustStepInterval(queries []qbtypes.QueryEnvelope, start, end
 			if qe.GetStepInterval().Seconds() == 0 {
 				qe.SetStepInterval(secondsStep(metricRecommended))
 			}
-		case qbtypes.QueryTypeBuilderAI:
-			clampStep(qe, traceLogRecommended, traceLogMin, &warnings)
 		case qbtypes.QueryTypeTraceOperator:
 			clampStep(qe, traceLogRecommended, traceLogMin, &warnings)
 		}

pkg/querier/querier_test.go

@@ -49,7 +49,6 @@ func TestQueryRange_MetricTypeMissing(t *testing.T) {
 		metadataStore,
 		nil,                // prometheus
 		nil,                // traceStmtBuilder
-		nil,                // aiTraceStmtBuilder
 		nil,                // logStmtBuilder
 		nil,                // auditStmtBuilder
 		nil,                // metricStmtBuilder
@@ -122,7 +121,6 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {
 		metadataStore,
 		nil,                      // prometheus
 		nil,                      // traceStmtBuilder
-		nil,                      // aiTraceStmtBuilder
 		nil,                      // logStmtBuilder
 		nil,                      // auditStmtBuilder
 		&mockMetricStmtBuilder{}, // metricStmtBuilder

pkg/querier/signozquerier/provider.go

@@ -9,13 +9,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryai"
 	"github.com/SigNoz/signoz/pkg/telemetryaudit"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
 	"github.com/SigNoz/signoz/pkg/telemetrymeter"
 	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetryscopedtraces"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 )
@@ -94,18 +92,6 @@ func newProvider(
 		cfg.SkipResourceFingerprint.Threshold,
 	)
 
-	// AI trace statement builder (builder_ai_query). The gen_ai gate/column keys are
-	// surfaced by the metadata store itself (enrichWithGenAIKeys), so queries work
-	// before any gen_ai metadata is ingested — no per-builder decoration needed.
-	// The standard trace builder doubles as the delegate for the span-list path.
-	aiTraceStmtBuilder := telemetryscopedtraces.NewScopedTraceStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		telemetryai.Scope(),
-		traceStmtBuilder,
-		flagger,
-	)
-
 	// Create trace operator statement builder
 	traceOperatorStmtBuilder := telemetrytraces.NewTraceOperatorStatementBuilder(
 		settings,
@@ -195,7 +181,6 @@ func newProvider(
 		telemetryMetadataStore,
 		prometheus,
 		traceStmtBuilder,
-		aiTraceStmtBuilder,
 		logStmtBuilder,
 		auditStmtBuilder,
 		metricStmtBuilder,

pkg/query-service/rules/setups_test.go

@@ -48,7 +48,6 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Teleme
 		metadataStore,
 		nil, // prometheus
 		nil, // traceStmtBuilder
-		nil, // aiTraceStmtBuilder
 		nil, // logStmtBuilder
 		nil, // auditStmtBuilder
 		metricStmtBuilder,
@@ -102,7 +101,6 @@ func prepareQuerierForLogs(t *testing.T, telemetryStore telemetrystore.Telemetry
 		metadataStore,
 		nil,            // prometheus
 		nil,            // traceStmtBuilder
-		nil,            // aiTraceStmtBuilder
 		logStmtBuilder, // logStmtBuilder
 		nil,            // auditStmtBuilder
 		nil,            // metricStmtBuilder
@@ -152,7 +150,6 @@ func prepareQuerierForTraces(t *testing.T, telemetryStore telemetrystore.Telemet
 		metadataStore,
 		nil,              // prometheus
 		traceStmtBuilder, // traceStmtBuilder
-		nil,              // aiTraceStmtBuilder
 		nil,              // logStmtBuilder
 		nil,              // auditStmtBuilder
 		nil,              // metricStmtBuilder

pkg/querybuilder/filter_split.go

@@ -1,176 +0,0 @@
-package querybuilder
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/antlr4-go/antlr/v4"
-)
-
-// SplitFilterForAggregates partitions a single filter expression into a span-level
-// part (a WHERE over spans) and a trace-level part (a HAVING over per-trace
-// aggregates), splitting on the top-level AND.
-//
-// A key is trace-level when it carries the trace field context (`trace.completion_tokens`)
-// or, with no context, its bare name is in aggregateNames. Any other explicit context
-// (`span.`, `resource.`, …) is span-level. Trace-level and span-level keys may be
-// AND-combined (they run at different query stages) but not OR-combined; an OR that
-// mixes the two is an error.
-func SplitFilterForAggregates(query string, aggregateNames map[string]struct{}) (spanExpr string, havingExpr string, err error) {
-	if strings.TrimSpace(query) == "" {
-		return "", "", nil
-	}
-
-	tree, syntaxErrors := parseFilterQuery(query)
-	if len(syntaxErrors) > 0 {
-		combinedErrors := errors.Newf(
-			errors.TypeInvalidInput,
-			errors.CodeInvalidInput,
-			"Found %d syntax errors while parsing the filter expression.",
-			len(syntaxErrors),
-		)
-		additionals := make([]string, 0, len(syntaxErrors))
-		for _, syntaxError := range syntaxErrors {
-			if syntaxError.Error() != "" {
-				additionals = append(additionals, syntaxError.Error())
-			}
-		}
-		// TODO: add troubleshooting link to the filter query syntax guide once it's published.
-		return "", "", combinedErrors.WithAdditional(additionals...)
-	}
-
-	s := filterSplitter{query: []rune(query), aggregateNames: aggregateNames}
-	s.visit(tree)
-
-	if s.mixed {
-		return "", "", errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"trace-level and span-level filters cannot be combined within an OR/NOT group; separate them with a top-level AND")
-	}
-	return strings.Join(s.span, " AND "), strings.Join(s.having, " AND "), nil
-}
-
-func parseFilterQuery(query string) (antlr.Tree, []*SyntaxErr) {
-	lexerErrorListener := NewErrorListener()
-	lexer := grammar.NewFilterQueryLexer(antlr.NewInputStream(query))
-	lexer.RemoveErrorListeners()
-	lexer.AddErrorListener(lexerErrorListener)
-
-	parserErrorListener := NewErrorListener()
-	parser := grammar.NewFilterQueryParser(antlr.NewCommonTokenStream(lexer, 0))
-	parser.RemoveErrorListeners()
-	parser.AddErrorListener(parserErrorListener)
-
-	tree := parser.Query()
-	return tree, append(lexerErrorListener.SyntaxErrors, parserErrorListener.SyntaxErrors...)
-}
-
-// filterSplitter walks the parse tree once, flattening the top-level AND chain and
-// routing each atom (a comparison, a NOT expression, or a whole multi-branch OR group)
-// to the span or having bucket by the class of the keys it references.
-type filterSplitter struct {
-	query          []rune
-	aggregateNames map[string]struct{}
-	span           []string
-	having         []string
-	mixed          bool
-}
-
-func (s *filterSplitter) visit(node antlr.Tree) {
-	switch n := node.(type) {
-	case *grammar.QueryContext:
-		if n.Expression() != nil {
-			s.visit(n.Expression())
-		}
-	case *grammar.ExpressionContext:
-		if n.OrExpression() != nil {
-			s.visit(n.OrExpression())
-		}
-	case *grammar.OrExpressionContext:
-		// a single branch is just an AND chain; multiple branches are a real OR, kept
-		// whole so a class-mixing OR can be rejected.
-		if ands := n.AllAndExpression(); len(ands) == 1 {
-			s.visit(ands[0])
-		} else {
-			s.route(n)
-		}
-	case *grammar.AndExpressionContext:
-		for _, u := range n.AllUnaryExpression() {
-			s.visit(u)
-		}
-	case *grammar.UnaryExpressionContext:
-		if n.NOT() != nil {
-			s.route(n)
-		} else if n.Primary() != nil {
-			s.visit(n.Primary())
-		}
-	case *grammar.PrimaryContext:
-		if n.OrExpression() != nil { // parenthesized sub-expression
-			s.visit(n.OrExpression())
-		} else {
-			s.route(n)
-		}
-	}
-}
-
-// route classifies an atom and appends its original source text to the right bucket.
-func (s *filterSplitter) route(atom antlr.ParserRuleContext) {
-	isTrace, isSpan := classifyKeys(atom, s.aggregateNames)
-	if isTrace && isSpan {
-		s.mixed = true
-		return
-	}
-	text := atomSourceText(s.query, atom)
-	// A multi-branch OR group's source slice excludes its enclosing parens (they belong
-	// to the parent Primary). Re-wrap it so rejoining a bucket with " AND " cannot invert
-	// OR/AND precedence, e.g. `a AND (b OR c)` must not flatten to `a AND b OR c`.
-	if or, ok := atom.(*grammar.OrExpressionContext); ok && len(or.AllAndExpression()) > 1 {
-		text = "(" + text + ")"
-	}
-	if isTrace {
-		s.having = append(s.having, text)
-	} else {
-		s.span = append(s.span, text)
-	}
-}
-
-// classifyKeys reports whether a subtree references trace-level and/or span-level keys.
-// A key is trace-level when it carries the trace field context or, with no context,
-// its name is a known aggregate; an unknown name under the trace context stays
-// trace-level so the aggregate validation rejects it with a targeted error. Any other
-// explicit context (`span.`, `resource.`, …) is span-level.
-func classifyKeys(node antlr.Tree, aggregateNames map[string]struct{}) (isTrace, isSpan bool) {
-	kc, ok := node.(*grammar.KeyContext)
-	if ok {
-		key := telemetrytypes.GetFieldKeyFromKeyText(kc.GetText())
-		switch key.FieldContext {
-		case telemetrytypes.FieldContextTrace:
-			isTrace = true
-		case telemetrytypes.FieldContextUnspecified:
-			_, isTrace = aggregateNames[key.Name]
-			isSpan = !isTrace
-		default:
-			isSpan = true
-		}
-		return
-	}
-	for i := 0; i < node.GetChildCount(); i++ {
-		t, s := classifyKeys(node.GetChild(i), aggregateNames)
-		isTrace = isTrace || t
-		isSpan = isSpan || s
-	}
-	return
-}
-
-// atomSourceText returns the original source substring for an atom, preserving
-// whitespace. The token stream drops skipped whitespace, which would glue word
-// operators (OR/AND/NOT) to their operands, so slice the input by token offsets.
-// ANTLR offsets are rune indices (InputStream holds []rune), hence the rune slice.
-func atomSourceText(query []rune, atom antlr.ParserRuleContext) string {
-	start, stop := atom.GetStart(), atom.GetStop()
-	if start == nil || stop == nil || start.GetStart() < 0 || stop.GetStop() >= len(query) || stop.GetStop() < start.GetStart() {
-		return atom.GetText()
-	}
-	return string(query[start.GetStart() : stop.GetStop()+1])
-}

pkg/querybuilder/filter_split_test.go

@@ -1,222 +0,0 @@
-package querybuilder
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestSplitFilterForAggregates(t *testing.T) {
-	agg := map[string]struct{}{"completion_tokens": {}, "span_count": {}, "prompt_tokens": {}}
-
-	type tc struct {
-		name    string
-		query   string
-		span    string // expected span-level (WHERE) part; "" => empty
-		having  string // expected trace-level (HAVING) part; "" => empty
-		wantErr bool
-	}
-
-	cases := []tc{
-		// --- empty input ---------------------------------------------------------
-		{
-			name: "empty",
-		},
-		{
-			name:  "whitespace only",
-			query: "   ",
-		},
-
-		// --- single class --------------------------------------------------------
-		{
-			name:  "span only",
-			query: "service.name = 'x'",
-			span:  "service.name = 'x'",
-		},
-		{
-			name:   "agg only bare",
-			query:  "completion_tokens > 1000",
-			having: "completion_tokens > 1000",
-		},
-		{
-			// the user-facing `trace.` prefix marks a trace-level aggregate.
-			name:   "agg only trace prefix",
-			query:  "trace.completion_tokens > 1000",
-			having: "trace.completion_tokens > 1000",
-		},
-		{
-			// an unknown name under the trace context still routes trace-level, so the
-			// aggregate validation rejects it with a targeted error instead of the span
-			// path failing on an unknown field.
-			name:   "unknown aggregate under trace context stays trace-level",
-			query:  "trace.not_an_aggregate > 1000",
-			having: "trace.not_an_aggregate > 1000",
-		},
-
-		{
-			// ANTLR token offsets are rune indices; slicing must not shift after a
-			// multi-byte char (this used to truncate 1000 → 100).
-			name:   "unicode value before the split",
-			query:  "service.name = 'héllo' AND completion_tokens > 1000",
-			span:   "service.name = 'héllo'",
-			having: "completion_tokens > 1000",
-		},
-
-		// --- top-level AND splits across the two buckets -------------------------
-		{
-			name:   "span AND agg",
-			query:  "service.name = 'x' AND completion_tokens > 1000",
-			span:   "service.name = 'x'",
-			having: "completion_tokens > 1000",
-		},
-		{
-			// order within a bucket is preserved; the two span atoms join with AND.
-			name:   "span AND span AND agg",
-			query:  "service.name = 'x' AND kind_string = 'Internal' AND completion_tokens > 1000",
-			span:   "service.name = 'x' AND kind_string = 'Internal'",
-			having: "completion_tokens > 1000",
-		},
-		{
-			// a parenthesized top-level AND still splits across the two buckets.
-			name:   "parenthesized span AND agg",
-			query:  "(service.name = 'x' AND completion_tokens > 1000)",
-			span:   "service.name = 'x'",
-			having: "completion_tokens > 1000",
-		},
-
-		// --- OR groups are re-wrapped in parens so a later AND-join can't invert
-		//     precedence (`a AND (b OR c)` must not flatten to `a AND b OR c`) ------
-		{
-			name:   "agg OR agg",
-			query:  "completion_tokens > 1000 OR span_count > 3",
-			having: "(completion_tokens > 1000 OR span_count > 3)",
-		},
-		{
-			name:  "span OR span",
-			query: "service.name = 'x' OR kind_string = 'Internal'",
-			span:  "(service.name = 'x' OR kind_string = 'Internal')",
-		},
-		{
-			name:  "span AND (span OR span)",
-			query: "service.name = 'x' AND (kind_string = 'Internal' OR kind_string = 'Client')",
-			span:  "service.name = 'x' AND (kind_string = 'Internal' OR kind_string = 'Client')",
-		},
-		{
-			name:   "agg AND (agg OR agg)",
-			query:  "prompt_tokens > 5 AND (completion_tokens > 1000 OR span_count > 3)",
-			having: "prompt_tokens > 5 AND (completion_tokens > 1000 OR span_count > 3)",
-		},
-		{
-			// the OR group routes to span, the trailing aggregate to having.
-			name:   "span AND (span OR span) AND agg",
-			query:  "a.b = 'x' AND (c.d = 'y' OR e.f = 'z') AND completion_tokens > 1000",
-			span:   "a.b = 'x' AND (c.d = 'y' OR e.f = 'z')",
-			having: "completion_tokens > 1000",
-		},
-
-		// --- a nested AND group flattens across the buckets (no spurious parens) --
-		{
-			name:   "(span AND agg) AND agg",
-			query:  "(service.name = 'x' AND completion_tokens > 1000) AND prompt_tokens > 5",
-			span:   "service.name = 'x'",
-			having: "completion_tokens > 1000 AND prompt_tokens > 5",
-		},
-
-		// --- NOT wrapping a single-class group is routed whole to that class ------
-		{
-			name:   "not agg",
-			query:  "NOT (completion_tokens > 1000)",
-			having: "NOT (completion_tokens > 1000)",
-		},
-		{
-			name:  "not span",
-			query: "NOT (service.name = 'x')",
-			span:  "NOT (service.name = 'x')",
-		},
-
-		// --- an explicit non-trace context escapes the aggregate-alias shadow -----
-		{
-			// a span attribute named like an aggregate stays reachable via `attribute.`.
-			name:  "attribute prefix on aggregate name routes span-level",
-			query: "attribute.completion_tokens > 5",
-			span:  "attribute.completion_tokens > 5",
-		},
-		{
-			name:  "span prefix on aggregate name routes span-level",
-			query: "span.completion_tokens > 5",
-			span:  "span.completion_tokens > 5",
-		},
-		{
-			name:   "prefixed attribute AND bare aggregate split across buckets",
-			query:  "attribute.completion_tokens > 5 AND completion_tokens > 1000",
-			span:   "attribute.completion_tokens > 5",
-			having: "completion_tokens > 1000",
-		},
-
-		// --- class-mixing is rejected in an OR group, a NOT group, or a nested OR -
-		{
-			name:    "agg OR span rejected",
-			query:   "completion_tokens > 1000 OR service.name = 'x'",
-			wantErr: true,
-		},
-		{
-			name:    "not mixed rejected",
-			query:   "NOT (completion_tokens > 1000 AND service.name = 'x')",
-			wantErr: true,
-		},
-		{
-			name:    "span AND (agg OR span) rejected",
-			query:   "service.name = 'x' AND (completion_tokens > 1000 OR kind_string = 'Client')",
-			wantErr: true,
-		},
-
-		// --- syntax errors are rejected, not silently dropped by error recovery ---
-		{
-			// recovery would yield an empty tree → both buckets empty → filter ignored.
-			name:    "lone paren rejected",
-			query:   ")",
-			wantErr: true,
-		},
-		{
-			name:    "unbalanced parens rejected",
-			query:   "((",
-			wantErr: true,
-		},
-		{
-			name:    "bare operator rejected",
-			query:   "AND",
-			wantErr: true,
-		},
-		{
-			// lexer-level error: recovery drops the whole expression.
-			name:    "unterminated quote rejected",
-			query:   "'unterminated",
-			wantErr: true,
-		},
-		{
-			// recovery would drop only the malformed atom and keep the rest — a
-			// partially applied filter with no error.
-			name:    "garbage atom alongside valid agg rejected",
-			query:   ") AND completion_tokens > 5",
-			wantErr: true,
-		},
-		{
-			name:    "missing value rejected",
-			query:   "completion_tokens >",
-			wantErr: true,
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			span, having, err := SplitFilterForAggregates(c.query, agg)
-			if c.wantErr {
-				require.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-			require.Equal(t, c.span, span, "span part")
-			require.Equal(t, c.having, having, "having part")
-		})
-	}
-}

pkg/querybuilder/having_rewriter.go

@@ -18,19 +18,6 @@ func NewHavingExpressionRewriter() *HavingExpressionRewriter {
 	}
 }
 
-// Rewrite rewrites and validates a HAVING expression against a caller-supplied
-// column map (user-facing name -> SQL identifier/expression). Values are inlined, so
-// the result is a bare SQL boolean expression with no bound args. Used by callers
-// that project their own aggregate columns (e.g. the AI trace list) rather than the
-// query's Aggregations.
-func (r *HavingExpressionRewriter) Rewrite(expression string, columnMap map[string]string) (string, error) {
-	if len(strings.TrimSpace(expression)) == 0 {
-		return "", nil
-	}
-	r.columnMap = columnMap
-	return r.rewriteAndValidate(expression)
-}
-
 // RewriteForTraces rewrites and validates the HAVING expression for a traces query.
 func (r *HavingExpressionRewriter) RewriteForTraces(expression string, aggregations []qbtypes.TraceAggregation) (string, error) {
 	if len(strings.TrimSpace(expression)) == 0 {

pkg/querybuilder/query_range_resources.go

@@ -82,10 +82,6 @@ func resourcesForQuery(query gjson.Result, variables map[string]qbtypes.Variable
 	switch queryType {
 	case qbtypes.QueryTypeBuilder.StringValue(), qbtypes.QueryTypeSubQuery.StringValue():
 		return resourcesForBuilderQuery(queryType, query.Get("spec"), variables)
-	case qbtypes.QueryTypeBuilderAI.StringValue():
-		// An AI builder query is always a traces query; the signal is implied by the
-		// type (and may be absent from the payload), so pin the resource directly.
-		return builderQueryResourceRefs(queryType, coretypes.ResourceTelemetryResourceTraces, query.Get("spec"), variables)
 	case qbtypes.QueryTypePromQL.StringValue():
 		return []coretypes.ResourceWithID{{Resource: coretypes.ResourceTelemetryResourceMetrics, ID: typeWildcard}}, nil
 	case qbtypes.QueryTypeClickHouseSQL.StringValue():
@@ -107,10 +103,7 @@ func resourcesForBuilderQuery(queryType string, spec gjson.Result, variables map
 	if err != nil {
 		return nil, err
 	}
-	return builderQueryResourceRefs(queryType, resource, spec, variables)
-}
 
-func builderQueryResourceRefs(queryType string, resource coretypes.Resource, spec gjson.Result, variables map[string]qbtypes.VariableItem) ([]coretypes.ResourceWithID, error) {
 	ids, err := builderQuerySelectors(queryType, spec.Get("filter.expression").String(), variables)
 	if err != nil {
 		return nil, err

pkg/querybuilder/query_range_resources_test.go

@@ -92,20 +92,6 @@ func TestQueryRangeResources(t *testing.T) {
 				{Resource: coretypes.ResourceTelemetryResourceAuditLogs, ID: "builder_query/signoz.workspace.key.id/a"},
 			},
 		},
-		{
-			name: "ai builder query maps to traces resource without a signal",
-			body: `{"compositeQuery":{"queries":[{"type":"builder_ai_query","spec":{"filter":{"expression":"signoz.workspace.key.id = 'checkout'"}}}]}}`,
-			expected: []coretypes.ResourceWithID{
-				{Resource: coretypes.ResourceTelemetryResourceTraces, ID: "builder_ai_query/signoz.workspace.key.id/checkout"},
-			},
-		},
-		{
-			name: "ai builder query without filter is wildcard",
-			body: `{"compositeQuery":{"queries":[{"type":"builder_ai_query","spec":{}}]}}`,
-			expected: []coretypes.ResourceWithID{
-				{Resource: coretypes.ResourceTelemetryResourceTraces, ID: "builder_ai_query/*"},
-			},
-		},
 		{
 			name: "promql is wildcard only",
 			body: `{"compositeQuery":{"queries":[{"type":"promql","spec":{"query":"up"}}]}}`,

pkg/telemetryai/genai.go

@@ -1,66 +0,0 @@
-package telemetryai
-
-import (
-	"strings"
-
-	scopedtraces "github.com/SigNoz/signoz/pkg/telemetryscopedtraces"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-// Scope describes gen_ai for the scoped trace builder: an AI trace has >=1 gen_ai
-// LLM, tool, or agent span, and its list adds AI/LLM per-trace metrics on top of the
-// common columns. This package holds only gen_ai domain knowledge; the query
-// topology lives in telemetryscopedtraces.
-func Scope() scopedtraces.TraceScope {
-	gateKeyNames := []string{telemetrytypes.GenAIRequestModel, telemetrytypes.GenAIToolName, telemetrytypes.GenAIAgentName}
-	gateExprs := make([]string, 0, len(gateKeyNames))
-	gateKeys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(gateKeyNames))
-	for _, name := range gateKeyNames {
-		gateExprs = append(gateExprs, name+" EXISTS")
-		gateKeys = append(gateKeys, &telemetrytypes.TelemetryFieldKey{
-			Name:         name,
-			Signal:       telemetrytypes.SignalTraces,
-			FieldContext: telemetrytypes.FieldContextAttribute,
-		})
-	}
-
-	defs := telemetrytypes.GenAIFieldDefinitions
-	reqModel := defs[telemetrytypes.GenAIRequestModel]
-	toolName := defs[telemetrytypes.GenAIToolName]
-	inTok := defs[telemetrytypes.GenAIUsageInputTokens]
-	outTok := defs[telemetrytypes.GenAIUsageOutputTokens]
-	cost := defs[telemetrytypes.SignozGenAITotalCost]
-	inMsg := defs[telemetrytypes.GenAIInputMessages]
-	outMsg := defs[telemetrytypes.GenAIOutputMessages]
-
-	str := telemetrytypes.FieldDataTypeString
-	columns := append(scopedtraces.CommonTraceColumns(),
-		// LLM calls only (request model present), not the full gate.
-		scopedtraces.TraceColumn{Alias: "llm_call_count", Orderable: true, Expr: scopedtraces.CountExists(&reqModel)},
-		scopedtraces.TraceColumn{Alias: "tool_call_count", Orderable: true, Expr: scopedtraces.CountExists(&toolName)},
-		scopedtraces.TraceColumn{Alias: "distinct_tool_count", Orderable: true, Expr: scopedtraces.UniqCount(&toolName, str)},
-		// tokens live only on LLM spans, so a plain sum needs no gate scoping.
-		scopedtraces.TraceColumn{Alias: "input_tokens", Orderable: true, Expr: scopedtraces.Reduce(scopedtraces.AggSum, &inTok)},
-		scopedtraces.TraceColumn{Alias: "output_tokens", Orderable: true, Expr: scopedtraces.Reduce(scopedtraces.AggSum, &outTok)},
-		scopedtraces.TraceColumn{Alias: "total_tokens", Orderable: true, Expr: scopedtraces.SumOfKeys(telemetrytypes.FieldDataTypeFloat64, &inTok, &outTok)},
-		// per-span cost attached by the SigNoz LLM pricing processor.
-		scopedtraces.TraceColumn{Alias: "estimated_total_cost", Orderable: true, Expr: scopedtraces.Reduce(scopedtraces.AggSum, &cost)},
-		// slowest single LLM call in the trace.
-		scopedtraces.TraceColumn{Alias: "max_llm_duration_nano", Orderable: true, Expr: scopedtraces.ScopedToKeyColumn(scopedtraces.AggMax, scopedtraces.IntrinsicSpanKey("duration_nano"), &reqModel)},
-		// errors across the whole trace (any span), so display-only.
-		scopedtraces.TraceColumn{Alias: "error_count", Expr: scopedtraces.CondCount(scopedtraces.IntrinsicSpanKey("has_error"), qbtypes.FilterOperatorEqual, true)},
-		// timestamp of the last gen_ai span (LLM/tool/agent), hence gate-scoped.
-		scopedtraces.TraceColumn{Alias: "last_activity_time", Orderable: true, Expr: scopedtraces.ScopedReduce(scopedtraces.AggMax, scopedtraces.IntrinsicSpanKey("timestamp"))},
-		// previews: first call's input (the prompt), last call's output (the answer).
-		scopedtraces.TraceColumn{Alias: "input", SpanLevel: true, Expr: scopedtraces.PickBy(&inMsg, str, scopedtraces.IntrinsicSpanKey("timestamp"), scopedtraces.PickEarliest)},
-		scopedtraces.TraceColumn{Alias: "output", SpanLevel: true, Expr: scopedtraces.PickBy(&outMsg, str, scopedtraces.IntrinsicSpanKey("timestamp"), scopedtraces.PickLatest)},
-	)
-
-	return scopedtraces.TraceScope{
-		FilterExpression:  strings.Join(gateExprs, " OR "),
-		FieldKeys:         gateKeys,
-		Columns:           columns,
-		DefaultOrderAlias: "last_activity_time",
-	}
-}

pkg/telemetrymetadata/metadata.go

@@ -1188,27 +1188,6 @@ func enrichWithIntrinsicMetricKeys(keys map[string][]*telemetrytypes.TelemetryFi
 	return keys
 }
 
-// enrichWithGenAIKeys adds keys that can be queried for GenAI signals, even though they have not been ingested yet.
-func enrichWithGenAIKeys(keys map[string][]*telemetrytypes.TelemetryFieldKey, selectors []*telemetrytypes.FieldKeySelector) map[string][]*telemetrytypes.TelemetryFieldKey {
-	for _, selector := range selectors {
-		if selector.Signal != telemetrytypes.SignalTraces && selector.Signal != telemetrytypes.SignalUnspecified {
-			continue
-		}
-		for name, def := range telemetrytypes.GenAIFieldDefinitions {
-			if len(keys[name]) > 0 {
-				continue // already resolved from ingested data
-			}
-			if !selectorMatchesIntrinsicField(selector, def) {
-				continue
-			}
-			keyCopy := def
-			keys[name] = []*telemetrytypes.TelemetryFieldKey{&keyCopy}
-		}
-	}
-
-	return keys
-}
-
 func selectorMatchesIntrinsicField(selector *telemetrytypes.FieldKeySelector, definition telemetrytypes.TelemetryFieldKey) bool {
 	if selector.FieldContext != telemetrytypes.FieldContextUnspecified && selector.FieldContext != definition.FieldContext {
 		return false
@@ -1294,9 +1273,6 @@ func (t *telemetryMetaStore) GetKeys(ctx context.Context, orgID valuer.UUID, fie
 
 	applyBackwardCompatibleKeys(mapOfKeys)
 	mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, selectors)
-	if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {
-		mapOfKeys = enrichWithGenAIKeys(mapOfKeys, selectors)
-	}
 
 	return mapOfKeys, complete, nil
 }
@@ -1375,9 +1351,6 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, orgID valuer.UUID
 
 	applyBackwardCompatibleKeys(mapOfKeys)
 	mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, fieldKeySelectors)
-	if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {
-		mapOfKeys = enrichWithGenAIKeys(mapOfKeys, fieldKeySelectors)
-	}
 
 	return mapOfKeys, complete, nil
 }

pkg/telemetryscopedtraces/aggregate.go

@@ -1,208 +0,0 @@
-package telemetryscopedtraces
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// This file holds the Aggregate constructors a TraceScope's columns are declared
-// with. All SQL rendering goes through the fieldMapper.
-
-// Aggregate renders one column's SQL through the fieldMapper and lists the attribute
-// keys it references so the builder can pre-fetch their metadata. Build one with the
-// constructors below; the zero value is not usable.
-type Aggregate struct {
-	keys   []*telemetrytypes.TelemetryFieldKey
-	render func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (expr string, args []any, err error)
-}
-
-// IntrinsicSpanKey references an intrinsic span-index field (timestamp, name, …) by
-// its canonical name; the field mapper resolves it to the physical column.
-func IntrinsicSpanKey(name string) *telemetrytypes.TelemetryFieldKey {
-	return &telemetrytypes.TelemetryFieldKey{
-		Name:         name,
-		Signal:       telemetrytypes.SignalTraces,
-		FieldContext: telemetrytypes.FieldContextSpan,
-	}
-}
-
-// AggFunc is a ClickHouse aggregate function name.
-type AggFunc string
-
-const (
-	AggSum AggFunc = "sum"
-	AggMax AggFunc = "max"
-	AggMin AggFunc = "min"
-)
-
-// PickDirection selects the earliest (argMin) or latest (argMax) span by ordering.
-type PickDirection int
-
-const (
-	PickLatest PickDirection = iota
-	PickEarliest
-)
-
-// CountAll renders count().
-func CountAll() Aggregate {
-	return Aggregate{render: func(context.Context, valuer.UUID, uint64, uint64, *fieldMapper) (string, []any, error) {
-		return "count()", nil, nil
-	}}
-}
-
-// FieldReduce renders <fn>(<field>) over a field-mapper-resolved column.
-func FieldReduce(fn AggFunc, key *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		f, err := m.FieldFor(ctx, orgID, startNs, endNs, key)
-		if err != nil {
-			return "", nil, err
-		}
-		return fmt.Sprintf("%s(%s)", fn, f), nil, nil
-	}}
-}
-
-// TraceDuration renders the full-trace wall duration: last span end minus first
-// span start.
-func TraceDuration(tsKey, durationKey *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		ts, err := m.FieldFor(ctx, orgID, startNs, endNs, tsKey)
-		if err != nil {
-			return "", nil, err
-		}
-		dur, err := m.FieldFor(ctx, orgID, startNs, endNs, durationKey)
-		if err != nil {
-			return "", nil, err
-		}
-		return fmt.Sprintf("(max(toUnixTimestamp64Nano(%s) + %s) - min(toUnixTimestamp64Nano(%s)))", ts, dur, ts), nil, nil
-	}}
-}
-
-// FieldAnyWhere renders anyIf(<field>, <cond>) — the field value from any span
-// matching the condition.
-func FieldAnyWhere(valueKey, condKey *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, condValue any) Aggregate {
-	return Aggregate{render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		v, err := m.FieldFor(ctx, orgID, startNs, endNs, valueKey)
-		if err != nil {
-			return "", nil, err
-		}
-		cond, args, err := m.ConditionFor(ctx, orgID, startNs, endNs, condKey, op, condValue)
-		return fmt.Sprintf("anyIf(%s, %s)", v, cond), args, err
-	}}
-}
-
-// AnyValue renders any(<value>) over a metadata-resolved attribute value.
-func AnyValue(key *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) Aggregate {
-	return Aggregate{keys: keysOf(key), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		v, args, err := m.ValueFor(ctx, orgID, startNs, endNs, key, dt)
-		return fmt.Sprintf("any(%s)", v), args, err
-	}}
-}
-
-// CountExists renders countIf(<key> EXISTS) — counts spans carrying key.
-func CountExists(key *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{keys: keysOf(key), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		cond, args, err := m.ExistsFor(ctx, orgID, startNs, endNs, key)
-		return fmt.Sprintf("countIf(%s)", cond), args, err
-	}}
-}
-
-// CondCount renders countIf(<cond>) over a condition-builder-resolved predicate.
-func CondCount(key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) Aggregate {
-	return Aggregate{render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		cond, args, err := m.ConditionFor(ctx, orgID, startNs, endNs, key, op, value)
-		return fmt.Sprintf("countIf(%s)", cond), args, err
-	}}
-}
-
-// Reduce renders <fn>(<value>) over a resolved numeric attribute value.
-func Reduce(fn AggFunc, valueKey *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{keys: keysOf(valueKey), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		v, args, err := m.ValueFor(ctx, orgID, startNs, endNs, valueKey, telemetrytypes.FieldDataTypeFloat64)
-		return fmt.Sprintf("%s(%s)", fn, v), args, err
-	}}
-}
-
-// ScopedReduce renders <fn>If(<field>, <gate mask>) over a field-mapper-resolved column.
-func ScopedReduce(fn AggFunc, key *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		f, err := m.FieldFor(ctx, orgID, startNs, endNs, key)
-		if err != nil {
-			return "", nil, err
-		}
-		return fmt.Sprintf("%sIf(%s, %s)", fn, f, m.maskExpr), append([]any{}, m.maskArgs...), nil
-	}}
-}
-
-// ScopedToKeyColumn renders <fn>If(<field>, <scopeKey> EXISTS) — a span-index field
-// aggregated over spans carrying scopeKey (e.g. max LLM latency).
-func ScopedToKeyColumn(fn AggFunc, columnKey, scopeKey *telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{keys: keysOf(scopeKey), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		col, err := m.FieldFor(ctx, orgID, startNs, endNs, columnKey)
-		if err != nil {
-			return "", nil, err
-		}
-		cond, args, err := m.ExistsFor(ctx, orgID, startNs, endNs, scopeKey)
-		return fmt.Sprintf("%sIf(%s, %s)", fn, col, cond), args, err
-	}}
-}
-
-// PickBy renders argMinIf/argMaxIf(<value>, <orderField>, <value> EXISTS) — the value
-// from the earliest/latest span that carries it.
-func PickBy(valueKey *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType, orderKey *telemetrytypes.TelemetryFieldKey, dir PickDirection) Aggregate {
-	fn := "argMaxIf"
-	if dir == PickEarliest {
-		fn = "argMinIf"
-	}
-	return Aggregate{keys: keysOf(valueKey), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		v, vargs, err := m.ValueFor(ctx, orgID, startNs, endNs, valueKey, dt)
-		if err != nil {
-			return "", nil, err
-		}
-		order, err := m.FieldFor(ctx, orgID, startNs, endNs, orderKey)
-		if err != nil {
-			return "", nil, err
-		}
-		cond, cargs, err := m.ExistsFor(ctx, orgID, startNs, endNs, valueKey)
-		return fmt.Sprintf("%s(%s, %s, %s)", fn, v, order, cond), append(vargs, cargs...), err
-	}}
-}
-
-// UniqCount renders uniqIf(<value>, <value> EXISTS) — distinct count of an attribute.
-func UniqCount(valueKey *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) Aggregate {
-	return Aggregate{keys: keysOf(valueKey), render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		v, vargs, err := m.ValueFor(ctx, orgID, startNs, endNs, valueKey, dt)
-		if err != nil {
-			return "", nil, err
-		}
-		cond, cargs, err := m.ExistsFor(ctx, orgID, startNs, endNs, valueKey)
-		return fmt.Sprintf("uniqIf(%s, %s)", v, cond), append(vargs, cargs...), err
-	}}
-}
-
-// SumOfKeys renders coalesce(sum(<v1>), 0) + coalesce(sum(<v2>), 0) + … over several
-// numeric attributes. Coalesced because a key absent from every span sums to NULL and
-// NULL + n = NULL — a trace with only output tokens would otherwise total NULL.
-func SumOfKeys(dt telemetrytypes.FieldDataType, valueKeys ...*telemetrytypes.TelemetryFieldKey) Aggregate {
-	return Aggregate{keys: valueKeys, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, m *fieldMapper) (string, []any, error) {
-		parts := make([]string, 0, len(valueKeys))
-		var args []any
-		for _, k := range valueKeys {
-			v, vargs, err := m.ValueFor(ctx, orgID, startNs, endNs, k, dt)
-			if err != nil {
-				return "", nil, err
-			}
-			parts = append(parts, fmt.Sprintf("coalesce(sum(%s), 0)", v))
-			args = append(args, vargs...)
-		}
-		return strings.Join(parts, " + "), args, nil
-	}}
-}
-
-func keysOf(k *telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
-	return []*telemetrytypes.TelemetryFieldKey{k}
-}

pkg/telemetryscopedtraces/field_mapper.go

@@ -1,82 +0,0 @@
-package telemetryscopedtraces
-
-import (
-	"context"
-	"strings"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-// fieldMapper resolves aggregate-column SQL through the shared field mapper and
-// condition builder, following their method shapes (FieldFor / ConditionFor / …) so
-// column resolution reads like the other statement builders. keys is the fetched
-// metadata for the keys the columns reference; the gate mask is set by the builder
-// after resolveMask (Scoped* aggregates embed it). All returned expressions are
-// escaped once, ready to embed in an outer builder.
-type fieldMapper struct {
-	fm       qbtypes.FieldMapper
-	cb       qbtypes.ConditionBuilder
-	keys     map[string][]*telemetrytypes.TelemetryFieldKey
-	maskExpr string
-	maskArgs []any
-}
-
-func newFieldMapper(fm qbtypes.FieldMapper, cb qbtypes.ConditionBuilder, keys map[string][]*telemetrytypes.TelemetryFieldKey) *fieldMapper {
-	return &fieldMapper{fm: fm, cb: cb, keys: keys}
-}
-
-// FieldFor returns the column expression for key via the field mapper.
-func (r *fieldMapper) FieldFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
-	return r.fm.FieldFor(ctx, orgID, startNs, endNs, key)
-
-}
-
-// ConditionFor returns a boolean predicate for key via the condition builder
-// (materialized column when present, else map access).
-func (r *fieldMapper) ConditionFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) (string, []any, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-	// The condition builder owns key resolution: hand it the raw key plus the full
-	// metadata map and it matches/synthesizes the candidates itself.
-	conds, _, err := r.cb.ConditionFor(ctx, orgID, startNs, endNs, key, r.keys, qbtypes.ConditionBuilderOptions{}, op, value, sb)
-	if err != nil {
-		return "", nil, err
-	}
-	if len(conds) == 0 {
-		return "", nil, nil
-	}
-	// One condition per candidate variant (a key can be ingested under several data
-	// types); OR them all, like the visitor does for EXISTS.
-	if len(conds) == 1 {
-		sb.Where(conds[0])
-	} else {
-		sb.Where(sb.Or(conds...))
-	}
-	expr, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	expr = strings.TrimPrefix(expr, "WHERE ")
-	return sqlbuilder.Escape(expr), args, nil
-}
-
-// ExistsFor returns the EXISTS predicate for key.
-func (r *fieldMapper) ExistsFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, []any, error) {
-	return r.ConditionFor(ctx, orgID, startNs, endNs, key, qbtypes.FilterOperatorExists, nil)
-}
-
-// ValueFor returns the value expression for an attribute key.
-func (r *fieldMapper) ValueFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) (string, []any, error) {
-	// The scope declares keys statically, so a key like service.name can have evolutions.
-	// this is added for the evolution.
-	if cands := r.keys[key.Name]; len(cands) > 0 {
-		key = cands[0]
-	}
-	expr, err := r.fm.ColumnExpressionFor(ctx, orgID, startNs, endNs, key, dt, r.keys)
-	if err != nil {
-		return "", nil, err
-	}
-	// Escape before embedding in the outer builder: a materialized column name carries
-	// `$$` (from the dotted attribute name), which go-sqlbuilder's Build would otherwise
-	// unescape to a single `$` and reference the wrong column.
-	return sqlbuilder.Escape(expr), nil, nil
-}

pkg/telemetryscopedtraces/scope.go

@@ -1,66 +0,0 @@
-package telemetryscopedtraces
-
-import (
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-// TraceScope is the configuration the scoped trace builder accepts: which spans are
-// in scope and which per-trace columns the list computes. It only declares the gate
-// and the columns; the builder resolves everything through the field mapper, so
-// attribute access stays materialization-aware. A new span category only needs a
-// new TraceScope.
-type TraceScope struct {
-	// FilterExpression is the grammar-level (EXISTS) gate, used on the delegated
-	// span-list path.
-	FilterExpression string
-	// FieldKeys are the gate's keys, used to build the per-span mask
-	// (OR of resolved EXISTS conditions).
-	FieldKeys []*telemetrytypes.TelemetryFieldKey
-	// Columns are the per-trace output columns.
-	Columns []TraceColumn
-	// DefaultOrderAlias is sorted by (desc) when the query gives no order.
-	DefaultOrderAlias string
-}
-
-// TraceColumn is one per-trace output column.
-type TraceColumn struct {
-	// Alias must not reuse a physical span-index column name (e.g. duration_nano):
-	// ClickHouse resolves bare identifiers to same-SELECT aliases first, so any
-	// expression referencing that column would silently bind to the alias.
-	Alias string
-	// Orderable columns can be used in ORDER BY and the aggregate filter. All-span
-	// aggregates (span_count, trace_duration_nano, …) are display-only and set false.
-	Orderable bool
-	// SpanLevel columns surface a real span/resource attribute (service.name,
-	// input/output messages); a filter on them is applied span-level, so they are
-	// excluded from the trace-level aliases.
-	SpanLevel bool
-	Expr      Aggregate
-}
-
-// CommonTraceColumns are domain-neutral columns any trace list can reuse. All
-// aggregate over every span, so none is Orderable.
-func CommonTraceColumns() []TraceColumn {
-	ts := IntrinsicSpanKey("timestamp")
-	duration := IntrinsicSpanKey("duration_nano")
-	name := IntrinsicSpanKey("name")
-	parentSpanID := IntrinsicSpanKey("parent_span_id")
-	serviceName := &telemetrytypes.TelemetryFieldKey{
-		Name:          "service.name",
-		Signal:        telemetrytypes.SignalTraces,
-		FieldContext:  telemetrytypes.FieldContextResource,
-		FieldDataType: telemetrytypes.FieldDataTypeString,
-	}
-	return []TraceColumn{
-		{Alias: "start_time", Expr: FieldReduce(AggMin, ts)},
-		{Alias: "end_time", Expr: FieldReduce(AggMax, ts)},
-		// Not plain "duration_nano": that name is the intrinsic span field, and an
-		// alias would shadow it — both in ClickHouse identifier resolution and in
-		// bare-name filter classification.
-		{Alias: "trace_duration_nano", Expr: TraceDuration(ts, duration)},
-		{Alias: "span_count", Expr: CountAll()},
-		{Alias: "root_span_name", Expr: FieldAnyWhere(name, parentSpanID, qbtypes.FilterOperatorEqual, "")},
-		{Alias: "service.name", SpanLevel: true, Expr: AnyValue(serviceName, telemetrytypes.FieldDataTypeString)},
-	}
-}

pkg/telemetryscopedtraces/statement_builder.go

@@ -1,775 +0,0 @@
-package telemetryscopedtraces
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"sort"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryresourcefilter"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	qbvariables "github.com/SigNoz/signoz/pkg/variables"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-var (
-	ErrUnsupportedRequestType = errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported request type for the scoped trace builder")
-)
-
-// scopedTraceStatementBuilder builds a trace list scoped to one span category
-// (e.g. gen_ai spans). The query shape is fixed; the TraceScope decides which spans
-// are in scope and which per-trace columns to compute, so a new category only needs
-// a new scope.
-type scopedTraceStatementBuilder struct {
-	logger                    *slog.Logger
-	metadataStore             telemetrytypes.MetadataStore
-	fm                        qbtypes.FieldMapper
-	cb                        qbtypes.ConditionBuilder
-	scope                     TraceScope
-	traceStmtBuilder          qbtypes.StatementBuilder[qbtypes.TraceAggregation]
-	resourceFilterStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation]
-}
-
-var _ qbtypes.StatementBuilder[qbtypes.TraceAggregation] = (*scopedTraceStatementBuilder)(nil)
-
-// NewScopedTraceStatementBuilder wires the generic trace-list builder. The field
-// mapper / condition builder are built here, not injected — the list always scans the
-// telemetrytraces span index. traceStmtBuilder (the delegate for the span-list path)
-// is injected because the provider already has the canonical instance.
-func NewScopedTraceStatementBuilder(
-	settings factory.ProviderSettings,
-	metadataStore telemetrytypes.MetadataStore,
-	scope TraceScope,
-	traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
-	fl flagger.Flagger,
-) qbtypes.StatementBuilder[qbtypes.TraceAggregation] {
-	scopedSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryscopedtraces")
-
-	fm := telemetrytraces.NewFieldMapper()
-	cb := telemetrytraces.NewConditionBuilder(fm)
-
-	// Same resource-fingerprint prune as the standard trace builder — the list scans
-	// the same span index.
-	resourceFilterStmtBuilder := telemetryresourcefilter.New[qbtypes.TraceAggregation](
-		settings,
-		telemetrytraces.DBName,
-		telemetrytraces.TracesResourceV3TableName,
-		telemetrytypes.SignalTraces,
-		telemetrytypes.SourceUnspecified,
-		metadataStore,
-		nil,
-		fl,
-	)
-
-	return &scopedTraceStatementBuilder{
-		logger:                    scopedSettings.Logger(),
-		metadataStore:             metadataStore,
-		fm:                        fm,
-		cb:                        cb,
-		scope:                     scope,
-		traceStmtBuilder:          traceStmtBuilder,
-		resourceFilterStmtBuilder: resourceFilterStmtBuilder,
-	}
-}
-
-func (b *scopedTraceStatementBuilder) Build(
-	ctx context.Context,
-	orgID valuer.UUID,
-	start uint64,
-	end uint64,
-	requestType qbtypes.RequestType,
-	query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation],
-	variables map[string]qbtypes.VariableItem,
-) (*qbtypes.Statement, error) {
-	switch requestType {
-	case qbtypes.RequestTypeTrace:
-		return b.buildTraceListQuery(ctx, orgID, querybuilder.ToNanoSecs(start), querybuilder.ToNanoSecs(end), query, variables)
-	case qbtypes.RequestTypeRaw:
-		return b.buildDelegated(ctx, orgID, start, end, requestType, query, variables)
-	default:
-		return nil, ErrUnsupportedRequestType
-	}
-}
-
-// buildDelegated ANDs the base gate into the user filter and delegates to the
-// standard trace builder (the span-list / raw path).
-func (b *scopedTraceStatementBuilder) buildDelegated(
-	ctx context.Context,
-	orgID valuer.UUID,
-	start, end uint64,
-	requestType qbtypes.RequestType,
-	query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation],
-	variables map[string]qbtypes.VariableItem,
-) (*qbtypes.Statement, error) {
-	gate := b.scope.FilterExpression
-	expr := gate
-	if query.Filter != nil && strings.TrimSpace(query.Filter.Expression) != "" {
-		expr = fmt.Sprintf("(%s) AND (%s)", gate, query.Filter.Expression)
-	}
-
-	// shallow copy; only Filter is replaced, caller's query untouched
-	gated := query
-	gated.Filter = &qbtypes.Filter{Expression: expr}
-
-	return b.traceStmtBuilder.Build(ctx, orgID, start, end, requestType, gated, variables)
-}
-
-// buildTraceListQuery wires the CTE pipeline: one windowed pass picks the top-N
-// traces, then a bucket-pruned pass enriches only those.
-// Helpers appear in this file in the order they run. start/end are nanoseconds.
-//
-//	RESOLVE (keys/columns → SQL via the field mapper)
-//	  fetchKeys         metadata for every key we reference
-//	  resolveMask       the "span is in scope" predicate (OR of EXISTS)
-//	  resolveColumns    per-trace column SQL
-//	  resolveListOrders which columns to ORDER BY
-//	  splitFilter       span-level predicate + trace-level HAVING
-//
-//	BUILD
-//	  matched    one windowed, mask-pruned GROUP BY trace_id scan fusing gate + span
-//	     │       filter + HAVING + ORDER BY + LIMIT/OFFSET → the top-N trace_ids
-//	     ▼
-//	  ranked     [start,end] bounds of those traces, from the small summary table
-//	     ▼
-//	  buckets    the ts_bucket_start values they touch, to prune the next scan
-//	     ▼
-//	  enrichment every per-trace column for those traces over their full extent
-//	             (not window-clipped), scanning only their buckets
-//
-// Only Orderable columns are computable in the mask-pruned matched pass, so only they
-// can be ordered or filtered on; all-span columns (span_count, …) are output-only.
-func (b *scopedTraceStatementBuilder) buildTraceListQuery(
-	ctx context.Context,
-	orgID valuer.UUID,
-	start, end uint64,
-	query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation],
-	variables map[string]qbtypes.VariableItem,
-) (*qbtypes.Statement, error) {
-
-	startBucket := start/querybuilder.NsToSeconds - querybuilder.BucketAdjustment
-	endBucket := end / querybuilder.NsToSeconds
-
-	limit := query.Limit
-	if limit <= 0 {
-		limit = 100
-	}
-
-	// Resolve keys and columns once; all attribute access goes through the field mapper.
-	keys, err := b.fetchKeys(ctx, orgID)
-	if err != nil {
-		return nil, err
-	}
-	mapper := newFieldMapper(b.fm, b.cb, keys)
-	maskExpr, maskArgs, err := b.resolveMask(ctx, orgID, start, end, mapper)
-	if err != nil {
-		return nil, err
-	}
-	mapper.maskExpr, mapper.maskArgs = maskExpr, maskArgs
-	resolved, err := b.resolveColumns(ctx, orgID, start, end, mapper)
-	if err != nil {
-		return nil, err
-	}
-	orders, err := b.resolveListOrders(query.Order, resolved)
-	if err != nil {
-		return nil, err
-	}
-	orderableSet := orderableAliasSet(resolved)
-
-	// If the filter references resource attributes, add a __resource_filter CTE and
-	// narrow the matched scan by resource_fingerprint; the span predicate drops those
-	// keys so they aren't applied twice.
-	resourceFrag, resourceArgs, resourcePred, err := b.maybeAttachResourceFilter(ctx, orgID, query, start, end, variables)
-	if err != nil {
-		return nil, err
-	}
-
-	// Split the user filter: span-level predicate + trace-level HAVING expression.
-	fp, err := b.splitFilter(ctx, orgID, query, b.aggregateAliasSet(), orderableSet, start, end, variables)
-	if err != nil {
-		return nil, err
-	}
-
-	// matched → ranked → buckets → enrichment
-	matchedFrag, matchedArgs, err := b.buildMatchedCTE(start, end, startBucket, endBucket, resolved, orders, orderableSet, maskExpr, maskArgs, fp, resourcePred, limit, query.Offset)
-	if err != nil {
-		return nil, err
-	}
-	rankedFrag, rankedArgs := b.buildRankedCTE(start, end)
-	bucketsFrag := buildBucketsCTE()
-	mainSQL, mainArgs := b.buildEnrichmentSelect(resolved, orders)
-
-	cteFragments := []string{matchedFrag, rankedFrag, bucketsFrag}
-	cteArgs := [][]any{matchedArgs, rankedArgs, nil}
-
-	// __resource_filter must precede `matched`, which references it.
-	if resourceFrag != "" {
-		cteFragments = append([]string{resourceFrag}, cteFragments...)
-		cteArgs = append([][]any{resourceArgs}, cteArgs...)
-	}
-
-	finalSQL := querybuilder.CombineCTEs(cteFragments) + mainSQL + " SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000"
-	finalArgs := querybuilder.PrependArgs(cteArgs, mainArgs)
-
-	return &qbtypes.Statement{
-		Query:          finalSQL,
-		Args:           finalArgs,
-		Warnings:       fp.warnings,
-		WarningsDocURL: fp.warningsURL,
-	}, nil
-}
-
-// maybeAttachResourceFilter builds the __resource_filter CTE (fingerprints matching
-// the filter's resource conditions) and the predicate narrowing the span scan by
-// resource_fingerprint; with no resource conditions it returns empty fragments.
-//
-// Unlike the standard trace builder there is deliberately no skip-fingerprint
-// fallback: falling back would leave the resource conditions inside the OR'd
-// span-filter bucket, which changes trace membership (any span from the resource +
-// any gen_ai span, instead of a gen_ai span from the resource). Resource conditions
-// always scope the whole matched scan.
-func (b *scopedTraceStatementBuilder) maybeAttachResourceFilter(
-	ctx context.Context,
-	orgID valuer.UUID,
-	query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation],
-	start, end uint64,
-	variables map[string]qbtypes.VariableItem,
-) (cteFrag string, cteArgs []any, fingerprintPred string, err error) {
-	stmt, err := b.resourceFilterStmtBuilder.Build(
-		ctx, orgID, start, end, qbtypes.RequestTypeRaw, query, variables,
-	)
-	if err != nil {
-		return "", nil, "", err
-	}
-	if stmt == nil {
-		return "", nil, "", nil
-	}
-	return fmt.Sprintf("__resource_filter AS (%s)", stmt.Query), stmt.Args,
-		"resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)", nil
-}
-
-// ---------------------------------------------------------------------------
-// RESOLVE — turn keys/columns into field-mapper-aware SQL
-// ---------------------------------------------------------------------------
-
-func (b *scopedTraceStatementBuilder) fetchKeys(ctx context.Context, orgID valuer.UUID) (map[string][]*telemetrytypes.TelemetryFieldKey, error) {
-	fields := b.resolverFieldKeys()
-	selectors := make([]*telemetrytypes.FieldKeySelector, 0, len(fields))
-	for _, k := range fields {
-		selectors = append(selectors, &telemetrytypes.FieldKeySelector{
-			Name:              k.Name,
-			Signal:            k.Signal,
-			FieldContext:      k.FieldContext,
-			SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact,
-		})
-	}
-	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, selectors)
-	return keys, err
-}
-
-func (b *scopedTraceStatementBuilder) resolverFieldKeys() []*telemetrytypes.TelemetryFieldKey {
-	seen := make(map[string]struct{})
-	var out []*telemetrytypes.TelemetryFieldKey
-	add := func(k *telemetrytypes.TelemetryFieldKey) {
-		if k == nil {
-			return
-		}
-		if _, dup := seen[k.Name]; dup {
-			return
-		}
-		seen[k.Name] = struct{}{}
-		out = append(out, k)
-	}
-	for _, k := range b.scope.FieldKeys {
-		add(k)
-	}
-	for _, c := range b.scope.Columns {
-		for _, k := range c.Expr.keys {
-			add(k)
-		}
-	}
-	return out
-}
-
-// resolveMask builds the per-span in-scope mask: OR of resolved EXISTS predicates
-// over the base condition's field keys.
-func (b *scopedTraceStatementBuilder) resolveMask(ctx context.Context, orgID valuer.UUID, start, end uint64, mapper *fieldMapper) (string, []any, error) {
-	fieldKeys := b.scope.FieldKeys
-	parts := make([]string, 0, len(fieldKeys))
-	var args []any
-	for _, key := range fieldKeys {
-		e, a, err := mapper.ExistsFor(ctx, orgID, start, end, key)
-		if err != nil {
-			return "", nil, err
-		}
-		parts = append(parts, e)
-		args = append(args, a...)
-	}
-	return "(" + strings.Join(parts, " OR ") + ")", args, nil
-}
-
-// resolvedColumn is a column resolved to SQL via the field mapper; expr is escaped
-// once, ready to embed in an outer SELECT.
-type resolvedColumn struct {
-	alias     string
-	expr      string
-	args      []any
-	orderable bool
-}
-
-// resolveColumns turns the declarative columns into SQL through the resolver, so all
-// attribute access goes through the field mapper / condition builder.
-func (b *scopedTraceStatementBuilder) resolveColumns(ctx context.Context, orgID valuer.UUID, start, end uint64, mapper *fieldMapper) ([]resolvedColumn, error) {
-	cols := b.scope.Columns
-	out := make([]resolvedColumn, 0, len(cols))
-	for _, c := range cols {
-		expr, args, err := c.Expr.render(ctx, orgID, start, end, mapper)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, resolvedColumn{alias: c.Alias, expr: expr, args: args, orderable: c.Orderable})
-	}
-	return out, nil
-}
-
-// listOrder is a sort key resolved to a column alias + direction; both the matched
-// CTE and the enrichment ORDER BY it.
-type listOrder struct {
-	alias     string
-	direction string
-}
-
-// resolveListOrders maps order keys to the resolved orderable columns; non-orderable
-// columns are rejected. Defaults to the column provider's default order.
-func (b *scopedTraceStatementBuilder) resolveListOrders(order []qbtypes.OrderBy, resolved []resolvedColumn) ([]listOrder, error) {
-	byAlias := make(map[string]resolvedColumn, len(resolved))
-	orderable := make([]string, 0, len(resolved))
-	for _, rc := range resolved {
-		byAlias[rc.alias] = rc
-		if rc.orderable {
-			orderable = append(orderable, rc.alias)
-		}
-	}
-
-	if len(order) == 0 {
-		return []listOrder{{alias: b.scope.DefaultOrderAlias, direction: "DESC"}}, nil
-	}
-
-	orders := make([]listOrder, 0, len(order))
-	for _, o := range order {
-		direction := "DESC"
-		if o.Direction == qbtypes.OrderDirectionAsc {
-			direction = "ASC"
-		}
-		rc, ok := byAlias[o.Key.Name]
-		if !ok || !rc.orderable {
-			return nil, errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"unsupported order key %q for the trace list; orderable keys: %s", o.Key.Name, strings.Join(orderable, ", "))
-		}
-		orders = append(orders, listOrder{alias: rc.alias, direction: direction})
-	}
-	return orders, nil
-}
-
-// filterParts is the user filter split into a span-level predicate (widens the
-// matched WHERE prune and becomes a countIf existence check in HAVING) and a
-// trace-level HAVING expression.
-type filterParts struct {
-	spanPred      string
-	spanArgs      []any
-	hasSpanFilter bool
-	havingExpr    string
-	warnings      []string
-	warningsURL   string
-}
-
-// splitFilter splits query.Filter into a span-level predicate and a trace-level
-// HAVING expression (an explicit query.Having is ANDed onto the latter), then
-// validates the trace-level part against the matched-pass aggregates.
-func (b *scopedTraceStatementBuilder) splitFilter(ctx context.Context, orgID valuer.UUID, query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation], classifySet, orderableSet map[string]struct{}, start, end uint64, variables map[string]qbtypes.VariableItem) (filterParts, error) {
-	var fp filterParts
-	if query.Filter != nil && strings.TrimSpace(query.Filter.Expression) != "" {
-		spanExpr, traceExpr, err := querybuilder.SplitFilterForAggregates(query.Filter.Expression, classifySet)
-		if err != nil {
-			return fp, err
-		}
-		fp.havingExpr = traceExpr
-		if strings.TrimSpace(spanExpr) != "" {
-			pred, args, warnings, url, err := b.resolveSpanPredicate(ctx, orgID, start, end, spanExpr, variables)
-			if err != nil {
-				return fp, err
-			}
-			// pred is empty when the span-level keys were all resource attributes
-			// already handled by the __resource_filter CTE.
-			if strings.TrimSpace(pred) != "" {
-				fp.spanPred, fp.spanArgs, fp.hasSpanFilter = pred, args, true
-			}
-			fp.warnings, fp.warningsURL = warnings, url
-		}
-	}
-	if query.Having != nil && strings.TrimSpace(query.Having.Expression) != "" {
-		if fp.havingExpr != "" {
-			fp.havingExpr = fmt.Sprintf("(%s) AND (%s)", fp.havingExpr, query.Having.Expression)
-		} else {
-			fp.havingExpr = query.Having.Expression
-		}
-	}
-	// The span predicate binds variables via PrepareWhereClause; the HAVING is a plain
-	// text rewrite, so substitute variables here (list/IN quoting, __all__ drops the
-	// condition) before validating.
-	if strings.TrimSpace(fp.havingExpr) != "" && len(variables) > 0 {
-		replaced, err := qbvariables.ReplaceVariablesInExpression(fp.havingExpr, variables)
-		if err != nil {
-			return fp, err
-		}
-		fp.havingExpr = replaced
-	}
-	if err := validateAggregateFilter(fp.havingExpr, orderableSet); err != nil {
-		return fp, err
-	}
-	return fp, nil
-}
-
-// resolveSpanPredicate resolves a span-level filter expression to a bare boolean
-// SQL predicate + args via the field mapper.
-func (b *scopedTraceStatementBuilder) resolveSpanPredicate(ctx context.Context, orgID valuer.UUID, start, end uint64, expr string, variables map[string]qbtypes.VariableItem) (string, []any, []string, string, error) {
-	selectors := querybuilder.QueryStringToKeysSelectors(expr)
-	for i := range selectors {
-		selectors[i].Signal = telemetrytypes.SignalTraces
-	}
-	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, selectors)
-	if err != nil {
-		return "", nil, nil, "", err
-	}
-	prepared, err := querybuilder.PrepareWhereClause(expr, querybuilder.FilterExprVisitorOpts{
-		Context:          ctx,
-		Logger:           b.logger,
-		FieldMapper:      b.fm,
-		ConditionBuilder: b.cb,
-		FieldKeys:        keys,
-		// resource conditions are always handled by the __resource_filter CTE
-		SkipResourceFilter: true,
-		Variables:          variables,
-		StartNs:            start,
-		EndNs:              end,
-	})
-	if err != nil {
-		return "", nil, nil, "", err
-	}
-	if prepared.IsEmpty() {
-		return "", nil, nil, "", nil
-	}
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.AddWhereClause(prepared.WhereClause)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	pred := sql[strings.Index(sql, "WHERE ")+len("WHERE "):]
-	return sqlbuilder.Escape(pred), args, prepared.Warnings, prepared.WarningsDocURL, nil
-}
-
-// buildMatchedCTE builds `matched`: the single windowed GROUP BY trace_id scan that
-// fuses gate + span filter + HAVING + ORDER BY + LIMIT/OFFSET, selecting only the
-// aliases the ORDER BY / HAVING reference.
-func (b *scopedTraceStatementBuilder) buildMatchedCTE(start, end, startBucket, endBucket uint64, resolved []resolvedColumn, orders []listOrder, orderableSet map[string]struct{}, maskExpr string, maskArgs []any, fp filterParts, resourcePred string, limit, offset int) (string, []any, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-
-	// SELECT trace_id + only the aggregates ORDER BY / HAVING reference (as aliases).
-	needed := neededMatchedAliases(orders, fp.havingExpr, orderableSet)
-	selects := []string{"trace_id"}
-	for _, rc := range resolved {
-		if _, ok := needed[rc.alias]; !ok {
-			continue
-		}
-		colExpr, err := embedExpr(sb, rc.expr, rc.args)
-		if err != nil {
-			return "", nil, err
-		}
-		selects = append(selects, colExpr+" AS "+quoteAlias(rc.alias))
-	}
-	sb.Select(selects...)
-	sb.From(spanTable())
-
-	// WHERE: window + prune to in-scope spans, widened by the span filter so its
-	// spans survive for the countIf existence check below.
-	win := windowWhere(sb, start, end, startBucket, endBucket)
-	mask, err := embedExpr(sb, maskExpr, maskArgs)
-	if err != nil {
-		return "", nil, err
-	}
-	prune := "(" + mask
-	if fp.hasSpanFilter {
-		spanPred, err := embedExpr(sb, fp.spanPred, fp.spanArgs)
-		if err != nil {
-			return "", nil, err
-		}
-		prune += " OR " + spanPred
-	}
-	prune += ")"
-	where := append(win, prune)
-	if resourcePred != "" {
-		where = append(where, resourcePred)
-	}
-	sb.Where(where...)
-	sb.GroupBy("trace_id")
-
-	// HAVING: the gate/span existence checks are only needed when the WHERE was
-	// widened by a span filter; otherwise the mask alone already enforces the gate.
-	var having []string
-	if fp.hasSpanFilter {
-		havingMask, err := embedExpr(sb, maskExpr, maskArgs)
-		if err != nil {
-			return "", nil, err
-		}
-		havingPred, err := embedExpr(sb, fp.spanPred, fp.spanArgs)
-		if err != nil {
-			return "", nil, err
-		}
-		having = append(having, "countIf("+havingMask+") > 0")
-		having = append(having, "countIf("+havingPred+") > 0")
-	}
-	if strings.TrimSpace(fp.havingExpr) != "" {
-		hv, err := b.buildHaving(fp.havingExpr, orderableSet)
-		if err != nil {
-			return "", nil, err
-		}
-		if hv != "" {
-			// hv carries user text with values inlined by the rewriter; escape it so a
-			// literal $ can't be read as an interpolation marker at Build time. The
-			// countIf entries above hold live placeholders and must stay unescaped.
-			having = append(having, sqlbuilder.Escape(hv))
-		}
-	}
-	if len(having) > 0 {
-		sb.Having(strings.Join(having, " AND "))
-	}
-
-	sb.OrderBy(orderClause(orders)...)
-	sb.Limit(limit)
-	if offset > 0 {
-		sb.Offset(offset)
-	}
-
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return fmt.Sprintf("matched AS (%s)", sql), args, nil
-}
-
-// buildRankedCTE builds `ranked`: [start,end] bounds per matched trace, read from the
-// small trace-summary table.
-func (b *scopedTraceStatementBuilder) buildRankedCTE(start, end uint64) (string, []any) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("trace_id", "min(start) AS t_start", "max(end) AS t_end")
-	sb.From(summaryTable())
-	sb.Where(
-		"trace_id GLOBAL IN (SELECT trace_id FROM matched)",
-		"end >= fromUnixTimestamp64Nano("+sb.Var(start)+")",
-		"start < fromUnixTimestamp64Nano("+sb.Var(end)+")",
-	)
-	sb.GroupBy("trace_id")
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return fmt.Sprintf("ranked AS (%s)", sql), args
-}
-
-// buildBucketsCTE builds `buckets`: the ts_bucket_start values the matched traces
-// span, so the enrichment scan is primary-key pruned. No args.
-func buildBucketsCTE() string {
-	adj := querybuilder.BucketAdjustment // 30-min bucket width in seconds
-	return fmt.Sprintf("buckets AS (SELECT DISTINCT b AS ts_bucket FROM ranked "+
-		"ARRAY JOIN range("+
-		"toUInt64(intDiv(toUnixTimestamp(t_start), %d) * %d - %d), "+
-		"toUInt64(intDiv(toUnixTimestamp(t_end), %d) * %d + %d), "+
-		"%d) AS b)", adj, adj, adj, adj, adj, adj, adj)
-}
-
-// buildEnrichmentSelect builds the final SELECT: every per-trace column for the
-// matched traces over their full extent, scanning only their buckets.
-//
-// Accepted discrepancy: matched ranks/paginates on window-clipped values (and, with a
-// resource filter, only over fingerprint-matching spans), while this pass recomputes
-// and ORDER BYs full-trace values — so a trace with activity outside the window or
-// resource can sort differently than it ranked. Page membership is unaffected
-// (LIMIT/OFFSET runs only in matched); rows still sort by the values the user sees.
-// Ordering by matched's values instead would re-run the matched scan (ClickHouse
-// re-executes a CTE per reference) without fixing the visible cross-page artifact.
-func (b *scopedTraceStatementBuilder) buildEnrichmentSelect(resolved []resolvedColumn, orders []listOrder) (string, []any) {
-	sb := sqlbuilder.NewSelectBuilder()
-	selects, selectArgs := selectAllColumns(resolved)
-	sb.Select(selects...)
-	sb.From(spanTable())
-	sb.Where(
-		"ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)",
-		"trace_id GLOBAL IN (SELECT trace_id FROM ranked)",
-	)
-	sb.GroupBy("trace_id")
-	sb.OrderBy(orderClause(orders)...)
-	sql, builtArgs := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return sql, append(append([]any{}, selectArgs...), builtArgs...)
-}
-
-// buildHaving rewrites a trace-level HAVING expression to the matched-pass column
-// aliases. The rewriter matches raw key text, so the trace. form is mapped alongside
-// the bare name.
-func (b *scopedTraceStatementBuilder) buildHaving(havingExpr string, orderableSet map[string]struct{}) (string, error) {
-	columnMap := make(map[string]string, len(orderableSet)*2)
-	for a := range orderableSet {
-		columnMap[a] = quoteAlias(a)
-		columnMap[telemetrytypes.FieldContextTrace.StringValue()+"."+a] = quoteAlias(a)
-	}
-	return querybuilder.NewHavingExpressionRewriter().Rewrite(havingExpr, columnMap)
-}
-
-// ---------------------------------------------------------------------------
-// Small shared SQL-builder utilities
-// ---------------------------------------------------------------------------
-
-// spanTable is the fully-qualified span index table.
-func spanTable() string {
-	return fmt.Sprintf("%s.%s", telemetrytraces.DBName, telemetrytraces.SpanIndexV3TableName)
-}
-
-// summaryTable is the fully-qualified trace-summary table.
-func summaryTable() string {
-	return fmt.Sprintf("%s.%s", telemetrytraces.DBName, telemetrytraces.TraceSummaryTableName)
-}
-
-// aggregateAliasSet is every trace-level column alias, used to classify filter keys
-// as trace-level vs span-level. Derived from the scope's columns so a new column
-// can't be forgotten; SpanLevel columns are filtered span-level, so skip them.
-func (b *scopedTraceStatementBuilder) aggregateAliasSet() map[string]struct{} {
-	set := make(map[string]struct{}, len(b.scope.Columns))
-	for _, c := range b.scope.Columns {
-		if !c.SpanLevel {
-			set[c.Alias] = struct{}{}
-		}
-	}
-	return set
-}
-
-// orderableAliasSet is the subset of aliases computable in the matched pass — the
-// only ones usable in ORDER BY and the aggregate filter.
-func orderableAliasSet(resolved []resolvedColumn) map[string]struct{} {
-	set := make(map[string]struct{})
-	for _, rc := range resolved {
-		if rc.orderable {
-			set[rc.alias] = struct{}{}
-		}
-	}
-	return set
-}
-
-// neededMatchedAliases is the minimal alias set the matched pass must select: those
-// in ORDER BY plus those in the aggregate HAVING. Everything else is left to the
-// enrichment scan.
-func neededMatchedAliases(orders []listOrder, havingExpr string, orderableSet map[string]struct{}) map[string]struct{} {
-	needed := make(map[string]struct{})
-	for _, o := range orders {
-		needed[o.alias] = struct{}{}
-	}
-	for _, name := range traceAggregateNames(havingExpr) {
-		if _, ok := orderableSet[name]; ok {
-			needed[name] = struct{}{}
-		}
-	}
-	return needed
-}
-
-// traceAggregateNames extracts the aggregate names a trace-level HAVING expression
-// references. QueryStringToKeysSelectors emits an extra attribute-context fallback
-// selector for context-prefixed keys (`trace.x` → attribute "trace.x"); only the
-// unspecified- and trace-context selectors name aggregates.
-func traceAggregateNames(havingExpr string) []string {
-	var names []string
-	for _, sel := range querybuilder.QueryStringToKeysSelectors(havingExpr) {
-		if sel.FieldContext == telemetrytypes.FieldContextUnspecified || sel.FieldContext == telemetrytypes.FieldContextTrace {
-			names = append(names, sel.Name)
-		}
-	}
-	return names
-}
-
-// validateAggregateFilter rejects a trace-level filter referencing an aggregate not
-// computable in the matched pass (e.g. span_count, trace_duration_nano).
-func validateAggregateFilter(havingExpr string, orderableSet map[string]struct{}) error {
-	if strings.TrimSpace(havingExpr) == "" {
-		return nil
-	}
-	allowed := make([]string, 0, len(orderableSet))
-	for a := range orderableSet {
-		allowed = append(allowed, a)
-	}
-	sort.Strings(allowed)
-	for _, name := range traceAggregateNames(havingExpr) {
-		if _, ok := orderableSet[name]; !ok {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput,
-				"aggregate %q cannot be used in the trace-list filter; filterable aggregates: %s", name, strings.Join(allowed, ", "))
-		}
-	}
-	return nil
-}
-
-// embedExpr inlines a resolved expr into sb, replacing each `?` placeholder with a
-// builder Var so the args are tracked in appearance order. Resolved exprs carry
-// values only as bound args, so every `?` is a placeholder; a count mismatch would
-// silently shift args into the wrong slots — error out instead.
-func embedExpr(sb *sqlbuilder.SelectBuilder, expr string, args []any) (string, error) {
-	if n := strings.Count(expr, "?"); n != len(args) {
-		return "", errors.NewInternalf(errors.CodeInternal,
-			"scoped trace builder: %d placeholders != %d args embedding %q", n, len(args), expr)
-	}
-	var out strings.Builder
-	ai := 0
-	for i := 0; i < len(expr); i++ {
-		if expr[i] == '?' {
-			out.WriteString(sb.Var(args[ai]))
-			ai++
-			continue
-		}
-		out.WriteByte(expr[i])
-	}
-	return out.String(), nil
-}
-
-// windowWhere binds the time-window predicates to sb and returns them so the caller
-// can add its own predicates in the same Where call.
-func windowWhere(sb *sqlbuilder.SelectBuilder, start, end, startBucket, endBucket uint64) []string {
-	return []string{
-		sb.GE("timestamp", fmt.Sprintf("%d", start)),
-		sb.L("timestamp", fmt.Sprintf("%d", end)),
-		sb.GE("ts_bucket_start", startBucket),
-		sb.LE("ts_bucket_start", endBucket),
-	}
-}
-
-// orderClause renders the ORDER BY terms plus the trace_id tiebreak.
-func orderClause(orders []listOrder) []string {
-	out := make([]string, 0, len(orders)+1)
-	for _, o := range orders {
-		out = append(out, fmt.Sprintf("%s %s", quoteAlias(o.alias), o.direction))
-	}
-	return append(out, "trace_id DESC")
-}
-
-// selectAllColumns renders `expr AS alias` for every resolved column, args in select
-// order.
-func selectAllColumns(resolved []resolvedColumn) ([]string, []any) {
-	selects := []string{"trace_id"}
-	var args []any
-	for _, rc := range resolved {
-		selects = append(selects, rc.expr+" AS "+quoteAlias(rc.alias))
-		args = append(args, rc.args...)
-	}
-	return selects, args
-}
-
-// quoteAlias backticks an alias containing characters special to the SQL builder.
-func quoteAlias(alias string) string {
-	if strings.ContainsAny(alias, ".$`") {
-		return "`" + alias + "`"
-	}
-	return alias
-}

pkg/telemetryscopedtraces/statement_builder_test.go

@@ -1,30 +0,0 @@
-package telemetryscopedtraces
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/huandu/go-sqlbuilder"
-	"github.com/stretchr/testify/require"
-)
-
-// The full-pipeline golden tests live in pkg/telemetryai, which exercises this
-// builder through its production provider pair. The tests here cover only what
-// needs the package internals.
-
-// embedExpr treats every `?` byte as a placeholder; a count/args mismatch (an expr
-// carrying a literal `?`, or a dropped arg) must fail loudly instead of silently
-// shifting every subsequent arg into the wrong placeholder.
-func TestEmbedExpr_PlaceholderArgMismatch(t *testing.T) {
-	sb := sqlbuilder.NewSelectBuilder()
-
-	out, err := embedExpr(sb, "x = ? AND y = ?", []any{1, 2})
-	require.NoError(t, err)
-	require.Equal(t, 2, strings.Count(out, "$"), "both placeholders bound as builder vars")
-
-	_, err = embedExpr(sb, "x = ? AND y LIKE 'a?b'", []any{1})
-	require.Error(t, err, "literal ? in the expr must not pass as a placeholder")
-
-	_, err = embedExpr(sb, "x = ?", []any{1, 2})
-	require.Error(t, err, "extra args must not be silently dropped")
-}

pkg/templating/markdownrenderer/googlechat/doc.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Package googlechat provides a goldmark extension that renders markdown as
+// Google Chat's webhook text format.
+//
+// Google Chat webhooks support a limited markdown subset with different syntax
+// than standard markdown: *bold* (not **bold**), _italic_ (not *italic*),
+// ~strikethrough~ (not ~~strikethrough~~), and <url|text> links (not [text](url)).
+//
+// This renderer converts standard markdown to Google Chat's format, allowing
+// custom alert templates authored in standard markdown to display correctly
+// in Google Chat notifications.
+package googlechat

pkg/templating/markdownrenderer/googlechat/googlechat.go

@@ -0,0 +1,226 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package googlechat
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/extension"
+	extensionast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+// Extender is a goldmark extension that converts markdown to Google Chat format.
+var Extender = &extender{}
+
+type extender struct{}
+
+func (e *extender) Extend(m goldmark.Markdown) {
+	// Add strikethrough extension to parse ~~text~~ properly
+	extension.Strikethrough.Extend(m)
+	m.Renderer().AddOptions(
+		renderer.WithNodeRenderers(util.Prioritized(&googlechatRenderer{}, 0)),
+	)
+}
+
+type googlechatRenderer struct{}
+
+// RegisterFuncs implements renderer.NodeRenderer.
+func (r *googlechatRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	// Inline elements
+	reg.Register(ast.KindText, r.renderText)
+	reg.Register(ast.KindString, r.renderString)
+	reg.Register(ast.KindEmphasis, r.renderEmphasis)
+	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
+	reg.Register(ast.KindLink, r.renderLink)
+	reg.Register(ast.KindAutoLink, r.renderAutoLink)
+
+	// Extensions
+	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
+
+	// Block elements
+	reg.Register(ast.KindParagraph, r.renderParagraph)
+	reg.Register(ast.KindHeading, r.renderHeading)
+	reg.Register(ast.KindBlockquote, r.renderBlockquote)
+	reg.Register(ast.KindList, r.renderList)
+	reg.Register(ast.KindListItem, r.renderListItem)
+	reg.Register(ast.KindFencedCodeBlock, r.renderFencedCodeBlock)
+	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
+
+	// Document
+	reg.Register(ast.KindDocument, r.renderDocument)
+}
+
+func (r *googlechatRenderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		n := node.(*ast.Text)
+		_, _ = w.Write(n.Segment.Value(source))
+		if n.SoftLineBreak() {
+			_ = w.WriteByte('\n')
+		} else if n.HardLineBreak() {
+			_ = w.WriteByte('\n')
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderString(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		n := node.(*ast.String)
+		_, _ = w.Write(n.Value)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Emphasis)
+
+	if n.Level == 2 {
+		// Strong/bold: **text** → *text*
+		_ = w.WriteByte('*')
+	} else {
+		// Emphasis/italic: *text* or _text_ → _text_
+		_ = w.WriteByte('_')
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderCodeSpan(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_ = w.WriteByte('`')
+		for c := node.FirstChild(); c != nil; c = c.NextSibling() {
+			segment := c.(*ast.Text).Segment
+			_, _ = w.Write(segment.Value(source))
+		}
+		_ = w.WriteByte('`')
+	}
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *googlechatRenderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Link)
+
+	if entering {
+		// Convert [text](url) → <url|text>
+		url := string(n.Destination)
+		_ = w.WriteByte('<')
+		_, _ = w.WriteString(url)
+		_ = w.WriteByte('|')
+	} else {
+		_ = w.WriteByte('>')
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.AutoLink)
+	if entering {
+		// Auto links can be plain URLs
+		_, _ = w.Write(n.URL(source))
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderParagraph(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering && node.NextSibling() != nil {
+		// Add blank line between paragraphs
+		_, _ = w.WriteString("\n\n")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	// Google Chat doesn't support headings in webhooks, so render as bold text
+	if entering {
+		_ = w.WriteByte('*')
+	} else {
+		_ = w.WriteByte('*')
+		if node.NextSibling() != nil {
+			_, _ = w.WriteString("\n\n")
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderBlockquote(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_ = w.WriteByte('>')
+	} else if node.NextSibling() != nil {
+		_, _ = w.WriteString("\n\n")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering && node.NextSibling() != nil {
+		_, _ = w.WriteString("\n\n")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderListItem(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		// Use * for bullet points
+		_, _ = w.WriteString("* ")
+	} else {
+		_ = w.WriteByte('\n')
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderFencedCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_, _ = w.WriteString("```\n")
+		lines := node.Lines()
+		for i := 0; i < lines.Len(); i++ {
+			line := lines.At(i)
+			_, _ = w.Write(line.Value(source))
+		}
+		_, _ = w.WriteString("```")
+		if node.NextSibling() != nil {
+			_, _ = w.WriteString("\n\n")
+		}
+	}
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *googlechatRenderer) renderCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_, _ = w.WriteString("```\n")
+		lines := node.Lines()
+		for i := 0; i < lines.Len(); i++ {
+			line := lines.At(i)
+			_, _ = w.Write(line.Value(source))
+		}
+		_, _ = w.WriteString("```")
+		if node.NextSibling() != nil {
+			_, _ = w.WriteString("\n\n")
+		}
+	}
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *googlechatRenderer) renderThematicBreak(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		// Google Chat doesn't have horizontal rules, use a line of dashes
+		_, _ = w.WriteString("---")
+		if node.NextSibling() != nil {
+			_, _ = w.WriteString("\n\n")
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	// Document doesn't render anything itself
+	return ast.WalkContinue, nil
+}
+
+func (r *googlechatRenderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	// Google Chat uses single tilde for strikethrough
+	_ = w.WriteByte('~')
+	return ast.WalkContinue, nil
+}

pkg/templating/markdownrenderer/googlechat/googlechat_test.go

@@ -0,0 +1,131 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package googlechat_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/googlechat"
+	"github.com/yuin/goldmark"
+)
+
+func TestRenderer(t *testing.T) {
+	md := goldmark.New(goldmark.WithExtensions(googlechat.Extender))
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "empty input",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "simple paragraph",
+			input:    "Hello, world!",
+			expected: "Hello, world!",
+		},
+		{
+			name:     "heading (rendered as bold)",
+			input:    "# My Heading",
+			expected: "*My Heading*",
+		},
+		{
+			name:     "multiple paragraphs",
+			input:    "First paragraph.\n\nSecond paragraph.",
+			expected: "First paragraph.\n\nSecond paragraph.",
+		},
+		{
+			name:     "bold text (** becomes *)",
+			input:    "This is **bold** text.",
+			expected: "This is *bold* text.",
+		},
+		{
+			name:     "italic text (* becomes _)",
+			input:    "This is *italic* text.",
+			expected: "This is _italic_ text.",
+		},
+		{
+			name:     "italic text (_ stays _)",
+			input:    "This is _italic_ text.",
+			expected: "This is _italic_ text.",
+		},
+		{
+			name:     "bold and italic",
+			input:    "**bold** and *italic* together.",
+			expected: "*bold* and _italic_ together.",
+		},
+		{
+			name:     "code span",
+			input:    "Use `code` here.",
+			expected: "Use `code` here.",
+		},
+		{
+			name:     "link conversion ([text](url) becomes <url|text>)",
+			input:    "Check [this link](https://example.com).",
+			expected: "Check <https://example.com|this link>.",
+		},
+		{
+			name:     "plain autolink",
+			input:    "<https://example.com>",
+			expected: "https://example.com",
+		},
+		{
+			name:     "bullet list",
+			input:    "- Item 1\n- Item 2\n- Item 3",
+			expected: "* Item 1\n* Item 2\n* Item 3\n",
+		},
+		{
+			name:     "fenced code block",
+			input:    "```\ncode line 1\ncode line 2\n```",
+			expected: "```\ncode line 1\ncode line 2\n```",
+		},
+		{
+			name:     "fenced code block with language",
+			input:    "```go\nfunc main() {}\n```",
+			expected: "```\nfunc main() {}\n```",
+		},
+		{
+			name:     "blockquote",
+			input:    "> This is a quote",
+			expected: ">This is a quote",
+		},
+		{
+			name:     "thematic break (--- for horizontal rule)",
+			input:    "Above\n\n---\n\nBelow",
+			expected: "Above\n\n---\n\nBelow",
+		},
+		{
+			name:     "mixed inline formatting",
+			input:    "**bold**, *italic*, `code`, and [link](https://example.com).",
+			expected: "*bold*, _italic_, `code`, and <https://example.com|link>.",
+		},
+		{
+			name:     "alert-like message",
+			input:    "# Alert: High CPU\n\n**Status:** Firing\n\n**Details:**\n- Host: server1\n- CPU: 95%",
+			expected: "*Alert: High CPU*\n\n*Status:* Firing\n\n*Details:*\n\n* Host: server1\n* CPU: 95%\n",
+		},
+		{
+			name:     "strikethrough (~~text~~ becomes ~text~)",
+			input:    "This is ~~strikethrough~~ text.",
+			expected: "This is ~strikethrough~ text.",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := md.Convert([]byte(tt.input), &buf); err != nil {
+				t.Fatalf("Convert failed: %v", err)
+			}
+			got := buf.String()
+			if got != tt.expected {
+				t.Errorf("expected:\n%q\n\ngot:\n%q", tt.expected, got)
+			}
+		})
+	}
+}

pkg/templating/markdownrenderer/markdownrenderer.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/blockkit"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/googlechat"
 	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/mrkdwn"
 	"github.com/yuin/goldmark"
 	"github.com/yuin/goldmark/extension"
@@ -32,6 +33,11 @@ var (
 			return goldmark.New(goldmark.WithExtensions(mrkdwn.Extender))
 		},
 	}
+	googlechatPool = sync.Pool{
+		New: func() any {
+			return goldmark.New(goldmark.WithExtensions(googlechat.Extender))
+		},
+	}
 )
 
 // RenderHTML converts markdown to HTML.
@@ -53,6 +59,13 @@ func RenderSlackMrkdwn(markdown string) (string, error) {
 	return render(md, markdown, "Slack mrkdwn")
 }
 
+// RenderGoogleChatMarkdown converts markdown to Google Chat's webhook text format.
+func RenderGoogleChatMarkdown(markdown string) (string, error) {
+	md := googlechatPool.Get().(goldmark.Markdown)
+	defer googlechatPool.Put(md)
+	return render(md, markdown, "Google Chat")
+}
+
 func render(md goldmark.Markdown, markdown string, format string) (string, error) {
 	var buf bytes.Buffer
 	if err := md.Convert([]byte(markdown), &buf); err != nil {

pkg/types/alertmanagertypes/googlechat.go

@@ -1,6 +1,10 @@
 package alertmanagertypes
 
 import (
+	"net/url"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/prometheus/alertmanager/config"
 	commoncfg "github.com/prometheus/common/config"
 )
@@ -32,3 +36,18 @@ func (c *GoogleChatReceiverConfig) UnmarshalYAML(unmarshal func(any) error) erro
 	type plain GoogleChatReceiverConfig
 	return unmarshal((*plain)(c))
 }
+
+// ValidateGoogleChatWebhookURL validates the Google Chat webhook URL format.
+func ValidateGoogleChatWebhookURL(rawURL string) error {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid google chat webhook_url: %v", err)
+	}
+	if u.Scheme != "https" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url must use https")
+	}
+	if strings.ToLower(u.Hostname()) != "chat.googleapis.com" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url must use chat.googleapis.com")
+	}
+	return nil
+}

pkg/types/alertmanagertypes/googlechat_test.go

@@ -0,0 +1,44 @@
+package alertmanagertypes
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestValidateGoogleChatWebhookURL(t *testing.T) {
+	cases := []struct {
+		name    string
+		url     string
+		wantErr bool
+	}{
+		{"valid", "https://chat.googleapis.com/v1/spaces/AAA/messages?key=k&token=t", false},
+		{"http scheme rejected", "http://chat.googleapis.com/v1/spaces/AAA/messages", true},
+		{"wrong host rejected", "https://example.com/v1/spaces/AAA/messages", true},
+		{"empty rejected", "", true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			err := ValidateGoogleChatWebhookURL(c.url)
+			if c.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestNewReceiverGoogleChatRejectsBadURL(t *testing.T) {
+	// http scheme
+	_, err := NewReceiver(`{"name":"gc","googlechat_configs":[{"webhook_url":"http://chat.googleapis.com/v1/spaces/x/messages"}]}`)
+	require.Error(t, err)
+
+	// wrong host
+	_, err = NewReceiver(`{"name":"gc","googlechat_configs":[{"webhook_url":"https://example.com/x"}]}`)
+	require.Error(t, err)
+
+	// missing webhook_url
+	_, err = NewReceiver(`{"name":"gc","googlechat_configs":[{"title":"x"}]}`)
+	require.Error(t, err)
+}

pkg/types/alertmanagertypes/receiver.go

@@ -45,12 +45,23 @@ func NewReceiver(input string) (*Receiver, error) {
 		if err != nil {
 			return nil, err
 		}
+		if err := validateGoogleChatConfig(defaulted); err != nil {
+			return nil, err
+		}
 		receiver.GoogleChatConfigs[i] = defaulted
 	}
 
 	return receiver, nil
 }
 
+// validateGoogleChatConfig validates a Google Chat receiver configuration.
+func validateGoogleChatConfig(cfg *GoogleChatReceiverConfig) error {
+	if cfg.WebhookURL == nil {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "google chat webhook_url is required")
+	}
+	return ValidateGoogleChatWebhookURL(cfg.WebhookURL.String())
+}
+
 func defaultedBaseReceiver(base *config.Receiver) (*config.Receiver, error) {
 	bytes, err := yaml.Marshal(base)
 	if err != nil {

pkg/types/llmpricingruletypes/pricing.go

@@ -16,10 +16,18 @@ import (
 const (
 	LLMCostFeatureType agentConf.AgentFeatureType = "llm_pricing"
 
+	GenAIRequestModel                  = "gen_ai.request.model"
+	GenAIProviderName                  = "gen_ai.provider.name"
+	GenAIUsageInputTokens              = "gen_ai.usage.input_tokens"
+	GenAIUsageOutputTokens             = "gen_ai.usage.output_tokens"
+	GenAIUsageCacheReadInputTokens     = "gen_ai.usage.cache_read.input_tokens"
+	GenAIUsageCacheCreationInputTokens = "gen_ai.usage.cache_creation.input_tokens"
+
 	SignozGenAICostInput      = "_signoz.gen_ai.cost_input"
 	SignozGenAICostOutput     = "_signoz.gen_ai.cost_output"
 	SignozGenAICostCacheRead  = "_signoz.gen_ai.cost_cache_read"
 	SignozGenAICostCacheWrite = "_signoz.gen_ai.cost_cache_write"
+	SignozGenAITotalCost      = "_signoz.gen_ai.total_cost"
 )
 
 var (

pkg/types/llmpricingruletypes/processorconfig.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"gopkg.in/yaml.v3"
 )
 
@@ -84,11 +83,11 @@ func buildProcessorConfig(rules []*LLMPricingRule) *LLMPricingRuleProcessorConfi
 
 	return &LLMPricingRuleProcessorConfig{
 		Attrs: LLMPricingRuleProcessorAttrs{
-			Model:      telemetrytypes.GenAIRequestModel,
-			In:         telemetrytypes.GenAIUsageInputTokens,
-			Out:        telemetrytypes.GenAIUsageOutputTokens,
-			CacheRead:  telemetrytypes.GenAIUsageCacheReadInputTokens,
-			CacheWrite: telemetrytypes.GenAIUsageCacheCreationInputTokens,
+			Model:      GenAIRequestModel,
+			In:         GenAIUsageInputTokens,
+			Out:        GenAIUsageOutputTokens,
+			CacheRead:  GenAIUsageCacheReadInputTokens,
+			CacheWrite: GenAIUsageCacheCreationInputTokens,
 		},
 		DefaultPricing: LLMPricingRuleProcessorDefaultPricing{
 			Rules: pricingRules,
@@ -98,7 +97,7 @@ func buildProcessorConfig(rules []*LLMPricingRule) *LLMPricingRuleProcessorConfi
 			Out:        SignozGenAICostOutput,
 			CacheRead:  SignozGenAICostCacheRead,
 			CacheWrite: SignozGenAICostCacheWrite,
-			Total:      telemetrytypes.SignozGenAITotalCost,
+			Total:      SignozGenAITotalCost,
 		},
 	}
 }

pkg/types/querybuildertypes/querybuildertypesv5/query_type.go

@@ -9,7 +9,6 @@ type QueryType struct {
 var (
 	QueryTypeUnknown       = QueryType{valuer.NewString("unknown")}
 	QueryTypeBuilder       = QueryType{valuer.NewString("builder_query")}
-	QueryTypeBuilderAI     = QueryType{valuer.NewString("builder_ai_query")}
 	QueryTypeFormula       = QueryType{valuer.NewString("builder_formula")}
 	QueryTypeSubQuery      = QueryType{valuer.NewString("builder_sub_query")}
 	QueryTypeJoin          = QueryType{valuer.NewString("builder_join")}
@@ -22,7 +21,6 @@ var (
 func (QueryType) Enum() []any {
 	return []any{
 		QueryTypeBuilder,
-		QueryTypeBuilderAI,
 		QueryTypeFormula,
 		// Not yet supported.
 		// QueryTypeSubQuery,

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -62,13 +62,6 @@ type queryEnvelopeBuilder struct {
 	Spec builderQuerySpec `json:"spec" description:"The builder query specification."`
 }
 
-// queryEnvelopeBuilderAI is the OpenAPI schema for a builder_ai_query QueryEnvelope.
-// The spec is always a traces builder query (the signal is implied by the type).
-type queryEnvelopeBuilderAI struct {
-	Type QueryType                           `json:"type" required:"true" description:"The type of the query."`
-	Spec QueryBuilderQuery[TraceAggregation] `json:"spec" description:"The AI builder query specification."`
-}
-
 // queryEnvelopeFormula is the OpenAPI schema for a QueryEnvelope with type=builder_formula.
 type queryEnvelopeFormula struct {
 	Type QueryType           `json:"type" required:"true" description:"The type of the query."`
@@ -107,7 +100,6 @@ var _ jsonschema.OneOfExposer = QueryEnvelope{}
 func (QueryEnvelope) JSONSchemaOneOf() []any {
 	return []any{
 		queryEnvelopeBuilder{},
-		queryEnvelopeBuilderAI{},
 		queryEnvelopeFormula{},
 		// queryEnvelopeJoin{}, // deferred — see commented queryEnvelopeJoin above
 		queryEnvelopeTraceOperator{},
@@ -128,7 +120,6 @@ func (QueryEnvelope) PrepareJSONSchema(s *jsonschema.Schema) error {
 		"propertyName": "type",
 		"mapping": map[string]string{
 			QueryTypeBuilder.StringValue():       "#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilder",
-			QueryTypeBuilderAI.StringValue():     "#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilderAI",
 			QueryTypeFormula.StringValue():       "#/components/schemas/Querybuildertypesv5QueryEnvelopeFormula",
 			QueryTypeTraceOperator.StringValue(): "#/components/schemas/Querybuildertypesv5QueryEnvelopeTraceOperator",
 			QueryTypePromQL.StringValue():        "#/components/schemas/Querybuildertypesv5QueryEnvelopePromQL",
@@ -159,16 +150,6 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 		}
 		q.Spec = spec
 
-	case QueryTypeBuilderAI:
-		// A dedicated AI query is always a traces builder query; the signal is
-		// implied by the type, so pin it rather than requiring the caller to send it.
-		var spec QueryBuilderQuery[TraceAggregation]
-		if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
-			return err
-		}
-		spec.Signal = telemetrytypes.SignalTraces
-		q.Spec = spec
-
 	case QueryTypeFormula:
 		var spec QueryBuilderFormula
 		if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
@@ -213,7 +194,7 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 			"unknown query type %q",
 			shadow.Type,
 		).WithAdditional(
-			"Valid query types are: builder_query, builder_ai_query, builder_sub_query, builder_formula, builder_join, builder_trace_operator, promql, clickhouse_sql",
+			"Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, builder_trace_operator, promql, clickhouse_sql",
 		).WithSuggestions(errors.NewValidReferences(errors.NounQueryTypes, QueryType{}.Enum()...))
 	}
 

pkg/types/querybuildertypes/querybuildertypesv5/validation.go

@@ -641,7 +641,7 @@ func (r *QueryRangeRequest) ValidateRequestScope() ([]ValidationOption, error) {
 	// Builder query names must be unique across the composite query.
 	queryNames := make(map[string]bool)
 	for _, envelope := range r.CompositeQuery.Queries {
-		if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery || envelope.Type == QueryTypeBuilderAI {
+		if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery {
 			name := envelope.GetQueryName()
 			if name != "" {
 				if queryNames[name] {
@@ -710,7 +710,7 @@ func (c *CompositeQuery) Validate(opts ...ValidationOption) error {
 		}
 
 		// Check name uniqueness for builder queries
-		if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery || envelope.Type == QueryTypeBuilderAI {
+		if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery {
 			name := envelope.GetQueryName()
 			if name != "" {
 				if queryNames[name] {
@@ -744,15 +744,6 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err
 				"unknown query spec type",
 			)
 		}
-	case QueryTypeBuilderAI:
-		spec, ok := envelope.Spec.(QueryBuilderQuery[TraceAggregation])
-		if !ok {
-			return errors.NewInvalidInputf(
-				errors.CodeInvalidInput,
-				"invalid AI builder query spec",
-			)
-		}
-		return spec.Validate(opts...)
 	case QueryTypeFormula:
 		spec, ok := envelope.Spec.(QueryBuilderFormula)
 		if !ok {
@@ -822,7 +813,7 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err
 			"unknown query type: %s",
 			envelope.Type,
 		).WithAdditional(
-			"Valid query types are: builder_query, builder_ai_query, builder_sub_query, builder_formula, builder_join, promql, clickhouse_sql, trace_operator",
+			"Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, promql, clickhouse_sql, trace_operator",
 		).WithSuggestions(errors.NewValidReferences(errors.NounQueryTypes, QueryType{}.Enum()...))
 	}
 }

pkg/types/telemetrytypes/field_context.go

@@ -76,7 +76,6 @@ var (
 		"log":        FieldContextLog,
 		"metric":     FieldContextMetric,
 		"tracefield": FieldContextTrace,
-		"trace":      FieldContextTrace,
 	}
 )
 

pkg/types/telemetrytypes/genai_semconv.go

@@ -1,43 +0,0 @@
-package telemetrytypes
-
-// OpenTelemetry gen_ai semantic-convention attribute keys. Single source of truth
-// shared by the AI query builder and the LLM pricing pipeline.
-const (
-	GenAIRequestModel = "gen_ai.request.model"
-	GenAIToolName     = "gen_ai.tool.name"
-	GenAIAgentName    = "gen_ai.agent.name"
-	GenAIProviderName = "gen_ai.provider.name"
-
-	GenAIUsageInputTokens              = "gen_ai.usage.input_tokens"
-	GenAIUsageOutputTokens             = "gen_ai.usage.output_tokens"
-	GenAIUsageCacheReadInputTokens     = "gen_ai.usage.cache_read.input_tokens"
-	GenAIUsageCacheCreationInputTokens = "gen_ai.usage.cache_creation.input_tokens"
-
-	GenAIInputMessages  = "gen_ai.input.messages"
-	GenAIOutputMessages = "gen_ai.output.messages"
-
-	// SignozGenAITotalCost is not OTel semconv: it is the per-span total cost the
-	// SigNoz LLM pricing processor computes and attaches (see llmpricingruletypes).
-	SignozGenAITotalCost = "_signoz.gen_ai.total_cost"
-)
-
-// GenAIFieldDefinitions are the gen_ai semantic-convention span attributes the AI
-// query builder relies on. They are surfaced by the metadata store for trace
-// queries regardless of whether they have been ingested yet, so the AI gate/columns
-// resolve on a fresh install (mirrors intrinsic metric keys). String keys are the
-// gate; the usage keys are numeric.
-var GenAIFieldDefinitions = map[string]TelemetryFieldKey{
-	GenAIRequestModel: {Name: GenAIRequestModel, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIToolName:     {Name: GenAIToolName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIAgentName:    {Name: GenAIAgentName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIProviderName: {Name: GenAIProviderName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-
-	GenAIUsageInputTokens:              {Name: GenAIUsageInputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
-	GenAIUsageOutputTokens:             {Name: GenAIUsageOutputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
-	GenAIUsageCacheReadInputTokens:     {Name: GenAIUsageCacheReadInputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
-	GenAIUsageCacheCreationInputTokens: {Name: GenAIUsageCacheCreationInputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
-	SignozGenAITotalCost:               {Name: SignozGenAITotalCost, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
-
-	GenAIInputMessages:  {Name: GenAIInputMessages, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIOutputMessages: {Name: GenAIOutputMessages, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-}

pkg/types/telemetrytypes/selector.go

@@ -10,7 +10,6 @@ const wildcardSelector = "*"
 
 var telemetryGrantQueryTypes = map[string]bool{
 	"builder_query":     true,
-	"builder_ai_query":  true,
 	"builder_sub_query": true,
 	"promql":            false,
 	"clickhouse_sql":    false,

tests/fixtures/querier.py

@@ -78,15 +78,12 @@ class BuilderQuery:
     signal: str
     name: str = "A"
     source: str | None = None
-    query_type: str = "builder_query"
     limit: int | None = None
     offset: int | None = None
     filter_expression: str | None = None
-    having_expression: str | None = None
     select_fields: list[TelemetryFieldKey] | None = None
     order: list[OrderBy] | None = None
     aggregations: list[Aggregation | MetricAggregation] | None = None
-    group_by: list[TelemetryFieldKey] | None = None
     step_interval: int | None = None
 
     def to_dict(self) -> dict:
@@ -102,20 +99,16 @@ class BuilderQuery:
             spec["offset"] = self.offset
         if self.filter_expression:
             spec["filter"] = {"expression": self.filter_expression}
-        if self.having_expression:
-            spec["having"] = {"expression": self.having_expression}
         if self.select_fields:
             spec["selectFields"] = [f.to_dict() for f in self.select_fields]
         if self.order:
             spec["order"] = [o.to_dict() if hasattr(o, "to_dict") else o for o in self.order]
         if self.aggregations:
             spec["aggregations"] = [agg.to_dict() if hasattr(agg, "to_dict") else agg for agg in self.aggregations]
-        if self.group_by:
-            spec["groupBy"] = [k.to_dict() for k in self.group_by]
         if self.step_interval is not None:
             spec["stepInterval"] = self.step_interval
 
-        return {"type": self.query_type, "spec": spec}
+        return {"type": "builder_query", "spec": spec}
 
 
 @dataclass

tests/integration/tests/querierai/01_ai_traces.py

@@ -1,843 +0,0 @@
-"""
-Integration tests for query_type="builder_ai_query" over the traces signal.
-
-Data shape (generic OTel gen_ai semantic conventions):
-  - a root span (no gen_ai attributes)
-  - an LLM span carrying gen_ai.request.model (str) and numeric usage attributes
-    (gen_ai.usage.input_tokens / output_tokens / cost) plus gen_ai.user.id
-Each test tags its spans with a unique service.name and filters on it, so tests do
-not interfere with each other's data.
-"""
-
-import json
-from collections.abc import Callable
-from datetime import UTC, datetime, timedelta
-from http import HTTPStatus
-
-import pytest
-
-from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.querier import (
-    BuilderQuery,
-    OrderBy,
-    RequestType,
-    TelemetryFieldKey,
-    make_query_request,
-)
-from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode
-
-
-def _ai_trace(
-    *,
-    now: datetime,
-    service: str,
-    user: str,
-    in_tokens: int | None,
-    out_tokens: int,
-    cost: float,
-    model: str = "gpt-4o-mini",
-    llm_duration_s: float = 1.0,
-    error: bool = False,
-    environment: str = "production",
-) -> list[Traces]:
-    """A minimal AI trace: root span + one LLM span with gen_ai attributes.
-    in_tokens=None omits the input-tokens attribute entirely (not zero)."""
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-    llm_id = TraceIdGenerator.span_id()
-    resources = {"service.name": service, "deployment.environment": environment}
-
-    root = Traces(
-        timestamp=now - timedelta(seconds=5),
-        duration=timedelta(seconds=llm_duration_s + 0.1),
-        trace_id=trace_id,
-        span_id=root_id,
-        parent_span_id="",
-        name="POST /api/chat",
-        kind=TracesKind.SPAN_KIND_SERVER,
-        status_code=TracesStatusCode.STATUS_CODE_OK,
-        resources=resources,
-        attributes={"http.request.method": "POST"},
-    )
-    attributes = {
-        "gen_ai.request.model": model,
-        "gen_ai.system": "openai",
-        "gen_ai.user.id": user,
-        # numeric values land in attributes_number
-        "gen_ai.usage.output_tokens": out_tokens,
-        "_signoz.gen_ai.total_cost": cost,
-    }
-    if in_tokens is not None:
-        attributes["gen_ai.usage.input_tokens"] = in_tokens
-    llm = Traces(
-        timestamp=now - timedelta(seconds=4),
-        duration=timedelta(seconds=llm_duration_s),
-        trace_id=trace_id,
-        span_id=llm_id,
-        parent_span_id=root_id,
-        name="chat gpt-4o-mini",
-        kind=TracesKind.SPAN_KIND_CLIENT,
-        status_code=(TracesStatusCode.STATUS_CODE_ERROR if error else TracesStatusCode.STATUS_CODE_OK),
-        resources=resources,
-        attributes=attributes,
-    )
-    return [root, llm]
-
-
-def _non_ai_trace(*, now: datetime, service: str) -> list[Traces]:
-    """A plain HTTP trace with no gen_ai attributes; must be excluded by the AI gate."""
-    trace_id = TraceIdGenerator.trace_id()
-    span_id = TraceIdGenerator.span_id()
-    return [
-        Traces(
-            timestamp=now - timedelta(seconds=4),
-            duration=timedelta(seconds=1),
-            trace_id=trace_id,
-            span_id=span_id,
-            parent_span_id="",
-            name="GET /health",
-            kind=TracesKind.SPAN_KIND_SERVER,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            resources={"service.name": service},
-            attributes={"http.request.method": "GET"},
-        )
-    ]
-
-
-def _window_ms(now: datetime) -> tuple[int, int]:
-    start_ms = int((now - timedelta(minutes=10)).timestamp() * 1000)
-    end_ms = int((now + timedelta(minutes=1)).timestamp() * 1000)
-    return start_ms, end_ms
-
-
-def test_ai_list_excludes_non_ai(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    Trace-list panel (requestType="trace"): returns AI traces and excludes the
-    non-AI trace. Asserts on the raw response payload to stay agnostic to the exact
-    row schema.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-list"
-
-    ai = _ai_trace(now=now, service=service, user="alice", in_tokens=100, out_tokens=20, cost=0.5)
-    non_ai = _non_ai_trace(now=now, service=service)
-    ai_trace_id = ai[0].trace_id
-    non_ai_trace_id = non_ai[0].trace_id
-    insert_traces(ai + non_ai)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}'",
-        limit=10,
-    )
-
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    body = json.dumps(response.json())
-    assert ai_trace_id in body, f"expected AI trace {ai_trace_id} in list response"
-    assert non_ai_trace_id not in body, f"non-AI trace {non_ai_trace_id} should be excluded by the gate"
-
-
-def _ai_trace_mixed_spans(*, now: datetime, service: str, user: str) -> list[Traces]:
-    """
-    Root + one LLM span + one tool span + one agent span. The gate matches all three
-    child spans, but only the LLM span carries gen_ai.request.model.
-    """
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-    resources = {"service.name": service, "deployment.environment": "production"}
-
-    def _span(name, kind, attributes, offset_s):
-        return Traces(
-            timestamp=now - timedelta(seconds=offset_s),
-            duration=timedelta(seconds=0.5),
-            trace_id=trace_id,
-            span_id=TraceIdGenerator.span_id(),
-            parent_span_id=root_id,
-            name=name,
-            kind=kind,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            resources=resources,
-            attributes=attributes,
-        )
-
-    root = Traces(
-        timestamp=now - timedelta(seconds=5),
-        duration=timedelta(seconds=4),
-        trace_id=trace_id,
-        span_id=root_id,
-        parent_span_id="",
-        name="POST /api/chat",
-        kind=TracesKind.SPAN_KIND_SERVER,
-        status_code=TracesStatusCode.STATUS_CODE_OK,
-        resources=resources,
-        attributes={"http.request.method": "POST"},
-    )
-    llm = _span(
-        "chat gpt-4o-mini",
-        TracesKind.SPAN_KIND_CLIENT,
-        {
-            "gen_ai.request.model": "gpt-4o-mini",
-            "gen_ai.system": "openai",
-            "gen_ai.user.id": user,
-            "gen_ai.usage.input_tokens": 100,
-            "gen_ai.usage.output_tokens": 20,
-        },
-        4,
-    )
-    tool = _span(
-        "execute_tool",
-        TracesKind.SPAN_KIND_INTERNAL,
-        {
-            "gen_ai.tool.name": "get_weather",
-            "gen_ai.tool.type": "function",
-        },
-        3,
-    )
-    agent = _span(
-        "agent.step",
-        TracesKind.SPAN_KIND_INTERNAL,
-        {
-            "gen_ai.agent.name": "chat-agent",
-        },
-        2,
-    )
-    return [root, llm, tool, agent]
-
-
-def test_ai_list_having_aggregate_filter(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    Aggregate filter written in the SAME filter box: the span-level predicate narrows
-    to the service, the trace-level `output_tokens > 100` keeps the large-token
-    trace and drops the small one (split internally into WHERE + HAVING). Both
-    spellings of a trace-level aggregate — bare and `trace.` — behave identically
-    (unit tests pin them to byte-identical SQL; this covers the wiring once
-    end-to-end). An output-only aggregate is rejected under either spelling.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-having"
-
-    small = _ai_trace(now=now, service=service, user="alice", in_tokens=10, out_tokens=20, cost=0.1)
-    large = _ai_trace(now=now, service=service, user="bob", in_tokens=10, out_tokens=500, cost=0.2)
-    small_id = small[0].trace_id
-    large_id = large[0].trace_id
-    insert_traces(small + large)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    for spelling in ("output_tokens", "trace.output_tokens"):
-        query = BuilderQuery(
-            signal="traces",
-            query_type="builder_ai_query",
-            name="A",
-            filter_expression=f"service.name = '{service}' AND {spelling} > 100",
-            limit=10,
-        )
-        response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-        assert response.status_code == HTTPStatus.OK, f"{spelling}: {response.text}"
-
-        body = json.dumps(response.json())
-        assert large_id in body, f"{spelling}: trace with 500 out-tokens should pass > 100"
-        assert small_id not in body, f"{spelling}: trace with 20 out-tokens should be filtered out by HAVING"
-
-    # output-only aggregate gets the targeted rejection.
-    bad = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression="trace.span_count > 3",
-        limit=10,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [bad.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert "cannot be used" in response.text
-
-
-def test_ai_list_order_limit_offset(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """Trace list honors order by (aggregate column) + limit + offset (pagination)."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-order"
-
-    traces: list[Traces] = []
-    for out in (100, 200, 300, 400, 500):
-        traces += _ai_trace(now=now, service=service, user="u", in_tokens=10, out_tokens=out, cost=0.1)
-    insert_traces(traces)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    def page(offset: int) -> list[int]:
-        query = BuilderQuery(
-            signal="traces",
-            query_type="builder_ai_query",
-            name="A",
-            filter_expression=f"service.name = '{service}'",
-            order=[OrderBy(key=TelemetryFieldKey(name="output_tokens"), direction="desc")],
-            limit=2,
-            offset=offset,
-        )
-        resp = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-        assert resp.status_code == HTTPStatus.OK, resp.text
-        rows = resp.json()["data"]["data"]["results"][0]["rows"]
-        return [int(r["data"]["output_tokens"]) for r in rows]
-
-    assert page(0) == [500, 400], "first page: highest output_tokens, desc"
-    assert page(2) == [300, 200], "second page (offset 2): next two, desc"
-
-
-def test_ai_span_list_limit(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """Span list honors limit (delegated raw path): 6 gen_ai spans available, capped to 4."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-spanlimit"
-    insert_traces(_ai_trace_mixed_spans(now=now, service=service, user="a") + _ai_trace_mixed_spans(now=now, service=service, user="b"))
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}'",
-        limit=4,
-    )
-    resp = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type=RequestType.RAW)
-    assert resp.status_code == HTTPStatus.OK, resp.text
-    rows = resp.json()["data"]["data"]["results"][0]["rows"]
-    assert len(rows) == 4, f"limit should cap at 4 (6 gen_ai spans available), got {len(rows)}"
-
-
-def test_ai_span_list_excludes_non_gen_ai_spans(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    Span list (requestType=raw): returns only the gen_ai spans (LLM/tool/agent); the
-    root span of the same trace (no gen_ai attributes) is excluded by the span-level gate.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-spanlist"
-    insert_traces(_ai_trace_mixed_spans(now=now, service=service, user="alice"))
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}'",
-        select_fields=[TelemetryFieldKey(name="name", field_context="span")],
-        limit=50,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type=RequestType.RAW)
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    rows = response.json()["data"]["data"]["results"][0]["rows"]
-    names = sorted(r["data"]["name"] for r in rows)
-    assert names == ["agent.step", "chat gpt-4o-mini", "execute_tool"], names
-    assert "POST /api/chat" not in names  # root span excluded
-
-
-def test_ai_list_having_or_aggregates(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    Two trace-level aggregates OR-ed within the filter box (regression guard for OR-group
-    whitespace handling): output_tokens > 100 OR input_tokens > 1000 keeps only the
-    large-output trace (input_tokens is 10 for both, so that branch never matches).
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-having-or"
-
-    small = _ai_trace(now=now, service=service, user="a", in_tokens=10, out_tokens=20, cost=0.1)
-    large = _ai_trace(now=now, service=service, user="b", in_tokens=10, out_tokens=500, cost=0.2)
-    small_id, large_id = small[0].trace_id, large[0].trace_id
-    insert_traces(small + large)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}' AND (output_tokens > 100 OR input_tokens > 1000)",
-        limit=10,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    body = json.dumps(response.json())
-    assert large_id in body
-    assert small_id not in body
-
-
-def test_ai_list_resource_filter_isolates_by_fingerprint(
-    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 resource attribute in the filter is pulled into the __resource_filter fingerprint
-    CTE (see maybeAttachResourceFilter). Two traces on the same service but different
-    deployment.environment: `resource.deployment.environment = 'production'` must keep
-    the production trace and drop the staging one — the fingerprint prune isolates by
-    the resource, not by any span attribute.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-resfilter"
-
-    prod = _ai_trace(now=now, service=service, user="a", in_tokens=10, out_tokens=20, cost=0.1, environment="production")
-    stag = _ai_trace(now=now, service=service, user="b", in_tokens=10, out_tokens=20, cost=0.1, environment="staging")
-    prod_id, stag_id = prod[0].trace_id, stag[0].trace_id
-    insert_traces(prod + stag)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=(f"resource.service.name = '{service}' AND resource.deployment.environment = 'production'"),
-        limit=10,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    body = json.dumps(response.json())
-    assert prod_id in body, "production trace should match the resource filter"
-    assert stag_id not in body, "staging trace should be excluded by the resource fingerprint prune"
-
-
-def test_ai_list_rejects_aggregate_or_span_filter(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    Aggregate (HAVING) columns may not be OR-ed with span-level keys in the trace
-    list; a span-OR-span filter is fine.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-orfilter"
-    # seed a trace so service.name resolves as a known key in this window (resource
-    # keys are discovered from ingested data).
-    insert_traces(_ai_trace(now=now, service=service, user="a", in_tokens=10, out_tokens=20, cost=0.1))
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    # aggregate OR span -> rejected
-    bad = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=10,
-        filter_expression=f"output_tokens > 1000 OR service.name = '{service}'",
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [bad.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert "cannot be combined" in response.text
-
-    # span OR span -> accepted (result content doesn't matter; just not an error)
-    ok = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=10,
-        filter_expression=f"service.name = '{service}' OR has_error = true",
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [ok.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-
-def test_ai_list_nested_group_span_or_and_aggregate(
-    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 complex filter that mixes all three routing paths in one expression:
-        service.name = X AND (has_error = true OR gen_ai.request.model = 'gpt-4o') AND total_tokens > 100
-    The nested (span OR span) group must not flatten (precedence), the span predicates
-    go to WHERE as a trace-existence check, and the new `total_tokens` aggregate goes to
-    HAVING. Three traces isolate each discriminator:
-      - t_ok:      gpt-4o, out=500 -> OR matches (model) AND total_tokens>100  -> IN
-      - t_or_miss: gpt-4o-mini, out=500 -> OR fails (no error, wrong model)    -> OUT
-      - t_agg_miss: gpt-4o, out=20  -> OR matches but total_tokens<=100         -> OUT
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-nested"
-
-    t_ok = _ai_trace(now=now, service=service, user="a", model="gpt-4o", in_tokens=10, out_tokens=500, cost=0.1)
-    t_or_miss = _ai_trace(now=now, service=service, user="b", model="gpt-4o-mini", in_tokens=10, out_tokens=500, cost=0.1)
-    t_agg_miss = _ai_trace(now=now, service=service, user="c", model="gpt-4o", in_tokens=10, out_tokens=20, cost=0.1)
-    insert_traces(t_ok + t_or_miss + t_agg_miss)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=(f"service.name = '{service}' AND (has_error = true OR gen_ai.request.model = 'gpt-4o') AND total_tokens > 100"),
-        limit=10,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    body = json.dumps(response.json())
-    assert t_ok[0].trace_id in body
-    assert t_or_miss[0].trace_id not in body, "nested (span OR span) group must exclude the wrong-model, no-error trace"
-    assert t_agg_miss[0].trace_id not in body, "HAVING total_tokens > 100 must exclude the low-token trace"
-
-
-def test_ai_list_rejects_unknown_aggregate_key(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-) -> None:
-    """A trace-level filter on an unknown aggregate name is rejected, not silently run."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=10,
-        filter_expression="trace.bogus_tokens > 1",
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-
-
-def test_ai_list_rejects_order_by_span_attribute(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-) -> None:
-    """Only gen_ai-scoped aggregates are orderable; ordering by a span/resource key errors."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=5,
-        order=[OrderBy(key=TelemetryFieldKey(name="service.name"), direction="asc")],
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
-    assert "order key" in response.text
-
-
-def test_ai_list_total_tokens_output_only(
-    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 LLM span carries only output tokens (no input-tokens attribute at
-    all) must still total: total_tokens is coalesce(sum(in),0)+coalesce(sum(out),0),
-    since sum over an absent attribute is NULL and NULL + n = NULL in ClickHouse.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-total-coalesce"
-    insert_traces(_ai_trace(now=now, service=service, user="a", in_tokens=None, out_tokens=300, cost=0.1))
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}'",
-        limit=10,
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    rows = response.json()["data"]["data"]["results"][0]["rows"]
-    assert len(rows) == 1, f"expected one trace, got: {rows}"
-    data = rows[0]["data"]
-    assert data["input_tokens"] is None, data  # attribute absent -> NULL, not 0
-    assert data["output_tokens"] == 300, data
-    assert data["total_tokens"] == 300, f"total must coalesce the missing input side: {data}"
-
-
-def test_ai_list_variable_in_aggregate_filter(
-    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 query variable in a trace-level condition is substituted into the HAVING."""
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-having-var"
-
-    small = _ai_trace(now=now, service=service, user="a", in_tokens=10, out_tokens=20, cost=0.1)
-    large = _ai_trace(now=now, service=service, user="b", in_tokens=10, out_tokens=500, cost=0.2)
-    small_id, large_id = small[0].trace_id, large[0].trace_id
-    insert_traces(small + large)
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        filter_expression=f"service.name = '{service}' AND trace.output_tokens > $threshold",
-        limit=10,
-    )
-    response = make_query_request(
-        signoz,
-        token,
-        start_ms,
-        end_ms,
-        [query.to_dict()],
-        request_type="trace",
-        variables={"threshold": {"type": "custom", "value": 100}},
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    body = json.dumps(response.json())
-    assert large_id in body
-    assert small_id not in body
-
-
-def _ai_trace_two_llm(*, now: datetime, service: str) -> list[Traces]:
-    """Root + two LLM spans at different times, each with distinct input/output messages."""
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-    resources = {"service.name": service}
-
-    def _llm(offset_s: float, prompt: str, answer: str) -> Traces:
-        return Traces(
-            timestamp=now - timedelta(seconds=offset_s),
-            duration=timedelta(seconds=1),
-            trace_id=trace_id,
-            span_id=TraceIdGenerator.span_id(),
-            parent_span_id=root_id,
-            name="chat",
-            kind=TracesKind.SPAN_KIND_CLIENT,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            resources=resources,
-            attributes={
-                "gen_ai.request.model": "gpt-4o-mini",
-                "gen_ai.input.messages": prompt,
-                "gen_ai.output.messages": answer,
-            },
-        )
-
-    root = Traces(
-        timestamp=now - timedelta(seconds=5),
-        duration=timedelta(seconds=4),
-        trace_id=trace_id,
-        span_id=root_id,
-        parent_span_id="",
-        name="POST /api/chat",
-        kind=TracesKind.SPAN_KIND_SERVER,
-        status_code=TracesStatusCode.STATUS_CODE_OK,
-        resources=resources,
-        attributes={"http.request.method": "POST"},
-    )
-    # earlier call is the "first" (its input is the prompt), later call is the "last"
-    # (its output is the final answer).
-    first = _llm(4, "first prompt", "first answer")
-    last = _llm(2, "second prompt", "second answer")
-    return [root, first, last]
-
-
-def test_ai_list_messages_first_input_last_output(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    `input` is the FIRST LLM span's prompt (argMin over timestamp) and `output` is the
-    LAST LLM span's answer (argMax) — the question -> final-answer preview.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-messages"
-    insert_traces(_ai_trace_two_llm(now=now, service=service))
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=10,
-        filter_expression=f"service.name = '{service}'",
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    rows = response.json()["data"]["data"]["results"][0]["rows"]
-    assert len(rows) == 1, f"expected one trace, got: {rows}"
-    data = rows[0]["data"]
-    assert data["input"] == "first prompt", f"input should be the earliest call's prompt: {data}"
-    assert data["output"] == "second answer", f"output should be the latest call's answer: {data}"
-
-
-def _ai_trace_for_metrics(*, now: datetime, service: str) -> list[Traces]:
-    """
-    Root + one errored LLM span (tokens/cost) + three tool spans (two 'get_weather',
-    one 'get_time') + one agent span, so the derived per-trace metrics have distinct
-    expected values. The agent span is in the gen_ai gate but carries no request.model,
-    so it must NOT count toward llm_call_count (only span_count / last_activity_time).
-    """
-    trace_id = TraceIdGenerator.trace_id()
-    root_id = TraceIdGenerator.span_id()
-    resources = {"service.name": service}
-
-    def _tool(name: str, offset_s: float) -> Traces:
-        return Traces(
-            timestamp=now - timedelta(seconds=offset_s),
-            duration=timedelta(seconds=0.2),
-            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": name, "gen_ai.tool.type": "function"},
-        )
-
-    root = Traces(
-        timestamp=now - timedelta(seconds=5),
-        duration=timedelta(seconds=4),
-        trace_id=trace_id,
-        span_id=root_id,
-        parent_span_id="",
-        name="POST /api/chat",
-        kind=TracesKind.SPAN_KIND_SERVER,
-        status_code=TracesStatusCode.STATUS_CODE_OK,
-        resources=resources,
-        attributes={"http.request.method": "POST"},
-    )
-    llm = Traces(
-        timestamp=now - timedelta(seconds=4),
-        duration=timedelta(seconds=2),
-        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,  # -> has_error, drives error_count
-        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.5,
-        },
-    )
-    agent = Traces(
-        timestamp=now - timedelta(seconds=1),
-        duration=timedelta(seconds=0.5),
-        trace_id=trace_id,
-        span_id=TraceIdGenerator.span_id(),
-        parent_span_id=root_id,
-        name="agent.step",
-        kind=TracesKind.SPAN_KIND_INTERNAL,
-        status_code=TracesStatusCode.STATUS_CODE_OK,
-        resources=resources,
-        attributes={"gen_ai.agent.name": "chat-agent"},
-    )
-    return [root, llm, _tool("get_weather", 3), _tool("get_weather", 2.5), _tool("get_time", 2), agent]
-
-
-def test_ai_list_enrichment_values(
-    signoz: types.SigNoz,
-    create_user_admin: None,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-) -> None:
-    """
-    End-to-end values of the derived per-trace columns (only integration can check that
-    ClickHouse computes uniqIf / sum+sum / countIf(predicate) correctly, not just that
-    the SQL is shaped right). One trace: root + 1 errored LLM + 3 tool spans
-    (get_weather x2, get_time x1) + 1 agent span. The tool and agent spans are in the
-    gen_ai gate but carry no request.model, so llm_call_count stays 1 while span_count
-    counts them all.
-    """
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-    service = "ai-it-metrics"
-    insert_traces(_ai_trace_for_metrics(now=now, service=service))
-
-    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    start_ms, end_ms = _window_ms(now)
-
-    query = BuilderQuery(
-        signal="traces",
-        query_type="builder_ai_query",
-        name="A",
-        limit=10,
-        filter_expression=f"service.name = '{service}'",
-    )
-    response = make_query_request(signoz, token, start_ms, end_ms, [query.to_dict()], request_type="trace")
-    assert response.status_code == HTTPStatus.OK, response.text
-
-    rows = response.json()["data"]["data"]["results"][0]["rows"]
-    assert len(rows) == 1, f"expected one trace, got: {rows}"
-    data = rows[0]["data"]
-
-    assert data["span_count"] == 6, data  # root + llm + 3 tools + agent
-    assert data["llm_call_count"] == 1, data  # only the request.model span, not tool/agent
-    assert data["tool_call_count"] == 3, data  # all three tool spans
-    assert data["distinct_tool_count"] == 2, data  # get_weather, get_time
-    assert data["input_tokens"] == 100, data
-    assert data["output_tokens"] == 20, data
-    assert data["total_tokens"] == 120, data  # input + output
-    assert data["estimated_total_cost"] == pytest.approx(0.5), data
-    assert data["error_count"] == 1, data  # the errored LLM span
-    assert data["max_llm_duration_nano"] > 0, data  # scoped max over LLM spans