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[ai-011y]: fields API for ai query builder (#12140)
Nityananda Gohainedb63ae7beff
diff --git a/docs/api/openapi.yml b/docs/api/openapi.ymlindex a1524bb3d1..115c6a4a4a 100644--- a/docs/api/openapi.yml+++ b/docs/api/openapi.yml@@ -8805,6 +8805,7 @@ components:- metric- log- span+ - trace- resource- attribute- body@@ -9115,6 +9116,158 @@ info:version: ""openapi: 3.0.3paths:+ /api/v1/ai_observability/fields/keys:+ get:+ deprecated: false+ description: This endpoint returns the field keys the AI observability explorer+ can filter on, including the computed per-trace aggregates+ operationId: GetAIObservabilityFieldsKeys+ parameters:+ - in: query+ name: searchText+ schema:+ type: string+ - in: query+ name: fieldContext+ schema:+ $ref: '#/components/schemas/TelemetrytypesFieldContext'+ - in: query+ name: fieldDataType+ schema:+ $ref: '#/components/schemas/TelemetrytypesFieldDataType'+ - in: query+ name: startUnixMilli+ schema:+ format: int64+ type: integer+ - in: query+ name: endUnixMilli+ schema:+ format: int64+ type: integer+ - in: query+ name: limit+ schema:+ type: integer+ responses:+ "200":+ content:+ application/json:+ schema:+ properties:+ data:+ $ref: '#/components/schemas/TelemetrytypesGettableFieldKeys'+ status:+ type: string+ required:+ - status+ - data+ type: object+ description: OK+ "401":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Unauthorized+ "403":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Forbidden+ "500":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Internal Server Error+ security:+ - api_key:+ - VIEWER+ - tokenizer:+ - VIEWER+ summary: Get AI observability field keys+ tags:+ - ai_observability+ /api/v1/ai_observability/fields/values:+ get:+ deprecated: false+ description: This endpoint returns the values the AI observability explorer+ can filter a field key on+ operationId: GetAIObservabilityFieldsValues+ parameters:+ - in: query+ name: searchText+ schema:+ type: string+ - in: query+ name: fieldContext+ schema:+ $ref: '#/components/schemas/TelemetrytypesFieldContext'+ - in: query+ name: fieldDataType+ schema:+ $ref: '#/components/schemas/TelemetrytypesFieldDataType'+ - in: query+ name: startUnixMilli+ schema:+ format: int64+ type: integer+ - in: query+ name: endUnixMilli+ schema:+ format: int64+ type: integer+ - in: query+ name: limit+ schema:+ type: integer+ - in: query+ name: name+ schema:+ type: string+ responses:+ "200":+ content:+ application/json:+ schema:+ properties:+ data:+ $ref: '#/components/schemas/TelemetrytypesGettableFieldValues'+ status:+ type: string+ required:+ - status+ - data+ type: object+ description: OK+ "401":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Unauthorized+ "403":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Forbidden+ "500":+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/RenderErrorResponse'+ description: Internal Server Error+ security:+ - api_key:+ - VIEWER+ - tokenizer:+ - VIEWER+ summary: Get AI observability field values+ tags:+ - ai_observability/api/v1/alerts:get:deprecated: falsediff --git a/frontend/src/api/generated/services/ai-observability/index.ts b/frontend/src/api/generated/services/ai-observability/index.tsnew file mode 100644index 0000000000..cff330cd78--- /dev/null+++ b/frontend/src/api/generated/services/ai-observability/index.ts@@ -0,0 +1,236 @@+/**+ * ! Do not edit manually+ * * The file has been auto-generated using Orval for SigNoz+ * * regenerate with 'pnpm generate:api'+ * SigNoz+ */+import { useQuery } from 'react-query';+import type {+ InvalidateOptions,+ QueryClient,+ QueryFunction,+ QueryKey,+ UseQueryOptions,+ UseQueryResult,+} from 'react-query';++import type {+ GetAIObservabilityFieldsKeys200,+ GetAIObservabilityFieldsKeysParams,+ GetAIObservabilityFieldsValues200,+ GetAIObservabilityFieldsValuesParams,+ RenderErrorResponseDTO,+} from '../sigNoz.schemas';++import { GeneratedAPIInstance } from '../../../generatedAPIInstance';+import type { ErrorType } from '../../../generatedAPIInstance';++/**+ * This endpoint returns the field keys the AI observability explorer can filter on, including the computed per-trace aggregates+ * @summary Get AI observability field keys+ */+export const getAIObservabilityFieldsKeys = (+ params?: GetAIObservabilityFieldsKeysParams,+ signal?: AbortSignal,+) => {+ return GeneratedAPIInstance<GetAIObservabilityFieldsKeys200>({+ url: `/api/v1/ai_observability/fields/keys`,+ method: 'GET',+ params,+ signal,+ });+};++export const getGetAIObservabilityFieldsKeysQueryKey = (+ params?: GetAIObservabilityFieldsKeysParams,+) => {+ return [+ `/api/v1/ai_observability/fields/keys`,+ ...(params ? [params] : []),+ ] as const;+};++export const getGetAIObservabilityFieldsKeysQueryOptions = <+ TData = Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>,+ TError = ErrorType<RenderErrorResponseDTO>,+>(+ params?: GetAIObservabilityFieldsKeysParams,+ options?: {+ query?: UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>,+ TError,+ TData+ >;+ },+) => {+ const { query: queryOptions } = options ?? {};++ const queryKey =+ queryOptions?.queryKey ?? getGetAIObservabilityFieldsKeysQueryKey(params);++ const queryFn: QueryFunction<+ Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>+ > = ({ signal }) => getAIObservabilityFieldsKeys(params, signal);++ return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>,+ TError,+ TData+ > & { queryKey: QueryKey };+};++export type GetAIObservabilityFieldsKeysQueryResult = NonNullable<+ Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>+>;+export type GetAIObservabilityFieldsKeysQueryError =+ ErrorType<RenderErrorResponseDTO>;++/**+ * @summary Get AI observability field keys+ */++export function useGetAIObservabilityFieldsKeys<+ TData = Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>,+ TError = ErrorType<RenderErrorResponseDTO>,+>(+ params?: GetAIObservabilityFieldsKeysParams,+ options?: {+ query?: UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsKeys>>,+ TError,+ TData+ >;+ },+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {+ const queryOptions = getGetAIObservabilityFieldsKeysQueryOptions(+ params,+ options,+ );++ const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {+ queryKey: QueryKey;+ };++ return { ...query, queryKey: queryOptions.queryKey };+}++/**+ * @summary Get AI observability field keys+ */+export const invalidateGetAIObservabilityFieldsKeys = async (+ queryClient: QueryClient,+ params?: GetAIObservabilityFieldsKeysParams,+ options?: InvalidateOptions,+): Promise<QueryClient> => {+ await queryClient.invalidateQueries(+ { queryKey: getGetAIObservabilityFieldsKeysQueryKey(params) },+ options,+ );++ return queryClient;+};++/**+ * This endpoint returns the values the AI observability explorer can filter a field key on+ * @summary Get AI observability field values+ */+export const getAIObservabilityFieldsValues = (+ params?: GetAIObservabilityFieldsValuesParams,+ signal?: AbortSignal,+) => {+ return GeneratedAPIInstance<GetAIObservabilityFieldsValues200>({+ url: `/api/v1/ai_observability/fields/values`,+ method: 'GET',+ params,+ signal,+ });+};++export const getGetAIObservabilityFieldsValuesQueryKey = (+ params?: GetAIObservabilityFieldsValuesParams,+) => {+ return [+ `/api/v1/ai_observability/fields/values`,+ ...(params ? [params] : []),+ ] as const;+};++export const getGetAIObservabilityFieldsValuesQueryOptions = <+ TData = Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>,+ TError = ErrorType<RenderErrorResponseDTO>,+>(+ params?: GetAIObservabilityFieldsValuesParams,+ options?: {+ query?: UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>,+ TError,+ TData+ >;+ },+) => {+ const { query: queryOptions } = options ?? {};++ const queryKey =+ queryOptions?.queryKey ?? getGetAIObservabilityFieldsValuesQueryKey(params);++ const queryFn: QueryFunction<+ Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>+ > = ({ signal }) => getAIObservabilityFieldsValues(params, signal);++ return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>,+ TError,+ TData+ > & { queryKey: QueryKey };+};++export type GetAIObservabilityFieldsValuesQueryResult = NonNullable<+ Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>+>;+export type GetAIObservabilityFieldsValuesQueryError =+ ErrorType<RenderErrorResponseDTO>;++/**+ * @summary Get AI observability field values+ */++export function useGetAIObservabilityFieldsValues<+ TData = Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>,+ TError = ErrorType<RenderErrorResponseDTO>,+>(+ params?: GetAIObservabilityFieldsValuesParams,+ options?: {+ query?: UseQueryOptions<+ Awaited<ReturnType<typeof getAIObservabilityFieldsValues>>,+ TError,+ TData+ >;+ },+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {+ const queryOptions = getGetAIObservabilityFieldsValuesQueryOptions(+ params,+ options,+ );++ const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {+ queryKey: QueryKey;+ };++ return { ...query, queryKey: queryOptions.queryKey };+}++/**+ * @summary Get AI observability field values+ */+export const invalidateGetAIObservabilityFieldsValues = async (+ queryClient: QueryClient,+ params?: GetAIObservabilityFieldsValuesParams,+ options?: InvalidateOptions,+): Promise<QueryClient> => {+ await queryClient.invalidateQueries(+ { queryKey: getGetAIObservabilityFieldsValuesQueryKey(params) },+ options,+ );++ return queryClient;+};diff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.tsindex b77a0ffc6b..65ef281cb5 100644--- a/frontend/src/api/generated/services/sigNoz.schemas.ts+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts@@ -3490,6 +3490,7 @@ export enum TelemetrytypesFieldContextDTO {metric = 'metric',log = 'log',span = 'span',+ trace = 'trace',resource = 'resource',attribute = 'attribute',body = 'body',@@ -10175,6 +10176,93 @@ export interface ZeustypesPostableProfileDTO {where_did_you_discover_signoz: string;}+export type GetAIObservabilityFieldsKeysParams = {+ /**+ * @type string+ * @description undefined+ */+ searchText?: string;+ /**+ * @description undefined+ */+ fieldContext?: TelemetrytypesFieldContextDTO;+ /**+ * @description undefined+ */+ fieldDataType?: TelemetrytypesFieldDataTypeDTO;+ /**+ * @type integer+ * @format int64+ * @description undefined+ */+ startUnixMilli?: number;+ /**+ * @type integer+ * @format int64+ * @description undefined+ */+ endUnixMilli?: number;+ /**+ * @type integer+ * @description undefined+ */+ limit?: number;+};++export type GetAIObservabilityFieldsKeys200 = {+ data: TelemetrytypesGettableFieldKeysDTO;+ /**+ * @type string+ */+ status: string;+};++export type GetAIObservabilityFieldsValuesParams = {+ /**+ * @type string+ * @description undefined+ */+ searchText?: string;+ /**+ * @description undefined+ */+ fieldContext?: TelemetrytypesFieldContextDTO;+ /**+ * @description undefined+ */+ fieldDataType?: TelemetrytypesFieldDataTypeDTO;+ /**+ * @type integer+ * @format int64+ * @description undefined+ */+ startUnixMilli?: number;+ /**+ * @type integer+ * @format int64+ * @description undefined+ */+ endUnixMilli?: number;+ /**+ * @type integer+ * @description undefined+ */+ limit?: number;+ /**+ * @type string+ * @description undefined+ */+ name?: string;+};++export type GetAIObservabilityFieldsValues200 = {+ data: TelemetrytypesGettableFieldValuesDTO;+ /**+ * @type string+ */+ status: string;+};+export type GetAlerts200 = {/*** @type arraydiff --git a/frontend/src/container/AlertHistory/Timeline/Table/utils.ts b/frontend/src/container/AlertHistory/Timeline/Table/utils.tsindex 1ac9fd33a2..349a205df6 100644--- a/frontend/src/container/AlertHistory/Timeline/Table/utils.ts+++ b/frontend/src/container/AlertHistory/Timeline/Table/utils.ts@@ -9,6 +9,7 @@ const fieldContextToSuggestionMap: Record<[TelemetrytypesFieldContextDTO.span]: 'span',[TelemetrytypesFieldContextDTO.attribute]: 'attribute',// no maps for the following values on suggestion context+ [TelemetrytypesFieldContextDTO.trace]: undefined,[TelemetrytypesFieldContextDTO.body]: undefined,[TelemetrytypesFieldContextDTO.metric]: undefined,[TelemetrytypesFieldContextDTO.log]: undefined,diff --git a/pkg/apiserver/signozapiserver/aiobservability.go b/pkg/apiserver/signozapiserver/aiobservability.gonew file mode 100644index 0000000000..0bafc183ec--- /dev/null+++ b/pkg/apiserver/signozapiserver/aiobservability.go@@ -0,0 +1,51 @@+package signozapiserver++import (+ "net/http"++ "github.com/SigNoz/signoz/pkg/http/handler"+ "github.com/SigNoz/signoz/pkg/types"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/gorilla/mux"+)++func (provider *provider) addAIObservabilityRoutes(router *mux.Router) error {+ if err := router.Handle("/api/v1/ai_observability/fields/keys", handler.New(provider.authzMiddleware.ViewAccess(provider.aiObservabilityHandler.GetFieldsKeys), handler.OpenAPIDef{+ ID: "GetAIObservabilityFieldsKeys",+ Tags: []string{"ai_observability"},+ Summary: "Get AI observability field keys",+ Description: "This endpoint returns the field keys the AI observability explorer can filter on, including the computed per-trace aggregates",+ Request: nil,+ RequestQuery: new(aiobservabilitytypes.PostableFieldKeysParams),+ RequestContentType: "",+ Response: new(telemetrytypes.GettableFieldKeys),+ ResponseContentType: "application/json",+ SuccessStatusCode: http.StatusOK,+ ErrorStatusCodes: []int{},+ Deprecated: false,+ SecuritySchemes: newSecuritySchemes(types.RoleViewer),+ })).Methods(http.MethodGet).GetError(); err != nil {+ return err+ }++ if err := router.Handle("/api/v1/ai_observability/fields/values", handler.New(provider.authzMiddleware.ViewAccess(provider.aiObservabilityHandler.GetFieldsValues), handler.OpenAPIDef{+ ID: "GetAIObservabilityFieldsValues",+ Tags: []string{"ai_observability"},+ Summary: "Get AI observability field values",+ Description: "This endpoint returns the values the AI observability explorer can filter a field key on",+ Request: nil,+ RequestQuery: new(aiobservabilitytypes.PostableFieldValueParams),+ RequestContentType: "",+ Response: new(telemetrytypes.GettableFieldValues),+ ResponseContentType: "application/json",+ SuccessStatusCode: http.StatusOK,+ ErrorStatusCodes: []int{},+ Deprecated: false,+ SecuritySchemes: newSecuritySchemes(types.RoleViewer),+ })).Methods(http.MethodGet).GetError(); err != nil {+ return err+ }++ return nil+}diff --git a/pkg/apiserver/signozapiserver/provider.go b/pkg/apiserver/signozapiserver/provider.goindex dc3dbee0e7..4854bf0185 100644--- a/pkg/apiserver/signozapiserver/provider.go+++ b/pkg/apiserver/signozapiserver/provider.go@@ -12,6 +12,7 @@ import ("github.com/SigNoz/signoz/pkg/global""github.com/SigNoz/signoz/pkg/http/handler""github.com/SigNoz/signoz/pkg/http/middleware"+ "github.com/SigNoz/signoz/pkg/modules/aiobservability""github.com/SigNoz/signoz/pkg/modules/authdomain""github.com/SigNoz/signoz/pkg/modules/cloudintegration""github.com/SigNoz/signoz/pkg/modules/dashboard"@@ -61,6 +62,7 @@ type provider struct {infraMonitoringHandler inframonitoring.HandlergatewayHandler gateway.HandlerfieldsHandler fields.Handler+ aiObservabilityHandler aiobservability.HandlerauthzHandler authz.HandlerrawDataExportHandler rawdataexport.HandlerzeusHandler zeus.Handler@@ -97,6 +99,7 @@ func NewFactory(infraMonitoringHandler inframonitoring.Handler,gatewayHandler gateway.Handler,fieldsHandler fields.Handler,+ aiObservabilityHandler aiobservability.Handler,authzHandler authz.Handler,rawDataExportHandler rawdataexport.Handler,zeusHandler zeus.Handler,@@ -136,6 +139,7 @@ func NewFactory(infraMonitoringHandler,gatewayHandler,fieldsHandler,+ aiObservabilityHandler,authzHandler,rawDataExportHandler,zeusHandler,@@ -177,6 +181,7 @@ func newProvider(infraMonitoringHandler inframonitoring.Handler,gatewayHandler gateway.Handler,fieldsHandler fields.Handler,+ aiObservabilityHandler aiobservability.Handler,authzHandler authz.Handler,rawDataExportHandler rawdataexport.Handler,zeusHandler zeus.Handler,@@ -217,6 +222,7 @@ func newProvider(infraMonitoringHandler: infraMonitoringHandler,gatewayHandler: gatewayHandler,fieldsHandler: fieldsHandler,+ aiObservabilityHandler: aiObservabilityHandler,authzHandler: authzHandler,rawDataExportHandler: rawDataExportHandler,zeusHandler: zeusHandler,@@ -313,6 +319,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {return err}+ if err := provider.addAIObservabilityRoutes(router); err != nil {+ return err+ }+if err := provider.addRawDataExportRoutes(router); err != nil {return err}diff --git a/pkg/modules/aiobservability/handler.go b/pkg/modules/aiobservability/handler.gonew file mode 100644index 0000000000..40caddcc41--- /dev/null+++ b/pkg/modules/aiobservability/handler.go@@ -0,0 +1,11 @@+package aiobservability++import "net/http"++type Handler interface {+ // Gets the fields keys the AI observability explorer can filter on+ GetFieldsKeys(http.ResponseWriter, *http.Request)++ // Gets the values the AI observability explorer can filter a field key on+ GetFieldsValues(http.ResponseWriter, *http.Request)+}diff --git a/pkg/modules/aiobservability/implaiobservability/handler.go b/pkg/modules/aiobservability/implaiobservability/handler.gonew file mode 100644index 0000000000..e9d5a07902--- /dev/null+++ b/pkg/modules/aiobservability/implaiobservability/handler.go@@ -0,0 +1,105 @@+package implaiobservability++import (+ "context"+ "net/http"+ "time"++ "github.com/SigNoz/signoz/pkg/errors"+ "github.com/SigNoz/signoz/pkg/http/binding"+ "github.com/SigNoz/signoz/pkg/http/render"+ "github.com/SigNoz/signoz/pkg/modules/aiobservability"+ "github.com/SigNoz/signoz/pkg/telemetryschema/aitelemetryschema"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"+ "github.com/SigNoz/signoz/pkg/types/authtypes"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/SigNoz/signoz/pkg/valuer"+)++type handler struct {+ telemetryMetadataStore telemetrytypes.MetadataStore+}++func NewHandler(telemetryMetadataStore telemetrytypes.MetadataStore) aiobservability.Handler {+ return &handler{+ telemetryMetadataStore: telemetryMetadataStore,+ }+}++func (handler *handler) GetFieldsKeys(rw http.ResponseWriter, req *http.Request) {+ ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)+ defer cancel()++ var params aiobservabilitytypes.PostableFieldKeysParams+ if err := binding.Query.BindQuery(req.URL.Query(), ¶ms); err != nil {+ render.Error(rw, err)+ return+ }++ claims, err := authtypes.ClaimsFromContext(ctx)+ if err != nil {+ render.Error(rw, err)+ return+ }+ orgID := valuer.MustNewUUID(claims.OrgID)++ fieldKeySelector := aiobservabilitytypes.NewFieldKeySelectorFromPostableFieldKeysParams(params)++ keys := make(map[string][]*telemetrytypes.TelemetryFieldKey)+ complete := true+ // the trace context names the computed per-trace aggregates, which no scan can serve+ if fieldKeySelector.FieldContext != telemetrytypes.FieldContextTrace {+ keys, complete, err = handler.telemetryMetadataStore.GetKeys(ctx, orgID, fieldKeySelector)+ if err != nil {+ render.Error(rw, err)+ return+ }+ }++ render.Success(rw, http.StatusOK, &telemetrytypes.GettableFieldKeys{+ Keys: aitelemetryschema.FieldKeys(keys, fieldKeySelector),+ Complete: complete,+ })+}++func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Request) {+ ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)+ defer cancel()++ // binding ignores query params the struct does not declare, so an unsupported+ // existingQuery would silently return values it did not narrow+ if req.URL.Query().Has("existingQuery") {+ render.Error(rw, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "existingQuery is not supported"))+ return+ }++ var params aiobservabilitytypes.PostableFieldValueParams+ if err := binding.Query.BindQuery(req.URL.Query(), ¶ms); err != nil {+ render.Error(rw, err)+ return+ }++ claims, err := authtypes.ClaimsFromContext(ctx)+ if err != nil {+ render.Error(rw, err)+ return+ }++ fieldValueSelector := aiobservabilitytypes.NewFieldValueSelectorFromPostableFieldValueParams(params)++ values := &telemetrytypes.TelemetryFieldValues{}+ complete := true+ // the trace context names the computed per-trace aggregates, which are never ingested+ if fieldValueSelector.FieldContext != telemetrytypes.FieldContextTrace {+ values, complete, err = handler.telemetryMetadataStore.GetAllValues(ctx, valuer.MustNewUUID(claims.OrgID), fieldValueSelector)+ if err != nil {+ render.Error(rw, err)+ return+ }+ }++ render.Success(rw, http.StatusOK, &telemetrytypes.GettableFieldValues{+ Values: values,+ Complete: complete,+ })+}diff --git a/pkg/modules/llmpricingrule/impllmpricingrule/module.go b/pkg/modules/llmpricingrule/impllmpricingrule/module.goindex 1141bf6d3c..4036b0ea09 100644--- a/pkg/modules/llmpricingrule/impllmpricingrule/module.go+++ b/pkg/modules/llmpricingrule/impllmpricingrule/module.go@@ -11,6 +11,7 @@ import ("github.com/SigNoz/signoz/pkg/modules/llmpricingrule""github.com/SigNoz/signoz/pkg/querier""github.com/SigNoz/signoz/pkg/query-service/agentConf"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes""github.com/SigNoz/signoz/pkg/types/featuretypes""github.com/SigNoz/signoz/pkg/types/llmpricingruletypes""github.com/SigNoz/signoz/pkg/types/opamptypes"@@ -213,18 +214,18 @@ func (module *module) discoverModels(ctx context.Context, orgID valuer.UUID) ([]Spec: qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{Name: "A",Signal: telemetrytypes.SignalTraces,- Filter: &qbtypes.Filter{Expression: fmt.Sprintf("%s EXISTS", telemetrytypes.GenAIRequestModel)},+ Filter: &qbtypes.Filter{Expression: fmt.Sprintf("%s EXISTS", aiobservabilitytypes.GenAIRequestModel)},Aggregations: []qbtypes.TraceAggregation{{Expression: "count()", Alias: "spanCount"},},GroupBy: []qbtypes.GroupByKey{{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{- Name: telemetrytypes.GenAIRequestModel,+ Name: aiobservabilitytypes.GenAIRequestModel,FieldContext: telemetrytypes.FieldContextSpan,FieldDataType: telemetrytypes.FieldDataTypeString,}},{TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{- Name: telemetrytypes.GenAIProviderName,+ Name: aiobservabilitytypes.GenAIProviderName,FieldContext: telemetrytypes.FieldContextSpan,FieldDataType: telemetrytypes.FieldDataTypeString,}},@@ -254,9 +255,9 @@ func (module *module) discoverModels(ctx context.Context, orgID valuer.UUID) ([]switch c.Type {case qbtypes.ColumnTypeGroup:switch c.Name {- case telemetrytypes.GenAIRequestModel:+ case aiobservabilitytypes.GenAIRequestModel:modelIdx = i- case telemetrytypes.GenAIProviderName:+ case aiobservabilitytypes.GenAIProviderName:providerIdx = i}case qbtypes.ColumnTypeAggregation:diff --git a/pkg/signoz/handler.go b/pkg/signoz/handler.goindex 365dfb4316..e56018db87 100644--- a/pkg/signoz/handler.go+++ b/pkg/signoz/handler.go@@ -12,6 +12,8 @@ import ("github.com/SigNoz/signoz/pkg/global""github.com/SigNoz/signoz/pkg/global/signozglobal""github.com/SigNoz/signoz/pkg/licensing"+ "github.com/SigNoz/signoz/pkg/modules/aiobservability"+ "github.com/SigNoz/signoz/pkg/modules/aiobservability/implaiobservability""github.com/SigNoz/signoz/pkg/modules/apdex""github.com/SigNoz/signoz/pkg/modules/apdex/implapdex""github.com/SigNoz/signoz/pkg/modules/cloudintegration"@@ -72,6 +74,7 @@ type Handlers struct {FlaggerHandler flagger.HandlerGatewayHandler gateway.HandlerFields fields.Handler+ AIObservability aiobservability.HandlerAuthzHandler authz.HandlerZeusHandler zeus.HandlerQuerierHandler querier.Handler@@ -120,6 +123,7 @@ func NewHandlers(FlaggerHandler: flagger.NewHandler(flaggerService),GatewayHandler: gateway.NewHandler(gatewayService),Fields: implfields.NewHandler(providerSettings, telemetryMetadataStore),+ AIObservability: implaiobservability.NewHandler(telemetryMetadataStore),AuthzHandler: signozauthzapi.NewHandler(authz),ZeusHandler: zeus.NewHandler(zeusService, licensing),QuerierHandler: querierHandler,diff --git a/pkg/signoz/openapi.go b/pkg/signoz/openapi.goindex 42e41b7bfa..064cc56abe 100644--- a/pkg/signoz/openapi.go+++ b/pkg/signoz/openapi.go@@ -17,6 +17,7 @@ import ("github.com/SigNoz/signoz/pkg/global""github.com/SigNoz/signoz/pkg/http/handler""github.com/SigNoz/signoz/pkg/instrumentation"+ "github.com/SigNoz/signoz/pkg/modules/aiobservability""github.com/SigNoz/signoz/pkg/modules/authdomain""github.com/SigNoz/signoz/pkg/modules/cloudintegration""github.com/SigNoz/signoz/pkg/modules/dashboard"@@ -74,6 +75,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumentastruct{ inframonitoring.Handler }{},struct{ gateway.Handler }{},struct{ fields.Handler }{},+ struct{ aiobservability.Handler }{},struct{ authz.Handler }{},struct{ rawdataexport.Handler }{},struct{ zeus.Handler }{},diff --git a/pkg/signoz/provider.go b/pkg/signoz/provider.goindex ad521f037b..8e879731f6 100644--- a/pkg/signoz/provider.go+++ b/pkg/signoz/provider.go@@ -326,6 +326,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Auhandlers.InfraMonitoring,handlers.GatewayHandler,handlers.Fields,+ handlers.AIObservability,handlers.AuthzHandler,handlers.RawDataExport,handlers.ZeusHandler,diff --git a/pkg/statementbuilder/aistatementbuilder/statement_builder.go b/pkg/statementbuilder/aistatementbuilder/statement_builder.goindex dff34e7281..ee658c0560 100644--- a/pkg/statementbuilder/aistatementbuilder/statement_builder.go+++ b/pkg/statementbuilder/aistatementbuilder/statement_builder.go@@ -7,7 +7,9 @@ import ("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/telemetryschema/aitelemetryschema""github.com/SigNoz/signoz/pkg/telemetrystore"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5""github.com/SigNoz/signoz/pkg/types/telemetrytypes")@@ -25,7 +27,7 @@ func NewFactory(// 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}+ gateKeyNames := []string{aiobservabilitytypes.GenAIRequestModel, aiobservabilitytypes.GenAIToolName, aiobservabilitytypes.GenAIAgentName}gateExprs := make([]string, 0, len(gateKeyNames))gateKeys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(gateKeyNames))for _, name := range gateKeyNames {@@ -37,14 +39,14 @@ func Scope() scopedtraces.TraceScope {})}- 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]+ defs := aitelemetryschema.GenAIFields+ reqModel := defs[aiobservabilitytypes.GenAIRequestModel]+ toolName := defs[aiobservabilitytypes.GenAIToolName]+ inTok := defs[aiobservabilitytypes.GenAIUsageInputTokens]+ outTok := defs[aiobservabilitytypes.GenAIUsageOutputTokens]+ cost := defs[aiobservabilitytypes.SignozGenAITotalCost]+ inMsg := defs[aiobservabilitytypes.GenAIInputMessages]+ outMsg := defs[aiobservabilitytypes.GenAIOutputMessages]str := telemetrytypes.FieldDataTypeStringcolumns := append(scopedtraces.CommonTraceColumns(),@@ -62,13 +64,20 @@ func Scope() scopedtraces.TraceScope {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.+ // timestamp of the last gen_ai span (LLM/tool/agent), hence gate-scoped;+ // order-only: a raw-nanos threshold makes no sense in the filter bar.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)},)+ for i, c := range columns {+ if _, ok := aitelemetryschema.TraceAggregateFields[c.Alias]; ok {+ columns[i].Filterable = true+ }+ }+return scopedtraces.TraceScope{FilterExpression: strings.Join(gateExprs, " OR "),FieldKeys: gateKeys,diff --git a/pkg/statementbuilder/aistatementbuilder/statement_builder_test.go b/pkg/statementbuilder/aistatementbuilder/statement_builder_test.goindex 256006c09a..6c23654aed 100644--- a/pkg/statementbuilder/aistatementbuilder/statement_builder_test.go+++ b/pkg/statementbuilder/aistatementbuilder/statement_builder_test.go@@ -11,6 +11,8 @@ import ("github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest""github.com/SigNoz/signoz/pkg/statementbuilder"scopedtraces "github.com/SigNoz/signoz/pkg/statementbuilder/scopedtracesstatementbuilder"+ "github.com/SigNoz/signoz/pkg/telemetryschema/aitelemetryschema"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5""github.com/SigNoz/signoz/pkg/types/telemetrytypes""github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"@@ -40,8 +42,7 @@ func otelKeysMap() map[string][]*telemetrytypes.TelemetryFieldKey {m := make(map[string][]*telemetrytypes.TelemetryFieldKey)- // mirrors what enrichWithGenAIKeys surfaces in production- for name, def := range telemetrytypes.GenAIFieldDefinitions {+ for name, def := range aitelemetryschema.GenAIFields {keyCopy := defm[name] = []*telemetrytypes.TelemetryFieldKey{&keyCopy}}@@ -976,8 +977,8 @@ func TestBuild_UnsupportedRequestType(t *testing.T) {// mask, OR-combined.func TestBuild_TraceList_MultiVariantGateKey(t *testing.T) {keys := otelKeysMap()- keys[telemetrytypes.GenAIToolName] = append(keys[telemetrytypes.GenAIToolName], &telemetrytypes.TelemetryFieldKey{- Name: telemetrytypes.GenAIToolName,+ keys[aiobservabilitytypes.GenAIToolName] = append(keys[aiobservabilitytypes.GenAIToolName], &telemetrytypes.TelemetryFieldKey{+ Name: aiobservabilitytypes.GenAIToolName,Signal: telemetrytypes.SignalTraces,FieldContext: telemetrytypes.FieldContextAttribute,FieldDataType: telemetrytypes.FieldDataTypeFloat64,diff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/scope.go b/pkg/statementbuilder/scopedtracesstatementbuilder/scope.goindex a799720543..a35c002f26 100644--- a/pkg/statementbuilder/scopedtracesstatementbuilder/scope.go+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/scope.go@@ -24,9 +24,10 @@ type TraceColumn struct {// 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+ // Orderable columns can be used in ORDER BY, Filterable ones in the aggregate+ // filter; all-span aggregates are display-only and set neither.+ Orderable bool+ Filterable 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 booldiff --git a/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go b/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.goindex 7bcca2036d..302254aa2a 100644--- a/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go+++ b/pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go@@ -185,18 +185,19 @@ func (b *scopedTraceStatementBuilder) buildTraceListQuery(return nil, err}orderableSet := orderableAliasSet(resolved)+ filterableSet := filterableAliasSet(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)+ fp, err := b.splitFilter(ctx, orgID, query, b.aggregateAliasSet(), filterableSet, 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)+ matchedFrag, matchedArgs, err := b.buildMatchedCTE(matchedSB, start, end, startBucket, endBucket, resolved, orders, orderableSet, filterableSet, maskExpr, fp, resourcePred, limit, query.Offset)if err != nil {return nil, err}@@ -326,9 +327,10 @@ func (b *scopedTraceStatementBuilder) resolveMask(ctx context.Context, orgID val}type resolvedColumn struct {- alias string- expr string- orderable bool+ alias string+ expr string+ orderable bool+ filterable bool}func (b *scopedTraceStatementBuilder) resolveColumns(ctx context.Context, orgID valuer.UUID, start, end uint64, cols *columnResolver, preds *predicateResolver) ([]resolvedColumn, error) {@@ -338,7 +340,7 @@ func (b *scopedTraceStatementBuilder) resolveColumns(ctx context.Context, orgIDif err != nil {return nil, err}- out = append(out, resolvedColumn{alias: c.Alias, expr: expr, orderable: c.Orderable})+ out = append(out, resolvedColumn{alias: c.Alias, expr: expr, orderable: c.Orderable, filterable: c.Filterable})}return out, nil}@@ -393,7 +395,7 @@ type filterParts struct {// 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) {+func (b *scopedTraceStatementBuilder) splitFilter(ctx context.Context, orgID valuer.UUID, query qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation], classifySet, filterableSet map[string]struct{}, start, end uint64, variables map[string]qbtypes.VariableItem, sb *sqlbuilder.SelectBuilder) (filterParts, error) {var fp filterPartsif query.Filter != nil && strings.TrimSpace(query.Filter.Expression) != "" {spanExpr, traceExpr, err := querybuilder.SplitFilterForAggregates(query.Filter.Expression, classifySet)@@ -429,7 +431,7 @@ func (b *scopedTraceStatementBuilder) splitFilter(ctx context.Context, orgID val}fp.havingExpr = replaced}- if err := validateAggregateFilter(fp.havingExpr, orderableSet); err != nil {+ if err := validateAggregateFilter(fp.havingExpr, filterableSet); err != nil {return fp, err}return fp, nil@@ -473,7 +475,7 @@ func (b *scopedTraceStatementBuilder) resolveSpanPredicate(ctx context.Context,// 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) {+func (b *scopedTraceStatementBuilder) buildMatchedCTE(sb *sqlbuilder.SelectBuilder, start, end, startBucket, endBucket uint64, resolved []resolvedColumn, orders []listOrder, orderableSet, filterableSet 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 {@@ -513,8 +515,8 @@ func (b *scopedTraceStatementBuilder) buildMatchedCTE(sb *sqlbuilder.SelectBuild}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 := make(map[string]string, len(filterableSet)*2)+ for a := range filterableSet {columnMap[a] = quoteAlias(a)columnMap[telemetrytypes.FieldContextTrace.StringValue()+"."+a] = quoteAlias(a)}@@ -603,6 +605,17 @@ func orderableAliasSet(resolved []resolvedColumn) map[string]struct{} {return set}+// filterableAliasSet is the subset of aliases usable in the trace-level filter.+func filterableAliasSet(resolved []resolvedColumn) map[string]struct{} {+ set := make(map[string]struct{})+ for _, rc := range resolved {+ if rc.filterable {+ 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{} {@@ -630,19 +643,19 @@ func traceAggregateNames(havingExpr string) []string {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 {+// validateAggregateFilter rejects a trace-level filter referencing an aggregate that+// is not filterable.+func validateAggregateFilter(havingExpr string, filterableSet map[string]struct{}) error {if strings.TrimSpace(havingExpr) == "" {return nil}- allowed := make([]string, 0, len(orderableSet))- for a := range orderableSet {+ allowed := make([]string, 0, len(filterableSet))+ for a := range filterableSet {allowed = append(allowed, a)}sort.Strings(allowed)for _, name := range traceAggregateNames(havingExpr) {- if _, ok := orderableSet[name]; !ok {+ if _, ok := filterableSet[name]; !ok {return errors.NewInvalidInputf(errors.CodeInvalidInput,"aggregate %q cannot be used in the trace-list filter; filterable aggregates: %s", name, strings.Join(allowed, ", "))}diff --git a/pkg/telemetrymetadata/metadata.go b/pkg/telemetrymetadata/metadata.goindex c96f791d35..68db7b0b40 100644--- a/pkg/telemetrymetadata/metadata.go+++ b/pkg/telemetrymetadata/metadata.go@@ -1168,27 +1168,6 @@ 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@@ -1274,9 +1253,6 @@ 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}@@ -1355,9 +1331,6 @@ 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/aitelemetryschema/const.go b/pkg/telemetryschema/aitelemetryschema/const.gonew file mode 100644index 0000000000..ffd617291b--- /dev/null+++ b/pkg/telemetryschema/aitelemetryschema/const.go@@ -0,0 +1,58 @@+package aitelemetryschema++import (+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+)++var (+ // GenAIFields are the gen_ai span attributes the AI query builder relies on,+ // suggested before ingestion so the filter bar works on a fresh install.+ GenAIFields = map[string]telemetrytypes.TelemetryFieldKey{+ aiobservabilitytypes.GenAIRequestModel: genAIAttribute(aiobservabilitytypes.GenAIRequestModel, telemetrytypes.FieldDataTypeString),+ aiobservabilitytypes.GenAIOperationName: genAIAttribute(aiobservabilitytypes.GenAIOperationName, telemetrytypes.FieldDataTypeString),+ aiobservabilitytypes.GenAIToolName: genAIAttribute(aiobservabilitytypes.GenAIToolName, telemetrytypes.FieldDataTypeString),+ aiobservabilitytypes.GenAIAgentName: genAIAttribute(aiobservabilitytypes.GenAIAgentName, telemetrytypes.FieldDataTypeString),+ aiobservabilitytypes.GenAIProviderName: genAIAttribute(aiobservabilitytypes.GenAIProviderName, telemetrytypes.FieldDataTypeString),++ aiobservabilitytypes.GenAIUsageInputTokens: genAIAttribute(aiobservabilitytypes.GenAIUsageInputTokens, telemetrytypes.FieldDataTypeFloat64),+ aiobservabilitytypes.GenAIUsageOutputTokens: genAIAttribute(aiobservabilitytypes.GenAIUsageOutputTokens, telemetrytypes.FieldDataTypeFloat64),+ aiobservabilitytypes.GenAIUsageCacheReadInputTokens: genAIAttribute(aiobservabilitytypes.GenAIUsageCacheReadInputTokens, telemetrytypes.FieldDataTypeFloat64),+ aiobservabilitytypes.GenAIUsageCacheCreationInputTokens: genAIAttribute(aiobservabilitytypes.GenAIUsageCacheCreationInputTokens, telemetrytypes.FieldDataTypeFloat64),+ aiobservabilitytypes.SignozGenAITotalCost: genAIAttribute(aiobservabilitytypes.SignozGenAITotalCost, telemetrytypes.FieldDataTypeFloat64),++ aiobservabilitytypes.GenAIInputMessages: genAIAttribute(aiobservabilitytypes.GenAIInputMessages, telemetrytypes.FieldDataTypeString),+ aiobservabilitytypes.GenAIOutputMessages: genAIAttribute(aiobservabilitytypes.GenAIOutputMessages, telemetrytypes.FieldDataTypeString),+ }++ // TraceAggregateFields are the per-trace aggregates the AI trace list computes;+ // they are never ingested, so only this definition can surface them.+ TraceAggregateFields = map[string]telemetrytypes.TelemetryFieldKey{+ "llm_call_count": traceAggregate("llm_call_count"),+ "tool_call_count": traceAggregate("tool_call_count"),+ "distinct_tool_count": traceAggregate("distinct_tool_count"),+ "input_tokens": traceAggregate("input_tokens"),+ "output_tokens": traceAggregate("output_tokens"),+ "total_tokens": traceAggregate("total_tokens"),+ "estimated_total_cost": traceAggregate("estimated_total_cost"),+ "max_llm_duration_nano": traceAggregate("max_llm_duration_nano"),+ }+)++func genAIAttribute(name string, dataType telemetrytypes.FieldDataType) telemetrytypes.TelemetryFieldKey {+ return telemetrytypes.TelemetryFieldKey{+ Name: name,+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextAttribute,+ FieldDataType: dataType,+ }+}++func traceAggregate(name string) telemetrytypes.TelemetryFieldKey {+ return telemetrytypes.TelemetryFieldKey{+ Name: name,+ Signal: telemetrytypes.SignalTraces,+ FieldContext: telemetrytypes.FieldContextTrace,+ FieldDataType: telemetrytypes.FieldDataTypeFloat64,+ }+}diff --git a/pkg/telemetryschema/aitelemetryschema/field_keys.go b/pkg/telemetryschema/aitelemetryschema/field_keys.gonew file mode 100644index 0000000000..a9637702be--- /dev/null+++ b/pkg/telemetryschema/aitelemetryschema/field_keys.go@@ -0,0 +1,26 @@+package aitelemetryschema++import (+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+)++// FieldKeys merges in the keys the metadata store cannot serve: the computed+// aggregates always, the gen_ai attributes only where ingestion has not.+func FieldKeys(keys map[string][]*telemetrytypes.TelemetryFieldKey, selector *telemetrytypes.FieldKeySelector) map[string][]*telemetrytypes.TelemetryFieldKey {+ for name, def := range TraceAggregateFields {+ if selector.MatchesKey(&def) {+ keys[name] = append(keys[name], &def)+ }+ }++ for name, def := range GenAIFields {+ if len(keys[name]) > 0 {+ continue+ }+ if selector.MatchesKey(&def) {+ keys[name] = []*telemetrytypes.TelemetryFieldKey{&def}+ }+ }++ return keys+}diff --git a/pkg/types/aiobservabilitytypes/field.go b/pkg/types/aiobservabilitytypes/field.gonew file mode 100644index 0000000000..c45e638350--- /dev/null+++ b/pkg/types/aiobservabilitytypes/field.go@@ -0,0 +1,46 @@+package aiobservabilitytypes++import (+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+)++// the explorer lists AI traces, so the signal is always traces and the metric+// selectors do not apply.+type PostableFieldKeysParams struct {+ SearchText string `query:"searchText"`+ FieldContext telemetrytypes.FieldContext `query:"fieldContext"`+ FieldDataType telemetrytypes.FieldDataType `query:"fieldDataType"`+ StartUnixMilli int64 `query:"startUnixMilli"`+ EndUnixMilli int64 `query:"endUnixMilli"`+ Limit int `query:"limit"`+}++// existingQuery is unsupported until the computed per-trace aggregates it may+// reference can be narrowed on.+type PostableFieldValueParams struct {+ PostableFieldKeysParams+ Name string `query:"name"`+}++func NewFieldKeySelectorFromPostableFieldKeysParams(params PostableFieldKeysParams) *telemetrytypes.FieldKeySelector {+ return telemetrytypes.NewFieldKeySelectorFromPostableFieldKeysParams(params.telemetryParams())+}++func NewFieldValueSelectorFromPostableFieldValueParams(params PostableFieldValueParams) *telemetrytypes.FieldValueSelector {+ return telemetrytypes.NewFieldValueSelectorFromPostableFieldValueParams(telemetrytypes.PostableFieldValueParams{+ PostableFieldKeysParams: params.telemetryParams(),+ Name: params.Name,+ })+}++func (params PostableFieldKeysParams) telemetryParams() telemetrytypes.PostableFieldKeysParams {+ return telemetrytypes.PostableFieldKeysParams{+ Signal: telemetrytypes.SignalTraces,+ SearchText: params.SearchText,+ FieldContext: params.FieldContext,+ FieldDataType: params.FieldDataType,+ StartUnixMilli: params.StartUnixMilli,+ EndUnixMilli: params.EndUnixMilli,+ Limit: params.Limit,+ }+}diff --git a/pkg/types/aiobservabilitytypes/keys.go b/pkg/types/aiobservabilitytypes/keys.gonew file mode 100644index 0000000000..5d8f822d2e--- /dev/null+++ b/pkg/types/aiobservabilitytypes/keys.go@@ -0,0 +1,28 @@+package aiobservabilitytypes++// 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"+ GenAIOperationName = "gen_ai.operation.name"+ 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"+)++// Per-span costs the SigNoz LLM pricing processor attaches; not OTel semconv.+const (+ 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"+)diff --git a/pkg/types/llmpricingruletypes/pricing.go b/pkg/types/llmpricingruletypes/pricing.goindex 9d2dee95c6..6dbb276a19 100644--- a/pkg/types/llmpricingruletypes/pricing.go+++ b/pkg/types/llmpricingruletypes/pricing.go@@ -15,11 +15,6 @@ import (const (LLMCostFeatureType agentConf.AgentFeatureType = "llm_pricing"-- 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")var (diff --git a/pkg/types/llmpricingruletypes/processorconfig.go b/pkg/types/llmpricingruletypes/processorconfig.goindex e3c716b054..057a1beaaf 100644--- a/pkg/types/llmpricingruletypes/processorconfig.go+++ b/pkg/types/llmpricingruletypes/processorconfig.go@@ -4,7 +4,7 @@ import ("bytes""github.com/SigNoz/signoz/pkg/errors"- "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes""gopkg.in/yaml.v3")@@ -84,21 +84,21 @@ func buildProcessorConfig(rules []*LLMPricingRule) *LLMPricingRuleProcessorConfireturn &LLMPricingRuleProcessorConfig{Attrs: LLMPricingRuleProcessorAttrs{- Model: telemetrytypes.GenAIRequestModel,- In: telemetrytypes.GenAIUsageInputTokens,- Out: telemetrytypes.GenAIUsageOutputTokens,- CacheRead: telemetrytypes.GenAIUsageCacheReadInputTokens,- CacheWrite: telemetrytypes.GenAIUsageCacheCreationInputTokens,+ Model: aiobservabilitytypes.GenAIRequestModel,+ In: aiobservabilitytypes.GenAIUsageInputTokens,+ Out: aiobservabilitytypes.GenAIUsageOutputTokens,+ CacheRead: aiobservabilitytypes.GenAIUsageCacheReadInputTokens,+ CacheWrite: aiobservabilitytypes.GenAIUsageCacheCreationInputTokens,},DefaultPricing: LLMPricingRuleProcessorDefaultPricing{Rules: pricingRules,},OutputAttrs: LLMPricingRuleProcessorOutputAttrs{- In: SignozGenAICostInput,- Out: SignozGenAICostOutput,- CacheRead: SignozGenAICostCacheRead,- CacheWrite: SignozGenAICostCacheWrite,- Total: telemetrytypes.SignozGenAITotalCost,+ In: aiobservabilitytypes.SignozGenAICostInput,+ Out: aiobservabilitytypes.SignozGenAICostOutput,+ CacheRead: aiobservabilitytypes.SignozGenAICostCacheRead,+ CacheWrite: aiobservabilitytypes.SignozGenAICostCacheWrite,+ Total: aiobservabilitytypes.SignozGenAITotalCost,},}}diff --git a/pkg/types/quickfiltertypes/filter.go b/pkg/types/quickfiltertypes/filter.goindex 4aaa259258..688c903c05 100644--- a/pkg/types/quickfiltertypes/filter.go+++ b/pkg/types/quickfiltertypes/filter.go@@ -7,7 +7,7 @@ import ("github.com/SigNoz/signoz/pkg/errors"v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3""github.com/SigNoz/signoz/pkg/types"- "github.com/SigNoz/signoz/pkg/types/telemetrytypes"+ "github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes""github.com/SigNoz/signoz/pkg/valuer""github.com/uptrace/bun")@@ -195,12 +195,12 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {// usage: env scoping, the LLM identity keys, then service and the rest.aiObservabilityFilters := []map[string]interface{}{{"key": "deployment.environment", "dataType": "string", "type": "resource"},- {"key": telemetrytypes.GenAIOperationName, "dataType": "string", "type": "tag"},- {"key": telemetrytypes.GenAIProviderName, "dataType": "string", "type": "tag"},- {"key": telemetrytypes.GenAIRequestModel, "dataType": "string", "type": "tag"},+ {"key": aiobservabilitytypes.GenAIOperationName, "dataType": "string", "type": "tag"},+ {"key": aiobservabilitytypes.GenAIProviderName, "dataType": "string", "type": "tag"},+ {"key": aiobservabilitytypes.GenAIRequestModel, "dataType": "string", "type": "tag"},{"key": "service.name", "dataType": "string", "type": "resource"},- {"key": telemetrytypes.GenAIToolName, "dataType": "string", "type": "tag"},- {"key": telemetrytypes.GenAIAgentName, "dataType": "string", "type": "tag"},+ {"key": aiobservabilitytypes.GenAIToolName, "dataType": "string", "type": "tag"},+ {"key": aiobservabilitytypes.GenAIAgentName, "dataType": "string", "type": "tag"},}tracesJSON, err := json.Marshal(tracesFilters)diff --git a/pkg/types/telemetrytypes/field.go b/pkg/types/telemetrytypes/field.goindex a765e4232b..c46c24fc94 100644--- a/pkg/types/telemetrytypes/field.go+++ b/pkg/types/telemetrytypes/field.go@@ -246,6 +246,27 @@ type FieldKeySelector struct {MetricContext *MetricContext `json:"metricContext,omitempty"`}+// MatchesKey reports whether a statically defined key satisfies the selector, so+// callers can suggest keys that were never ingested.+func (s *FieldKeySelector) MatchesKey(key *TelemetryFieldKey) bool {+ if s.FieldContext != FieldContextUnspecified && s.FieldContext != key.FieldContext {+ return false+ }++ if s.FieldDataType != FieldDataTypeUnspecified && s.FieldDataType != key.FieldDataType {+ return false+ }++ if s.Name == "" {+ return true+ }++ if s.SelectorMatchType == FieldSelectorMatchTypeExact {+ return strings.EqualFold(s.Name, key.Name)+ }+ return strings.Contains(strings.ToLower(key.Name), strings.ToLower(s.Name))+}+type FieldValueSelector struct {*FieldKeySelectorExistingQuery string `json:"existingQuery"`diff --git a/pkg/types/telemetrytypes/field_context.go b/pkg/types/telemetrytypes/field_context.goindex 8b8ab4380d..c5536bbb28 100644--- a/pkg/types/telemetrytypes/field_context.go+++ b/pkg/types/telemetrytypes/field_context.go@@ -188,7 +188,7 @@ func (FieldContext) Enum() []any {FieldContextMetric,FieldContextLog,FieldContextSpan,- // FieldContextTrace,+ FieldContextTrace,FieldContextResource,// FieldContextScope,FieldContextAttribute,diff --git a/pkg/types/telemetrytypes/genai_semconv.go b/pkg/types/telemetrytypes/genai_semconv.godeleted file mode 100644index b6b1569da2..0000000000--- a/pkg/types/telemetrytypes/genai_semconv.go+++ /dev/null@@ -1,43 +0,0 @@-package telemetrytypes--// OpenTelemetry gen_ai semantic-convention attribute keys. Single source of truth-// shared by the AI query builder and the LLM pricing pipeline.-const (- GenAIRequestModel = "gen_ai.request.model"- GenAIOperationName = "gen_ai.operation.name"- 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},- GenAIOperationName: {Name: GenAIOperationName, 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/tests/fixtures/metadata.py b/tests/fixtures/metadata.pyindex 5c192e5ede..f20c1b49c7 100644--- a/tests/fixtures/metadata.py+++ b/tests/fixtures/metadata.py@@ -6,6 +6,7 @@ from typing import Anyimport numpy as npimport pytest+import requestsfrom fixtures import typesfrom fixtures.fingerprint import LogsOrTracesFingerprint@@ -106,6 +107,24 @@ def truncate_attributes_metadata_table(conn, cluster: str) -> None:conn.query(f"TRUNCATE TABLE signoz_metadata.attributes_metadata ON CLUSTER '{cluster}' SYNC")+def get_field_keys(signoz: types.SigNoz, token: str, params: dict, path: str = "/api/v1/fields/keys") -> requests.Response:+ return requests.get(+ signoz.self.host_configs["8080"].get(path),+ timeout=5,+ headers={"authorization": f"Bearer {token}"},+ params=params,+ )+++def get_field_values(signoz: types.SigNoz, token: str, params: dict, path: str = "/api/v1/fields/values") -> requests.Response:+ return requests.get(+ signoz.self.host_configs["8080"].get(path),+ timeout=5,+ headers={"authorization": f"Bearer {token}"},+ params=params,+ )++@pytest.fixture(name="insert_attributes_metadata", scope="function")def insert_attributes_metadata(clickhouse: types.TestContainerClickhouse,diff --git a/tests/integration/tests/querierai/03_ai_metadata.py b/tests/integration/tests/querierai/03_ai_metadata.pynew file mode 100644index 0000000000..c50b3920ed--- /dev/null+++ b/tests/integration/tests/querierai/03_ai_metadata.py@@ -0,0 +1,137 @@+from collections.abc import Callable+from datetime import UTC, datetime+from http import HTTPStatus++from fixtures import types+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD+from fixtures.metadata import get_field_keys, get_field_values+from fixtures.querierai import ai_trace+from fixtures.traces import Traces++AI_KEYS_PATH = "/api/v1/ai_observability/fields/keys"+AI_VALUES_PATH = "/api/v1/ai_observability/fields/values"++# The filterable per-trace aggregates; the display-only columns (error_count,+# last_activity_time, span_count, input, output) must not be suggested.+AI_TRACE_AGGREGATES = {+ "llm_call_count",+ "tool_call_count",+ "distinct_tool_count",+ "input_tokens",+ "output_tokens",+ "total_tokens",+ "estimated_total_cost",+ "max_llm_duration_nano",+}+++def test_ai_fields_lists_filterable_aggregates(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_keys(signoz, token, {}, AI_KEYS_PATH)+ assert response.status_code == HTTPStatus.OK, response.text+ assert response.json()["status"] == "success"++ keys = response.json()["data"]["keys"]+ trace_context_names = {name for name, variants in keys.items() if any(key["fieldContext"] == "trace" for key in variants)}+ assert trace_context_names == AI_TRACE_AGGREGATES, keys+++def test_ai_fields_trace_prefix_search(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ # `trace.output` in the filter bar parses into the trace context+ response = get_field_keys(signoz, token, {"searchText": "trace.output"}, AI_KEYS_PATH)+ assert response.status_code == HTTPStatus.OK, response.text++ keys = response.json()["data"]["keys"]+ trace_context_names = {name for name, variants in keys.items() if any(key["fieldContext"] == "trace" for key in variants)}+ assert trace_context_names == {"output_tokens"}, keys+++def test_ai_fields_bare_prefix_suggests_aggregate_and_attribute(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_keys(signoz, token, {"searchText": "output_tok"}, AI_KEYS_PATH)+ assert response.status_code == HTTPStatus.OK, response.text++ keys = response.json()["data"]["keys"]+ assert any(key["fieldContext"] == "trace" for key in keys["output_tokens"]), keys+ assert any(key["fieldContext"] == "attribute" for key in keys["gen_ai.usage.output_tokens"]), keys+++def test_ai_fields_are_not_served_by_the_generic_endpoint(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_keys(signoz, token, {"signal": "traces", "searchText": "output_tok"})+ assert response.status_code == HTTPStatus.OK, response.text++ keys = response.json()["data"]["keys"]+ assert "output_tokens" not in keys, keys+ assert "gen_ai.usage.output_tokens" not in keys, keys+++def test_ai_field_values_suggests_ingested_attribute_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:+ now = datetime.now(tz=UTC).replace(second=0, microsecond=0)+ insert_traces(ai_trace(now=now, service="ai-it-values", user="alice", in_tokens=100, out_tokens=20, cost=0.5, model="gpt-it-values"))++ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_values(signoz, token, {"name": "gen_ai.request.model", "searchText": "gpt-it-values"}, AI_VALUES_PATH)+ assert response.status_code == HTTPStatus.OK, response.text+ assert response.json()["status"] == "success"++ values = response.json()["data"]["values"]+ assert values["stringValues"] == ["gpt-it-values"], values+++def test_ai_field_values_reject_existing_query(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_values(+ signoz,+ token,+ {"name": "gen_ai.request.model", "existingQuery": "service.name = 'ai-it-values'"},+ AI_VALUES_PATH,+ )+ assert response.status_code == HTTPStatus.BAD_REQUEST, response.text+++def test_ai_field_values_of_computed_aggregate_are_empty(+ signoz: types.SigNoz,+ create_user_admin: None, # pylint: disable=unused-argument+ get_token: Callable[[str, str], str],+) -> None:+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ response = get_field_values(signoz, token, {"name": "llm_call_count", "fieldContext": "trace"}, AI_VALUES_PATH)+ assert response.status_code == HTTPStatus.OK, response.text++ values = response.json()["data"]["values"]+ assert values.get("stringValues", []) == [], values+ assert values.get("numberValues", []) == [], values