Skip to content

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.

fix: add quick filters v2 api to support TelemetryFieldKey (#12698)

Nityananda Gohaina75442f31eb5
diff --git a/.github/workflows/integrationci.yaml b/.github/workflows/integrationci.yaml
index ca80a12ad3..30137c3b2a 100644
--- a/.github/workflows/integrationci.yaml
+++ b/.github/workflows/integrationci.yaml
@@ -50,6 +50,7 @@ jobs:
- logspipelines
- passwordauthn
- preference
+ - quickfilter
- querierlogs
- queriertraces
- queriermetrics
diff --git a/docs/api/openapi.yml b/docs/api/openapi.yml
index 853589f414..c2bd5dc553 100644
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -7873,6 +7873,48 @@ components:
- custom
- text
type: string
+ QuickfiltertypesSource:
+ enum:
+ - traces
+ - logs
+ - api_monitoring
+ - exceptions
+ - meter
+ - ai_observability
+ type: string
+ QuickfiltertypesSourceFilters:
+ properties:
+ createdAt:
+ format: date-time
+ type: string
+ filters:
+ items:
+ $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
+ type: array
+ id:
+ type: string
+ orgId:
+ type: string
+ source:
+ $ref: '#/components/schemas/QuickfiltertypesSource'
+ updatedAt:
+ format: date-time
+ type: string
+ required:
+ - id
+ - orgId
+ - source
+ - filters
+ type: object
+ QuickfiltertypesUpdatableQuickFilters:
+ properties:
+ filters:
+ items:
+ $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
+ type: array
+ required:
+ - filters
+ type: object
RenderErrorResponse:
properties:
error:
@@ -19196,6 +19238,170 @@ paths:
summary: Get query range result (v2)
tags:
- dashboard
+ /api/v2/quick_filters:
+ get:
+ deprecated: false
+ description: Returns the org's quick filters for every source, each filter as
+ a telemetry field key.
+ operationId: ListQuickFilters
+ responses:
+ "200":
+ content:
+ application/json:
+ schema:
+ properties:
+ data:
+ items:
+ $ref: '#/components/schemas/QuickfiltertypesSourceFilters'
+ type: array
+ status:
+ type: string
+ required:
+ - status
+ - data
+ type: object
+ description: OK
+ "400":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Bad Request
+ "401":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Unauthorized
+ "403":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Forbidden
+ "500":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Internal Server Error
+ security:
+ - api_key:
+ - quick-filter:list
+ - tokenizer:
+ - quick-filter:list
+ summary: List quick filters
+ tags:
+ - quick_filter
+ /api/v2/quick_filters/{source}:
+ get:
+ deprecated: false
+ description: Returns the org's quick filters for one source, each filter as
+ a telemetry field key.
+ operationId: GetQuickFilters
+ parameters:
+ - in: path
+ name: source
+ required: true
+ schema:
+ type: string
+ responses:
+ "200":
+ content:
+ application/json:
+ schema:
+ properties:
+ data:
+ $ref: '#/components/schemas/QuickfiltertypesSourceFilters'
+ status:
+ type: string
+ required:
+ - status
+ - data
+ type: object
+ description: OK
+ "400":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Bad Request
+ "401":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Unauthorized
+ "403":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Forbidden
+ "500":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Internal Server Error
+ security:
+ - api_key:
+ - quick-filter:read
+ - tokenizer:
+ - quick-filter:read
+ summary: Get a source's quick filters
+ tags:
+ - quick_filter
+ put:
+ deprecated: false
+ description: Replaces the org's quick filters for the source named in the path.
+ operationId: UpdateQuickFilters
+ parameters:
+ - in: path
+ name: source
+ required: true
+ schema:
+ type: string
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/QuickfiltertypesUpdatableQuickFilters'
+ responses:
+ "204":
+ description: No Content
+ "400":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Bad Request
+ "401":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Unauthorized
+ "403":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Forbidden
+ "500":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Internal Server Error
+ security:
+ - api_key:
+ - quick-filter:update
+ - tokenizer:
+ - quick-filter:update
+ summary: Update quick filters
+ tags:
+ - quick_filter
/api/v2/readyz:
get:
operationId: Readyz
diff --git a/frontend/src/api/generated/services/quick-filter/index.ts b/frontend/src/api/generated/services/quick-filter/index.ts
new file mode 100644
index 0000000000..5d43d975b2
--- /dev/null
+++ b/frontend/src/api/generated/services/quick-filter/index.ts
@@ -0,0 +1,316 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'pnpm generate:api'
+ * SigNoz
+ */
+import { useMutation, useQuery } from 'react-query';
+import type {
+ InvalidateOptions,
+ MutationFunction,
+ QueryClient,
+ QueryFunction,
+ QueryKey,
+ UseMutationOptions,
+ UseMutationResult,
+ UseQueryOptions,
+ UseQueryResult,
+} from 'react-query';
+
+import type {
+ GetQuickFilters200,
+ GetQuickFiltersPathParameters,
+ ListQuickFilters200,
+ QuickfiltertypesUpdatableQuickFiltersDTO,
+ RenderErrorResponseDTO,
+ UpdateQuickFiltersPathParameters,
+} from '../sigNoz.schemas';
+
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
+
+/**
+ * Returns the org's quick filters for every source, each filter as a telemetry field key.
+ * @summary List quick filters
+ */
+export const listQuickFilters = (signal?: AbortSignal) => {
+ return GeneratedAPIInstance<ListQuickFilters200>({
+ url: `/api/v2/quick_filters`,
+ method: 'GET',
+ signal,
+ });
+};
+
+export const getListQuickFiltersQueryKey = () => {
+ return [`/api/v2/quick_filters`] as const;
+};
+
+export const getListQuickFiltersQueryOptions = <
+ TData = Awaited<ReturnType<typeof listQuickFilters>>,
+ TError = ErrorType<RenderErrorResponseDTO>,
+>(options?: {
+ query?: UseQueryOptions<
+ Awaited<ReturnType<typeof listQuickFilters>>,
+ TError,
+ TData
+ >;
+}) => {
+ const { query: queryOptions } = options ?? {};
+
+ const queryKey = queryOptions?.queryKey ?? getListQuickFiltersQueryKey();
+
+ const queryFn: QueryFunction<Awaited<ReturnType<typeof listQuickFilters>>> = ({
+ signal,
+ }) => listQuickFilters(signal);
+
+ return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+ Awaited<ReturnType<typeof listQuickFilters>>,
+ TError,
+ TData
+ > & { queryKey: QueryKey };
+};
+
+export type ListQuickFiltersQueryResult = NonNullable<
+ Awaited<ReturnType<typeof listQuickFilters>>
+>;
+export type ListQuickFiltersQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List quick filters
+ */
+
+export function useListQuickFilters<
+ TData = Awaited<ReturnType<typeof listQuickFilters>>,
+ TError = ErrorType<RenderErrorResponseDTO>,
+>(options?: {
+ query?: UseQueryOptions<
+ Awaited<ReturnType<typeof listQuickFilters>>,
+ TError,
+ TData
+ >;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+ const queryOptions = getListQuickFiltersQueryOptions(options);
+
+ const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+ queryKey: QueryKey;
+ };
+
+ return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary List quick filters
+ */
+export const invalidateListQuickFilters = async (
+ queryClient: QueryClient,
+ options?: InvalidateOptions,
+): Promise<QueryClient> => {
+ await queryClient.invalidateQueries(
+ { queryKey: getListQuickFiltersQueryKey() },
+ options,
+ );
+
+ return queryClient;
+};
+
+/**
+ * Returns the org's quick filters for one source, each filter as a telemetry field key.
+ * @summary Get a source's quick filters
+ */
+export const getQuickFilters = (
+ { source }: GetQuickFiltersPathParameters,
+ signal?: AbortSignal,
+) => {
+ return GeneratedAPIInstance<GetQuickFilters200>({
+ url: `/api/v2/quick_filters/${source}`,
+ method: 'GET',
+ signal,
+ });
+};
+
+export const getGetQuickFiltersQueryKey = ({
+ source,
+}: GetQuickFiltersPathParameters) => {
+ return [`/api/v2/quick_filters/${source}`] as const;
+};
+
+export const getGetQuickFiltersQueryOptions = <
+ TData = Awaited<ReturnType<typeof getQuickFilters>>,
+ TError = ErrorType<RenderErrorResponseDTO>,
+>(
+ { source }: GetQuickFiltersPathParameters,
+ options?: {
+ query?: UseQueryOptions<
+ Awaited<ReturnType<typeof getQuickFilters>>,
+ TError,
+ TData
+ >;
+ },
+) => {
+ const { query: queryOptions } = options ?? {};
+
+ const queryKey =
+ queryOptions?.queryKey ?? getGetQuickFiltersQueryKey({ source });
+
+ const queryFn: QueryFunction<Awaited<ReturnType<typeof getQuickFilters>>> = ({
+ signal,
+ }) => getQuickFilters({ source }, signal);
+
+ return {
+ queryKey,
+ queryFn,
+ enabled: !!source,
+ ...queryOptions,
+ } as UseQueryOptions<
+ Awaited<ReturnType<typeof getQuickFilters>>,
+ TError,
+ TData
+ > & { queryKey: QueryKey };
+};
+
+export type GetQuickFiltersQueryResult = NonNullable<
+ Awaited<ReturnType<typeof getQuickFilters>>
+>;
+export type GetQuickFiltersQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get a source's quick filters
+ */
+
+export function useGetQuickFilters<
+ TData = Awaited<ReturnType<typeof getQuickFilters>>,
+ TError = ErrorType<RenderErrorResponseDTO>,
+>(
+ { source }: GetQuickFiltersPathParameters,
+ options?: {
+ query?: UseQueryOptions<
+ Awaited<ReturnType<typeof getQuickFilters>>,
+ TError,
+ TData
+ >;
+ },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+ const queryOptions = getGetQuickFiltersQueryOptions({ source }, options);
+
+ const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+ queryKey: QueryKey;
+ };
+
+ return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary Get a source's quick filters
+ */
+export const invalidateGetQuickFilters = async (
+ queryClient: QueryClient,
+ { source }: GetQuickFiltersPathParameters,
+ options?: InvalidateOptions,
+): Promise<QueryClient> => {
+ await queryClient.invalidateQueries(
+ { queryKey: getGetQuickFiltersQueryKey({ source }) },
+ options,
+ );
+
+ return queryClient;
+};
+
+/**
+ * Replaces the org's quick filters for the source named in the path.
+ * @summary Update quick filters
+ */
+export const updateQuickFilters = (
+ { source }: UpdateQuickFiltersPathParameters,
+ quickfiltertypesUpdatableQuickFiltersDTO?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>,
+ signal?: AbortSignal,
+) => {
+ return GeneratedAPIInstance<void>({
+ url: `/api/v2/quick_filters/${source}`,
+ method: 'PUT',
+ headers: { 'Content-Type': 'application/json' },
+ data: quickfiltertypesUpdatableQuickFiltersDTO,
+ signal,
+ });
+};
+
+export const getUpdateQuickFiltersMutationOptions = <
+ TError = ErrorType<RenderErrorResponseDTO>,
+ TContext = unknown,
+>(options?: {
+ mutation?: UseMutationOptions<
+ Awaited<ReturnType<typeof updateQuickFilters>>,
+ TError,
+ {
+ pathParams: UpdateQuickFiltersPathParameters;
+ data?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>;
+ },
+ TContext
+ >;
+}): UseMutationOptions<
+ Awaited<ReturnType<typeof updateQuickFilters>>,
+ TError,
+ {
+ pathParams: UpdateQuickFiltersPathParameters;
+ data?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>;
+ },
+ TContext
+> => {
+ const mutationKey = ['updateQuickFilters'];
+ const { mutation: mutationOptions } = options
+ ? options.mutation &&
+ 'mutationKey' in options.mutation &&
+ options.mutation.mutationKey
+ ? options
+ : { ...options, mutation: { ...options.mutation, mutationKey } }
+ : { mutation: { mutationKey } };
+
+ const mutationFn: MutationFunction<
+ Awaited<ReturnType<typeof updateQuickFilters>>,
+ {
+ pathParams: UpdateQuickFiltersPathParameters;
+ data?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>;
+ }
+ > = (props) => {
+ const { pathParams, data } = props ?? {};
+
+ return updateQuickFilters(pathParams, data);
+ };
+
+ return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateQuickFiltersMutationResult = NonNullable<
+ Awaited<ReturnType<typeof updateQuickFilters>>
+>;
+export type UpdateQuickFiltersMutationBody =
+ | BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>
+ | undefined;
+export type UpdateQuickFiltersMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update quick filters
+ */
+export const useUpdateQuickFilters = <
+ TError = ErrorType<RenderErrorResponseDTO>,
+ TContext = unknown,
+>(options?: {
+ mutation?: UseMutationOptions<
+ Awaited<ReturnType<typeof updateQuickFilters>>,
+ TError,
+ {
+ pathParams: UpdateQuickFiltersPathParameters;
+ data?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>;
+ },
+ TContext
+ >;
+}): UseMutationResult<
+ Awaited<ReturnType<typeof updateQuickFilters>>,
+ TError,
+ {
+ pathParams: UpdateQuickFiltersPathParameters;
+ data?: BodyType<QuickfiltertypesUpdatableQuickFiltersDTO>;
+ },
+ TContext
+> => {
+ return useMutation(getUpdateQuickFiltersMutationOptions(options));
+};
diff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.ts
index d5ae3337b3..e059724ebc 100644
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -9026,6 +9026,47 @@ export enum Querybuildertypesv5QueryTypeDTO {
clickhouse_sql = 'clickhouse_sql',
promql = 'promql',
}
+export enum QuickfiltertypesSourceDTO {
+ traces = 'traces',
+ logs = 'logs',
+ api_monitoring = 'api_monitoring',
+ exceptions = 'exceptions',
+ meter = 'meter',
+ ai_observability = 'ai_observability',
+}
+export interface QuickfiltertypesSourceFiltersDTO {
+ /**
+ * @type string
+ * @format date-time
+ */
+ createdAt?: string;
+ /**
+ * @type array
+ */
+ filters: TelemetrytypesTelemetryFieldKeyDTO[];
+ /**
+ * @type string
+ */
+ id: string;
+ /**
+ * @type string
+ */
+ orgId: string;
+ source: QuickfiltertypesSourceDTO;
+ /**
+ * @type string
+ * @format date-time
+ */
+ updatedAt?: string;
+}
+
+export interface QuickfiltertypesUpdatableQuickFiltersDTO {
+ /**
+ * @type array
+ */
+ filters: TelemetrytypesTelemetryFieldKeyDTO[];
+}
+
export interface RenderErrorResponseDTO {
error: ErrorsJSONDTO;
/**
@@ -12482,6 +12523,31 @@ export type GetPublicDashboardPanelQueryRangeV2200 = {
status: string;
};
+export type ListQuickFilters200 = {
+ /**
+ * @type array
+ */
+ data: QuickfiltertypesSourceFiltersDTO[];
+ /**
+ * @type string
+ */
+ status: string;
+};
+
+export type GetQuickFiltersPathParameters = {
+ source: string;
+};
+export type GetQuickFilters200 = {
+ data: QuickfiltertypesSourceFiltersDTO;
+ /**
+ * @type string
+ */
+ status: string;
+};
+
+export type UpdateQuickFiltersPathParameters = {
+ source: string;
+};
export type Readyz200 = {
data: FactoryResponseDTO;
/**
diff --git a/pkg/apiserver/signozapiserver/provider.go b/pkg/apiserver/signozapiserver/provider.go
index 1645283ed1..80a916bf6c 100644
--- a/pkg/apiserver/signozapiserver/provider.go
+++ b/pkg/apiserver/signozapiserver/provider.go
@@ -25,6 +25,7 @@ import (
"github.com/SigNoz/signoz/pkg/modules/organization"
"github.com/SigNoz/signoz/pkg/modules/preference"
"github.com/SigNoz/signoz/pkg/modules/promote"
+ "github.com/SigNoz/signoz/pkg/modules/quickfilter"
"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
"github.com/SigNoz/signoz/pkg/modules/savedview"
@@ -84,6 +85,8 @@ type provider struct {
llmPricingRuleHandler llmpricingrule.Handler
statsHandler statsreporter.Handler
savedViewHandler savedview.Handler
+ quickFilterModule quickfilter.Module
+ quickFilterHandler quickfilter.Handler
}
func NewFactory(
@@ -124,6 +127,8 @@ func NewFactory(
rulerHandler ruler.Handler,
statsHandler statsreporter.Handler,
savedViewHandler savedview.Handler,
+ quickFilterModule quickfilter.Module,
+ quickFilterHandler quickfilter.Handler,
) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
return newProvider(
@@ -167,6 +172,8 @@ func NewFactory(
rulerHandler,
statsHandler,
savedViewHandler,
+ quickFilterModule,
+ quickFilterHandler,
)
})
}
@@ -212,6 +219,8 @@ func newProvider(
rulerHandler ruler.Handler,
statsHandler statsreporter.Handler,
savedViewHandler savedview.Handler,
+ quickFilterModule quickfilter.Module,
+ quickFilterHandler quickfilter.Handler,
) (apiserver.APIServer, error) {
settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
router := mux.NewRouter().UseEncodedPath()
@@ -256,6 +265,8 @@ func newProvider(
llmPricingRuleHandler: llmPricingRuleHandler,
statsHandler: statsHandler,
savedViewHandler: savedViewHandler,
+ quickFilterModule: quickFilterModule,
+ quickFilterHandler: quickFilterHandler,
}
provider.authzMiddleware = middleware.NewAuthZ(settings.Logger(), orgGetter, authzService)
@@ -404,6 +415,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
return err
}
+ if err := provider.addQuickFilterRoutes(router); err != nil {
+ return err
+ }
+
return nil
}
diff --git a/pkg/apiserver/signozapiserver/quickfilter.go b/pkg/apiserver/signozapiserver/quickfilter.go
new file mode 100644
index 0000000000..b9d2d76938
--- /dev/null
+++ b/pkg/apiserver/signozapiserver/quickfilter.go
@@ -0,0 +1,120 @@
+package signozapiserver
+
+import (
+ "context"
+ "net/http"
+
+ "github.com/SigNoz/signoz/pkg/errors"
+ "github.com/SigNoz/signoz/pkg/http/handler"
+ "github.com/SigNoz/signoz/pkg/types/authtypes"
+ "github.com/SigNoz/signoz/pkg/types/coretypes"
+ "github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+ "github.com/SigNoz/signoz/pkg/valuer"
+ "github.com/gorilla/mux"
+)
+
+func (provider *provider) addQuickFilterRoutes(router *mux.Router) error {
+ if err := router.Handle("/api/v2/quick_filters", handler.New(
+ provider.authzMiddleware.CheckResources(provider.quickFilterHandler.ListQuickFiltersV2, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName),
+ handler.OpenAPIDef{
+ ID: "ListQuickFilters",
+ Tags: []string{"quick_filter"},
+ Summary: "List quick filters",
+ Description: "Returns the org's quick filters for every source, each filter as a telemetry field key.",
+ Request: nil,
+ RequestContentType: "",
+ Response: make([]*quickfiltertypes.SourceFilters, 0),
+ ResponseContentType: "application/json",
+ SuccessStatusCode: http.StatusOK,
+ ErrorStatusCodes: []int{http.StatusBadRequest},
+ Deprecated: false,
+ SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceQuickFilter.Scope(coretypes.VerbList)}),
+ },
+ handler.WithResourceDefs(handler.BasicResourceDef{
+ Resource: coretypes.ResourceMetaResourceQuickFilter,
+ Verb: coretypes.VerbList,
+ Category: coretypes.ActionCategoryDataAccess,
+ Selector: coretypes.WildcardSelector,
+ }),
+ )).Methods(http.MethodGet).GetError(); err != nil {
+ return err
+ }
+
+ if err := router.Handle("/api/v2/quick_filters/{source}", handler.New(
+ provider.authzMiddleware.CheckResources(provider.quickFilterHandler.GetQuickFiltersV2, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName),
+ handler.OpenAPIDef{
+ ID: "GetQuickFilters",
+ Tags: []string{"quick_filter"},
+ Summary: "Get a source's quick filters",
+ Description: "Returns the org's quick filters for one source, each filter as a telemetry field key.",
+ Request: nil,
+ RequestContentType: "",
+ Response: new(quickfiltertypes.SourceFilters),
+ ResponseContentType: "application/json",
+ SuccessStatusCode: http.StatusOK,
+ ErrorStatusCodes: []int{http.StatusBadRequest},
+ Deprecated: false,
+ SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceQuickFilter.Scope(coretypes.VerbRead)}),
+ },
+ handler.WithResourceDefs(handler.BasicResourceDef{
+ Resource: coretypes.ResourceMetaResourceQuickFilter,
+ Verb: coretypes.VerbRead,
+ Category: coretypes.ActionCategoryDataAccess,
+ ID: coretypes.PathParam("source"),
+ Selector: provider.quickFilterSelector,
+ }),
+ )).Methods(http.MethodGet).GetError(); err != nil {
+ return err
+ }
+
+ if err := router.Handle("/api/v2/quick_filters/{source}", handler.New(
+ provider.authzMiddleware.CheckResources(provider.quickFilterHandler.UpdateQuickFiltersV2, authtypes.SigNozAdminRoleName),
+ handler.OpenAPIDef{
+ ID: "UpdateQuickFilters",
+ Tags: []string{"quick_filter"},
+ Summary: "Update quick filters",
+ Description: "Replaces the org's quick filters for the source named in the path.",
+ Request: new(quickfiltertypes.UpdatableQuickFilters),
+ RequestContentType: "application/json",
+ Response: nil,
+ ResponseContentType: "application/json",
+ SuccessStatusCode: http.StatusNoContent,
+ ErrorStatusCodes: []int{http.StatusBadRequest},
+ Deprecated: false,
+ SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceQuickFilter.Scope(coretypes.VerbUpdate)}),
+ },
+ handler.WithResourceDefs(handler.BasicResourceDef{
+ Resource: coretypes.ResourceMetaResourceQuickFilter,
+ Verb: coretypes.VerbUpdate,
+ Category: coretypes.ActionCategoryConfigurationChange,
+ ID: coretypes.PathParam("source"),
+ Selector: provider.quickFilterSelector,
+ }),
+ )).Methods(http.MethodPut).GetError(); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (provider *provider) quickFilterSelector(ctx context.Context, resource coretypes.Resource, source string, orgID valuer.UUID) ([]coretypes.Selector, error) {
+ validatedSource, err := quickfiltertypes.NewSource(source)
+ if err != nil {
+ return nil, err
+ }
+
+ // A source can have no stored row yet: GET serves it as empty and PUT
+ // creates it, so only the wildcard grant applies until the row exists.
+ quickFilter, err := provider.quickFilterModule.Get(ctx, orgID, validatedSource)
+ if err != nil {
+ if errors.Ast(err, errors.TypeNotFound) {
+ return []coretypes.Selector{resource.Type().MustSelector(coretypes.WildCardSelectorString)}, nil
+ }
+ return nil, err
+ }
+
+ return []coretypes.Selector{
+ resource.Type().MustSelector(quickFilter.ID.StringValue()),
+ resource.Type().MustSelector(coretypes.WildCardSelectorString),
+ }, nil
+}
diff --git a/pkg/modules/quickfilter/implquickfilter/handler.go b/pkg/modules/quickfilter/implquickfilter/handler.go
index 65d0477a28..2bee3d6a9c 100644
--- a/pkg/modules/quickfilter/implquickfilter/handler.go
+++ b/pkg/modules/quickfilter/implquickfilter/handler.go
@@ -4,10 +4,13 @@ import (
"encoding/json"
"net/http"
+ "github.com/SigNoz/signoz/pkg/errors"
"github.com/SigNoz/signoz/pkg/http/render"
"github.com/SigNoz/signoz/pkg/modules/quickfilter"
+ v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
"github.com/SigNoz/signoz/pkg/types/authtypes"
"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
"github.com/SigNoz/signoz/pkg/valuer"
"github.com/gorilla/mux"
)
@@ -20,6 +23,13 @@ func NewHandler(module quickfilter.Module) quickfilter.Handler {
return &handler{module: module}
}
+// legacySourceFilters is the v1 API shape: filters as v3 attribute keys,
+// with the source still spelled "signal" on the wire.
+type legacySourceFilters struct {
+ Source quickfiltertypes.Source `json:"signal"`
+ Filters []v3.AttributeKey `json:"filters"`
+}
+
func (handler *handler) GetQuickFilters(rw http.ResponseWriter, r *http.Request) {
claims, err := authtypes.ClaimsFromContext(r.Context())
if err != nil {
@@ -27,13 +37,41 @@ func (handler *handler) GetQuickFilters(rw http.ResponseWriter, r *http.Request)
return
}
- filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID))
+ filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), quickfiltertypes.Source{})
if err != nil {
render.Error(rw, err)
return
}
- render.Success(rw, http.StatusOK, filters)
+ legacyFilters := make([]*legacySourceFilters, 0, len(filters))
+ for _, sourceFilters := range filters {
+ legacyFilters = append(legacyFilters, newLegacySourceFilters(sourceFilters))
+ }
+
+ render.Success(rw, http.StatusOK, legacyFilters)
+}
+
+func (handler *handler) GetSourceFilters(rw http.ResponseWriter, r *http.Request) {
+ claims, err := authtypes.ClaimsFromContext(r.Context())
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ source := mux.Vars(r)["signal"]
+ validatedSource, err := quickfiltertypes.NewSource(source)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSource)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ render.Success(rw, http.StatusOK, newLegacySourceFilters(handler.sourceFiltersOrEmpty(filters, validatedSource)))
}
func (handler *handler) UpdateQuickFilters(rw http.ResponseWriter, r *http.Request) {
@@ -43,14 +81,64 @@ func (handler *handler) UpdateQuickFilters(rw http.ResponseWriter, r *http.Reque
return
}
+ var req legacySourceFilters
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ fieldKeys, err := newTelemetryFieldKeysFromLegacy(req.Source, req.Filters)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ err = handler.module.UpsertQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), req.Source, fieldKeys)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) ListQuickFiltersV2(rw http.ResponseWriter, r *http.Request) {
+ claims, err := authtypes.ClaimsFromContext(r.Context())
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), quickfiltertypes.Source{})
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ render.Success(rw, http.StatusOK, filters)
+}
+
+func (handler *handler) UpdateQuickFiltersV2(rw http.ResponseWriter, r *http.Request) {
+ claims, err := authtypes.ClaimsFromContext(r.Context())
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ source := mux.Vars(r)["source"]
+ validatedSource, err := quickfiltertypes.NewSource(source)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
var req quickfiltertypes.UpdatableQuickFilters
- decodeErr := json.NewDecoder(r.Body).Decode(&req)
- if decodeErr != nil {
- render.Error(rw, decodeErr)
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ render.Error(rw, err)
return
}
- err = handler.module.UpdateQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), req.Signal, req.Filters)
+ err = handler.module.UpsertQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSource, req.Filters)
if err != nil {
render.Error(rw, err)
return
@@ -59,25 +147,111 @@ func (handler *handler) UpdateQuickFilters(rw http.ResponseWriter, r *http.Reque
render.Success(rw, http.StatusNoContent, nil)
}
-func (handler *handler) GetSignalFilters(rw http.ResponseWriter, r *http.Request) {
+func (handler *handler) GetQuickFiltersV2(rw http.ResponseWriter, r *http.Request) {
claims, err := authtypes.ClaimsFromContext(r.Context())
if err != nil {
render.Error(rw, err)
return
}
- signal := mux.Vars(r)["signal"]
- validatedSignal, err := quickfiltertypes.NewSignal(signal)
+ source := mux.Vars(r)["source"]
+ validatedSource, err := quickfiltertypes.NewSource(source)
if err != nil {
render.Error(rw, err)
return
}
- filters, err := handler.module.GetSignalFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSignal)
+ filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSource)
if err != nil {
render.Error(rw, err)
return
}
- render.Success(rw, http.StatusOK, filters)
+ render.Success(rw, http.StatusOK, handler.sourceFiltersOrEmpty(filters, validatedSource))
+}
+
+// sourceFiltersOrEmpty keeps the single-source response contract: a source
+// with no stored filters is served as an empty filter list, not an error.
+func (handler *handler) sourceFiltersOrEmpty(filters []*quickfiltertypes.SourceFilters, source quickfiltertypes.Source) *quickfiltertypes.SourceFilters {
+ if len(filters) == 0 {
+ return quickfiltertypes.NewSourceFiltersFromSource(source)
+ }
+ return filters[0]
+}
+
+// newTelemetryFieldKeysFromLegacy converts a v1 write payload with the same
+// normalizations as the storage migration: alias contexts, numerics to number.
+// The v1 shape carries no per filter signal, so meter keys get it restored.
+func newTelemetryFieldKeysFromLegacy(source quickfiltertypes.Source, filters []v3.AttributeKey) ([]telemetrytypes.TelemetryFieldKey, error) {
+ var fieldSignal telemetrytypes.Signal
+ if source == quickfiltertypes.SourceMeter {
+ fieldSignal = telemetrytypes.SignalMetrics
+ }
+
+ fieldKeys := make([]telemetrytypes.TelemetryFieldKey, 0, len(filters))
+ for _, filter := range filters {
+ if err := filter.Validate(); err != nil {
+ return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid filter: %v", err)
+ }
+
+ fieldContext, ok := telemetrytypes.FieldContextFromText(string(filter.Type))
+ if !ok {
+ fieldContext = telemetrytypes.FieldContextUnspecified
+ }
+
+ var fieldDataType telemetrytypes.FieldDataType
+ if err := fieldDataType.Scan(string(filter.DataType)); err != nil {
+ fieldDataType = telemetrytypes.FieldDataTypeUnspecified
+ }
+ if fieldDataType == telemetrytypes.FieldDataTypeInt64 {
+ fieldDataType = telemetrytypes.FieldDataTypeNumber
+ }
+
+ fieldKeys = append(fieldKeys, telemetrytypes.TelemetryFieldKey{
+ Name: filter.Key,
+ Signal: fieldSignal,
+ FieldContext: fieldContext,
+ FieldDataType: fieldDataType,
+ })
+ }
+
+ return fieldKeys, nil
+}
+
+// newLegacySourceFilters renders stored telemetry field keys
+// back into the v1 shape, restoring the legacy spellings v1 clients expect.
+func newLegacySourceFilters(sourceFilters *quickfiltertypes.SourceFilters) *legacySourceFilters {
+ filters := make([]v3.AttributeKey, 0, len(sourceFilters.Filters))
+ for _, fieldKey := range sourceFilters.Filters {
+ // Only tag and resource exist in the v3 enum; other contexts render as
+ // unspecified so v1 clients never see spellings their queries can't use.
+ var attributeType v3.AttributeKeyType
+ switch fieldKey.FieldContext {
+ case telemetrytypes.FieldContextAttribute:
+ attributeType = v3.AttributeKeyTypeTag
+ case telemetrytypes.FieldContextResource:
+ attributeType = v3.AttributeKeyTypeResource
+ default:
+ attributeType = v3.AttributeKeyTypeUnspecified
+ }
+
+ var dataType v3.AttributeKeyDataType
+ switch fieldKey.FieldDataType {
+ case telemetrytypes.FieldDataTypeNumber:
+ dataType = v3.AttributeKeyDataTypeFloat64
+ default:
+ dataType = v3.AttributeKeyDataType(fieldKey.FieldDataType.StringValue())
+ }
+
+ filters = append(filters, v3.AttributeKey{
+ Key: fieldKey.Name,
+ Type: attributeType,
+ DataType: dataType,
+ })
+ }
+
+ return &legacySourceFilters{
+ Source: sourceFilters.Source,
+ Filters: filters,
+ }
}
diff --git a/pkg/modules/quickfilter/implquickfilter/handler_test.go b/pkg/modules/quickfilter/implquickfilter/handler_test.go
new file mode 100644
index 0000000000..f9749de71d
--- /dev/null
+++ b/pkg/modules/quickfilter/implquickfilter/handler_test.go
@@ -0,0 +1,62 @@
+package implquickfilter
+
+import (
+ "testing"
+
+ v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+ "github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestNewTelemetryFieldKeysFromLegacy(t *testing.T) {
+ fieldKeys, err := newTelemetryFieldKeysFromLegacy(quickfiltertypes.SourceTraces, []v3.AttributeKey{
+ {Key: "service.name", Type: v3.AttributeKeyTypeResource, DataType: v3.AttributeKeyDataTypeString},
+ {Key: "http.method", Type: v3.AttributeKeyTypeTag, DataType: v3.AttributeKeyDataTypeString},
+ {Key: "duration_nano", Type: v3.AttributeKeyTypeTag, DataType: v3.AttributeKeyDataTypeFloat64},
+ {Key: "code_line", Type: v3.AttributeKeyTypeTag, DataType: v3.AttributeKeyDataTypeInt64},
+ })
+ require.NoError(t, err)
+ require.Len(t, fieldKeys, 4)
+
+ assert.Equal(t, telemetrytypes.TelemetryFieldKey{Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString}, fieldKeys[0])
+ assert.Equal(t, telemetrytypes.FieldContextAttribute, fieldKeys[1].FieldContext)
+ assert.Equal(t, telemetrytypes.FieldDataTypeNumber, fieldKeys[2].FieldDataType)
+ assert.Equal(t, telemetrytypes.FieldDataTypeNumber, fieldKeys[3].FieldDataType)
+
+ t.Run("meter writes restore the per-filter telemetry signal", func(t *testing.T) {
+ fieldKeys, err := newTelemetryFieldKeysFromLegacy(quickfiltertypes.SourceMeter, []v3.AttributeKey{
+ {Key: "host.name", DataType: v3.AttributeKeyDataTypeString},
+ })
+ require.NoError(t, err)
+ require.Len(t, fieldKeys, 1)
+ assert.Equal(t, telemetrytypes.SignalMetrics, fieldKeys[0].Signal)
+ })
+
+ t.Run("rejects a filter without a key", func(t *testing.T) {
+ _, err := newTelemetryFieldKeysFromLegacy(quickfiltertypes.SourceTraces, []v3.AttributeKey{{DataType: v3.AttributeKeyDataTypeString}})
+ require.Error(t, err)
+ })
+}
+
+func TestNewLegacySourceFilters(t *testing.T) {
+ legacy := newLegacySourceFilters(&quickfiltertypes.SourceFilters{
+ Source: quickfiltertypes.SourceLogs,
+ Filters: []telemetrytypes.TelemetryFieldKey{
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "http.method", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "duration_nano", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeNumber},
+ {Name: "severity_text", FieldContext: telemetrytypes.FieldContextLog, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "host.name", Signal: telemetrytypes.SignalMetrics},
+ },
+ })
+
+ assert.Equal(t, quickfiltertypes.SourceLogs, legacy.Source)
+ require.Len(t, legacy.Filters, 5)
+ assert.Equal(t, v3.AttributeKey{Key: "service.name", Type: v3.AttributeKeyTypeResource, DataType: v3.AttributeKeyDataTypeString}, legacy.Filters[0])
+ assert.Equal(t, v3.AttributeKeyTypeTag, legacy.Filters[1].Type)
+ assert.Equal(t, v3.AttributeKeyDataTypeFloat64, legacy.Filters[2].DataType)
+ assert.Equal(t, v3.AttributeKeyTypeUnspecified, legacy.Filters[3].Type, "contexts outside the v3 enum must render as unspecified")
+ assert.Equal(t, v3.AttributeKey{Key: "host.name"}, legacy.Filters[4])
+}
diff --git a/pkg/modules/quickfilter/implquickfilter/module.go b/pkg/modules/quickfilter/implquickfilter/module.go
index 092bb01881..951ee46742 100644
--- a/pkg/modules/quickfilter/implquickfilter/module.go
+++ b/pkg/modules/quickfilter/implquickfilter/module.go
@@ -2,12 +2,11 @@ package implquickfilter
import (
"context"
- "encoding/json"
"github.com/SigNoz/signoz/pkg/errors"
"github.com/SigNoz/signoz/pkg/modules/quickfilter"
- v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
"github.com/SigNoz/signoz/pkg/valuer"
)
@@ -19,91 +18,54 @@ func NewModule(store quickfiltertypes.QuickFilterStore) quickfilter.Module {
return &module{store: store}
}
-// GetQuickFilters returns all quick filters for an organization.
-func (module *module) GetQuickFilters(ctx context.Context, orgID valuer.UUID) ([]*quickfiltertypes.SignalFilters, error) {
- storedFilters, err := module.store.Get(ctx, orgID)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error fetching organization filters")
- }
+func (module *module) Get(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source) (*quickfiltertypes.StorableQuickFilter, error) {
+ return module.store.GetBySource(ctx, orgID, source.StringValue())
+}
- result := make([]*quickfiltertypes.SignalFilters, 0, len(storedFilters))
- for _, storedFilter := range storedFilters {
- signalFilter, err := quickfiltertypes.NewSignalFilterFromStorableQuickFilter(storedFilter)
+// GetQuickFilters returns quick filters for a source, or for every source when source is zero.
+func (module *module) GetQuickFilters(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source) ([]*quickfiltertypes.SourceFilters, error) {
+ if source.IsZero() {
+ storedFilters, err := module.store.Get(ctx, orgID)
if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for signal: %s", storedFilter.Signal)
+ return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error fetching organization filters")
}
- result = append(result, signalFilter)
- }
-
- return result, nil
-}
-// GetSignalFilters returns quick filters for a specific signal in an organization.
-func (m *module) GetSignalFilters(ctx context.Context, orgID valuer.UUID, signal quickfiltertypes.Signal) (*quickfiltertypes.SignalFilters, error) {
- storedFilter, err := m.store.GetBySignal(ctx, orgID, signal.StringValue())
- if err != nil {
- return nil, err
- }
+ result := make([]*quickfiltertypes.SourceFilters, 0, len(storedFilters))
+ for _, storedFilter := range storedFilters {
+ sourceFilter, err := quickfiltertypes.NewSourceFilterFromStorableQuickFilter(storedFilter)
+ if err != nil {
+ return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for source: %s", storedFilter.Source)
+ }
+ result = append(result, sourceFilter)
+ }
- // If no filter exists for this signal, return empty filters with the requested signal
- if storedFilter == nil {
- return &quickfiltertypes.SignalFilters{
- Signal: signal,
- Filters: []v3.AttributeKey{},
- }, nil
+ return result, nil
}
- // Convert stored filter to signal filter
- signalFilter, err := quickfiltertypes.NewSignalFilterFromStorableQuickFilter(storedFilter)
+ storedFilter, err := module.store.GetBySource(ctx, orgID, source.StringValue())
if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for signal: %s", storedFilter.Signal)
- }
-
- return signalFilter, nil
-}
-
-// UpdateQuickFilters updates quick filters for a specific signal in an organization.
-func (module *module) UpdateQuickFilters(ctx context.Context, orgID valuer.UUID, signal quickfiltertypes.Signal, filters []v3.AttributeKey) error {
- // Validate each filter
- for _, filter := range filters {
- if err := filter.Validate(); err != nil {
- return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid filter: %v", err)
+ if errors.Ast(err, errors.TypeNotFound) {
+ return []*quickfiltertypes.SourceFilters{}, nil
}
+ return nil, err
}
- // Marshal filters to JSON
- filterJSON, err := json.Marshal(filters)
- if err != nil {
- return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error marshalling filters")
- }
-
- // Check if filter exists
- existingFilter, err := module.store.GetBySignal(ctx, orgID, signal.StringValue())
+ sourceFilter, err := quickfiltertypes.NewSourceFilterFromStorableQuickFilter(storedFilter)
if err != nil {
- return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error checking existing filters")
+ return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for source: %s", storedFilter.Source)
}
- var filter *quickfiltertypes.StorableQuickFilter
- if existingFilter != nil {
- // Update in place
- if err := existingFilter.Update(filterJSON); err != nil {
- return errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "error updating existing filter")
- }
- filter = existingFilter
- } else {
- // Create new
- filter, err = quickfiltertypes.NewStorableQuickFilter(orgID, signal, filterJSON)
- if err != nil {
- return errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "error creating new filter")
- }
- }
+ return []*quickfiltertypes.SourceFilters{sourceFilter}, nil
+}
- // Persist filter
- if err := module.store.Upsert(ctx, filter); err != nil {
+// UpsertQuickFilters replaces quick filters for a specific source in an organization, creating them if absent.
+func (module *module) UpsertQuickFilters(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source, filters []telemetrytypes.TelemetryFieldKey) error {
+ filter, err := quickfiltertypes.NewStorableQuickFilter(orgID, source, filters)
+ if err != nil {
return err
}
- return nil
+ return module.store.Upsert(ctx, filter)
}
func (module *module) SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error {
diff --git a/pkg/modules/quickfilter/implquickfilter/store.go b/pkg/modules/quickfilter/implquickfilter/store.go
index 4a1e0d1d8b..7b494fd8a6 100644
--- a/pkg/modules/quickfilter/implquickfilter/store.go
+++ b/pkg/modules/quickfilter/implquickfilter/store.go
@@ -26,7 +26,7 @@ func (s *store) Get(ctx context.Context, orgID valuer.UUID) ([]*quickfiltertypes
NewSelect().
Model(&filters).
Where("org_id = ?", orgID).
- Order("signal ASC").
+ Order("source ASC").
Scan(ctx)
if err != nil {
@@ -36,7 +36,7 @@ func (s *store) Get(ctx context.Context, orgID valuer.UUID) ([]*quickfiltertypes
return filters, nil
}
-func (s *store) GetBySignal(ctx context.Context, orgID valuer.UUID, signal string) (*quickfiltertypes.StorableQuickFilter, error) {
+func (s *store) GetBySource(ctx context.Context, orgID valuer.UUID, source string) (*quickfiltertypes.StorableQuickFilter, error) {
filter := new(quickfiltertypes.StorableQuickFilter)
err := s.store.
@@ -44,12 +44,12 @@ func (s *store) GetBySignal(ctx context.Context, orgID valuer.UUID, signal strin
NewSelect().
Model(filter).
Where("org_id = ?", orgID).
- Where("signal = ?", signal).
+ Where("source = ?", source).
Scan(ctx)
if err != nil {
if err == sql.ErrNoRows {
- return nil, s.store.WrapNotFoundErrf(err, errors.CodeNotFound, "No rows found for org_id: "+orgID.StringValue()+" signal: "+signal)
+ return nil, s.store.WrapNotFoundErrf(err, errors.CodeNotFound, "No rows found for org_id: "+orgID.StringValue()+" source: "+source)
}
return nil, err
}
@@ -62,7 +62,7 @@ func (s *store) Upsert(ctx context.Context, filter *quickfiltertypes.StorableQui
BunDB().
NewInsert().
Model(filter).
- On("CONFLICT (id) DO UPDATE").
+ On("CONFLICT (org_id, source) DO UPDATE").
Set("filter = EXCLUDED.filter").
Set("updated_at = EXCLUDED.updated_at").
Exec(ctx)
@@ -78,7 +78,7 @@ func (s *store) Create(ctx context.Context, filters []*quickfiltertypes.Storable
BunDBCtx(ctx).
NewInsert().
Model(&filters).
- On("CONFLICT (org_id, signal) DO NOTHING").
+ On("CONFLICT (org_id, source) DO NOTHING").
Exec(ctx)
if err != nil {
diff --git a/pkg/modules/quickfilter/quickfilter.go b/pkg/modules/quickfilter/quickfilter.go
index 6528b966fc..431abff200 100644
--- a/pkg/modules/quickfilter/quickfilter.go
+++ b/pkg/modules/quickfilter/quickfilter.go
@@ -4,20 +4,27 @@ import (
"context"
"net/http"
- v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
"github.com/SigNoz/signoz/pkg/valuer"
)
type Module interface {
- GetQuickFilters(ctx context.Context, orgID valuer.UUID) ([]*quickfiltertypes.SignalFilters, error)
- UpdateQuickFilters(ctx context.Context, orgID valuer.UUID, signal quickfiltertypes.Signal, filters []v3.AttributeKey) error
- GetSignalFilters(ctx context.Context, orgID valuer.UUID, signal quickfiltertypes.Signal) (*quickfiltertypes.SignalFilters, error)
+ // Get returns the stored quick filter row for a source.
+ Get(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source) (*quickfiltertypes.StorableQuickFilter, error)
+ // GetQuickFilters returns quick filters for a source, or for every source when source is zero.
+ GetQuickFilters(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source) ([]*quickfiltertypes.SourceFilters, error)
+ UpsertQuickFilters(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source, filters []telemetrytypes.TelemetryFieldKey) error
SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error
}
type Handler interface {
+ // Legacy v1 endpoints, served by converting to and from the v3 attribute key shape.
GetQuickFilters(http.ResponseWriter, *http.Request)
UpdateQuickFilters(http.ResponseWriter, *http.Request)
- GetSignalFilters(http.ResponseWriter, *http.Request)
+ GetSourceFilters(http.ResponseWriter, *http.Request)
+
+ ListQuickFiltersV2(http.ResponseWriter, *http.Request)
+ GetQuickFiltersV2(http.ResponseWriter, *http.Request)
+ UpdateQuickFiltersV2(http.ResponseWriter, *http.Request)
}
diff --git a/pkg/query-service/app/http_handler.go b/pkg/query-service/app/http_handler.go
index 01e0e7a286..1f492a0acf 100644
--- a/pkg/query-service/app/http_handler.go
+++ b/pkg/query-service/app/http_handler.go
@@ -451,9 +451,9 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
router.HandleFunc("/api/v1/disks", am.ViewAccess(aH.getDisks)).Methods(http.MethodGet)
- // Quick Filters
+ // Quick Filters (v1 routes serve the legacy v3 shape; v2 lives in signozapiserver)
router.HandleFunc("/api/v1/orgs/me/filters", am.ViewAccess(aH.Signoz.Handlers.QuickFilter.GetQuickFilters)).Methods(http.MethodGet)
- router.HandleFunc("/api/v1/orgs/me/filters/{signal}", am.ViewAccess(aH.Signoz.Handlers.QuickFilter.GetSignalFilters)).Methods(http.MethodGet)
+ router.HandleFunc("/api/v1/orgs/me/filters/{signal}", am.ViewAccess(aH.Signoz.Handlers.QuickFilter.GetSourceFilters)).Methods(http.MethodGet)
router.HandleFunc("/api/v1/orgs/me/filters", am.AdminAccess(aH.Signoz.Handlers.QuickFilter.UpdateQuickFilters)).Methods(http.MethodPut)
router.HandleFunc("/api/v1/register", am.OpenAccess(aH.registerUser)).Methods(http.MethodPost)
diff --git a/pkg/signoz/openapi.go b/pkg/signoz/openapi.go
index acad6d2bc5..b4ad7416bb 100644
--- a/pkg/signoz/openapi.go
+++ b/pkg/signoz/openapi.go
@@ -30,6 +30,7 @@ import (
"github.com/SigNoz/signoz/pkg/modules/organization"
"github.com/SigNoz/signoz/pkg/modules/preference"
"github.com/SigNoz/signoz/pkg/modules/promote"
+ "github.com/SigNoz/signoz/pkg/modules/quickfilter"
"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
"github.com/SigNoz/signoz/pkg/modules/savedview"
@@ -97,6 +98,8 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
struct{ ruler.Handler }{},
struct{ statsreporter.Handler }{},
struct{ savedview.Handler }{},
+ struct{ quickfilter.Module }{},
+ struct{ quickfilter.Handler }{},
).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
if err != nil {
return nil, err
diff --git a/pkg/signoz/provider.go b/pkg/signoz/provider.go
index ca17cc4da5..1246e2bbc9 100644
--- a/pkg/signoz/provider.go
+++ b/pkg/signoz/provider.go
@@ -248,6 +248,8 @@ func NewSQLMigrationProviderFactories(
sqlmigration.NewAddSystemDashboardFactory(sqlstore, sqlschema),
sqlmigration.NewAddLicenseTuplesFactory(sqlstore),
sqlmigration.NewAddChannelDisplayNameFactory(sqlstore, sqlschema),
+ sqlmigration.NewMigrateQuickFiltersFactory(sqlstore),
+ sqlmigration.NewAddQuickFilterTuplesFactory(sqlstore),
)
}
@@ -353,6 +355,8 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
handlers.RulerHandler,
handlers.StatsHandler,
handlers.SavedView,
+ modules.QuickFilter,
+ handlers.QuickFilter,
),
)
}
diff --git a/pkg/sqlmigration/122_migrate_quick_filters.go b/pkg/sqlmigration/122_migrate_quick_filters.go
new file mode 100644
index 0000000000..46e24e5aac
--- /dev/null
+++ b/pkg/sqlmigration/122_migrate_quick_filters.go
@@ -0,0 +1,180 @@
+package sqlmigration
+
+import (
+ "context"
+ "encoding/json"
+ "log/slog"
+ "strings"
+
+ "github.com/uptrace/bun"
+ "github.com/uptrace/bun/migrate"
+
+ "github.com/SigNoz/signoz/pkg/factory"
+ "github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+type storableQuickFilterRow struct {
+ bun.BaseModel `bun:"table:quick_filter"`
+
+ ID string `bun:"id,pk"`
+ Filter string `bun:"filter"`
+}
+
+// legacyQuickFilterEntry carries both shapes a stored entry can be in: the
+// legacy key/type/dataType shape and the current name-carrying shape.
+type legacyQuickFilterEntry struct {
+ Name string `json:"name"`
+ Key string `json:"key"`
+ Type string `json:"type"`
+ DataType string `json:"dataType"`
+ Signal string `json:"signal"`
+}
+
+// quickFilterLegacyTypeToFieldContext maps the v3 attribute key types the v1
+// write path could store. Materialized top-level fields carried no type, and
+// anything unknown (e.g. "Sum" in the old meter defaults) normalizes to
+// unspecified, matching what the v1 write path does at runtime.
+var quickFilterLegacyTypeToFieldContext = map[string]string{
+ "tag": "attribute",
+ "resource": "resource",
+ "scope": "scope",
+}
+
+// quickFilterLegacyDataTypeToFieldDataType maps the v3 attribute key data
+// types the v1 write path could store, with numerics collapsed to number,
+// matching the fields API and the v1 write path.
+var quickFilterLegacyDataTypeToFieldDataType = map[string]string{
+ "string": "string",
+ "bool": "bool",
+ "int64": "number",
+ "float64": "number",
+}
+
+type migrateQuickFilters struct {
+ sqlstore sqlstore.SQLStore
+ settings factory.ProviderSettings
+}
+
+func NewMigrateQuickFiltersFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+ return factory.NewProviderFactory(factory.MustNewName("migrate_quick_filters"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+ return &migrateQuickFilters{sqlstore: sqlstore, settings: ps}, nil
+ })
+}
+
+func (migration *migrateQuickFilters) Register(migrations *migrate.Migrations) error {
+ return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *migrateQuickFilters) Up(ctx context.Context, db *bun.DB) error {
+ tx, err := db.BeginTx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ var rows []*storableQuickFilterRow
+ if err := tx.NewSelect().Model(&rows).Scan(ctx); err != nil {
+ return err
+ }
+
+ var migrated, skipped int
+ for _, row := range rows {
+ migratedFilter, changed, ok := migrateQuickFilterEntries(row.Filter)
+ if !ok {
+ migration.settings.Logger.WarnContext(ctx, "quick filter could not be parsed, leaving it untouched", slog.String("quick_filter_id", row.ID), slog.String("raw_filter", row.Filter))
+ skipped++
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ migrated++
+ if _, err := tx.NewUpdate().Model((*storableQuickFilterRow)(nil)).Set("filter = ?", migratedFilter).Where("id = ?", row.ID).Exec(ctx); err != nil {
+ return err
+ }
+ }
+
+ migration.settings.Logger.InfoContext(ctx, "migrated quick filters to telemetry field keys", slog.Int("total", len(rows)), slog.Int("migrated", migrated), slog.Int("skipped", skipped))
+
+ if _, err := migration.sqlstore.Dialect().RenameColumn(ctx, tx, "quick_filter", "signal", "source"); err != nil {
+ return err
+ }
+
+ for _, column := range []string{"created_by", "updated_by"} {
+ if err := migration.sqlstore.Dialect().DropColumn(ctx, tx, "quick_filter", column); err != nil {
+ return err
+ }
+ }
+
+ return tx.Commit()
+}
+
+func (migration *migrateQuickFilters) Down(context.Context, *bun.DB) error {
+ return nil
+}
+
+// migrateQuickFilterEntries rewrites a stored filter list from the legacy
+// key/dataType/type shape to telemetry field keys; ok=false means unparseable.
+func migrateQuickFilterEntries(filter string) (migrated string, changed bool, ok bool) {
+ var entriesRaw []json.RawMessage
+ if err := json.Unmarshal([]byte(filter), &entriesRaw); err != nil {
+ return "", false, false
+ }
+
+ migratedEntries := make([]json.RawMessage, 0, len(entriesRaw))
+ for _, rawEntry := range entriesRaw {
+ var entry legacyQuickFilterEntry
+ if err := json.Unmarshal(rawEntry, &entry); err != nil {
+ // Some stored entries are plain strings rather than objects; treat
+ // the string as the filter key name, dropping empty ones.
+ var name string
+ if err := json.Unmarshal(rawEntry, &name); err != nil {
+ return "", false, false
+ }
+ entry = legacyQuickFilterEntry{Key: name}
+ }
+
+ switch {
+ case entry.Name != "":
+ migratedEntries = append(migratedEntries, rawEntry)
+ case entry.Key != "":
+ migratedJSON, err := marshalUnescaped(telemetryFieldKeyOutput{
+ Name: entry.Key,
+ Signal: entry.Signal,
+ FieldContext: quickFilterFieldContext(entry.Type),
+ FieldDataType: quickFilterFieldDataType(entry.DataType),
+ })
+ if err != nil {
+ return "", false, false
+ }
+ migratedEntries = append(migratedEntries, migratedJSON)
+ changed = true
+ default:
+ changed = true
+ }
+ }
+
+ if !changed {
+ return "", false, true
+ }
+
+ migratedJSON, err := marshalUnescaped(migratedEntries)
+ if err != nil {
+ return "", false, false
+ }
+
+ return string(migratedJSON), true, true
+}
+
+// quickFilterFieldDataType resolves legacy datatype spellings, with unknowns
+// normalized to unspecified.
+func quickFilterFieldDataType(legacyDataType string) string {
+ return quickFilterLegacyDataTypeToFieldDataType[strings.ToLower(strings.TrimSpace(legacyDataType))]
+}
+
+// quickFilterFieldContext resolves legacy type spellings, with unknowns
+// normalized to unspecified.
+func quickFilterFieldContext(legacyType string) string {
+ return quickFilterLegacyTypeToFieldContext[strings.ToLower(strings.TrimSpace(legacyType))]
+}
diff --git a/pkg/sqlmigration/123_add_quick_filter_tuples.go b/pkg/sqlmigration/123_add_quick_filter_tuples.go
new file mode 100644
index 0000000000..6d33a4afdd
--- /dev/null
+++ b/pkg/sqlmigration/123_add_quick_filter_tuples.go
@@ -0,0 +1,139 @@
+package sqlmigration
+
+import (
+ "context"
+ "database/sql"
+ "time"
+
+ "github.com/SigNoz/signoz/pkg/factory"
+ "github.com/SigNoz/signoz/pkg/sqlstore"
+ "github.com/SigNoz/signoz/pkg/types/authtypes"
+ "github.com/oklog/ulid/v2"
+ "github.com/uptrace/bun"
+ "github.com/uptrace/bun/dialect"
+ "github.com/uptrace/bun/migrate"
+)
+
+type addQuickFilterTuples struct {
+ sqlstore sqlstore.SQLStore
+}
+
+func NewAddQuickFilterTuplesFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+ return factory.NewProviderFactory(factory.MustNewName("add_quick_filter_tuples"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+ return &addQuickFilterTuples{sqlstore: sqlstore}, nil
+ })
+}
+
+func (migration *addQuickFilterTuples) Register(migrations *migrate.Migrations) error {
+ return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addQuickFilterTuples) Up(ctx context.Context, db *bun.DB) error {
+ tx, err := db.BeginTx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ var storeID string
+ err = tx.QueryRowContext(ctx, `SELECT id FROM store WHERE name = ? LIMIT 1`, "signoz").Scan(&storeID)
+ if err != nil {
+ return err
+ }
+
+ var orgIDs []string
+ err = tx.NewSelect().
+ Table("organizations").
+ Column("id").
+ Scan(ctx, &orgIDs)
+ if err != nil && err != sql.ErrNoRows {
+ return err
+ }
+
+ isPG := migration.sqlstore.BunDB().Dialect().Name() == dialect.PG
+
+ // quick-filter moved from the legacy ViewAccess/AdminAccess role gate to
+ // CheckResources, which on enterprise requires real tuples -- existing orgs
+ // never had these written, only new orgs get them from the registry at bootstrap.
+ tuples := []migrationTuple{
+ {authtypes.SigNozAdminRoleName, "metaresource", "quick-filter", "read"},
+ {authtypes.SigNozAdminRoleName, "metaresource", "quick-filter", "update"},
+ {authtypes.SigNozAdminRoleName, "metaresource", "quick-filter", "list"},
+ {authtypes.SigNozEditorRoleName, "metaresource", "quick-filter", "read"},
+ {authtypes.SigNozEditorRoleName, "metaresource", "quick-filter", "list"},
+ {authtypes.SigNozViewerRoleName, "metaresource", "quick-filter", "read"},
+ {authtypes.SigNozViewerRoleName, "metaresource", "quick-filter", "list"},
+ }
+
+ for _, orgID := range orgIDs {
+ for _, tuple := range tuples {
+ entropy := ulid.DefaultEntropy()
+ now := time.Now().UTC()
+ tupleID := ulid.MustNew(ulid.Timestamp(now), entropy).String()
+
+ objectID := "organization/" + orgID + "/" + tuple.objectName + "/*"
+ roleSubject := "organization/" + orgID + "/role/" + tuple.roleName
+
+ if isPG {
+ user := "role:" + roleSubject + "#assignee"
+ result, err := tx.ExecContext(ctx, `
+ INSERT INTO tuple (store, object_type, object_id, relation, _user, user_type, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, object_type, object_id, relation, _user) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, user, "userset", tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return err
+ }
+ if rowsAffected == 0 {
+ continue
+ }
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO changelog (store, object_type, object_id, relation, _user, operation, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, user, 0, tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ } else {
+ result, err := tx.ExecContext(ctx, `
+ INSERT INTO tuple (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, user_type, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", "userset", tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return err
+ }
+ if rowsAffected == 0 {
+ continue
+ }
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO changelog (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, operation, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", 0, tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ }
+ }
+ }
+
+ return tx.Commit()
+}
+
+func (migration *addQuickFilterTuples) Down(context.Context, *bun.DB) error {
+ return nil
+}
diff --git a/pkg/types/coretypes/registry_resource.go b/pkg/types/coretypes/registry_resource.go
index 9e7f8528a7..0aa35b62c4 100644
--- a/pkg/types/coretypes/registry_resource.go
+++ b/pkg/types/coretypes/registry_resource.go
@@ -62,7 +62,7 @@ var (
ResourceMetaResourcePipeline = NewResourceMetaResource(KindPipeline)
ResourceMetaResourceUserPreference = NewResourceMetaResource(KindUserPreference)
ResourceMetaResourceOrgPreference = NewResourceMetaResource(KindOrgPreference)
- ResourceMetaResourceQuickFilter = NewResourceMetaResource(KindQuickFilter)
+ ResourceMetaResourceQuickFilter = NewResourceMetaResource(KindQuickFilter, VerbList, VerbRead, VerbUpdate)
ResourceMetaResourceTTLSetting = NewResourceMetaResource(KindTTLSetting)
ResourceMetaResourceRule = NewResourceMetaResource(KindRule)
ResourceMetaResourcePlannedMaintenance = NewResourceMetaResource(KindPlannedMaintenance)
diff --git a/pkg/types/quickfiltertypes/filter.go b/pkg/types/quickfiltertypes/filter.go
index 688c903c05..e5604cebb9 100644
--- a/pkg/types/quickfiltertypes/filter.go
+++ b/pkg/types/quickfiltertypes/filter.go
@@ -5,58 +5,69 @@ import (
"time"
"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/aiobservabilitytypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
"github.com/SigNoz/signoz/pkg/valuer"
"github.com/uptrace/bun"
)
-type Signal struct {
+type Source struct {
valuer.String
}
-func (enum *Signal) UnmarshalJSON(data []byte) error {
+func (enum *Source) UnmarshalJSON(data []byte) error {
var str string
if err := json.Unmarshal(data, &str); err != nil {
return err
}
- signal, err := NewSignal(str)
+ source, err := NewSource(str)
if err != nil {
return err
}
- *enum = signal
+ *enum = source
return nil
}
var (
- SignalTraces = Signal{valuer.NewString("traces")}
- SignalLogs = Signal{valuer.NewString("logs")}
- SignalApiMonitoring = Signal{valuer.NewString("api_monitoring")}
- SignalExceptions = Signal{valuer.NewString("exceptions")}
- SignalMeter = Signal{valuer.NewString("meter")}
- SignalAiObservability = Signal{valuer.NewString("ai_observability")}
+ SourceTraces = Source{valuer.NewString("traces")}
+ SourceLogs = Source{valuer.NewString("logs")}
+ SourceApiMonitoring = Source{valuer.NewString("api_monitoring")}
+ SourceExceptions = Source{valuer.NewString("exceptions")}
+ SourceMeter = Source{valuer.NewString("meter")}
+ SourceAiObservability = Source{valuer.NewString("ai_observability")}
)
-// NewSignal creates a Signal from a string.
-func NewSignal(s string) (Signal, error) {
+func (Source) Enum() []any {
+ return []any{
+ SourceTraces,
+ SourceLogs,
+ SourceApiMonitoring,
+ SourceExceptions,
+ SourceMeter,
+ SourceAiObservability,
+ }
+}
+
+// NewSource creates a Source from a string.
+func NewSource(s string) (Source, error) {
switch s {
case "traces":
- return SignalTraces, nil
+ return SourceTraces, nil
case "logs":
- return SignalLogs, nil
+ return SourceLogs, nil
case "api_monitoring":
- return SignalApiMonitoring, nil
+ return SourceApiMonitoring, nil
case "exceptions":
- return SignalExceptions, nil
+ return SourceExceptions, nil
case "meter":
- return SignalMeter, nil
+ return SourceMeter, nil
case "ai_observability":
- return SignalAiObservability, nil
+ return SourceAiObservability, nil
default:
- return Signal{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid signal: %s", s)
+ return Source{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid source: %s", s)
}
}
@@ -65,33 +76,46 @@ type StorableQuickFilter struct {
types.Identifiable
OrgID valuer.UUID `bun:"org_id,type:text,notnull"`
Filter string `bun:"filter,type:text,notnull"`
- Signal Signal `bun:"signal,type:text,notnull"`
+ Source Source `bun:"source,type:text,notnull"`
types.TimeAuditable
}
-type SignalFilters struct {
- Signal Signal `json:"signal"`
- Filters []v3.AttributeKey `json:"filters"`
+type SourceFilters struct {
+ types.Identifiable
+ types.TimeAuditable
+
+ OrgID valuer.UUID `json:"orgId" required:"true"`
+ Source Source `json:"source" required:"true"`
+ Filters []telemetrytypes.TelemetryFieldKey `json:"filters" required:"true" nullable:"false"`
}
type UpdatableQuickFilters struct {
- Signal Signal `json:"signal"`
- Filters []v3.AttributeKey `json:"filters"`
+ Filters []telemetrytypes.TelemetryFieldKey `json:"filters" required:"true" nullable:"false"`
}
// NewStorableQuickFilter creates a new StorableQuickFilter after validation.
-func NewStorableQuickFilter(orgID valuer.UUID, signal Signal, filterJSON []byte) (*StorableQuickFilter, error) {
- if orgID.StringValue() == "" {
+func NewStorableQuickFilter(orgID valuer.UUID, source Source, filters []telemetrytypes.TelemetryFieldKey) (*StorableQuickFilter, error) {
+ if orgID.IsZero() {
return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgID is required")
}
- if _, err := NewSignal(signal.StringValue()); err != nil {
+ if _, err := NewSource(source.StringValue()); err != nil {
return nil, err
}
- var filters []v3.AttributeKey
- if err := json.Unmarshal(filterJSON, &filters); err != nil {
- return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid filter JSON")
+ if err := validateFilters(filters); err != nil {
+ return nil, err
+ }
+
+ // A nil slice marshals to the JSON literal "null"; store an empty array so
+ // reads never have to render a null filter list.
+ if filters == nil {
+ filters = []telemetrytypes.TelemetryFieldKey{}
+ }
+
+ filterJSON, err := json.Marshal(filters)
+ if err != nil {
+ return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error marshalling filters")
}
now := time.Now()
@@ -100,7 +124,7 @@ func NewStorableQuickFilter(orgID valuer.UUID, signal Signal, filterJSON []byte)
ID: valuer.GenerateUUID(),
},
OrgID: orgID,
- Signal: signal,
+ Source: source,
Filter: string(filterJSON),
TimeAuditable: types.TimeAuditable{
CreatedAt: now,
@@ -109,25 +133,21 @@ func NewStorableQuickFilter(orgID valuer.UUID, signal Signal, filterJSON []byte)
}, nil
}
-// Update updates an existing StorableQuickFilter with new filter data after validation.
-func (quickfilter *StorableQuickFilter) Update(filterJSON []byte) error {
- var filters []v3.AttributeKey
- if err := json.Unmarshal(filterJSON, &filters); err != nil {
- return errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid filter JSON")
+// NewSourceFiltersFromSource creates a SourceFilters with no filters for a source.
+func NewSourceFiltersFromSource(source Source) *SourceFilters {
+ return &SourceFilters{
+ Source: source,
+ Filters: []telemetrytypes.TelemetryFieldKey{},
}
-
- quickfilter.Filter = string(filterJSON)
- quickfilter.UpdatedAt = time.Now()
- return nil
}
-// NewSignalFilterFromStorableQuickFilter converts a StorableQuickFilter to a SignalFilters object.
-func NewSignalFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFilter) (*SignalFilters, error) {
+// NewSourceFilterFromStorableQuickFilter converts a StorableQuickFilter to a SourceFilters object.
+func NewSourceFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFilter) (*SourceFilters, error) {
if storableQuickFilter == nil {
return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "storableQuickFilter cannot be nil")
}
- var filters []v3.AttributeKey
+ filters := []telemetrytypes.TelemetryFieldKey{}
if storableQuickFilter.Filter != "" {
err := json.Unmarshal([]byte(storableQuickFilter.Filter), &filters)
if err != nil {
@@ -135,178 +155,114 @@ func NewSignalFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFi
}
}
- return &SignalFilters{
- Signal: storableQuickFilter.Signal,
- Filters: filters,
+ // Stored filter JSON can be the literal "null" (a nil slice was upserted),
+ // which unmarshals to nil; the API contract requires a non-null array.
+ if filters == nil {
+ filters = []telemetrytypes.TelemetryFieldKey{}
+ }
+
+ return &SourceFilters{
+ Identifiable: storableQuickFilter.Identifiable,
+ OrgID: storableQuickFilter.OrgID,
+ Source: storableQuickFilter.Source,
+ Filters: filters,
+ TimeAuditable: storableQuickFilter.TimeAuditable,
}, nil
}
-// NewDefaultQuickFilter generates default filters for all supported signals.
+// NewDefaultQuickFilter generates default filters for all supported sources.
func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
- tracesFilters := []map[string]interface{}{
- {"key": "duration_nano", "dataType": "float64", "type": "tag"},
- {"key": "deployment.environment", "dataType": "string", "type": "resource"},
- {"key": "hasError", "dataType": "bool", "type": "tag"},
- {"key": "service.name", "dataType": "string", "type": "resource"},
- {"key": "name", "dataType": "string", "type": "tag"},
- {"key": "rpc.method", "dataType": "string", "type": "tag"},
- {"key": "response_status_code", "dataType": "string", "type": "tag"},
- {"key": "http_host", "dataType": "string", "type": "tag"},
- {"key": "http.method", "dataType": "string", "type": "tag"},
- {"key": "http.route", "dataType": "string", "type": "tag"},
- {"key": "http_url", "dataType": "string", "type": "tag"},
- {"key": "trace_id", "dataType": "string", "type": "tag"},
+ tracesFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "duration_nano", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeNumber},
+ {Name: "deployment.environment", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "hasError", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeBool},
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "name", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "rpc.method", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "response_status_code", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "http_host", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "http.method", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "http.route", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "http_url", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "trace_id", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
}
- logsFilters := []map[string]interface{}{
- {"key": "severity_text", "dataType": "string", "type": "resource"},
- {"key": "deployment.environment", "dataType": "string", "type": "resource"},
- {"key": "service.name", "dataType": "string", "type": "resource"},
- {"key": "host.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.cluster.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.deployment.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.namespace.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.pod.name", "dataType": "string", "type": "resource"},
+ logsFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "severity_text", FieldContext: telemetrytypes.FieldContextLog, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "deployment.environment", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "host.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.cluster.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.deployment.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.namespace.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.pod.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
}
- apiMonitoringFilters := []map[string]interface{}{
- {"key": "deployment.environment", "dataType": "string", "type": "resource"},
- {"key": "service.name", "dataType": "string", "type": "resource"},
- {"key": "rpc.method", "dataType": "string", "type": "tag"},
+ apiMonitoringFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "deployment.environment", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "rpc.method", FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
}
- exceptionsFilters := []map[string]interface{}{
- {"key": "deployment.environment", "dataType": "string", "type": "resource"},
- {"key": "service.name", "dataType": "string", "type": "resource"},
- {"key": "host.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.cluster.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.deployment.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.namespace.name", "dataType": "string", "type": "resource"},
- {"key": "k8s.pod.name", "dataType": "string", "type": "resource"},
+ exceptionsFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "deployment.environment", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "host.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.cluster.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.deployment.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.namespace.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "k8s.pod.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
}
- meterFilters := []map[string]interface{}{
- {"key": "deployment.environment", "dataType": "float64", "type": "Sum"},
- {"key": "service.name", "dataType": "float64", "type": "Sum"},
- {"key": "host.name", "dataType": "float64", "type": "Sum"},
+ // Meter keys are label names with no context or datatype: the meter fields
+ // API returns them as name+signal only, so the defaults mirror that shape.
+ meterFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "deployment.environment", Signal: telemetrytypes.SignalMetrics},
+ {Name: "service.name", Signal: telemetrytypes.SignalMetrics},
+ {Name: "host.name", Signal: telemetrytypes.SignalMetrics},
}
// AI observability (builder_ai_query trace explorer), ordered by expected
// usage: env scoping, the LLM identity keys, then service and the rest.
- aiObservabilityFilters := []map[string]interface{}{
- {"key": "deployment.environment", "dataType": "string", "type": "resource"},
- {"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": aiobservabilitytypes.GenAIToolName, "dataType": "string", "type": "tag"},
- {"key": aiobservabilitytypes.GenAIAgentName, "dataType": "string", "type": "tag"},
- }
-
- tracesJSON, err := json.Marshal(tracesFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal traces filters")
- }
-
- logsJSON, err := json.Marshal(logsFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal logs filters")
+ aiObservabilityFilters := []telemetrytypes.TelemetryFieldKey{
+ {Name: "deployment.environment", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: aiobservabilitytypes.GenAIOperationName, FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: aiobservabilitytypes.GenAIProviderName, FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: aiobservabilitytypes.GenAIRequestModel, FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: "service.name", FieldContext: telemetrytypes.FieldContextResource, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: aiobservabilitytypes.GenAIToolName, FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
+ {Name: aiobservabilitytypes.GenAIAgentName, FieldContext: telemetrytypes.FieldContextAttribute, FieldDataType: telemetrytypes.FieldDataTypeString},
}
- apiMonitoringJSON, err := json.Marshal(apiMonitoringFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal api monitoring filters")
+ defaults := []struct {
+ source Source
+ filters []telemetrytypes.TelemetryFieldKey
+ }{
+ {SourceTraces, tracesFilters},
+ {SourceLogs, logsFilters},
+ {SourceApiMonitoring, apiMonitoringFilters},
+ {SourceExceptions, exceptionsFilters},
+ {SourceMeter, meterFilters},
+ {SourceAiObservability, aiObservabilityFilters},
}
- exceptionsJSON, err := json.Marshal(exceptionsFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal exceptions filters")
+ storableQuickFilters := make([]*StorableQuickFilter, 0, len(defaults))
+ for _, def := range defaults {
+ storableQuickFilter, err := NewStorableQuickFilter(orgID, def.source, def.filters)
+ if err != nil {
+ return nil, err
+ }
+ storableQuickFilters = append(storableQuickFilters, storableQuickFilter)
}
- meterJSON, err := json.Marshal(meterFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal meter filters")
- }
+ return storableQuickFilters, nil
+}
- aiObservabilityJSON, err := json.Marshal(aiObservabilityFilters)
- if err != nil {
- return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal ai observability filters")
+func validateFilters(filters []telemetrytypes.TelemetryFieldKey) error {
+ for _, filter := range filters {
+ if filter.Name == "" {
+ return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "filter name is required")
+ }
}
-
- timeRightNow := time.Now()
-
- return []*StorableQuickFilter{
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(tracesJSON),
- Signal: SignalTraces,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(logsJSON),
- Signal: SignalLogs,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(apiMonitoringJSON),
- Signal: SignalApiMonitoring,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(exceptionsJSON),
- Signal: SignalExceptions,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(meterJSON),
- Signal: SignalMeter,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- {
- Identifiable: types.Identifiable{
- ID: valuer.GenerateUUID(),
- },
- OrgID: orgID,
- Filter: string(aiObservabilityJSON),
- Signal: SignalAiObservability,
- TimeAuditable: types.TimeAuditable{
- CreatedAt: timeRightNow,
- UpdatedAt: timeRightNow,
- },
- },
- }, nil
+ return nil
}
diff --git a/pkg/types/quickfiltertypes/store.go b/pkg/types/quickfiltertypes/store.go
index 5cf2c3dd7e..632b878bff 100644
--- a/pkg/types/quickfiltertypes/store.go
+++ b/pkg/types/quickfiltertypes/store.go
@@ -10,10 +10,10 @@ type QuickFilterStore interface {
// Get retrieves all filters for an organization
Get(ctx context.Context, orgID valuer.UUID) ([]*StorableQuickFilter, error)
- // GetBySignal retrieves filters for a specific signal in an organization
- GetBySignal(ctx context.Context, orgID valuer.UUID, signal string) (*StorableQuickFilter, error)
+ // GetBySource retrieves filters for a specific source in an organization
+ GetBySource(ctx context.Context, orgID valuer.UUID, source string) (*StorableQuickFilter, error)
- // Upsert inserts or updates filters for an organization and signal
+ // Upsert inserts or updates filters for an organization and source
Upsert(ctx context.Context, filter *StorableQuickFilter) error
Create(ctx context.Context, filter []*StorableQuickFilter) error
}
diff --git a/tests/integration/tests/quickfilter/01_quick_filter.py b/tests/integration/tests/quickfilter/01_quick_filter.py
new file mode 100644
index 0000000000..17827a0bbe
--- /dev/null
+++ b/tests/integration/tests/quickfilter/01_quick_filter.py
@@ -0,0 +1,276 @@
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+from sqlalchemy import sql
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+
+ALL_SOURCES = {
+ "traces",
+ "logs",
+ "api_monitoring",
+ "exceptions",
+ "meter",
+ "ai_observability",
+}
+
+
+def test_get_quick_filters_returns_defaults(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+
+ assert response.status_code == HTTPStatus.OK, response.text
+ data = response.json()["data"]
+ assert {source_filters["source"] for source_filters in data} == ALL_SOURCES
+
+ for source_filters in data:
+ assert source_filters["id"] != "00000000-0000-0000-0000-000000000000"
+ assert source_filters["orgId"] != "00000000-0000-0000-0000-000000000000"
+ assert source_filters["createdAt"] != ""
+ assert source_filters["updatedAt"] != ""
+ assert len(source_filters["filters"]) > 0
+ for field_key in source_filters["filters"]:
+ assert field_key["name"] != ""
+ assert "fieldContext" in field_key
+ assert "fieldDataType" in field_key
+ assert "key" not in field_key
+
+
+def test_v1_get_serves_legacy_shape(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ data = response.json()["data"]
+ assert {source_filters["signal"] for source_filters in data} == ALL_SOURCES
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters/traces"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ filters = response.json()["data"]["filters"]
+ assert filters[0]["key"] == "duration_nano"
+ assert filters[0]["type"] == "tag"
+ assert filters[0]["dataType"] == "float64"
+ assert all("name" not in legacy_filter for legacy_filter in filters)
+
+
+def test_v1_update_round_trips_to_v2(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ response = requests.put(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters"),
+ json={
+ "signal": "exceptions",
+ "filters": [
+ {"key": "service.name", "dataType": "string", "type": "resource"},
+ {"key": "http.method", "dataType": "string", "type": "tag"},
+ {"key": "code_line", "dataType": "int64", "type": "tag"},
+ ],
+ },
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/exceptions"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ filters = response.json()["data"]["filters"]
+ assert [(field_key["name"], field_key["fieldContext"]) for field_key in filters] == [
+ ("service.name", "resource"),
+ ("http.method", "attribute"),
+ ("code_line", "attribute"),
+ ]
+ assert filters[2]["fieldDataType"] == "number"
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters/exceptions"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ filters = response.json()["data"]["filters"]
+ assert [(legacy_filter["key"], legacy_filter["type"]) for legacy_filter in filters] == [
+ ("service.name", "resource"),
+ ("http.method", "tag"),
+ ("code_line", "tag"),
+ ]
+
+ response = requests.put(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters"),
+ json={
+ "signal": "meter",
+ "filters": [{"key": "host.name", "dataType": "string", "type": ""}],
+ },
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/meter"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ assert [(field_key["name"], field_key["signal"]) for field_key in response.json()["data"]["filters"]] == [("host.name", "metrics")]
+
+
+def test_update_quick_filters_round_trip(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ response = requests.put(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/logs"),
+ json={
+ "filters": [
+ {
+ "name": "k8s.pod.name",
+ "fieldContext": "resource",
+ "fieldDataType": "string",
+ },
+ {
+ "name": "body.status",
+ "fieldContext": "body",
+ "fieldDataType": "string",
+ },
+ ],
+ },
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/logs"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+
+ assert response.status_code == HTTPStatus.OK, response.text
+ filters = response.json()["data"]["filters"]
+ assert [field_key["name"] for field_key in filters] == [
+ "k8s.pod.name",
+ "body.status",
+ ]
+ assert filters[0]["fieldContext"] == "resource"
+ assert filters[1]["fieldContext"] == "body"
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v1/orgs/me/filters/logs"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ assert [(legacy_filter["key"], legacy_filter["type"]) for legacy_filter in response.json()["data"]["filters"]] == [
+ ("k8s.pod.name", "resource"),
+ ("body.status", ""),
+ ]
+
+
+def test_update_quick_filters_creates_row_for_source_without_one(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ with signoz.sqlstore.conn.connect() as conn:
+ conn.execute(
+ sql.text("DELETE FROM quick_filter WHERE source = :source"),
+ {"source": "api_monitoring"},
+ )
+ conn.commit()
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/api_monitoring"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ data = response.json()["data"]
+ assert data["source"] == "api_monitoring"
+ assert data["filters"] == []
+ assert data["id"] == "00000000-0000-0000-0000-000000000000"
+
+ response = requests.put(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/api_monitoring"),
+ json={
+ "filters": [
+ {
+ "name": "service.name",
+ "fieldContext": "resource",
+ "fieldDataType": "string",
+ },
+ ],
+ },
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get("/api/v2/quick_filters/api_monitoring"),
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ data = response.json()["data"]
+ assert [field_key["name"] for field_key in data["filters"]] == ["service.name"]
+ assert data["id"] != "00000000-0000-0000-0000-000000000000"
+
+
+def test_update_quick_filters_rejects_invalid_input(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ for source, invalid_body in [
+ (
+ "traces",
+ {"filters": [{"key": "service.name", "dataType": "string", "type": "resource"}]},
+ ),
+ ("invalid", {"filters": []}),
+ ]:
+ response = requests.put(
+ signoz.self.host_configs["8080"].get(f"/api/v2/quick_filters/{source}"),
+ json=invalid_body,
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=2,
+ )
+ assert response.status_code == HTTPStatus.BAD_REQUEST, response.text