SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
feat: QB support for llm trace list and span list (#12027)
Nityananda Gohain816ae7760ecc
diff --git a/.github/workflows/integrationci.yaml b/.github/workflows/integrationci.yamlindex f74e63e8a3..df2c6c06a7 100644--- a/.github/workflows/integrationci.yaml+++ b/.github/workflows/integrationci.yaml@@ -55,6 +55,7 @@ jobs:- queriermetrics- querierscalar- queriercommon+ - querierai- rawexportdata- promqlconformance- querierauthzdiff --git a/docs/api/openapi.yml b/docs/api/openapi.ymlindex e944aea207..133e46e3f1 100644--- a/docs/api/openapi.yml+++ b/docs/api/openapi.yml@@ -6902,6 +6902,7 @@ 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'@@ -6910,6 +6911,7 @@ components:propertyName: typeoneOf:- $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilder'+ - $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeBuilderAI'- $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeFormula'- $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopeTraceOperator'- $ref: '#/components/schemas/Querybuildertypesv5QueryEnvelopePromQL'@@ -6924,6 +6926,15 @@ components:required:- typetype: object+ Querybuildertypesv5QueryEnvelopeBuilderAI:+ properties:+ spec:+ $ref: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregation'+ type:+ $ref: '#/components/schemas/Querybuildertypesv5QueryType'+ required:+ - type+ type: objectQuerybuildertypesv5QueryEnvelopeClickHouseSQL:properties:spec:@@ -7037,6 +7048,7 @@ components:Querybuildertypesv5QueryType:enum:- builder_query+ - builder_ai_query- builder_formula- builder_trace_operator- clickhouse_sqldiff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.tsindex d830003f35..9dd95ea5d0 100644--- a/frontend/src/api/generated/services/sigNoz.schemas.ts+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts@@ -4301,6 +4301,18 @@ 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@@ -4484,6 +4496,7 @@ export interface Querybuildertypesv5QueryEnvelopeClickHouseSQLDTO {export type Querybuildertypesv5QueryEnvelopeDTO =| Querybuildertypesv5QueryEnvelopeBuilderDTO+ | Querybuildertypesv5QueryEnvelopeBuilderAIDTO| Querybuildertypesv5QueryEnvelopeFormulaDTO| Querybuildertypesv5QueryEnvelopeTraceOperatorDTO| Querybuildertypesv5QueryEnvelopePromQLDTO@@ -8287,6 +8300,7 @@ 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',diff --git a/pkg/modules/llmpricingrule/impllmpricingrule/module.go b/pkg/modules/llmpricingrule/impllmpricingrule/module.goindex 7150a8abb4..1141bf6d3c 100644--- a/pkg/modules/llmpricingrule/impllmpricingrule/module.go+++ b/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", llmpricingruletypes.GenAIRequestModel)},+ Filter: &qbtypes.Filter{Expression: fmt.Sprintf("%s EXISTS", telemetrytypes.GenAIRequestModel)},Aggregations: []qbtypes.TraceAggregation{{Expression: "count()", Alias: "spanCount"},},GroupBy: []qbtypes.GroupByKey{{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{- Name: llmpricingruletypes.GenAIRequestModel,+ Name: telemetrytypes.GenAIRequestModel,FieldContext: telemetrytypes.FieldContextSpan,FieldDataType: telemetrytypes.FieldDataTypeString,}},{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{- Name: llmpricingruletypes.GenAIProviderName,+ Name: telemetrytypes.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 llmpricingruletypes.GenAIRequestModel:+ case telemetrytypes.GenAIRequestModel:modelIdx = i- case llmpricingruletypes.GenAIProviderName:+ case telemetrytypes.GenAIProviderName:providerIdx = i}case qbtypes.ColumnTypeAggregation:diff --git a/pkg/querier/api.go b/pkg/querier/api.goindex 9778cf4035..77090e0687 100644--- a/pkg/querier/api.go+++ b/pkg/querier/api.go@@ -250,7 +250,7 @@ func (handler *handler) ReplaceVariables(rw http.ResponseWriter, req *http.Requeerrs := []error{}for idx, item := range queryRangeRequest.CompositeQuery.Queries {- if item.Type == qbtypes.QueryTypeBuilder {+ if item.Type == qbtypes.QueryTypeBuilder || item.Type == qbtypes.QueryTypeBuilderAI {switch spec := item.Spec.(type) {case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:if spec.Filter != nil && spec.Filter.Expression != "" {diff --git a/pkg/querier/preview.go b/pkg/querier/preview.goindex e43e75d779..c7639b4a78 100644--- a/pkg/querier/preview.go+++ b/pkg/querier/preview.go@@ -249,6 +249,7 @@ func (q *querier) buildPreviewProviders(func rendersStandaloneStatement(t qbtypes.QueryType) bool {switch t {case qbtypes.QueryTypeBuilder,+ qbtypes.QueryTypeBuilderAI,qbtypes.QueryTypePromQL,qbtypes.QueryTypeClickHouseSQL,qbtypes.QueryTypeTraceOperator:diff --git a/pkg/querier/querier.go b/pkg/querier/querier.goindex 809750ba21..7281435e8a 100644--- a/pkg/querier/querier.go+++ b/pkg/querier/querier.go@@ -61,6 +61,7 @@ type querier struct {// stay clean.promV2 prometheus.PrometheustraceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation]+ aiTraceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation]logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation]auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation]metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation]@@ -89,6 +90,7 @@ func New(promEngine prometheus.Prometheus,promV2 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],@@ -111,6 +113,7 @@ func New(promEngine: promEngine,promV2: promV2,traceStmtBuilder: traceStmtBuilder,+ aiTraceStmtBuilder: aiTraceStmtBuilder,logStmtBuilder: logStmtBuilder,auditStmtBuilder: auditStmtBuilder,metricStmtBuilder: metricStmtBuilder,@@ -295,6 +298,16 @@ func (q *querier) buildQueries(}queries[traceOpQuery.Name] = toqsteps[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.StepIntervalcase qbtypes.QueryTypeBuilder:switch spec := query.Spec.(type) {case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:@@ -361,6 +374,11 @@ func (q *querier) populateQBEvent(event *qbtypes.QBEvent, queries []qbtypes.Quercase 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 = truecase qbtypes.QueryTypePromQL:event.MetricsUsed = truecase qbtypes.QueryTypeTraceOperator:@@ -923,7 +941,8 @@ func (q *querier) createRangedQuery(_ valuer.UUID, originalQuery qbtypes.Query,specCopy := qt.spec.Copy()specCopy.ShiftBy = extractShiftFromBuilderQuery(specCopy)adjustedTimeRange := adjustTimeRangeForShift(specCopy, timeRange, qt.kind)- return newBuilderQuery(q.logger, q.telemetryStore, qt.orgID, q.traceStmtBuilder, specCopy, adjustedTimeRange, qt.kind, qt.variables, builderConfig{})+ // reuse the original query's statement builder so an AI query keeps its AI builder+ return newBuilderQuery(q.logger, q.telemetryStore, qt.orgID, qt.stmtBuilder, specCopy, adjustedTimeRange, qt.kind, qt.variables, builderConfig{})case *builderQuery[qbtypes.LogAggregation]:specCopy := qt.spec.Copy()@@ -1280,6 +1299,8 @@ func (q *querier) adjustStepInterval(queries []qbtypes.QueryEnvelope, start, endif qe.GetStepInterval().Seconds() == 0 {qe.SetStepInterval(secondsStep(metricRecommended))}+ case qbtypes.QueryTypeBuilderAI:+ clampStep(qe, traceLogRecommended, traceLogMin, &warnings)case qbtypes.QueryTypeTraceOperator:clampStep(qe, traceLogRecommended, traceLogMin, &warnings)}diff --git a/pkg/querier/querier_test.go b/pkg/querier/querier_test.goindex 182d7ec7fa..17e40364d4 100644--- a/pkg/querier/querier_test.go+++ b/pkg/querier/querier_test.go@@ -50,6 +50,7 @@ func TestQueryRange_MetricTypeMissing(t *testing.T) {nil, // prometheusnil, // promV2nil, // traceStmtBuilder+ nil, // aiTraceStmtBuildernil, // logStmtBuildernil, // auditStmtBuildernil, // metricStmtBuilder@@ -123,6 +124,7 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {nil, // prometheusnil, // promV2nil, // traceStmtBuilder+ nil, // aiTraceStmtBuildernil, // logStmtBuildernil, // auditStmtBuilder&mockMetricStmtBuilder{},diff --git a/pkg/querier/signozquerier/provider.go b/pkg/querier/signozquerier/provider.goindex 77efc808a3..d21aa54dcd 100644--- a/pkg/querier/signozquerier/provider.go+++ b/pkg/querier/signozquerier/provider.go@@ -21,6 +21,7 @@ func NewFactory(promV2 prometheus.Prometheus,metadataStore telemetrytypes.MetadataStore,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],@@ -43,6 +44,7 @@ func NewFactory(prometheus,promV2,traceStmtBuilder,+ aiTraceStmtBuilder,logStmtBuilder,auditStmtBuilder,metricStmtBuilder,diff --git a/pkg/query-service/rules/managertestfactory.go b/pkg/query-service/rules/managertestfactory.goindex 88eefac06d..a2eab6eadf 100644--- a/pkg/query-service/rules/managertestfactory.go+++ b/pkg/query-service/rules/managertestfactory.go@@ -19,6 +19,7 @@ import ("github.com/SigNoz/signoz/pkg/sqlstore""github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest""github.com/SigNoz/signoz/pkg/statementbuilder"+ "github.com/SigNoz/signoz/pkg/statementbuilder/aistatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/auditstatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/logsstatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/meterstatementbuilder"@@ -117,6 +118,8 @@ func NewTestManager(t *testing.T, testOpts *TestManagerOptions) *Manager {ctx := context.Background()traceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)require.NoError(t, err)+ aiTraceStmtBuilder, err := aistatementbuilder.NewFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)+ require.NoError(t, err)traceOperatorStmtBuilder, err := tracesstatementbuilder.NewOperatorFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)require.NoError(t, err)logStmtBuilder, err := logsstatementbuilder.NewFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)@@ -128,7 +131,7 @@ func NewTestManager(t *testing.T, testOpts *TestManagerOptions) *Manager {meterStmtBuilder, err := meterstatementbuilder.NewFactory(metadataStore, flagger).New(ctx, providerSettings, cfg)require.NoError(t, err)bucketCache := querier.NewBucketCache(providerSettings, cache, 0, 0)- providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, nil, metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger)+ providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, nil, metadataStore, traceStmtBuilder, aiTraceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger)mockQuerier, err := providerFactory.New(context.Background(), providerSettings, querier.Config{})require.NoError(t, err)diff --git a/pkg/query-service/rules/setups_test.go b/pkg/query-service/rules/setups_test.goindex bcafaf11b7..b699ae5373 100644--- a/pkg/query-service/rules/setups_test.go+++ b/pkg/query-service/rules/setups_test.go@@ -42,6 +42,7 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Telemenil, // prometheusnil, // promV2nil, // traceStmtBuilder+ nil, // aiTraceStmtBuildernil, // logStmtBuildernil, // auditStmtBuildermetricStmtBuilder,@@ -77,6 +78,7 @@ func prepareQuerierForLogs(t *testing.T, telemetryStore telemetrystore.Telemetrynil, // prometheusnil, // promV2nil, // traceStmtBuilder+ nil, // aiTraceStmtBuilderlogStmtBuilder,nil, // auditStmtBuildernil, // metricStmtBuilder@@ -113,6 +115,7 @@ func prepareQuerierForTraces(t *testing.T, telemetryStore telemetrystore.Telemetnil, // prometheusnil, // promV2traceStmtBuilder,+ nil, // aiTraceStmtBuildernil, // logStmtBuildernil, // auditStmtBuildernil, // metricStmtBuilderdiff --git a/pkg/querybuilder/filter_split.go b/pkg/querybuilder/filter_split.gonew file mode 100644index 0000000000..914411d673--- /dev/null+++ b/pkg/querybuilder/filter_split.go@@ -0,0 +1,166 @@+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 filter expression on the top-level AND into a+// span-level part (WHERE) and a trace-level part (HAVING over per-trace aggregates).+// A key is trace-level when it carries the trace field context or its bare name is in+// aggregateNames; any other explicit context is span-level. An OR mixing the two+// classes 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 flattens the top-level AND chain and routes each atom 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 real OR is 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)+ // re-wrap an OR group (its source slice excludes the enclosing parens) so the+ // " AND " rejoin cannot invert OR/AND precedence+ 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. An unknown name under the trace context stays trace-level so the aggregate+// validation rejects it with a targeted error.+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 slices the input by token offsets to preserve whitespace (the token+// stream drops it, gluing word operators to operands). ANTLR offsets are rune indices,+// 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])+}diff --git a/pkg/querybuilder/filter_split_test.go b/pkg/querybuilder/filter_split_test.gonew file mode 100644index 0000000000..0ec36c5c2c--- /dev/null+++ b/pkg/querybuilder/filter_split_test.go@@ -0,0 +1,219 @@+package querybuilder++import (+ "testing"++ "github.com/stretchr/testify/assert"+ "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",+ },+ {+ // routes trace-level so aggregate validation rejects it with a targeted error+ 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+ 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 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)+ assert.Equal(t, c.span, span, "span part")+ assert.Equal(t, c.having, having, "having part")+ })+ }+}diff --git a/pkg/querybuilder/having_rewriter.go b/pkg/querybuilder/having_rewriter.goindex 2b8701ca65..c4a7b0f26f 100644--- a/pkg/querybuilder/having_rewriter.go+++ b/pkg/querybuilder/having_rewriter.go@@ -18,6 +18,17 @@ func NewHavingExpressionRewriter() *HavingExpressionRewriter {}}+// Rewrite rewrites and validates a HAVING expression against a caller-supplied column+// map (user-facing name -> SQL identifier). Values are inlined, so the result is a+// bare boolean expression with no bound args.+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 {diff --git a/pkg/querybuilder/query_range_resources.go b/pkg/querybuilder/query_range_resources.goindex 659ac4a2ac..c92284b0c4 100644--- a/pkg/querybuilder/query_range_resources.go+++ b/pkg/querybuilder/query_range_resources.go@@ -82,6 +82,9 @@ func resourcesForQuery(query gjson.Result, variables map[string]qbtypes.Variableswitch queryType {case qbtypes.QueryTypeBuilder.StringValue(), qbtypes.QueryTypeSubQuery.StringValue():return resourcesForBuilderQuery(queryType, query.Get("spec"), variables)+ case qbtypes.QueryTypeBuilderAI.StringValue():+ // always a traces query; the signal may be absent from the payload+ return builderQueryResourceRefs(queryType, coretypes.ResourceTelemetryResourceTraces, query.Get("spec"), variables)case qbtypes.QueryTypePromQL.StringValue():return []coretypes.ResourceWithID{{Resource: coretypes.ResourceTelemetryResourceMetrics, ID: typeWildcard}}, nilcase qbtypes.QueryTypeClickHouseSQL.StringValue():@@ -103,7 +106,10 @@ func resourcesForBuilderQuery(queryType string, spec gjson.Result, variables mapif 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, errdiff --git a/pkg/querybuilder/query_range_resources_test.go b/pkg/querybuilder/query_range_resources_test.goindex 2562039e41..abd3e05ecf 100644--- a/pkg/querybuilder/query_range_resources_test.go+++ b/pkg/querybuilder/query_range_resources_test.go@@ -92,6 +92,20 @@ 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"}}]}}`,diff --git a/pkg/querybuilder/where_clause_visitor.go b/pkg/querybuilder/where_clause_visitor.goindex a7f2760cd0..7eb2e0f2c9 100644--- a/pkg/querybuilder/where_clause_visitor.go+++ b/pkg/querybuilder/where_clause_visitor.go@@ -83,7 +83,10 @@ func newFilterExpressionVisitor(opts FilterExprVisitorOpts) *filterExpressionVis}type PreparedWhereClause struct {- WhereClause *sqlbuilder.WhereClause+ WhereClause *sqlbuilder.WhereClause+ // Expr is the bare predicate ($n markers bound to opts.Builder), embeddable+ // outside a WHERE clause (e.g. inside countIf).+ Expr stringWarnings []stringWarningsDocURL stringRequiresCostGuard bool@@ -173,7 +176,7 @@ func PrepareWhereClause(query string, opts FilterExprVisitorOpts) (PreparedWherewhereClause := sqlbuilder.NewWhereClause().AddWhereExpr(visitor.builder.Args, cond)- return PreparedWhereClause{WhereClause: whereClause, Warnings: visitor.warnings, WarningsDocURL: visitor.mainWarnURL, RequiresCostGuard: visitor.requiresCostGuard}, nil+ return PreparedWhereClause{WhereClause: whereClause, Expr: cond, Warnings: visitor.warnings, WarningsDocURL: visitor.mainWarnURL, RequiresCostGuard: visitor.requiresCostGuard}, nil}// Visit dispatches to the specific visit method based on node type.diff --git a/pkg/signoz/provider.go b/pkg/signoz/provider.goindex 9c26aac7fc..bdab15a742 100644--- a/pkg/signoz/provider.go+++ b/pkg/signoz/provider.go@@ -293,9 +293,9 @@ func NewStatsReporterProviderFactories(aggregator statsreporter.Aggregator, orgG)}-func NewQuerierProviderFactories(telemetryStore telemetrystore.TelemetryStore, prometheus prometheus.Prometheus, promV2 prometheus.Prometheus, metadataStore telemetrytypes.MetadataStore, traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation], logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation], auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation], metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation], meterStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation], traceOperatorStmtBuilder qbtypes.TraceOperatorStatementBuilder, bucketCache querier.BucketCache, flagger flagger.Flagger) factory.NamedMap[factory.ProviderFactory[querier.Querier, querier.Config]] {+func NewQuerierProviderFactories(telemetryStore telemetrystore.TelemetryStore, prometheus prometheus.Prometheus, promV2 prometheus.Prometheus, metadataStore telemetrytypes.MetadataStore, 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], meterStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation], traceOperatorStmtBuilder qbtypes.TraceOperatorStatementBuilder, bucketCache querier.BucketCache, flagger flagger.Flagger) factory.NamedMap[factory.ProviderFactory[querier.Querier, querier.Config]] {return factory.MustNewNamedMap(- signozquerier.NewFactory(telemetryStore, prometheus, promV2, metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),+ signozquerier.NewFactory(telemetryStore, prometheus, promV2, metadataStore, traceStmtBuilder, aiTraceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),)}diff --git a/pkg/signoz/signoz.go b/pkg/signoz/signoz.goindex e6ef5c0401..6224365f21 100644--- a/pkg/signoz/signoz.go+++ b/pkg/signoz/signoz.go@@ -49,6 +49,7 @@ import ("github.com/SigNoz/signoz/pkg/sqlmigrator""github.com/SigNoz/signoz/pkg/sqlschema""github.com/SigNoz/signoz/pkg/sqlstore"+ "github.com/SigNoz/signoz/pkg/statementbuilder/aistatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/auditstatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/logsstatementbuilder""github.com/SigNoz/signoz/pkg/statementbuilder/meterstatementbuilder"@@ -100,9 +101,9 @@ type SigNoz struct {// newQueryStack assembles the query stack once and returns, in order: the shared// telemetry metadata store (reused elsewhere in signoz.New), the per-signal-// statement builders (trace, log, audit, metric, meter, trace-operator), and the-// bucket cache. It is the only place that imports the concrete statement-builder-// sub-packages.+// statement builders (trace, ai-trace, log, audit, metric, meter, trace-operator),+// and the bucket cache. It is the only place that imports the concrete+// statement-builder sub-packages.func newQueryStack(ctx context.Context,settings factory.ProviderSettings,@@ -113,6 +114,7 @@ func newQueryStack() (telemetrytypes.MetadataStore,qbtypes.StatementBuilder[qbtypes.TraceAggregation],+ qbtypes.StatementBuilder[qbtypes.TraceAggregation],qbtypes.StatementBuilder[qbtypes.LogAggregation],qbtypes.StatementBuilder[qbtypes.LogAggregation],qbtypes.StatementBuilder[qbtypes.MetricAggregation],@@ -126,32 +128,36 @@ func newQueryStack(cfg := config.Querier.ConfigtraceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err+ }+ aiTraceStmtBuilder, err := aistatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)+ if err != nil {+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}traceOperatorStmtBuilder, err := tracesstatementbuilder.NewOperatorFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}logStmtBuilder, err := logsstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}auditStmtBuilder, err := auditstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}metricStmtBuilder, err := metricsstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}meterStmtBuilder, err := meterstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)if err != nil {- return nil, nil, nil, nil, nil, nil, nil, nil, err+ return nil, nil, nil, nil, nil, nil, nil, nil, nil, err}bucketCache := querier.NewBucketCache(settings, cache, config.Querier.CacheTTL, config.Querier.FluxInterval)- return metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, nil+ return metadataStore, traceStmtBuilder, aiTraceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, nil}func New(@@ -336,7 +342,7 @@ func New(// Assemble the query stack (metadata store, statement builders, bucket cache) once,// and reuse the single metadata store everywhere downstream.- telemetryMetadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, err := newQueryStack(ctx, providerSettings, config, telemetrystore, cache, flagger)+ telemetryMetadataStore, traceStmtBuilder, aiTraceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, err := newQueryStack(ctx, providerSettings, config, telemetrystore, cache, flagger)if err != nil {return nil, err}@@ -346,7 +352,7 @@ func New(ctx,providerSettings,config.Querier,- NewQuerierProviderFactories(telemetrystore, prometheus, promV2, telemetryMetadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),+ NewQuerierProviderFactories(telemetrystore, prometheus, promV2, telemetryMetadataStore, traceStmtBuilder, aiTraceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),config.Querier.Provider(),)if err != nil {diff --git a/pkg/statementbuilder/aistatementbuilder/statement_builder.go b/pkg/statementbuilder/aistatementbuilder/statement_builder.gonew file mode 100644index 0000000000..dff34e7281--- /dev/null+++ b/pkg/statementbuilder/aistatementbuilder/statement_builder.go@@ -0,0 +1,78 @@+package aistatementbuilder++import (+ "strings"++ "github.com/SigNoz/signoz/pkg/factory"+ "github.com/SigNoz/signoz/pkg/flagger"+ "github.com/SigNoz/signoz/pkg/statementbuilder"+ scopedtraces "github.com/SigNoz/signoz/pkg/statementbuilder/scopedtracesstatementbuilder"+ "github.com/SigNoz/signoz/pkg/telemetrystore"+ qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+)++// NewFactory returns the provider factory for builder_ai_query: the gen_ai Scope+// paired with the domain-neutral scoped-trace builder.+func NewFactory(+ telemetryStore telemetrystore.TelemetryStore,+ metadataStore telemetrytypes.MetadataStore,+ fl flagger.Flagger,+) factory.ProviderFactory[qbtypes.StatementBuilder[qbtypes.TraceAggregation], statementbuilder.Config] {+ return scopedtraces.NewFactory(factory.MustNewName("ai"), Scope(), telemetryStore, metadataStore, fl)+}++// 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.+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",+ }+}diff --git a/pkg/statementbuilder/aistatementbuilder/statement_builder_test.go b/pkg/statementbuilder/aistatementbuilder/statement_builder_test.gonew file mode 100644index 0000000000..256006c09a--- /dev/null+++ b/pkg/statementbuilder/aistatementbuilder/statement_builder_test.go@@ -0,0 +1,1058 @@+package aistatementbuilder++import (+ "context"+ "fmt"+ "strings"+ "testing"+ "time"++ "github.com/SigNoz/signoz/pkg/flagger/flaggertest"+ "github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"+ "github.com/SigNoz/signoz/pkg/statementbuilder"+ scopedtraces "github.com/SigNoz/signoz/pkg/statementbuilder/scopedtracesstatementbuilder"+ qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"+ "github.com/SigNoz/signoz/pkg/valuer"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++// otelKeysMap seeds the gen_ai semconv keys the AI queries reference.+func otelKeysMap() map[string][]*telemetrytypes.TelemetryFieldKey {+ strKey := func(name string) *telemetrytypes.TelemetryFieldKey {+ return &telemetrytypes.TelemetryFieldKey{+ Name: name,+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextAttribute,+ FieldDataType: telemetrytypes.FieldDataTypeString,+ }+ }+ numKey := func(name string) *telemetrytypes.TelemetryFieldKey {+ return &telemetrytypes.TelemetryFieldKey{+ Name: name,+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextAttribute,+ FieldDataType: telemetrytypes.FieldDataTypeFloat64,+ }+ }++ m := make(map[string][]*telemetrytypes.TelemetryFieldKey)++ // mirrors what enrichWithGenAIKeys surfaces in production+ for name, def := range telemetrytypes.GenAIFieldDefinitions {+ keyCopy := def+ m[name] = []*telemetrytypes.TelemetryFieldKey{&keyCopy}+ }++ // keys referenced by tests that aren't gen_ai semconv definitions+ m["gen_ai.user.id"] = []*telemetrytypes.TelemetryFieldKey{strKey("gen_ai.user.id")}+ m["_signoz.gen_ai.total_cost"] = []*telemetrytypes.TelemetryFieldKey{numKey("_signoz.gen_ai.total_cost")}+ m["gen_ai.usage.cached_input_tokens"] = []*telemetrytypes.TelemetryFieldKey{numKey("gen_ai.usage.cached_input_tokens")}+ m["has_error"] = []*telemetrytypes.TelemetryFieldKey{{+ Name: "has_error",+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextSpan,+ FieldDataType: telemetrytypes.FieldDataTypeBool,+ }}+ // resource-column evolutions so the value expression prefers the JSON resource column+ m["service.name"] = []*telemetrytypes.TelemetryFieldKey{{+ Name: "service.name",+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextResource,+ FieldDataType: telemetrytypes.FieldDataTypeString,+ Evolutions: resourceEvolutions(),+ }}+ return m+}++// resourceEvolutions: legacy resources_string map at epoch 0, JSON resource column+// released inside the test window.+func resourceEvolutions() []*telemetrytypes.EvolutionEntry {+ return []*telemetrytypes.EvolutionEntry{+ {+ Signal: telemetrytypes.SignalTraces,+ ColumnName: "resources_string",+ ColumnType: "Map(LowCardinality(String), String)",+ FieldContext: telemetrytypes.FieldContextResource,+ FieldName: "__all__",+ ReleaseTime: time.Unix(0, 0),+ },+ {+ Signal: telemetrytypes.SignalTraces,+ ColumnName: "resource",+ ColumnType: "JSON()",+ FieldContext: telemetrytypes.FieldContextResource,+ FieldName: "__all__",+ ReleaseTime: time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC),+ },+ }+}++// standard test window (ms), matching the traces builder tests.+const (+ testStartMs = uint64(1747947419000)+ testEndMs = uint64(1747983448000)+)++func newTestBuilder(t *testing.T) qbtypes.StatementBuilder[qbtypes.TraceAggregation] {+ return newTestBuilderWithKeys(t, otelKeysMap())+}++func newTestBuilderWithKeys(t *testing.T, keysMap map[string][]*telemetrytypes.TelemetryFieldKey) qbtypes.StatementBuilder[qbtypes.TraceAggregation] {+ t.Helper()+ settings := instrumentationtest.New().ToProviderSettings()+ mockMetadataStore := telemetrytypestest.NewMockMetadataStore()+ mockMetadataStore.KeysMap = keysMap++ stmtBuilder, err := NewFactory(nil, mockMetadataStore, flaggertest.New(t)).+ New(context.Background(), settings, statementbuilder.Config{SkipResourceFingerprint: statementbuilder.SkipResourceFingerprint{Threshold: 100000}})+ require.NoError(t, err)+ return stmtBuilder+}++// renderSQL substitutes bound args into the `?` placeholders.+func renderSQL(t *testing.T, stmt *qbtypes.Statement) string {+ t.Helper()+ var b strings.Builder+ argi := 0+ for i := 0; i < len(stmt.Query); i++ {+ if stmt.Query[i] == '?' {+ require.Less(t, argi, len(stmt.Args), "more ? than args in query")+ b.WriteString(formatArg(stmt.Args[argi]))+ argi+++ continue+ }+ b.WriteByte(stmt.Query[i])+ }+ assert.Equal(t, len(stmt.Args), argi, "arg count does not match number of placeholders")+ return b.String()+}++func formatArg(a any) string {+ if s, ok := a.(string); ok {+ return "'" + s + "'"+ }+ return fmt.Sprintf("%v", a)+}++// normalizeSQL drops backticks, collapses whitespace, and removes spaces inside+// parens so golden strings can be freely wrapped as raw literals.+func normalizeSQL(s string) string {+ s = strings.Join(strings.Fields(strings.ReplaceAll(s, "`", "")), " ")+ s = strings.ReplaceAll(s, "( ", "(")+ s = strings.ReplaceAll(s, " )", ")")+ return s+}++func assertSQLEqual(t *testing.T, want string, stmt *qbtypes.Statement) {+ t.Helper()+ got := renderSQL(t, stmt)+ t.Logf("\n%s", got)+ assert.Equal(t, normalizeSQL(want), normalizeSQL(got))+}++// No filter: WHERE is just window + gate mask, no HAVING.+func TestBuild_FullSQL_TraceList_NoFilter(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces, Limit: 20,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name')))+ GROUP BY trace_id+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 20+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// A materialized gen_ai attribute resolves to its materialized column everywhere it+// appears; un-promoted attributes stay in the attributes map within the same query.+func TestBuild_FullSQL_TraceList_MaterializedColumns(t *testing.T) {+ keys := otelKeysMap()+ for _, name := range []string{"gen_ai.request.model", "gen_ai.usage.input_tokens"} {+ for _, k := range keys[name] {+ k.Materialized = true+ }+ }+ b := newTestBuilderWithKeys(t, keys)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces, Limit: 20,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ maxIf(timestamp, (attribute_string_gen_ai$$request$$model_exists OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((attribute_string_gen_ai$$request$$model_exists OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name')))+ GROUP BY trace_id+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 20+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(attribute_string_gen_ai$$request$$model_exists) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(attribute_number_gen_ai$$usage$$input_tokens_exists, toFloat64(attribute_number_gen_ai$$usage$$input_tokens), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(attribute_number_gen_ai$$usage$$input_tokens_exists, toFloat64(attribute_number_gen_ai$$usage$$input_tokens), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, attribute_string_gen_ai$$request$$model_exists) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (attribute_string_gen_ai$$request$$model_exists OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Span-level AND trace-level filter with order + pagination: matched selects only the+// aggregates ORDER BY/HAVING reference; the span predicate widens the WHERE prune and+// becomes a countIf existence check.+func TestBuild_FullSQL_TraceList_SpanAndTraceFilter(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "gen_ai.request.model = 'gpt-4o-mini' AND output_tokens > 1000"},+ Order: []qbtypes.OrderBy{{Key: qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "output_tokens"}}, Direction: qbtypes.OrderDirectionDesc}},+ Limit: 10, Offset: 30,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))+ OR (attributes_string['gen_ai.request.model'] = 'gpt-4o-mini' AND mapContains(attributes_string, 'gen_ai.request.model')))+ GROUP BY trace_id+ HAVING countIf((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) > 0+ AND countIf((attributes_string['gen_ai.request.model'] = 'gpt-4o-mini' AND mapContains(attributes_string, 'gen_ai.request.model'))) > 0+ AND output_tokens > 1000+ ORDER BY output_tokens DESC, trace_id DESC+ LIMIT 10 OFFSET 30+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY output_tokens DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Aggregate-only filter: WHERE prune not widened, no gate/span countIf, just the+// aggregate HAVING; `trace.output_tokens` rewrites to the alias.+func TestBuild_FullSQL_TraceList_AggregateFilterOnly(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "trace.output_tokens > 1000"},+ Limit: 20,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name')))+ GROUP BY trace_id+ HAVING output_tokens > 1000+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 20+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Span-only filter: WHERE widened; HAVING has the gate + span countIf pair but no+// trailing aggregate.+func TestBuild_FullSQL_TraceList_SpanFilterOnly(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "has_error = true"},+ Limit: 20,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))+ OR has_error = true)+ GROUP BY trace_id+ HAVING countIf((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) > 0+ AND countIf(has_error = true) > 0+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 20+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Resource filter: routed into the __resource_filter CTE narrowing the matched scan+// by fingerprint, and dropped from the span predicate — no span-level existence check.+func TestBuild_FullSQL_TraceList_ResourceFilter(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "resource.service.name = 'checkout'"},+ Limit: 20,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH __resource_filter AS (+ SELECT fingerprint+ FROM signoz_traces.distributed_traces_v3_resource+ WHERE (simpleJSONExtractString(labels, 'service.name') = 'checkout' AND labels LIKE '%service.name%' AND labels LIKE '%service.name":"checkout%')+ AND seen_at_ts_bucket_start >= 1747945619+ AND seen_at_ts_bucket_start <= 1747983448+ GROUP BY fingerprint+),+matched AS (+ SELECT trace_id,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name')))+ AND resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)+ GROUP BY trace_id+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 20+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Mixed span + aggregate filter with a two-key order: matched selects only the+// ORDER BY and HAVING aggregates.+func TestBuild_FullSQL_TraceList_MixedFiltersMultiOrder(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "gen_ai.request.model = 'gpt-4o' AND has_error = true AND output_tokens > 500"},+ Order: []qbtypes.OrderBy{+ {Key: qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "input_tokens"}}, Direction: qbtypes.OrderDirectionDesc},+ {Key: qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "last_activity_time"}}, Direction: qbtypes.OrderDirectionAsc},+ },+ Limit: 15,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))+ OR ((attributes_string['gen_ai.request.model'] = 'gpt-4o' AND mapContains(attributes_string, 'gen_ai.request.model')) AND has_error = true))+ GROUP BY trace_id+ HAVING countIf((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) > 0+ AND countIf(((attributes_string['gen_ai.request.model'] = 'gpt-4o' AND mapContains(attributes_string, 'gen_ai.request.model')) AND has_error = true)) > 0+ AND output_tokens > 500+ ORDER BY input_tokens DESC, last_activity_time ASC, trace_id DESC+ LIMIT 15+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.service.name IS NOT NULL, resource.service.name::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS service.name,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY input_tokens DESC, last_activity_time ASC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, stmt)+}++// Span list (raw): delegated to the traces builder with the gate ANDed into the+// user filter.+func TestBuild_FullSQL_SpanList_Raw(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeRaw,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "gen_ai.request.model = 'gpt-4o-mini'"},+ Limit: 10,+ }, nil)+ require.NoError(t, err)++ assertSQLEqual(t, `+SELECT timestamp AS __SELECT_KEY_0_timestamp, trace_id AS __SELECT_KEY_1_trace_id, span_id AS __SELECT_KEY_2_span_id,+ trace_state AS __SELECT_KEY_3_trace_state, parent_span_id AS __SELECT_KEY_4_parent_span_id, flags AS __SELECT_KEY_5_flags,+ name AS __SELECT_KEY_6_name, kind AS __SELECT_KEY_7_kind, kind_string AS __SELECT_KEY_8_kind_string, duration_nano AS __SELECT_KEY_9_duration_nano,+ status_code AS __SELECT_KEY_10_status_code, status_message AS __SELECT_KEY_11_status_message,+ status_code_string AS __SELECT_KEY_12_status_code_string, events AS __SELECT_KEY_13_events, links AS __SELECT_KEY_14_links,+ response_status_code AS __SELECT_KEY_15_response_status_code, external_http_url AS __SELECT_KEY_16_external_http_url,+ http_url AS __SELECT_KEY_17_http_url, external_http_method AS __SELECT_KEY_18_external_http_method,+ http_method AS __SELECT_KEY_19_http_method, http_host AS __SELECT_KEY_20_http_host, db_name AS __SELECT_KEY_21_db_name,+ db_operation AS __SELECT_KEY_22_db_operation, has_error AS __SELECT_KEY_23_has_error, is_remote AS __SELECT_KEY_24_is_remote,+ attributes_string, attributes_number, attributes_bool, resources_string+FROM signoz_traces.distributed_signoz_index_v3+WHERE (((mapContains(attributes_string, 'gen_ai.request.model')+ OR mapContains(attributes_string, 'gen_ai.tool.name')+ OR mapContains(attributes_string, 'gen_ai.agent.name')))+ AND ((attributes_string['gen_ai.request.model'] = 'gpt-4o-mini'+ AND mapContains(attributes_string, 'gen_ai.request.model'))))+ AND timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+LIMIT 10+`, stmt)+}++// ---------------------------------------------------------------------------+// Behavior / branch tests not covered by the goldens above+// ---------------------------------------------------------------------------++// Resource + span + aggregate filter: fingerprint prune, countIf existence check, and+// HAVING respectively, all AND-combined.+func TestBuild_TraceList_ResourcePlusSpanPlusAggregateFilter(t *testing.T) {+ b := newTestBuilder(t)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "resource.service.name = 'checkout' AND has_error = true AND output_tokens > 1000"},+ Limit: 10,+ }, nil)+ require.NoError(t, err)++ got := renderSQL(t, stmt)+ assert.Contains(t, got, "__resource_filter AS (")+ assert.Contains(t, got, "resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)")+ assert.NotContains(t, got, "resources_string['service.name'] = 'checkout'")+ assert.Contains(t, got, "countIf(has_error = true) > 0")+ assert.Contains(t, got, "output_tokens")+}++// Trace-level and span-level predicates may not be OR-combined.+func TestBuild_TraceList_TraceOrSpanMixRejected(t *testing.T) {+ b := newTestBuilder(t)+ query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "trace.output_tokens > 1000 OR gen_ai.request.model = 'x'"},+ Limit: 10,+ }+ _, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace, query, nil)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "cannot be combined")+}++// An output-only aggregate (span_count / trace_duration_nano) can be displayed but not+// filtered or ordered on — it is not computable in the matched pass.+func TestBuild_TraceList_OutputOnlyAggregateRejected(t *testing.T) {+ b := newTestBuilder(t)++ _, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "span_count > 3"},+ }, nil)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "span_count")++ _, err = b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Order: []qbtypes.OrderBy{{Key: qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "trace_duration_nano"}}, Direction: qbtypes.OrderDirectionDesc}},+ }, nil)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "unsupported order key")+}++// A bare duration_nano filter is span-level (the trace column is trace_duration_nano).+func TestBuild_TraceList_SpanDurationFilterIsSpanLevel(t *testing.T) {+ keys := otelKeysMap()+ keys["duration_nano"] = []*telemetrytypes.TelemetryFieldKey{{+ Name: "duration_nano",+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextSpan,+ FieldDataType: telemetrytypes.FieldDataTypeNumber,+ }}+ b := newTestBuilderWithKeys(t, keys)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: "duration_nano > 1000000"},+ Limit: 10,+ }, nil)+ require.NoError(t, err)++ got := renderSQL(t, stmt)+ assert.Contains(t, got, "countIf(duration_nano > 1000000) > 0")+ assert.NotContains(t, got, "HAVING trace_duration_nano")+}++// A span attribute named like an aggregate alias is shadowed in bare spelling but+// stays reachable via an explicit context prefix (`attribute.` / `span.`).+func TestBuild_FullSQL_TraceList_AliasAttributeCollision(t *testing.T) {+ keys := otelKeysMap()+ keys["output_tokens"] = []*telemetrytypes.TelemetryFieldKey{{+ Name: "output_tokens",+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextAttribute,+ FieldDataType: telemetrytypes.FieldDataTypeNumber,+ }}+ b := newTestBuilderWithKeys(t, keys)+ build := func(expr string) *qbtypes.Statement {+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: expr},+ Limit: 10,+ }, nil)+ require.NoError(t, err)+ return stmt+ }++ attrStmt := build("attribute.output_tokens > 100")+ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))+ OR (toFloat64(attributes_number['output_tokens']) > 100 AND mapContains(attributes_number, 'output_tokens')))+ GROUP BY trace_id+ HAVING countIf((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) > 0+ AND countIf((toFloat64(attributes_number['output_tokens']) > 100 AND mapContains(attributes_number, 'output_tokens'))) > 0+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 10+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.`+"`service.name`"+` IS NOT NULL, resource.`+"`service.name`"+`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`+"`service.name`"+` IS NOT NULL, resource.`+"`service.name`"+`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `+"`service.name`"+`,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, attrStmt)++ assert.Empty(t, attrStmt.Warnings)++ // span. corrects to the same attribute (identical SQL) but the span-context+ // metadata lookup misses, surfacing a key-not-found warning.+ spanStmt := build("span.output_tokens > 100")+ assert.Equal(t, renderSQL(t, attrStmt), renderSQL(t, spanStmt))+ require.Len(t, spanStmt.Warnings, 1)+ assert.Contains(t, spanStmt.Warnings[0], "key `output_tokens` not found in metadata")++ // bare spelling is claimed by the aggregate alias+ bareStmt := build("output_tokens > 100")+ assert.Empty(t, bareStmt.Warnings)+ assertSQLEqual(t, `+WITH matched AS (+ SELECT trace_id,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time+ FROM signoz_traces.distributed_signoz_index_v3+ WHERE timestamp >= '1747947419000000000'+ AND timestamp < '1747983448000000000'+ AND ts_bucket_start >= 1747945619+ AND ts_bucket_start <= 1747983448+ AND ((mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name')))+ GROUP BY trace_id+ HAVING output_tokens > 100+ ORDER BY last_activity_time DESC, trace_id DESC+ LIMIT 10+),+ranked AS (+ SELECT trace_id, min(start) AS t_start, max(end) AS t_end+ FROM signoz_traces.distributed_trace_summary+ WHERE trace_id GLOBAL IN (SELECT trace_id FROM matched)+ AND end >= fromUnixTimestamp64Nano(1747947419000000000)+ AND start < fromUnixTimestamp64Nano(1747983448000000000)+ GROUP BY trace_id+),+buckets AS (+ SELECT DISTINCT b AS ts_bucket+ FROM ranked+ ARRAY JOIN range(toUInt64(intDiv(toUnixTimestamp(t_start), 1800) * 1800 - 1800), toUInt64(intDiv(toUnixTimestamp(t_end), 1800) * 1800 + 1800), 1800) AS b+)+SELECT trace_id,+ min(timestamp) AS start_time,+ max(timestamp) AS end_time,+ (max(toUnixTimestamp64Nano(timestamp) + duration_nano) - min(toUnixTimestamp64Nano(timestamp))) AS trace_duration_nano,+ count() AS span_count,+ anyIf(name, parent_span_id = '') AS root_span_name,+ any(multiIf(multiIf(resource.`+"`service.name`"+` IS NOT NULL, resource.`+"`service.name`"+`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL) IS NOT NULL, multiIf(resource.`+"`service.name`"+` IS NOT NULL, resource.`+"`service.name`"+`::String, mapContains(resources_string, 'service.name'), resources_string['service.name'], NULL), NULL)) AS `+"`service.name`"+`,+ countIf(mapContains(attributes_string, 'gen_ai.request.model')) AS llm_call_count,+ countIf(mapContains(attributes_string, 'gen_ai.tool.name')) AS tool_call_count,+ uniqIf(multiIf(mapContains(attributes_string, 'gen_ai.tool.name'), attributes_string['gen_ai.tool.name'], NULL), mapContains(attributes_string, 'gen_ai.tool.name')) AS distinct_tool_count,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)) AS input_tokens,+ sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)) AS output_tokens,+ coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.input_tokens'), toFloat64(attributes_number['gen_ai.usage.input_tokens']), NULL)), 0) + coalesce(sum(multiIf(mapContains(attributes_number, 'gen_ai.usage.output_tokens'), toFloat64(attributes_number['gen_ai.usage.output_tokens']), NULL)), 0) AS total_tokens,+ sum(multiIf(mapContains(attributes_number, '_signoz.gen_ai.total_cost'), toFloat64(attributes_number['_signoz.gen_ai.total_cost']), NULL)) AS estimated_total_cost,+ maxIf(duration_nano, mapContains(attributes_string, 'gen_ai.request.model')) AS max_llm_duration_nano,+ countIf(has_error = true) AS error_count,+ maxIf(timestamp, (mapContains(attributes_string, 'gen_ai.request.model') OR mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_string, 'gen_ai.agent.name'))) AS last_activity_time,+ argMinIf(multiIf(mapContains(attributes_string, 'gen_ai.input.messages'), attributes_string['gen_ai.input.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.input.messages')) AS input,+ argMaxIf(multiIf(mapContains(attributes_string, 'gen_ai.output.messages'), attributes_string['gen_ai.output.messages'], NULL), timestamp, mapContains(attributes_string, 'gen_ai.output.messages')) AS output+FROM signoz_traces.distributed_signoz_index_v3+WHERE ts_bucket_start GLOBAL IN (SELECT ts_bucket FROM buckets)+ AND trace_id GLOBAL IN (SELECT trace_id FROM ranked)+GROUP BY trace_id+ORDER BY last_activity_time DESC, trace_id DESC+SETTINGS distributed_product_mode='allow', max_memory_usage=10000000000+`, bareStmt)+}++// A HAVING referencing a non-aggregate column is rejected.+func TestBuild_TraceList_Having_UnknownColumn(t *testing.T) {+ b := newTestBuilder(t)+ query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Having: &qbtypes.Having{Expression: "service.name > 1"}, // not an aggregate column+ Limit: 10,+ }+ _, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace, query, nil)+ require.Error(t, err)+}++// Ordering by an unknown key is rejected.+func TestBuild_TraceList_UnsupportedOrderKey(t *testing.T) {+ b := newTestBuilder(t)+ query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Order: []qbtypes.OrderBy{+ {Key: qbtypes.OrderByKey{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "http.request.method"}}, Direction: qbtypes.OrderDirectionDesc},+ },+ }+ _, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace, query, nil)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "unsupported order key")+}++// With no limit set, the builder applies the default of 100.+func TestBuild_TraceList_DefaultLimit(t *testing.T) {+ b := newTestBuilder(t)+ query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ }+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace, query, nil)+ require.NoError(t, err)+ assert.Contains(t, stmt.Query, "LIMIT ?")+ assert.Contains(t, stmt.Args, 100)+}++// Only trace list and span list (raw) are supported; distribution is not.+func TestBuild_UnsupportedRequestType(t *testing.T) {+ b := newTestBuilder(t)+ query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Aggregations: []qbtypes.TraceAggregation{+ {Expression: "count()"},+ },+ }+ _, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeDistribution, query, nil)+ require.ErrorIs(t, err, scopedtraces.ErrUnsupportedRequestType)+}++// A gate key ingested under several data types contributes all variants to the+// mask, OR-combined.+func TestBuild_TraceList_MultiVariantGateKey(t *testing.T) {+ keys := otelKeysMap()+ keys[telemetrytypes.GenAIToolName] = append(keys[telemetrytypes.GenAIToolName], &telemetrytypes.TelemetryFieldKey{+ Name: telemetrytypes.GenAIToolName,+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextAttribute,+ FieldDataType: telemetrytypes.FieldDataTypeFloat64,+ })+ b := newTestBuilderWithKeys(t, keys)+ stmt, err := b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces, Limit: 10,+ }, nil)+ require.NoError(t, err)++ got := renderSQL(t, stmt)+ assert.Contains(t, got, "mapContains(attributes_string, 'gen_ai.tool.name') OR mapContains(attributes_number, 'gen_ai.tool.name')")+}++// `trace.` marks a trace-level aggregate; `tracefield.` routes trace-level too but is+// not a rewritable alias, so the HAVING rewriter rejects it.+func TestBuild_TraceList_TraceContextPrefix(t *testing.T) {+ b := newTestBuilder(t)+ build := func(q qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]) (*qbtypes.Statement, error) {+ q.Signal, q.Limit = telemetrytypes.SignalTraces, 20+ return b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace, q, nil)+ }++ _, err := build(qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Filter: &qbtypes.Filter{Expression: "trace.output_tokens > 1000"}})+ require.NoError(t, err)++ _, err = build(qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Filter: &qbtypes.Filter{Expression: "tracefield.output_tokens > 1000"}})+ require.Error(t, err)+ assert.Contains(t, err.Error(), "Invalid references in `Having` expression: [tracefield.output_tokens]")++ _, err = build(qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Having: &qbtypes.Having{Expression: "tracefield.output_tokens > 1000"}})+ require.Error(t, err)+ assert.Contains(t, err.Error(), "Invalid references in `Having` expression: [tracefield.output_tokens]")++ _, err = build(qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Filter: &qbtypes.Filter{Expression: "trace.span_count > 3"}})+ require.Error(t, err)+ assert.Contains(t, err.Error(), "cannot be used")+}++// Query variables in a trace-level condition are substituted into the HAVING.+func TestBuild_TraceList_VariableInAggregateFilter(t *testing.T) {+ b := newTestBuilder(t)+ build := func(expr string, vars map[string]qbtypes.VariableItem) (*qbtypes.Statement, error) {+ return b.Build(context.Background(), valuer.UUID{}, testStartMs, testEndMs, qbtypes.RequestTypeTrace,+ qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{+ Signal: telemetrytypes.SignalTraces,+ Filter: &qbtypes.Filter{Expression: expr},+ Limit: 20,+ }, vars)+ }++ // scalar variable -> literal in HAVING+ stmt, err := build("trace.output_tokens > $threshold",+ map[string]qbtypes.VariableItem{"threshold": {Value: 700}})+ require.NoError(t, err)+ assert.Contains(t, stmt.Query, "HAVING output_tokens > 700")++ // list variable with IN+ stmt, err = build("trace.llm_call_count IN $counts",+ map[string]qbtypes.VariableItem{"counts": {Value: []any{1, 2}}})+ require.NoError(t, err)+ assert.Contains(t, stmt.Query, "HAVING llm_call_count IN")++ // dynamic __all__ -> condition dropped, no HAVING at all+ stmt, err = build("trace.output_tokens > $threshold",+ map[string]qbtypes.VariableItem{"threshold": {Type: qbtypes.DynamicVariableType, Value: "__all__"}})+ require.NoError(t, err)+ assert.NotContains(t, stmt.Query, "HAVING")++ // unresolved variable -> rejected, not compared as a literal+ _, err = build("trace.output_tokens > $missing", map[string]qbtypes.VariableItem{"other": {Value: 1}})+ require.Error(t, err)+}diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/aggregate.go b/pkg/statementbuilder/scopedtracesstatementbuilder/aggregate.gonew file mode 100644index 0000000000..819016b5ee--- /dev/null+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/aggregate.go@@ -0,0 +1,199 @@+package scopedtracesstatementbuilder++import (+ "context"+ "fmt"+ "strings"++ "github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"+ qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/SigNoz/signoz/pkg/valuer"+)++// Aggregate renders one column's SQL through the resolvers 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, cols *columnResolver, preds *predicateResolver) (expr string, err error)+}++// IntrinsicSpanKey references an intrinsic span-index field (timestamp, name, …).+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, *columnResolver, *predicateResolver) (string, error) {+ return "count()", 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, cols *columnResolver, _ *predicateResolver) (string, error) {+ f, err := cols.FieldFor(ctx, orgID, startNs, endNs, key)+ if err != nil {+ return "", err+ }+ return fmt.Sprintf("%s(%s)", fn, f), 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, cols *columnResolver, _ *predicateResolver) (string, error) {+ ts, err := cols.FieldFor(ctx, orgID, startNs, endNs, tsKey)+ if err != nil {+ return "", err+ }+ dur, err := cols.FieldFor(ctx, orgID, startNs, endNs, durationKey)+ if err != nil {+ return "", err+ }+ tsNano := tracestelemetryschema.UnixNanoExpr(ts)+ return fmt.Sprintf("(max(%s + %s) - min(%s))", tsNano, dur, tsNano), 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, cols *columnResolver, preds *predicateResolver) (string, error) {+ v, err := cols.FieldFor(ctx, orgID, startNs, endNs, valueKey)+ if err != nil {+ return "", err+ }+ cond, err := preds.ConditionFor(ctx, orgID, startNs, endNs, condKey, op, condValue)+ return fmt.Sprintf("anyIf(%s, %s)", v, cond), err+ }}+}++// AnyValue renders any(<value>) over a metadata-resolved attribute value.+func AnyValue(key *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) Aggregate {+ return Aggregate{keys: []*telemetrytypes.TelemetryFieldKey{key}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, cols *columnResolver, _ *predicateResolver) (string, error) {+ v, err := cols.ValueFor(ctx, orgID, startNs, endNs, key, dt)+ return fmt.Sprintf("any(%s)", v), err+ }}+}++// CountExists renders countIf(<key> EXISTS) — counts spans carrying key.+func CountExists(key *telemetrytypes.TelemetryFieldKey) Aggregate {+ return Aggregate{keys: []*telemetrytypes.TelemetryFieldKey{key}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, _ *columnResolver, preds *predicateResolver) (string, error) {+ cond, err := preds.ExistsFor(ctx, orgID, startNs, endNs, key)+ return fmt.Sprintf("countIf(%s)", cond), 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, _ *columnResolver, preds *predicateResolver) (string, error) {+ cond, err := preds.ConditionFor(ctx, orgID, startNs, endNs, key, op, value)+ return fmt.Sprintf("countIf(%s)", cond), err+ }}+}++// Reduce renders <fn>(<value>) over a resolved numeric attribute value.+func Reduce(fn AggFunc, valueKey *telemetrytypes.TelemetryFieldKey) Aggregate {+ return Aggregate{keys: []*telemetrytypes.TelemetryFieldKey{valueKey}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, cols *columnResolver, _ *predicateResolver) (string, error) {+ v, err := cols.ValueFor(ctx, orgID, startNs, endNs, valueKey, telemetrytypes.FieldDataTypeFloat64)+ return fmt.Sprintf("%s(%s)", fn, v), 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, cols *columnResolver, preds *predicateResolver) (string, error) {+ f, err := cols.FieldFor(ctx, orgID, startNs, endNs, key)+ if err != nil {+ return "", err+ }+ return fmt.Sprintf("%sIf(%s, %s)", fn, f, preds.maskExpr), 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: []*telemetrytypes.TelemetryFieldKey{scopeKey}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, cols *columnResolver, preds *predicateResolver) (string, error) {+ col, err := cols.FieldFor(ctx, orgID, startNs, endNs, columnKey)+ if err != nil {+ return "", err+ }+ cond, err := preds.ExistsFor(ctx, orgID, startNs, endNs, scopeKey)+ return fmt.Sprintf("%sIf(%s, %s)", fn, col, cond), 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: []*telemetrytypes.TelemetryFieldKey{valueKey}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, cols *columnResolver, preds *predicateResolver) (string, error) {+ v, err := cols.ValueFor(ctx, orgID, startNs, endNs, valueKey, dt)+ if err != nil {+ return "", err+ }+ order, err := cols.FieldFor(ctx, orgID, startNs, endNs, orderKey)+ if err != nil {+ return "", err+ }+ cond, err := preds.ExistsFor(ctx, orgID, startNs, endNs, valueKey)+ return fmt.Sprintf("%s(%s, %s, %s)", fn, v, order, cond), err+ }}+}++// UniqCount renders uniqIf(<value>, <value> EXISTS) — distinct count of an attribute.+func UniqCount(valueKey *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) Aggregate {+ return Aggregate{keys: []*telemetrytypes.TelemetryFieldKey{valueKey}, render: func(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, cols *columnResolver, preds *predicateResolver) (string, error) {+ v, err := cols.ValueFor(ctx, orgID, startNs, endNs, valueKey, dt)+ if err != nil {+ return "", err+ }+ cond, err := preds.ExistsFor(ctx, orgID, startNs, endNs, valueKey)+ return fmt.Sprintf("uniqIf(%s, %s)", v, cond), err+ }}+}++// SumOfKeys renders coalesce(sum(<v1>), 0) + coalesce(sum(<v2>), 0) + …; coalesced+// because a key absent from every span sums to NULL and NULL + n = 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, cols *columnResolver, _ *predicateResolver) (string, error) {+ parts := make([]string, 0, len(valueKeys))+ for _, k := range valueKeys {+ v, err := cols.ValueFor(ctx, orgID, startNs, endNs, k, dt)+ if err != nil {+ return "", err+ }+ parts = append(parts, fmt.Sprintf("coalesce(sum(%s), 0)", v))+ }+ return strings.Join(parts, " + "), nil+ }}+}diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/column_resolver.go b/pkg/statementbuilder/scopedtracesstatementbuilder/column_resolver.gonew file mode 100644index 0000000000..9742d856ad--- /dev/null+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/column_resolver.go@@ -0,0 +1,41 @@+package scopedtracesstatementbuilder++import (+ "context"++ 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"+)++// columnResolver resolves keys to bare column/value expressions through the shared+// field mapper. It binds no args, so its expressions embed in any builder; predicates+// (which do bind args) are the predicateResolver's job.+type columnResolver struct {+ fm qbtypes.FieldMapper+ keys map[string][]*telemetrytypes.TelemetryFieldKey+}++func newColumnResolver(fm qbtypes.FieldMapper, keys map[string][]*telemetrytypes.TelemetryFieldKey) *columnResolver {+ return &columnResolver{fm: fm, keys: keys}+}++func (r *columnResolver) FieldFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {+ return r.fm.FieldFor(ctx, orgID, startNs, endNs, key)+}++// ValueFor returns the value expression for an attribute key.+func (r *columnResolver) ValueFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey, dt telemetrytypes.FieldDataType) (string, error) {+ // TODO(nitya): Fix this as this is not correct way+ 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 "", err+ }+ // a materialized column name carries `$$`, which Build would otherwise unescape+ // to a single `$` and reference the wrong column+ return sqlbuilder.Escape(expr), nil+}diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/predicate_resolver.go b/pkg/statementbuilder/scopedtracesstatementbuilder/predicate_resolver.gonew file mode 100644index 0000000000..7b33ee19fc--- /dev/null+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/predicate_resolver.go@@ -0,0 +1,47 @@+package scopedtracesstatementbuilder++import (+ "context"++ 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"+)++// predicateResolver resolves key + operator + value to boolean predicates through the+// shared condition builder. Args bind into sb as $n markers, so returned predicates+// can be embedded anywhere in sb; maskExpr is set by the builder after resolveMask+// (Scoped* aggregates embed it).+type predicateResolver struct {+ cb qbtypes.ConditionBuilder+ keys map[string][]*telemetrytypes.TelemetryFieldKey+ sb *sqlbuilder.SelectBuilder+ maskExpr string+}++func newPredicateResolver(cb qbtypes.ConditionBuilder, keys map[string][]*telemetrytypes.TelemetryFieldKey, sb *sqlbuilder.SelectBuilder) *predicateResolver {+ return &predicateResolver{cb: cb, keys: keys, sb: sb}+}++// ConditionFor returns a boolean predicate for key via the condition builder+// (materialized column when present, else map access), args bound into sb.+func (r *predicateResolver) ConditionFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) (string, error) {+ conds, _, err := r.cb.ConditionFor(ctx, orgID, startNs, endNs, key, r.keys, qbtypes.ConditionBuilderOptions{}, op, value, r.sb)+ if err != nil {+ return "", err+ }+ if len(conds) == 0 {+ return "", nil+ }+ // one condition per data-type variant of the key; OR them all+ if len(conds) == 1 {+ return conds[0], nil+ }+ return r.sb.Or(conds...), nil+}++// ExistsFor returns the EXISTS predicate for key.+func (r *predicateResolver) ExistsFor(ctx context.Context, orgID valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {+ return r.ConditionFor(ctx, orgID, startNs, endNs, key, qbtypes.FilterOperatorExists, nil)+}diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/scope.go b/pkg/statementbuilder/scopedtracesstatementbuilder/scope.gonew file mode 100644index 0000000000..a799720543--- /dev/null+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/scope.go@@ -0,0 +1,58 @@+package scopedtracesstatementbuilder++import (+ qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+)++// TraceScope configures the scoped trace builder: which spans are in scope and which+// per-trace columns the list computes.+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.+ FieldKeys []*telemetrytypes.TelemetryFieldKey+ 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 are display-only and set false.+ Orderable bool+ // SpanLevel columns surface a real span/resource attribute; 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": an alias would shadow the intrinsic span field+ {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)},+ }+}diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go b/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.gonew file mode 100644index 0000000000..7bcca2036d--- /dev/null+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go@@ -0,0 +1,668 @@+package scopedtracesstatementbuilder++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/statementbuilder"+ "github.com/SigNoz/signoz/pkg/statementbuilder/resourcefilter"+ "github.com/SigNoz/signoz/pkg/statementbuilder/tracesstatementbuilder"+ "github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"+ "github.com/SigNoz/signoz/pkg/telemetrystore"+ 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 TraceScope decides which spans are in scope and which+// per-trace columns to compute.+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)++// NewFactory returns a provider factory for a scoped trace statement builder. The+// package is domain-neutral: the caller supplies the factory name and the TraceScope+// (see aistatementbuilder for the gen_ai scope).+func NewFactory(+ name factory.Name,+ scope TraceScope,+ telemetryStore telemetrystore.TelemetryStore,+ metadataStore telemetrytypes.MetadataStore,+ fl flagger.Flagger,+) factory.ProviderFactory[qbtypes.StatementBuilder[qbtypes.TraceAggregation], statementbuilder.Config] {+ return factory.NewProviderFactory(+ name,+ func(ctx context.Context, settings factory.ProviderSettings, cfg statementbuilder.Config) (qbtypes.StatementBuilder[qbtypes.TraceAggregation], error) {+ traceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)+ if err != nil {+ return nil, err+ }+ fm := tracestelemetryschema.NewFieldMapper()+ cb := tracestelemetryschema.NewConditionBuilder(fm)+ return NewScopedTraceStatementBuilder(settings, metadataStore, fm, cb, scope, traceStmtBuilder, fl), nil+ },+ )+}++// NewScopedTraceStatementBuilder wires the generic trace-list builder;+// traceStmtBuilder is the delegate for the span-list path.+func NewScopedTraceStatementBuilder(+ settings factory.ProviderSettings,+ metadataStore telemetrytypes.MetadataStore,+ fieldMapper qbtypes.FieldMapper,+ conditionBuilder qbtypes.ConditionBuilder,+ scope TraceScope,+ traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],+ fl flagger.Flagger,+) qbtypes.StatementBuilder[qbtypes.TraceAggregation] {+ scopedSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/statementbuilder/scopedtracesstatementbuilder")++ resourceFilterStmtBuilder := resourcefilter.New[qbtypes.TraceAggregation](+ settings,+ tracestelemetryschema.DBName,+ tracestelemetryschema.TracesResourceV3TableName,+ telemetrytypes.SignalTraces,+ telemetrytypes.SourceUnspecified,+ metadataStore,+ nil,+ fl,+ )++ return &scopedTraceStatementBuilder{+ logger: scopedSettings.Logger(),+ metadataStore: metadataStore,+ fm: fieldMapper,+ cb: conditionBuilder,+ 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 (start/end are nanoseconds):+// matched (windowed, mask-pruned top-N trace_ids) → ranked (their [start,end] from+// the summary table) → buckets (ts_bucket_start prune) → enrichment (every per-trace+// column over each trace's full extent). Only Orderable columns are computable in the+// matched pass, so only they can be ordered or filtered on.+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+ }++ // Condition args bind into the builder an expression is embedded in, so the+ // matched and enrichment passes each resolve against their own builder.+ keys, err := b.fetchKeys(ctx, orgID)+ if err != nil {+ return nil, err+ }+ matchedSB := sqlbuilder.NewSelectBuilder()+ maskExpr, resolved, err := b.resolveFor(ctx, orgID, start, end, keys, matchedSB)+ if err != nil {+ return nil, err+ }+ enrichSB := sqlbuilder.NewSelectBuilder()+ _, enrichResolved, err := b.resolveFor(ctx, orgID, start, end, keys, enrichSB)+ if err != nil {+ return nil, err+ }+ orders, err := b.resolveListOrders(query.Order, resolved)+ if err != nil {+ return nil, err+ }+ orderableSet := orderableAliasSet(resolved)++ resourceFrag, resourceArgs, resourcePred, err := b.maybeAttachResourceFilter(ctx, orgID, query, start, end, variables)+ if err != nil {+ return nil, err+ }++ fp, err := b.splitFilter(ctx, orgID, query, b.aggregateAliasSet(), orderableSet, start, end, variables, matchedSB)+ if err != nil {+ return nil, err+ }++ matchedFrag, matchedArgs, err := b.buildMatchedCTE(matchedSB, start, end, startBucket, endBucket, resolved, orders, orderableSet, maskExpr, fp, resourcePred, limit, query.Offset)+ if err != nil {+ return nil, err+ }+ rankedFrag, rankedArgs := b.buildRankedCTE(start, end)++ adj := querybuilder.BucketAdjustment // 30-min bucket width in seconds+ bucketsFrag := 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)++ mainSQL, mainArgs := b.buildEnrichmentSelect(enrichSB, enrichResolved, 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 and the fingerprint+// predicate narrowing the span scan; empty fragments when the filter has no resource+// conditions. Deliberately no skip-fingerprint fallback: falling back would leave the+// resource conditions in the OR'd span-filter bucket and change trace membership.+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+}++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+}++// resolveFor renders the gate mask and every scope column with condition args bound+// into sb.+func (b *scopedTraceStatementBuilder) resolveFor(ctx context.Context, orgID valuer.UUID, start, end uint64, keys map[string][]*telemetrytypes.TelemetryFieldKey, sb *sqlbuilder.SelectBuilder) (string, []resolvedColumn, error) {+ cols := newColumnResolver(b.fm, keys)+ preds := newPredicateResolver(b.cb, keys, sb)+ maskExpr, err := b.resolveMask(ctx, orgID, start, end, preds)+ if err != nil {+ return "", nil, err+ }+ preds.maskExpr = maskExpr+ resolved, err := b.resolveColumns(ctx, orgID, start, end, cols, preds)+ if err != nil {+ return "", nil, err+ }+ return maskExpr, resolved, nil+}++// resolveMask builds the per-span in-scope mask: OR of the gate keys' EXISTS predicates.+func (b *scopedTraceStatementBuilder) resolveMask(ctx context.Context, orgID valuer.UUID, start, end uint64, preds *predicateResolver) (string, error) {+ fieldKeys := b.scope.FieldKeys+ parts := make([]string, 0, len(fieldKeys))+ for _, key := range fieldKeys {+ e, err := preds.ExistsFor(ctx, orgID, start, end, key)+ if err != nil {+ return "", err+ }+ parts = append(parts, e)+ }+ return "(" + strings.Join(parts, " OR ") + ")", nil+}++type resolvedColumn struct {+ alias string+ expr string+ orderable bool+}++func (b *scopedTraceStatementBuilder) resolveColumns(ctx context.Context, orgID valuer.UUID, start, end uint64, cols *columnResolver, preds *predicateResolver) ([]resolvedColumn, error) {+ out := make([]resolvedColumn, 0, len(b.scope.Columns))+ for _, c := range b.scope.Columns {+ expr, err := c.Expr.render(ctx, orgID, start, end, cols, preds)+ if err != nil {+ return nil, err+ }+ out = append(out, resolvedColumn{alias: c.Alias, expr: expr, orderable: c.Orderable})+ }+ return out, nil+}++type listOrder struct {+ alias string+ direction string+}++// resolveListOrders maps order keys to resolved orderable columns; non-orderable+// columns are rejected.+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 and a trace-level+// HAVING expression.+type filterParts struct {+ spanPred string+ hasSpanFilter bool+ havingExpr string+ warnings []string+ warningsURL string+}++// splitFilter splits query.Filter into a span-level predicate (args bound into sb)+// and a trace-level HAVING (explicit query.Having ANDed on), 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, sb *sqlbuilder.SelectBuilder) (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, warnings, url, err := b.resolveSpanPredicate(ctx, orgID, start, end, spanExpr, variables, sb)+ if err != nil {+ return fp, err+ }+ // pred is empty when all span-level keys were resource attributes+ // already handled by __resource_filter+ if strings.TrimSpace(pred) != "" {+ fp.spanPred, fp.hasSpanFilter = pred, 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 HAVING is a plain text rewrite, so substitute variables here+ 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+// predicate, args bound into sb.+func (b *scopedTraceStatementBuilder) resolveSpanPredicate(ctx context.Context, orgID valuer.UUID, start, end uint64, expr string, variables map[string]qbtypes.VariableItem, sb *sqlbuilder.SelectBuilder) (string, []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, "", err+ }+ prepared, err := querybuilder.PrepareWhereClause(expr, querybuilder.FilterExprVisitorOpts{+ Context: ctx,+ OrgID: orgID,+ Logger: b.logger,+ FieldMapper: b.fm,+ ConditionBuilder: b.cb,+ FieldKeys: keys,+ Builder: sb,+ // resource conditions are handled by __resource_filter+ SkipResourceFilter: true,+ Variables: variables,+ StartNs: start,+ EndNs: end,+ })+ if err != nil {+ return "", nil, "", err+ }+ if prepared.IsEmpty() {+ return "", nil, "", nil+ }+ return prepared.Expr, prepared.Warnings, prepared.WarningsDocURL, nil+}++// buildMatchedCTE builds `matched`: one windowed GROUP BY trace_id scan fusing gate ++// span filter + HAVING + ORDER BY + LIMIT/OFFSET, selecting only the aliases ORDER BY+// / HAVING reference. Expressions carry $n markers bound to sb, so each can appear+// several times and every occurrence resolves to the same arg.+func (b *scopedTraceStatementBuilder) buildMatchedCTE(sb *sqlbuilder.SelectBuilder, start, end, startBucket, endBucket uint64, resolved []resolvedColumn, orders []listOrder, orderableSet map[string]struct{}, maskExpr string, fp filterParts, resourcePred string, limit, offset int) (string, []any, error) {+ needed := neededMatchedAliases(orders, fp.havingExpr, orderableSet)+ selects := []string{"trace_id"}+ for _, rc := range resolved {+ if _, ok := needed[rc.alias]; !ok {+ continue+ }+ selects = append(selects, rc.expr+" AS "+quoteAlias(rc.alias))+ }+ sb.Select(selects...)+ sb.From(fmt.Sprintf("%s.%s", tracestelemetryschema.DBName, tracestelemetryschema.SpanIndexV3TableName))++ // prune widened by the span filter so its spans survive for the countIf below+ prune := "(" + maskExpr+ if fp.hasSpanFilter {+ prune += " OR " + fp.spanPred+ }+ prune += ")"+ where := []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),+ prune,+ }+ if resourcePred != "" {+ where = append(where, resourcePred)+ }+ sb.Where(where...)+ sb.GroupBy("trace_id")++ // gate/span existence checks are only needed when the WHERE was widened;+ // otherwise the mask alone enforces the gate+ var having []string+ if fp.hasSpanFilter {+ having = append(having, "countIf("+maskExpr+") > 0")+ having = append(having, "countIf("+fp.spanPred+") > 0")+ }+ if strings.TrimSpace(fp.havingExpr) != "" {+ // the rewriter matches raw key text, so map the trace. form alongside the bare name+ columnMap := make(map[string]string, len(orderableSet)*2)+ for a := range orderableSet {+ columnMap[a] = quoteAlias(a)+ columnMap[telemetrytypes.FieldContextTrace.StringValue()+"."+a] = quoteAlias(a)+ }+ hv, err := querybuilder.NewHavingExpressionRewriter().Rewrite(fp.havingExpr, columnMap)+ if err != nil {+ return "", nil, err+ }+ if hv != "" {+ // escape user text so a literal $ isn't read as an arg marker; the countIf+ // entries hold live $n markers 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 from the+// 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(fmt.Sprintf("%s.%s", tracestelemetryschema.DBName, tracestelemetryschema.TraceSummaryTableName))+ 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+}++// 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 while this+// pass ORDER BYs full-trace values, so a trace can sort differently than it ranked;+// page membership is unaffected (LIMIT/OFFSET runs only in matched).+func (b *scopedTraceStatementBuilder) buildEnrichmentSelect(sb *sqlbuilder.SelectBuilder, resolved []resolvedColumn, orders []listOrder) (string, []any) {+ selects := []string{"trace_id"}+ for _, rc := range resolved {+ selects = append(selects, rc.expr+" AS "+quoteAlias(rc.alias))+ }+ sb.Select(selects...)+ sb.From(fmt.Sprintf("%s.%s", tracestelemetryschema.DBName, tracestelemetryschema.SpanIndexV3TableName))+ 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)...)+ return sb.BuildWithFlavor(sqlbuilder.ClickHouse)+}++// aggregateAliasSet is every trace-level column alias, used to classify filter keys;+// 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.+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.+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 references;+// only 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.+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+}++// 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")+}++// quoteAlias backticks an alias containing characters special to the SQL builder.+func quoteAlias(alias string) string {+ if strings.ContainsAny(alias, ".$`") {+ return "`" + alias + "`"+ }+ return alias+}diff --git a/pkg/telemetrymetadata/metadata.go b/pkg/telemetrymetadata/metadata.goindex 68db7b0b40..c96f791d35 100644--- a/pkg/telemetrymetadata/metadata.go+++ b/pkg/telemetrymetadata/metadata.go@@ -1168,6 +1168,27 @@ func enrichWithIntrinsicMetricKeys(keys map[string][]*telemetrytypes.TelemetryFireturn 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@@ -1253,6 +1274,9 @@ func (t *telemetryMetaStore) GetKeys(ctx context.Context, orgID valuer.UUID, fieapplyBackwardCompatibleKeys(mapOfKeys)mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, selectors)+ if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {+ mapOfKeys = enrichWithGenAIKeys(mapOfKeys, selectors)+ }return mapOfKeys, complete, nil}@@ -1331,6 +1355,9 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, orgID valuer.UUIDapplyBackwardCompatibleKeys(mapOfKeys)mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, fieldKeySelectors)+ if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {+ mapOfKeys = enrichWithGenAIKeys(mapOfKeys, fieldKeySelectors)+ }return mapOfKeys, complete, nil}diff --git a/pkg/telemetryschema/tracestelemetryschema/trace_time_range.go b/pkg/telemetryschema/tracestelemetryschema/trace_time_range.goindex c21cc0ff4e..e196d12203 100644--- a/pkg/telemetryschema/tracestelemetryschema/trace_time_range.go+++ b/pkg/telemetryschema/tracestelemetryschema/trace_time_range.go@@ -51,11 +51,11 @@ func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, tracequery := fmt.Sprintf(`SELECTcount(),- toUnixTimestamp64Nano(min(start)),- toUnixTimestamp64Nano(max(end))+ %s,+ %sFROM %s.%sWHERE trace_id IN (%s)- `, DBName, TraceSummaryTableName, strings.Join(placeholders, ", "))+ `, UnixNanoExpr("min(start)"), UnixNanoExpr("max(end)"), DBName, TraceSummaryTableName, strings.Join(placeholders, ", "))row := f.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...)@@ -76,3 +76,9 @@ func (f *TraceTimeRangeFinder) GetTraceTimeRangeMulti(ctx context.Context, tracereturn startNano, endNano, true, nil}++// UnixNanoExpr renders the conversion of a timestamp-typed column expression+// (DateTime64(9)) to Unix epoch nanoseconds.+func UnixNanoExpr(expr string) string {+ return fmt.Sprintf("toUnixTimestamp64Nano(%s)", expr)+}diff --git a/pkg/types/llmpricingruletypes/pricing.go b/pkg/types/llmpricingruletypes/pricing.goindex 951ae5a9c3..9d2dee95c6 100644--- a/pkg/types/llmpricingruletypes/pricing.go+++ b/pkg/types/llmpricingruletypes/pricing.go@@ -16,18 +16,10 @@ 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 (diff --git a/pkg/types/llmpricingruletypes/processorconfig.go b/pkg/types/llmpricingruletypes/processorconfig.goindex 0278b537ed..e3c716b054 100644--- a/pkg/types/llmpricingruletypes/processorconfig.go+++ b/pkg/types/llmpricingruletypes/processorconfig.go@@ -4,6 +4,7 @@ import ("bytes""github.com/SigNoz/signoz/pkg/errors"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes""gopkg.in/yaml.v3")@@ -83,11 +84,11 @@ func buildProcessorConfig(rules []*LLMPricingRule) *LLMPricingRuleProcessorConfireturn &LLMPricingRuleProcessorConfig{Attrs: LLMPricingRuleProcessorAttrs{- Model: GenAIRequestModel,- In: GenAIUsageInputTokens,- Out: GenAIUsageOutputTokens,- CacheRead: GenAIUsageCacheReadInputTokens,- CacheWrite: GenAIUsageCacheCreationInputTokens,+ Model: telemetrytypes.GenAIRequestModel,+ In: telemetrytypes.GenAIUsageInputTokens,+ Out: telemetrytypes.GenAIUsageOutputTokens,+ CacheRead: telemetrytypes.GenAIUsageCacheReadInputTokens,+ CacheWrite: telemetrytypes.GenAIUsageCacheCreationInputTokens,},DefaultPricing: LLMPricingRuleProcessorDefaultPricing{Rules: pricingRules,@@ -97,7 +98,7 @@ func buildProcessorConfig(rules []*LLMPricingRule) *LLMPricingRuleProcessorConfiOut: SignozGenAICostOutput,CacheRead: SignozGenAICostCacheRead,CacheWrite: SignozGenAICostCacheWrite,- Total: SignozGenAITotalCost,+ Total: telemetrytypes.SignozGenAITotalCost,},}}diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/query_type.go b/pkg/types/querybuildertypes/querybuildertypesv5/query_type.goindex f2d8d4d3d4..b0159e5b78 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/query_type.go+++ b/pkg/types/querybuildertypes/querybuildertypesv5/query_type.go@@ -9,6 +9,7 @@ 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")}@@ -21,6 +22,7 @@ var (func (QueryType) Enum() []any {return []any{QueryTypeBuilder,+ QueryTypeBuilderAI,QueryTypeFormula,// Not yet supported.// QueryTypeSubQuery,diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/req.go b/pkg/types/querybuildertypes/querybuildertypesv5/req.goindex 6b7f916a8d..6acc311b96 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/req.go+++ b/pkg/types/querybuildertypes/querybuildertypesv5/req.go@@ -62,6 +62,13 @@ 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."`@@ -100,6 +107,7 @@ var _ jsonschema.OneOfExposer = QueryEnvelope{}func (QueryEnvelope) JSONSchemaOneOf() []any {return []any{queryEnvelopeBuilder{},+ queryEnvelopeBuilderAI{},queryEnvelopeFormula{},// queryEnvelopeJoin{}, // deferred — see commented queryEnvelopeJoin abovequeryEnvelopeTraceOperator{},@@ -120,6 +128,7 @@ 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",@@ -150,6 +159,15 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {}q.Spec = spec+ case QueryTypeBuilderAI:+ // the signal is implied by the type, so pin 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 QueryBuilderFormulaif err := json.Unmarshal(shadow.Spec, &spec); err != nil {@@ -194,7 +212,7 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {"unknown query type %q",shadow.Type,).WithAdditional(- "Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, builder_trace_operator, promql, clickhouse_sql",+ "Valid query types are: builder_query, builder_ai_query, builder_sub_query, builder_formula, builder_join, builder_trace_operator, promql, clickhouse_sql",).WithSuggestions(errors.NewValidReferences(errors.NounQueryTypes, QueryType{}.Enum()...))}diff --git a/pkg/types/querybuildertypes/querybuildertypesv5/validation.go b/pkg/types/querybuildertypes/querybuildertypesv5/validation.goindex 0664a35a17..55ee7e4864 100644--- a/pkg/types/querybuildertypes/querybuildertypesv5/validation.go+++ b/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 {+ if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery || envelope.Type == QueryTypeBuilderAI {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 {+ if envelope.Type == QueryTypeBuilder || envelope.Type == QueryTypeSubQuery || envelope.Type == QueryTypeBuilderAI {name := envelope.GetQueryName()if name != "" {if queryNames[name] {@@ -744,6 +744,15 @@ 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 {@@ -813,7 +822,7 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err"unknown query type: %s",envelope.Type,).WithAdditional(- "Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, promql, clickhouse_sql, trace_operator",+ "Valid query types are: builder_query, builder_ai_query, builder_sub_query, builder_formula, builder_join, promql, clickhouse_sql, trace_operator",).WithSuggestions(errors.NewValidReferences(errors.NounQueryTypes, QueryType{}.Enum()...))}}diff --git a/pkg/types/telemetrytypes/field_context.go b/pkg/types/telemetrytypes/field_context.goindex 2bdfe2fbf5..8b8ab4380d 100644--- a/pkg/types/telemetrytypes/field_context.go+++ b/pkg/types/telemetrytypes/field_context.go@@ -76,6 +76,7 @@ var ("log": FieldContextLog,"metric": FieldContextMetric,"tracefield": FieldContextTrace,+ "trace": FieldContextTrace,})diff --git a/pkg/types/telemetrytypes/genai_semconv.go b/pkg/types/telemetrytypes/genai_semconv.gonew file mode 100644index 0000000000..340f42bdaa--- /dev/null+++ b/pkg/types/telemetrytypes/genai_semconv.go@@ -0,0 +1,41 @@+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 cost the SigNoz+ // LLM pricing processor attaches.+ SignozGenAITotalCost = "_signoz.gen_ai.total_cost"+)++// GenAIFieldDefinitions are the gen_ai span attributes the AI query builder relies+// on, surfaced by the metadata store even before ingestion so the AI gate/columns+// resolve on a fresh install.+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},+}diff --git a/pkg/types/telemetrytypes/selector.go b/pkg/types/telemetrytypes/selector.goindex da5b0641cd..108f6e3ee5 100644--- a/pkg/types/telemetrytypes/selector.go+++ b/pkg/types/telemetrytypes/selector.go@@ -10,6 +10,7 @@ const wildcardSelector = "*"var telemetryGrantQueryTypes = map[string]bool{"builder_query": true,+ "builder_ai_query": true,"builder_sub_query": true,"promql": false,"clickhouse_sql": false,diff --git a/tests/fixtures/querier.py b/tests/fixtures/querier.pyindex bc654b1198..b709a82ae0 100644--- a/tests/fixtures/querier.py+++ b/tests/fixtures/querier.py@@ -78,12 +78,15 @@ class BuilderQuery:signal: strname: str = "A"source: str | None = None+ query_type: str = "builder_query"limit: int | None = Noneoffset: int | None = Nonefilter_expression: str | None = None+ having_expression: str | None = Noneselect_fields: list[TelemetryFieldKey] | None = Noneorder: list[OrderBy] | None = Noneaggregations: list[Aggregation | MetricAggregation] | None = None+ group_by: list[TelemetryFieldKey] | None = Nonestep_interval: int | None = Nonedef to_dict(self) -> dict:@@ -99,16 +102,20 @@ class BuilderQuery:spec["offset"] = self.offsetif 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": "builder_query", "spec": spec}+ return {"type": self.query_type, "spec": spec}@dataclassdiff --git a/tests/fixtures/querierai.py b/tests/fixtures/querierai.pynew file mode 100644index 0000000000..4562d105aa--- /dev/null+++ b/tests/fixtures/querierai.py@@ -0,0 +1,123 @@+"""+Trace builders for the querierai suite. Every builder pins its spans a few seconds+before the given `now` so `query_window(now)` covers them.+"""++from datetime import datetime, timedelta++from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode+++def query_window(now: datetime) -> tuple[int, int]:+ """[now-10min, now+1min) in epoch millis — wide enough for every builder here."""+ return (+ int((now - timedelta(minutes=10)).timestamp() * 1000),+ int((now + timedelta(minutes=1)).timestamp() * 1000),+ )+++def root_span(*, now: datetime, trace_id: str, span_id: str, resources: dict[str, str], duration_s: float) -> Traces:+ """The non-gen_ai entry span every AI trace hangs off; alone, it is a trace the+ AI gate must exclude."""+ return Traces(+ timestamp=now - timedelta(seconds=5),+ duration=timedelta(seconds=duration_s),+ trace_id=trace_id,+ span_id=span_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"},+ )+++def ai_trace(+ *,+ now: datetime,+ service: str,+ user: str,+ in_tokens: int | None,+ out_tokens: int,+ cost: float,+ model: str = "gpt-4o-mini",+ 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()+ resources = {"service.name": service, "deployment.environment": environment}++ 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=1),+ trace_id=trace_id,+ span_id=TraceIdGenerator.span_id(),+ parent_span_id=root_id,+ name="chat gpt-4o-mini",+ kind=TracesKind.SPAN_KIND_CLIENT,+ status_code=TracesStatusCode.STATUS_CODE_OK,+ resources=resources,+ attributes=attributes,+ )+ return [+ root_span(now=now, trace_id=trace_id, span_id=root_id, resources=resources, duration_s=1.1),+ llm,+ ]+++def ai_trace_mixed_spans(*, now: datetime, service: str, user: str) -> list[Traces]:+ """Root + LLM + tool + agent spans; 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 child(name: str, kind: TracesKind, attributes: dict, offset_s: float) -> Traces:+ 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,+ )++ return [+ root_span(now=now, trace_id=trace_id, span_id=root_id, resources=resources, duration_s=4),+ child(+ "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,+ ),+ child(+ "execute_tool",+ TracesKind.SPAN_KIND_INTERNAL,+ {"gen_ai.tool.name": "get_weather", "gen_ai.tool.type": "function"},+ 3,+ ),+ child("agent.step", TracesKind.SPAN_KIND_INTERNAL, {"gen_ai.agent.name": "chat-agent"}, 2),+ ]diff --git a/tests/integration/tests/querierai/01_ai_traces.py b/tests/integration/tests/querierai/01_ai_traces.pynew file mode 100644index 0000000000..1d9938dce8--- /dev/null+++ b/tests/integration/tests/querierai/01_ai_traces.py@@ -0,0 +1,632 @@+"""+Integration tests for query_type="builder_ai_query" over the traces signal.++Each test tags its spans with a unique service.name and filters on it, so tests do+not interfere with each other's data. Shared builders live in fixtures/querierai.py.+"""++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.querierai import (+ ai_trace,+ ai_trace_mixed_spans,+ query_window,+ root_span,+)+from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode+++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 returns AI traces and excludes the non-AI trace."""+ 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)+ # a lone root span, i.e. a trace with no gen_ai spans at all+ non_ai = root_span(+ now=now,+ trace_id=TraceIdGenerator.trace_id(),+ span_id=TraceIdGenerator.span_id(),+ resources={"service.name": service},+ duration_s=1,+ )+ ai_trace_id = ai[0].trace_id+ insert_traces([*ai, non_ai])++ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)+ start_ms, end_ms = query_window(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 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:+ """Span + aggregate condition in one filter box splits into WHERE + HAVING; bare+ and `trace.` spellings behave identically; an output-only aggregate is rejected."""+ 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 = query_window(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 = query_window(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 = query_window(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 (raw) returns only gen_ai spans; the root span is excluded by the 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 = query_window(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 in the filter box (regression guard for+ OR-group whitespace handling)."""+ 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 = query_window(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 routes into the fingerprint CTE: the+ production trace is kept, the staging one dropped."""+ 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 = query_window(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 columns may not be OR-ed with span-level keys; span OR span 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 = query_window(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:+ """service.name = X AND (has_error = true OR gen_ai.request.model = 'gpt-4o') AND+ total_tokens > 100: the nested OR group must not flatten, span predicates go to+ WHERE, the aggregate to HAVING."""+ 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 = query_window(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 = query_window(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 = query_window(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 with only output tokens must still total: sum over an absent attribute+ is NULL and NULL + n = NULL, hence the coalesce."""+ 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 = query_window(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 = query_window(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 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, `output` the last LLM span's answer."""+ now = datetime.now(tz=UTC).replace(second=0, microsecond=0)+ service = "ai-it-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,+ },+ )++ # earlier call is the "first" (its input is the prompt), later call is the "last"+ # (its output is the final answer).+ insert_traces(+ [+ root_span(now=now, trace_id=trace_id, span_id=root_id, resources=resources, duration_s=4),+ llm(4, "first prompt", "first answer"),+ llm(2, "second prompt", "second answer"),+ ]+ )++ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)+ start_ms, end_ms = query_window(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 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. One trace: root + 1 errored+ LLM + 3 tool spans (get_weather x2, get_time x1) + 1 agent span."""+ now = datetime.now(tz=UTC).replace(second=0, microsecond=0)+ service = "ai-it-metrics"+ 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"},+ )++ 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"},+ )+ insert_traces(+ [+ root_span(now=now, trace_id=trace_id, span_id=root_id, resources=resources, duration_s=4),+ llm,+ tool("get_weather", 3),+ tool("get_weather", 2.5),+ tool("get_time", 2),+ agent,+ ]+ )++ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)+ start_ms, end_ms = query_window(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