fix(quick-filters): keep the filter expression in sync with the filter items

Quick filters dispatch through the URL, where the composite-query parser merges
filters.items into filter.expression. That merge only adds and rewrites clauses,
so a clause left behind in the expression resurrects a filter the user removed.

Restore the invariant once before returning instead of at each removal site, and
stop the NOT IN branch from treating an already-excluded value as a new
selection, which made re-including it flip the clause to IN.

.github/workflows/integrationci.yaml

@@ -50,7 +50,6 @@ jobs:
           - logspipelines
           - passwordauthn
           - preference
-          - quickfilter
           - querierlogs
           - queriertraces
           - queriermetrics

docs/api/openapi.yml

@@ -7626,37 +7626,6 @@ components:
       - custom
       - text
       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:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-      required:
-      - id
-      - filters
-      type: object
-    QuickfiltertypesUpdatableQuickFilters:
-      properties:
-        filters:
-          items:
-            $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
-          type: array
-      required:
-      - filters
-      type: object
     RenderErrorResponse:
       properties:
         error:
@@ -18660,171 +18629,6 @@ 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'
-                    nullable: true
-                    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

frontend/public/locales/en-GB/channels.json

@@ -26,6 +26,55 @@
   "tooltip_ms_teams_url": "The URL of the Microsoft Teams [webhook](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498) to send alerts to. Learn more about Microsoft Teams integration in the docs [here](https://signoz.io/docs/alerts-management/notification-channel/ms-teams/).",
   "tooltip_google_chat_url": "The URL of the Google Chat space [incoming webhook](https://developers.google.com/workspace/chat/quickstart/webhooks) to send alerts to. It must be an https URL on chat.googleapis.com.",
   "google_chat_webhook_url_invalid": "Webhook URL must be an https URL on chat.googleapis.com",
+  "field_jira_site": "Site URL",
+  "tooltip_jira_site": "Your Jira Cloud base URL, e.g. https://your-domain.atlassian.net. Only Jira Cloud is supported.",
+  "jira_site_invalid": "Site URL must be an https URL on an atlassian.net domain",
+  "jira_required_fields": "Site URL, email, API token, project and issue type are required",
+  "jira_service_account_tip": "Recommended: use a Jira service account so alerts aren't reported under a personal name and the channel keeps working when someone leaves.",
+  "jira_service_account_tip_link": "Learn how",
+  "field_jira_email": "Email",
+  "help_jira_email": "The Atlassian account email used for authentication.",
+  "field_jira_api_token": "API token",
+  "help_jira_api_token": "Create one at id.atlassian.com under Security → API tokens.",
+  "field_jira_project": "Project key",
+  "field_jira_issue_type": "Issue type",
+  "help_jira_issue_type": "An issue type that exists in the project, e.g. Task, Bug or Incident.",
+  "field_jira_summary": "Summary (issue title)",
+  "help_jira_summary": "Template for the Jira issue title.",
+  "field_jira_description": "Description",
+  "help_jira_description": "Template for the issue description. Rendered as rich text with a status panel and links back to SigNoz.",
+  "jira_advanced_section": "Advanced Options",
+  "field_jira_priority": "Priority",
+  "placeholder_jira_priority": "Leave empty to use the project default",
+  "help_jira_priority": "Must match a priority in the project's scheme, e.g. High.",
+  "field_jira_labels": "Labels",
+  "placeholder_jira_labels": "Type a label and press Enter",
+  "help_jira_labels": "signoz and a deduplication label are added automatically.",
+  "field_jira_resolve_transition": "Resolve transition",
+  "field_jira_reopen_transition": "Reopen transition",
+  "help_jira_resolve_transition": "When the alert resolves, SigNoz moves the Jira issue to a \"Done\" status via a workflow transition. This is auto-detected — leave it empty unless your project has more than one \"Done\" transition (e.g. Done vs. Won't Do) and you want to force a specific one by name.",
+  "help_jira_reopen_transition": "When a resolved alert fires again (within the reopen window), SigNoz moves the issue back out of \"Done\" to an active status via a workflow transition. This is auto-detected — leave it empty unless you want to force a specific one by name (e.g. To Do or Reopen).",
+  "placeholder_jira_resolve_transition": "Auto-detected, e.g. Done",
+  "placeholder_jira_reopen_transition": "Auto-detected, e.g. To Do",
+  "field_jira_reopen_duration": "Reopen window",
+  "placeholder_jira_reopen_duration": "e.g. 72h",
+  "help_jira_reopen_duration": "If a resolved alert fires again within this window, the same ticket is reopened; after the window, a re-fire opens a new ticket instead. Default: 3d.",
+  "tooltip_jira_reopen_duration": "Accepted units: m (minutes), h (hours), d (days), w (weeks), y (years) — e.g. 30m, 72h or 3d. Minimum 1m.",
+  "jira_reopen_duration_invalid": "Reopen window must be a duration like 30m, 72h or 3d (minimum 1m)",
+  "jsmops_tip": "Create an API integration on your JSM team's Operations page and paste its key below.",
+  "jsmops_tip_link": "Learn how",
+  "field_jsmops_api_key": "API key",
+  "help_jsmops_api_key": "The JSM Ops integration API key, from your team's Operations → Integrations → API. Make sure the integration is turned on.",
+  "field_jsmops_message": "Message (alert title)",
+  "help_jsmops_message": "Template for the alert title. Truncated to 130 characters.",
+  "field_jsmops_description": "Description",
+  "help_jsmops_description": "Template for the alert description. Rendered as rich text; kept under 15,000 characters.",
+  "jsmops_advanced_section": "Advanced Options",
+  "field_jsmops_priority": "Priority",
+  "help_jsmops_priority": "Template resolving to one of P1–P5. Leave as-is to map from alert severity.",
+  "field_jsmops_tags": "Tags",
+  "placeholder_jsmops_tags": "Type a tag and press Enter",
+  "help_jsmops_tags": "Tags added to every alert.",
 
   "field_slack_recipient": "Recipient",
   "field_slack_title": "Title",

frontend/public/locales/en/channels.json

@@ -26,6 +26,55 @@
   "tooltip_ms_teams_url": "The URL of the Microsoft Teams [webhook](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498) to send alerts to. Learn more about Microsoft Teams integration in the docs [here](https://signoz.io/docs/alerts-management/notification-channel/ms-teams/).",
   "tooltip_google_chat_url": "The URL of the Google Chat space [incoming webhook](https://developers.google.com/workspace/chat/quickstart/webhooks) to send alerts to. It must be an https URL on chat.googleapis.com.",
   "google_chat_webhook_url_invalid": "Webhook URL must be an https URL on chat.googleapis.com",
+  "field_jira_site": "Site URL",
+  "tooltip_jira_site": "Your Jira Cloud base URL, e.g. https://your-domain.atlassian.net. Only Jira Cloud is supported.",
+  "jira_site_invalid": "Site URL must be an https URL on an atlassian.net domain",
+  "jira_required_fields": "Site URL, email, API token, project and issue type are required",
+  "jira_service_account_tip": "Recommended: use a Jira service account so alerts aren't reported under a personal name and the channel keeps working when someone leaves.",
+  "jira_service_account_tip_link": "Learn how",
+  "field_jira_email": "Email",
+  "help_jira_email": "The Atlassian account email used for authentication.",
+  "field_jira_api_token": "API token",
+  "help_jira_api_token": "Create one at id.atlassian.com under Security → API tokens.",
+  "field_jira_project": "Project key",
+  "field_jira_issue_type": "Issue type",
+  "help_jira_issue_type": "An issue type that exists in the project, e.g. Task, Bug or Incident.",
+  "field_jira_summary": "Summary (issue title)",
+  "help_jira_summary": "Template for the Jira issue title.",
+  "field_jira_description": "Description",
+  "help_jira_description": "Template for the issue description. Rendered as rich text with a status panel and links back to SigNoz.",
+  "jira_advanced_section": "Advanced Options",
+  "field_jira_priority": "Priority",
+  "placeholder_jira_priority": "Leave empty to use the project default",
+  "help_jira_priority": "Must match a priority in the project's scheme, e.g. High.",
+  "field_jira_labels": "Labels",
+  "placeholder_jira_labels": "Type a label and press Enter",
+  "help_jira_labels": "signoz and a deduplication label are added automatically.",
+  "field_jira_resolve_transition": "Resolve transition",
+  "field_jira_reopen_transition": "Reopen transition",
+  "help_jira_resolve_transition": "When the alert resolves, SigNoz moves the Jira issue to a \"Done\" status via a workflow transition. This is auto-detected — leave it empty unless your project has more than one \"Done\" transition (e.g. Done vs. Won't Do) and you want to force a specific one by name.",
+  "help_jira_reopen_transition": "When a resolved alert fires again (within the reopen window), SigNoz moves the issue back out of \"Done\" to an active status via a workflow transition. This is auto-detected — leave it empty unless you want to force a specific one by name (e.g. To Do or Reopen).",
+  "placeholder_jira_resolve_transition": "Auto-detected, e.g. Done",
+  "placeholder_jira_reopen_transition": "Auto-detected, e.g. To Do",
+  "field_jira_reopen_duration": "Reopen window",
+  "placeholder_jira_reopen_duration": "e.g. 72h",
+  "help_jira_reopen_duration": "If a resolved alert fires again within this window, the same ticket is reopened; after the window, a re-fire opens a new ticket instead. Default: 3d.",
+  "tooltip_jira_reopen_duration": "Accepted units: m (minutes), h (hours), d (days), w (weeks), y (years) — e.g. 30m, 72h or 3d. Minimum 1m.",
+  "jira_reopen_duration_invalid": "Reopen window must be a duration like 30m, 72h or 3d (minimum 1m)",
+  "jsmops_tip": "Create an API integration on your JSM team's Operations page and paste its key below.",
+  "jsmops_tip_link": "Learn how",
+  "field_jsmops_api_key": "API key",
+  "help_jsmops_api_key": "The JSM Ops integration API key, from your team's Operations → Integrations → API. Make sure the integration is turned on.",
+  "field_jsmops_message": "Message (alert title)",
+  "help_jsmops_message": "Template for the alert title. Truncated to 130 characters.",
+  "field_jsmops_description": "Description",
+  "help_jsmops_description": "Template for the alert description. Rendered as rich text; kept under 15,000 characters.",
+  "jsmops_advanced_section": "Advanced Options",
+  "field_jsmops_priority": "Priority",
+  "help_jsmops_priority": "Template resolving to one of P1–P5. Leave as-is to map from alert severity.",
+  "field_jsmops_tags": "Tags",
+  "placeholder_jsmops_tags": "Type a tag and press Enter",
+  "help_jsmops_tags": "Tags added to every alert.",
   "field_slack_recipient": "Recipient",
   "field_slack_title": "Title",
   "field_slack_description": "Description",

frontend/src/api/generated/services/quick-filter/index.ts

@@ -1,316 +0,0 @@
-/**
- * ! 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));
-};

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

@@ -8735,42 +8735,6 @@ export enum Querybuildertypesv5QueryTypeDTO {
 	clickhouse_sql = 'clickhouse_sql',
 	promql = 'promql',
 }
-export interface QuickfiltertypesSourceFiltersDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type array
-	 */
-	filters: TelemetrytypesTelemetryFieldKeyDTO[];
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	orgId?: string;
-	/**
-	 * @type string
-	 */
-	source?: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-}
-
-export interface QuickfiltertypesUpdatableQuickFiltersDTO {
-	/**
-	 * @type array
-	 */
-	filters: TelemetrytypesTelemetryFieldKeyDTO[];
-}
-
 export interface RenderErrorResponseDTO {
 	error: ErrorsJSONDTO;
 	/**
@@ -12172,31 +12136,6 @@ export type GetPublicDashboardPanelQueryRangeV2200 = {
 	status: string;
 };
 
-export type ListQuickFilters200 = {
-	/**
-	 * @type array,null
-	 */
-	data: QuickfiltertypesSourceFiltersDTO[] | null;
-	/**
-	 * @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;
 	/**

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.test.ts

@@ -0,0 +1,249 @@
+import { convertFiltersToExpressionWithExistingQuery } from 'components/QueryBuilderV2/utils';
+import {
+	FiltersType,
+	IQuickFiltersConfig,
+	QuickFiltersSource,
+} from 'components/QuickFilters/types';
+import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { applyCheckboxToggle } from './checkboxFilterQuery';
+import { CheckedState } from '../../types';
+import { SectionType } from './v2/itemRules';
+
+const ATTRIBUTE_KEY = 'k8s.cluster.name';
+
+const filter = {
+	type: FiltersType.CHECKBOX,
+	title: 'Cluster',
+	attributeKey: {
+		key: ATTRIBUTE_KEY,
+		dataType: 'string',
+		type: 'tag',
+		isColumn: false,
+	},
+	dataSource: DataSource.METRICS,
+	defaultOpen: true,
+} as unknown as IQuickFiltersConfig;
+
+function makeQuery(expression: string, items: TagFilterItem[]): Query {
+	return {
+		builder: {
+			queryData: [{ filter: { expression }, filters: { items, op: 'AND' } }],
+		},
+	} as unknown as Query;
+}
+
+/**
+ * Quick filters dispatch through the URL, and `useGetCompositeQueryParam` merges
+ * `filters.items` into `filter.expression` on the way back in — a clause left in
+ * the expression resurrects a filter the user just removed. Every assertion here
+ * runs through that round-trip.
+ */
+function roundTrip(query: Query): Query {
+	const queryData = query.builder.queryData[0];
+	const converted = convertFiltersToExpressionWithExistingQuery(
+		queryData.filters || { items: [], op: 'AND' },
+		queryData.filter?.expression || '',
+	);
+	return makeQuery(converted.filter.expression, converted.filters.items);
+}
+
+function toggle(
+	query: Query,
+	{
+		value,
+		checked,
+		previousState,
+		sectionType,
+		isOnlyOrAllClicked = false,
+		attributeValues = ['A', 'B', 'C'],
+	}: {
+		value: string;
+		checked: boolean;
+		previousState?: CheckedState;
+		sectionType?: SectionType;
+		isOnlyOrAllClicked?: boolean;
+		attributeValues?: string[];
+	},
+): Query {
+	return roundTrip(
+		applyCheckboxToggle({
+			currentQuery: query,
+			activeQueryIndex: 0,
+			filter,
+			source: QuickFiltersSource.INFRA_MONITORING,
+			attributeValues,
+			value,
+			checked,
+			isOnlyOrAllClicked,
+			previousState,
+			sectionType,
+		}),
+	);
+}
+
+const expressionOf = (query: Query): string =>
+	query.builder.queryData[0].filter?.expression ?? '';
+
+const itemsOf = (query: Query): TagFilterItem[] =>
+	query.builder.queryData[0].filters?.items ?? [];
+
+describe('applyCheckboxToggle expression sync', () => {
+	it('unchecking a value excludes it, re-checking it clears the filter', () => {
+		let query = makeQuery('', []);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: false,
+			previousState: 'checked',
+			sectionType: SectionType.SELECTED,
+		});
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} not in ['A']`);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: true,
+			previousState: 'unchecked',
+			sectionType: SectionType.SELECTED,
+		});
+		expect(expressionOf(query)).toBe('');
+		expect(itemsOf(query)).toHaveLength(0);
+	});
+
+	it('toggling the same value repeatedly stays a two-state cycle', () => {
+		let query = makeQuery('', []);
+
+		for (let i = 0; i < 3; i += 1) {
+			query = toggle(query, {
+				value: 'A',
+				checked: false,
+				previousState: 'checked',
+				sectionType: SectionType.SELECTED,
+			});
+			expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} not in ['A']`);
+
+			query = toggle(query, {
+				value: 'A',
+				checked: true,
+				previousState: 'unchecked',
+				sectionType: SectionType.SELECTED,
+			});
+			expect(expressionOf(query)).toBe('');
+		}
+	});
+
+	it('re-including one of several excluded values leaves the rest excluded', () => {
+		let query = makeQuery(`${ATTRIBUTE_KEY} not in ['A', 'B']`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: true,
+			previousState: 'unchecked',
+			sectionType: SectionType.SELECTED,
+		});
+
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} not in ['B']`);
+	});
+
+	it('unchecking the last selected value clears the filter', () => {
+		let query = makeQuery(`${ATTRIBUTE_KEY} in ['A']`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: false,
+			previousState: 'checked',
+			sectionType: SectionType.SELECTED,
+		});
+
+		expect(expressionOf(query)).toBe('');
+		expect(itemsOf(query)).toHaveLength(0);
+	});
+
+	it('unchecking one of several selected values keeps the others', () => {
+		let query = makeQuery(`${ATTRIBUTE_KEY} in ['A', 'B']`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: false,
+			previousState: 'checked',
+			sectionType: SectionType.SELECTED,
+		});
+
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} in ['B']`);
+	});
+
+	it('checking a value that is not excluded narrows the filter to it', () => {
+		let query = makeQuery(`${ATTRIBUTE_KEY} not in ['A']`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'C',
+			checked: true,
+			previousState: 'unchecked',
+			sectionType: SectionType.ALL_VALUES,
+		});
+
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} in ['C']`);
+	});
+
+	it('excluding a related value replaces the selection with a NOT IN clause', () => {
+		let query = makeQuery(`${ATTRIBUTE_KEY} in ['A']`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'B',
+			checked: false,
+			previousState: 'checked',
+			sectionType: SectionType.RELATED,
+		});
+
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} not in ['B']`);
+	});
+
+	it('Only narrows to the clicked value and All clears the filter', () => {
+		let query = makeQuery('', []);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: true,
+			isOnlyOrAllClicked: true,
+		});
+		expect(expressionOf(query)).toBe(`${ATTRIBUTE_KEY} in ['A']`);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: true,
+			isOnlyOrAllClicked: true,
+		});
+		expect(expressionOf(query)).toBe('');
+	});
+
+	it('leaves clauses for other keys untouched', () => {
+		let query = makeQuery(`k8s.namespace.name = 'default'`, []);
+		query = roundTrip(query);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: false,
+			previousState: 'checked',
+			sectionType: SectionType.SELECTED,
+		});
+		expect(expressionOf(query)).toContain(`k8s.namespace.name = 'default'`);
+		// consecutive clauses with no AND/OR are an implicit AND in the filter grammar
+		expect(expressionOf(query)).toMatch(
+			new RegExp(`${ATTRIBUTE_KEY} not in \\['A'\\]`, 'i'),
+		);
+
+		query = toggle(query, {
+			value: 'A',
+			checked: true,
+			previousState: 'unchecked',
+			sectionType: SectionType.SELECTED,
+		});
+		expect(expressionOf(query)).toBe(`k8s.namespace.name = 'default'`);
+	});
+});

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.ts

@@ -1,5 +1,8 @@
 /* eslint-disable sonarjs/no-identical-functions */
-import { removeKeysFromExpression } from 'components/QueryBuilderV2/utils';
+import {
+	convertFiltersToExpressionWithExistingQuery,
+	removeKeysFromExpression,
+} from 'components/QueryBuilderV2/utils';
 import {
 	IQuickFiltersConfig,
 	QuickFiltersSource,
@@ -194,12 +197,6 @@ export function applyCheckboxToggle({
 			(q) => !isKeyMatch(q.key?.key, filter.attributeKey.key),
 		);
 
-		if (query.filter?.expression) {
-			query.filter.expression = removeKeysFromExpression(query.filter.expression, [
-				filter.attributeKey.key,
-			]);
-		}
-
 		if (isOnlyOrAll === 'Only') {
 			const newFilterItem: TagFilterItem = {
 				id: uuid(),
@@ -267,12 +264,6 @@ export function applyCheckboxToggle({
 									}
 									return item;
 								});
-								if (query.filter?.expression) {
-									query.filter.expression = removeKeysFromExpression(
-										query.filter.expression,
-										[filter.attributeKey.key],
-									);
-								}
 							} else if (isArray(currentFilter.value)) {
 								// if we are removing some value when the running operator is IN we filter.
 								// example - key IN [value1,currentSelectedValue] becomes key IN [value1] in case of array
@@ -309,9 +300,10 @@ export function applyCheckboxToggle({
 							? currentFilter.value.includes(value)
 							: currentFilter.value === value;
 
-						// When clicking unchecked "Other" item, user wants to SELECT it
-						// Replace NOT IN filter with IN [value]
-						if (previousState === 'unchecked' && checked) {
+						// When clicking an unchecked value that is not itself excluded, the user
+						// wants to SELECT it: replace the NOT IN filter with IN [value]. A value
+						// that IS in the exclusion list falls through to the removal branch below.
+						if (previousState === 'unchecked' && checked && !isValueInFilter) {
 							const newFilter: TagFilterItem = {
 								id: uuid(),
 								op: getOperatorValue(OPERATORS.IN),
@@ -324,12 +316,6 @@ export function applyCheckboxToggle({
 								}
 								return item;
 							});
-							if (query.filter?.expression) {
-								query.filter.expression = removeKeysFromExpression(
-									query.filter.expression,
-									[filter.attributeKey.key],
-								);
-							}
 						} else if (!checked || !isValueInFilter) {
 							// Add to NOT IN when:
 							// - checked=false (user explicitly unchecked to exclude)
@@ -369,12 +355,6 @@ export function applyCheckboxToggle({
 									query.filters.items = query.filters.items.filter(
 										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
 									);
-									if (query.filter?.expression) {
-										query.filter.expression = removeKeysFromExpression(
-											query.filter.expression,
-											[filter.attributeKey.key],
-										);
-									}
 								} else {
 									query.filters.items = query.filters.items.map((item) => {
 										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
@@ -384,16 +364,6 @@ export function applyCheckboxToggle({
 									});
 								}
 							} else {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value === value ? null : currentFilter.value,
-								};
-								if (newFilter.value === null && query.filter?.expression) {
-									query.filter.expression = removeKeysFromExpression(
-										query.filter.expression,
-										[filter.attributeKey.key],
-									);
-								}
 								query.filters.items = query.filters.items.filter(
 									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
 								);
@@ -456,6 +426,17 @@ export function applyCheckboxToggle({
 		}
 	}
 
+	if (query) {
+		const synced = convertFiltersToExpressionWithExistingQuery(
+			query.filters ?? { items: [], op: 'AND' },
+			removeKeysFromExpression(query.filter?.expression ?? '', [
+				filter.attributeKey.key,
+			]),
+		);
+		query.filter = synced.filter;
+		query.filters = synced.filters;
+	}
+
 	return {
 		...currentQuery,
 		builder: {

frontend/src/constants/events.ts

@@ -29,6 +29,7 @@ export enum InfraMonitoringEvents {
 	MetricsView = 'metrics',
 	Total = 'total',
 	Cluster = 'cluster',
+	Container = 'container',
 	DaemonSet = 'daemonSet',
 	Deployment = 'deployment',
 	Job = 'job',

frontend/src/container/AllAlertChannels/__tests__/CreateAlertChannel.test.tsx

@@ -1,6 +1,10 @@
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
-import { GoogleChatInitialConfig } from 'container/CreateAlertChannels/defaults';
+import {
+	GoogleChatInitialConfig,
+	JiraInitialConfig,
+	JsmOpsInitialConfig,
+} from 'container/CreateAlertChannels/defaults';
 import {
 	googleChatDescriptionDefaultValue,
 	googleChatTitleDefaultValue,
@@ -526,6 +530,213 @@ describe('Create Alert Channel', () => {
 				});
 			});
 		});
+		describe('Jira', () => {
+			const validSite = 'https://acme.atlassian.net';
+
+			const fillRequired = async (
+				user: ReturnType<typeof userEvent.setup>,
+				site: string,
+			): Promise<void> => {
+				await user.type(screen.getByTestId('channel-name-textbox'), 'jira-channel');
+				await user.type(screen.getByTestId('jira-site-textbox'), site);
+				await user.type(screen.getByTestId('jira-email-textbox'), 'me@acme.com');
+				await user.type(screen.getByTestId('jira-api-token-textbox'), 'tok123');
+				await user.type(screen.getByTestId('jira-project-textbox'), 'KAN');
+			};
+
+			beforeEach(() => {
+				render(<CreateAlertChannels preType={ChannelType.Jira} />);
+			});
+
+			it('Should check if the selected item in the type dropdown has text "Jira"', () => {
+				expect(screen.getByText('Jira')).toBeInTheDocument();
+			});
+
+			it('Should check if the Site URL field is displayed properly', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_jira_site',
+					testId: 'jira-site-textbox',
+				});
+			});
+
+			it('Should prefill the issue type with Task', () => {
+				expect(screen.getByTestId('jira-issue-type-textbox')).toHaveValue('Task');
+			});
+
+			it('Should show the service-account recommendation tip linking to the docs', () => {
+				expect(screen.getByTestId('jira-service-account-tip')).toBeInTheDocument();
+				expect(
+					screen.getByRole('link', { name: 'jira_service_account_tip_link' }),
+				).toHaveAttribute(
+					'href',
+					'https://signoz.io/docs/alerts-management/notification-channel/jira/#use-a-service-account-recommended',
+				);
+			});
+
+			it('Should display an error when the site is not an atlassian.net URL', async () => {
+				const user = userEvent.setup({ delay: null });
+				await fillRequired(user, 'https://example.com');
+
+				await user.click(screen.getByTestId('save-channel-button'));
+
+				await waitFor(() =>
+					expect(errorNotification).toHaveBeenCalledWith({
+						message: 'Error',
+						description: 'jira_site_invalid',
+					}),
+				);
+			});
+
+			it('Should send a jira_configs payload with basic auth', async () => {
+				let requestBody: unknown;
+				server.use(
+					rest.post('http://localhost/api/v1/channels', async (req, res, ctx) => {
+						requestBody = await req.json();
+						return res(
+							ctx.status(201),
+							ctx.json({ status: 'success', data: 'channel created' }),
+						);
+					}),
+				);
+
+				const user = userEvent.setup({ delay: null });
+				await fillRequired(user, validSite);
+
+				await user.click(screen.getByTestId('save-channel-button'));
+
+				await waitFor(() =>
+					expect(successNotification).toHaveBeenCalledWith({
+						message: 'Success',
+						description: 'channel_creation_done',
+					}),
+				);
+
+				expect(requestBody).toStrictEqual({
+					name: 'jira-channel',
+					jira_configs: [
+						{
+							site: validSite,
+							project: 'KAN',
+							issue_type: 'Task',
+							summary: JiraInitialConfig.summary,
+							description: JiraInitialConfig.description,
+							send_resolved: true,
+							http_config: {
+								basic_auth: { username: 'me@acme.com', password: 'tok123' },
+							},
+						},
+					],
+				});
+			}, 15000);
+
+			it('Should block save when the reopen window is below the 1m minimum', async () => {
+				const user = userEvent.setup({ delay: null });
+				await fillRequired(user, validSite);
+
+				await user.click(screen.getByText('jira_advanced_section'));
+				await user.type(screen.getByTestId('jira-reopen-duration-textbox'), '30s');
+
+				// the rule surfaces an inline message, not just a red border
+				await expect(
+					screen.findByText('jira_reopen_duration_invalid'),
+				).resolves.toBeInTheDocument();
+
+				await user.click(screen.getByTestId('save-channel-button'));
+
+				await waitFor(() =>
+					expect(errorNotification).toHaveBeenCalledWith({
+						message: 'Error',
+						description: 'jira_reopen_duration_invalid',
+					}),
+				);
+			}, 15000);
+		});
+		describe('JSM Ops', () => {
+			beforeEach(() => {
+				render(<CreateAlertChannels preType={ChannelType.JsmOps} />);
+			});
+
+			it('Should show "Jira Service Management Ops" as the selected type', () => {
+				expect(screen.getByText('Jira Service Management Ops')).toBeInTheDocument();
+			});
+
+			it('Should display the API key field properly', () => {
+				testLabelInputAndHelpValue({
+					labelText: 'field_jsmops_api_key',
+					testId: 'jsmops-api-key-textbox',
+				});
+			});
+
+			it('Should show the tip linking to the JSM Ops docs', () => {
+				expect(screen.getByTestId('jsmops-tip')).toBeInTheDocument();
+				expect(
+					screen.getByRole('link', { name: 'jsmops_tip_link' }),
+				).toHaveAttribute(
+					'href',
+					'https://signoz.io/docs/alerts-management/notification-channel/jsm-ops/',
+				);
+			});
+
+			it('Should block save when the API key is missing', async () => {
+				const user = userEvent.setup();
+				await user.type(
+					screen.getByTestId('channel-name-textbox'),
+					'jsmops-channel',
+				);
+
+				await user.click(screen.getByTestId('save-channel-button'));
+
+				await waitFor(() =>
+					expect(errorNotification).toHaveBeenCalledWith({
+						message: 'Error',
+						description: 'api_key_required',
+					}),
+				);
+			});
+
+			it('Should send a jsmops_configs payload with prefilled defaults', async () => {
+				let requestBody: unknown;
+				server.use(
+					rest.post('http://localhost/api/v1/channels', async (req, res, ctx) => {
+						requestBody = await req.json();
+						return res(
+							ctx.status(201),
+							ctx.json({ status: 'success', data: 'channel created' }),
+						);
+					}),
+				);
+
+				const user = userEvent.setup();
+				await user.type(
+					screen.getByTestId('channel-name-textbox'),
+					'jsmops-channel',
+				);
+				await user.type(screen.getByTestId('jsmops-api-key-textbox'), 'key-abc');
+
+				await user.click(screen.getByTestId('save-channel-button'));
+
+				await waitFor(() =>
+					expect(successNotification).toHaveBeenCalledWith({
+						message: 'Success',
+						description: 'channel_creation_done',
+					}),
+				);
+
+				expect(requestBody).toStrictEqual({
+					name: 'jsmops-channel',
+					jsmops_configs: [
+						{
+							api_key: 'key-abc',
+							send_resolved: true,
+							message: JsmOpsInitialConfig.message,
+							description: JsmOpsInitialConfig.description,
+							priority: JsmOpsInitialConfig.priority,
+							tags: JsmOpsInitialConfig.tags?.join(','),
+						},
+					],
+				});
+			});
+		});
 		describe('Changing the channel type', () => {
 			async function selectType(
 				user: ReturnType<typeof userEvent.setup>,

frontend/src/container/AllAlertChannels/__tests__/EditAlertChannelSave.test.tsx

@@ -58,6 +58,38 @@ describe('EditAlertChannels save', () => {
 		expect(edit.calls[0].id).toBe('3');
 	});
 
+	it('blocks jira save when the reopen window is below the 1m minimum', async () => {
+		const edit = mockEditChannel();
+		const jiraInitialValue = {
+			type: 'jira',
+			name: 'jira-channel',
+			site: 'https://acme.atlassian.net',
+			username: 'user@acme.io',
+			password: 'token',
+			project: 'OPS',
+			issue_type: 'Task',
+			send_resolved: true,
+			reopen_duration: '30s',
+		};
+
+		const { unmount } = render(
+			<EditAlertChannels channelId="3" initialValue={jiraInitialValue} />,
+		);
+		const user = userEvent.setup();
+		await user.click(screen.getByTestId('save-channel-button'));
+		expect(edit.calls).toHaveLength(0);
+		unmount();
+
+		render(
+			<EditAlertChannels
+				channelId="3"
+				initialValue={{ ...jiraInitialValue, reopen_duration: '72h' }}
+			/>,
+		);
+		await user.click(screen.getByTestId('save-channel-button'));
+		await waitFor(() => expect(edit.calls).toHaveLength(1));
+	});
+
 	it('persists send_resolved toggle in the edit request', async () => {
 		const edit = mockEditChannel();
 		render(

frontend/src/container/CreateAlertChannels/config.ts

@@ -105,6 +105,8 @@ export enum ChannelType {
 	Opsgenie = 'opsgenie',
 	MsTeams = 'msteams',
 	GoogleChat = 'googlechat',
+	Jira = 'jira',
+	JsmOps = 'jsmops',
 }
 
 // LabelFilterStatement will be used for preparing filter conditions / matchers
@@ -134,3 +136,39 @@ export interface GoogleChatChannel extends Channel {
 	title?: string;
 	text?: string;
 }
+
+// JiraChannel configures the Jira Cloud alert channel. Auth is basic auth
+// (Atlassian account email + API token) carried in username / password.
+export interface JiraChannel extends Channel {
+	// Jira Cloud base URL, e.g. https://acme.atlassian.net
+	site: string;
+	project: string;
+	issue_type: string;
+	// issue title template
+	summary?: string;
+	// issue body template, rendered to rich text server-side
+	description?: string;
+	// basic auth: username is the Atlassian account email, password is the API token
+	username: string;
+	password: string;
+	priority?: string;
+	labels?: string[];
+	resolve_transition?: string;
+	reopen_transition?: string;
+	// duration string, e.g. 72h or 3d
+	reopen_duration?: string;
+}
+
+// JsmOpsChannel configures the Jira Service Management Ops alert channel
+// (ex-Opsgenie alert API). Auth is the JSM integration API key.
+export interface JsmOpsChannel extends Channel {
+	api_key: string;
+	// alert title template
+	message?: string;
+	// alert body template (markdown, rendered to HTML server-side)
+	description?: string;
+	// priority template, resolves to P1-P5
+	priority?: string;
+	// tags, joined to a comma-separated string for the backend
+	tags?: string[];
+}

frontend/src/container/CreateAlertChannels/defaults.ts

@@ -2,6 +2,8 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -47,6 +49,23 @@ export const GoogleChatInitialConfig: Partial<GoogleChatChannel> = {
 {{ end }}`,
 };
 
+// mirrors DefaultJiraSummaryTemplate / DefaultJiraDescriptionTemplate in
+// pkg/types/alertmanagertypes/jira.go, which the backend applies when the
+// summary / description are left empty. The description is markdown here and is
+// wrapped in the ADF status panel + deep-links server-side.
+export const JiraInitialConfig: Partial<JiraChannel> = {
+	issue_type: 'Task',
+	summary: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`,
+	description: `{{ range .Alerts -}}
+**Alert:** {{ .Labels.alertname }}{{ if .Labels.severity }} ({{ .Labels.severity }}){{ end }}
+{{ if .Annotations.summary }}
+**Summary:** {{ .Annotations.summary }}
+{{ end }}{{ if .Annotations.description }}
+**Description:** {{ .Annotations.description }}
+{{ end }}
+{{ end }}`,
+};
+
 export const PagerInitialConfig: Partial<PagerChannel> = {
 	description: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
 	{{- if gt (len .CommonLabels) (len .GroupLabels) -}}
@@ -98,6 +117,33 @@ export const OpsgenieInitialConfig: Partial<OpsgenieChannel> = {
 		'{{ if eq (index .Alerts 0).Labels.severity "critical" }}P1{{ else if eq (index .Alerts 0).Labels.severity "warning" }}P2{{ else if eq (index .Alerts 0).Labels.severity "info" }}P3{{ else }}P4{{ end }}',
 };
 
+// mirrors DefaultJSMOpsMessageTemplate / DefaultJSMOpsDescriptionTemplate in
+// pkg/types/alertmanagertypes/jsmops.go, applied by the backend when message /
+// description are left empty. send_resolved is seeded on so JSM alerts close on
+// resolve (the backend cannot default it, see jsmops.go). priority mirrors the
+// Opsgenie template mapping severity to P1-P5.
+export const JsmOpsInitialConfig: Partial<JsmOpsChannel> = {
+	send_resolved: true,
+	message: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`,
+	description: `{{ range .Alerts -}}
+**Alert:** {{ .Labels.alertname }}{{ if .Labels.severity }} ({{ .Labels.severity }}){{ end }}
+
+{{ if .Annotations.summary }}**Summary:** {{ .Annotations.summary }}
+
+{{ end }}{{ if .Annotations.description }}**Description:** {{ .Annotations.description }}
+
+{{ end }}{{ if .GeneratorURL }}[View in SigNoz]({{ .GeneratorURL }})
+
+{{ end }}{{ if .Annotations.related_logs }}[View related logs]({{ .Annotations.related_logs }})
+
+{{ end }}{{ if .Annotations.related_traces }}[View related traces]({{ .Annotations.related_traces }})
+
+{{ end }}{{ end }}`,
+	priority:
+		'{{ if eq (index .Alerts 0).Labels.severity "critical" }}P1{{ else if eq (index .Alerts 0).Labels.severity "warning" }}P2{{ else if eq (index .Alerts 0).Labels.severity "info" }}P3{{ else }}P4{{ end }}',
+	tags: ['signoz-alert'],
+};
+
 export const EmailInitialConfig: Partial<EmailChannel> = {
 	send_resolved: true,
 	html: `<!--
@@ -505,12 +551,16 @@ export const ChannelInitialConfig: Record<
 			MsTeamsChannel &
 			OpsgenieChannel &
 			EmailChannel &
-			GoogleChatChannel
+			GoogleChatChannel &
+			JiraChannel &
+			JsmOpsChannel
 	>
 > = {
 	[ChannelType.Slack]: SlackInitialConfig,
 	[ChannelType.MsTeams]: SlackInitialConfig,
 	[ChannelType.GoogleChat]: GoogleChatInitialConfig,
+	[ChannelType.Jira]: JiraInitialConfig,
+	[ChannelType.JsmOps]: JsmOpsInitialConfig,
 	[ChannelType.Pagerduty]: PagerInitialConfig,
 	[ChannelType.Opsgenie]: OpsgenieInitialConfig,
 	[ChannelType.Email]: EmailInitialConfig,

frontend/src/container/CreateAlertChannels/index.tsx

@@ -32,6 +32,8 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -43,7 +45,11 @@ import { ChannelInitialConfig } from './defaults';
 import {
 	isChannelType,
 	isValidGoogleChatWebhookURL,
+	isValidJiraReopenDuration,
+	isValidJiraSiteURL,
 	prepareGoogleChatRequest,
+	prepareJiraRequest,
+	prepareJsmOpsRequest,
 } from './utils';
 
 import './CreateAlertChannels.styles.scss';
@@ -69,7 +75,9 @@ function CreateAlertChannels({
 				MsTeamsChannel &
 				OpsgenieChannel &
 				EmailChannel &
-				GoogleChatChannel
+				GoogleChatChannel &
+				JiraChannel &
+				JsmOpsChannel
 		>
 	>(() => ({
 		send_resolved: true,
@@ -434,6 +442,114 @@ function CreateAlertChannels({
 		showErrorModal,
 	]);
 
+	const validateJiraConfig = useCallback((): boolean => {
+		if (
+			!selectedConfig.site ||
+			!selectedConfig.username ||
+			!selectedConfig.password ||
+			!selectedConfig.project ||
+			!selectedConfig.issue_type
+		) {
+			notifications.error({
+				message: 'Error',
+				description: t('jira_required_fields'),
+			});
+			return false;
+		}
+
+		if (!isValidJiraSiteURL(selectedConfig.site)) {
+			notifications.error({
+				message: 'Error',
+				description: t('jira_site_invalid'),
+			});
+			return false;
+		}
+
+		if (
+			selectedConfig.reopen_duration &&
+			!isValidJiraReopenDuration(selectedConfig.reopen_duration)
+		) {
+			notifications.error({
+				message: 'Error',
+				description: t('jira_reopen_duration_invalid'),
+			});
+			return false;
+		}
+
+		return true;
+	}, [selectedConfig, notifications, t]);
+
+	const onJiraHandler = useCallback(async () => {
+		if (!validateJiraConfig()) {
+			return { status: 'failed', statusMessage: t('channel_creation_failed') };
+		}
+
+		setSavingState(true);
+
+		try {
+			await createChannel({ data: prepareJiraRequest(selectedConfig) });
+			notifications.success({
+				message: 'Success',
+				description: t('channel_creation_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_creation_done') };
+		} catch (error) {
+			showErrorModal(toAPIError(error as ErrorType<RenderErrorResponseDTO>));
+			return { status: 'failed', statusMessage: t('channel_creation_failed') };
+		} finally {
+			setSavingState(false);
+		}
+	}, [
+		validateJiraConfig,
+		createChannel,
+		selectedConfig,
+		notifications,
+		t,
+		showErrorModal,
+	]);
+
+	const validateJsmOpsConfig = useCallback((): boolean => {
+		if (!selectedConfig.api_key) {
+			notifications.error({
+				message: 'Error',
+				description: t('api_key_required'),
+			});
+			return false;
+		}
+		return true;
+	}, [selectedConfig.api_key, notifications, t]);
+
+	const onJsmOpsHandler = useCallback(async () => {
+		if (!validateJsmOpsConfig()) {
+			return { status: 'failed', statusMessage: t('channel_creation_failed') };
+		}
+
+		setSavingState(true);
+
+		try {
+			await createChannel({ data: prepareJsmOpsRequest(selectedConfig) });
+			notifications.success({
+				message: 'Success',
+				description: t('channel_creation_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_creation_done') };
+		} catch (error) {
+			showErrorModal(toAPIError(error as ErrorType<RenderErrorResponseDTO>));
+			return { status: 'failed', statusMessage: t('channel_creation_failed') };
+		} finally {
+			setSavingState(false);
+		}
+	}, [
+		validateJsmOpsConfig,
+		createChannel,
+		selectedConfig,
+		notifications,
+		t,
+		showErrorModal,
+	]);
+
 	const onSaveHandler = useCallback(
 		async (value: ChannelType) => {
 			if (!selectedConfig.name) {
@@ -452,6 +568,8 @@ function CreateAlertChannels({
 				[ChannelType.MsTeams]: onMsTeamsHandler,
 				[ChannelType.Email]: onEmailHandler,
 				[ChannelType.GoogleChat]: onGoogleChatHandler,
+				[ChannelType.Jira]: onJiraHandler,
+				[ChannelType.JsmOps]: onJsmOpsHandler,
 			};
 
 			if (isChannelType(value)) {
@@ -484,6 +602,8 @@ function CreateAlertChannels({
 			onMsTeamsHandler,
 			onEmailHandler,
 			onGoogleChatHandler,
+			onJiraHandler,
+			onJsmOpsHandler,
 			notifications,
 			t,
 		],
@@ -528,6 +648,20 @@ function CreateAlertChannels({
 						}
 						await testChannel({ data: prepareGoogleChatRequest(selectedConfig) });
 						break;
+					case ChannelType.Jira:
+						if (!validateJiraConfig()) {
+							setTestingState(false);
+							return;
+						}
+						await testChannel({ data: prepareJiraRequest(selectedConfig) });
+						break;
+					case ChannelType.JsmOps:
+						if (!validateJsmOpsConfig()) {
+							setTestingState(false);
+							return;
+						}
+						await testChannel({ data: prepareJsmOpsRequest(selectedConfig) });
+						break;
 					default:
 						notifications.error({
 							message: 'Error',
@@ -576,6 +710,8 @@ function CreateAlertChannels({
 			prepareMsTeamsRequest,
 			prepareEmailRequest,
 			validateGoogleChatConfig,
+			validateJiraConfig,
+			validateJsmOpsConfig,
 			testChannel,
 			notifications,
 		],

frontend/src/container/CreateAlertChannels/utils.ts

@@ -1,9 +1,17 @@
 import {
+	AlertmanagertypesJiraReceiverConfigDTO,
+	AlertmanagertypesJSMOpsReceiverConfigDTO,
 	AlertmanagertypesPostableChannelDTO,
 	ConfigSecretURLDTO,
+	ModelDurationDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
-import { ChannelType, GoogleChatChannel } from './config';
+import {
+	ChannelType,
+	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
+} from './config';
 
 export const isChannelType = (type: string): type is ChannelType =>
 	Object.values(ChannelType).includes(type as ChannelType);
@@ -37,3 +45,126 @@ export const prepareGoogleChatRequest = (
 		},
 	],
 });
+
+const JIRA_CLOUD_HOST_SUFFIX = '.atlassian.net';
+
+// the backend enforces the same rule, this is only for a nicer error experience
+export const isValidJiraSiteURL = (url: string): boolean => {
+	try {
+		const { protocol, hostname } = new URL(url);
+		return (
+			protocol === 'https:' &&
+			hostname.toLowerCase().endsWith(JIRA_CLOUD_HOST_SUFFIX)
+		);
+	} catch {
+		return false;
+	}
+};
+
+// mirrors go's prometheus model.Duration units
+const JIRA_DURATION_UNIT_MS: Record<string, number> = {
+	ms: 1,
+	s: 1_000,
+	m: 60_000,
+	h: 3_600_000,
+	d: 86_400_000,
+	w: 604_800_000,
+	y: 31_536_000_000,
+};
+const JIRA_DURATION_RE = /^(\d+(ms|s|m|h|d|w|y))+$/;
+const JIRA_DURATION_TOKEN_RE = /(\d+)(ms|s|m|h|d|w|y)/g;
+const JIRA_MIN_REOPEN_MS = 60_000;
+
+// backend requires the same format and a >= 1m minimum, this is only for a
+// nicer error experience. Empty and "0" defer to the backend default.
+export const isValidJiraReopenDuration = (value: string): boolean => {
+	if (!value || value === '0') {
+		return true;
+	}
+	if (!JIRA_DURATION_RE.test(value)) {
+		return false;
+	}
+	let totalMs = 0;
+	for (const [, amount, unit] of value.matchAll(JIRA_DURATION_TOKEN_RE)) {
+		totalMs += Number(amount) * JIRA_DURATION_UNIT_MS[unit];
+	}
+	return totalMs >= JIRA_MIN_REOPEN_MS;
+};
+
+// create, update and test all send the same body shape. Optional fields are
+// omitted when empty so the backend applies its defaults.
+export const prepareJiraRequest = (
+	config: Partial<JiraChannel>,
+): AlertmanagertypesPostableChannelDTO => {
+	const jira: AlertmanagertypesJiraReceiverConfigDTO = {
+		site: config.site || '',
+		project: config.project || '',
+		issue_type: config.issue_type || '',
+		send_resolved: config.send_resolved || false,
+		http_config: {
+			basic_auth: {
+				username: config.username || '',
+				password: config.password || '',
+			},
+		},
+	};
+
+	if (config.summary) {
+		jira.summary = config.summary;
+	}
+	if (config.description) {
+		jira.description = config.description;
+	}
+	if (config.priority) {
+		jira.priority = config.priority;
+	}
+	if (config.labels?.length) {
+		jira.labels = config.labels;
+	}
+	if (config.resolve_transition) {
+		jira.resolve_transition = config.resolve_transition;
+	}
+	if (config.reopen_transition) {
+		jira.reopen_transition = config.reopen_transition;
+	}
+	if (config.reopen_duration) {
+		// the generated type models go's model.Duration as a number, the api takes a
+		// duration string like "72h"
+		jira.reopen_duration = config.reopen_duration as unknown as ModelDurationDTO;
+	}
+
+	return {
+		name: config.name || '',
+		jira_configs: [jira],
+	};
+};
+
+// create, update and test all send the same body shape. Optional fields are
+// omitted when empty so the backend applies its defaults.
+export const prepareJsmOpsRequest = (
+	config: Partial<JsmOpsChannel>,
+): AlertmanagertypesPostableChannelDTO => {
+	const jsmops: AlertmanagertypesJSMOpsReceiverConfigDTO = {
+		api_key: config.api_key || '',
+		send_resolved: config.send_resolved || false,
+	};
+
+	if (config.message) {
+		jsmops.message = config.message;
+	}
+	if (config.description) {
+		jsmops.description = config.description;
+	}
+	if (config.priority) {
+		jsmops.priority = config.priority;
+	}
+	if (config.tags?.length) {
+		// the backend takes a comma-separated string and splits it back
+		jsmops.tags = config.tags.join(',');
+	}
+
+	return {
+		name: config.name || '',
+		jsmops_configs: [jsmops],
+	};
+};

frontend/src/container/EditAlertChannels/index.tsx

@@ -25,6 +25,8 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -34,7 +36,11 @@ import {
 } from 'container/CreateAlertChannels/config';
 import {
 	isValidGoogleChatWebhookURL,
+	isValidJiraReopenDuration,
+	isValidJiraSiteURL,
 	prepareGoogleChatRequest,
+	prepareJiraRequest,
+	prepareJsmOpsRequest,
 } from 'container/CreateAlertChannels/utils';
 import FormAlertChannels from 'container/FormAlertChannels';
 import { useNotifications } from 'hooks/useNotifications';
@@ -58,7 +64,9 @@ function EditAlertChannels({
 				MsTeamsChannel &
 				OpsgenieChannel &
 				EmailChannel &
-				GoogleChatChannel
+				GoogleChatChannel &
+				JiraChannel &
+				JsmOpsChannel
 		>
 	>({
 		...initialValue,
@@ -452,6 +460,124 @@ function EditAlertChannels({
 		t,
 	]);
 
+	const validateJiraConfig = useCallback((): string => {
+		if (
+			!selectedConfig.site ||
+			!selectedConfig.username ||
+			!selectedConfig.password ||
+			!selectedConfig.project ||
+			!selectedConfig.issue_type
+		) {
+			return t('jira_required_fields');
+		}
+
+		if (!isValidJiraSiteURL(selectedConfig.site)) {
+			return t('jira_site_invalid');
+		}
+
+		if (
+			selectedConfig.reopen_duration &&
+			!isValidJiraReopenDuration(selectedConfig.reopen_duration)
+		) {
+			return t('jira_reopen_duration_invalid');
+		}
+
+		return '';
+	}, [selectedConfig, t]);
+
+	const onJiraEditHandler = useCallback(async () => {
+		const validationError = validateJiraConfig();
+
+		if (validationError !== '') {
+			notifications.error({
+				message: 'Error',
+				description: validationError,
+			});
+			return { status: 'failed', statusMessage: validationError };
+		}
+
+		setSavingState(true);
+
+		try {
+			await updateChannel({
+				pathParams: { id },
+				data: prepareJiraRequest(selectedConfig),
+			});
+			notifications.success({
+				message: 'Success',
+				description: t('channel_edit_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_edit_done') };
+		} catch (error) {
+			const apiError = notifyError(error);
+			return {
+				status: 'failed',
+				statusMessage: apiError.getErrorMessage() || t('channel_edit_failed'),
+			};
+		} finally {
+			setSavingState(false);
+		}
+	}, [
+		validateJiraConfig,
+		updateChannel,
+		id,
+		selectedConfig,
+		notifications,
+		notifyError,
+		t,
+	]);
+
+	const validateJsmOpsConfig = useCallback((): string => {
+		if (!selectedConfig.api_key) {
+			return t('api_key_required');
+		}
+		return '';
+	}, [selectedConfig, t]);
+
+	const onJsmOpsEditHandler = useCallback(async () => {
+		const validationError = validateJsmOpsConfig();
+
+		if (validationError !== '') {
+			notifications.error({
+				message: 'Error',
+				description: validationError,
+			});
+			return { status: 'failed', statusMessage: validationError };
+		}
+
+		setSavingState(true);
+
+		try {
+			await updateChannel({
+				pathParams: { id },
+				data: prepareJsmOpsRequest(selectedConfig),
+			});
+			notifications.success({
+				message: 'Success',
+				description: t('channel_edit_done'),
+			});
+			history.replace(ROUTES.ALL_CHANNELS);
+			return { status: 'success', statusMessage: t('channel_edit_done') };
+		} catch (error) {
+			const apiError = notifyError(error);
+			return {
+				status: 'failed',
+				statusMessage: apiError.getErrorMessage() || t('channel_edit_failed'),
+			};
+		} finally {
+			setSavingState(false);
+		}
+	}, [
+		validateJsmOpsConfig,
+		updateChannel,
+		id,
+		selectedConfig,
+		notifications,
+		notifyError,
+		t,
+	]);
+
 	const onSaveHandler = useCallback(
 		async (value: ChannelType) => {
 			let result;
@@ -469,6 +595,10 @@ function EditAlertChannels({
 				result = await onEmailEditHandler();
 			} else if (value === ChannelType.GoogleChat) {
 				result = await onGoogleChatEditHandler();
+			} else if (value === ChannelType.Jira) {
+				result = await onJiraEditHandler();
+			} else if (value === ChannelType.JsmOps) {
+				result = await onJsmOpsEditHandler();
 			}
 			logEvent('Alert Channel: Save channel', {
 				type: value,
@@ -488,10 +618,13 @@ function EditAlertChannels({
 			onOpsgenieEditHandler,
 			onEmailEditHandler,
 			onGoogleChatEditHandler,
+			onJiraEditHandler,
+			onJsmOpsEditHandler,
 		],
 	);
 
 	const performChannelTest = useCallback(
+		// eslint-disable-next-line sonarjs/cognitive-complexity
 		async (channelType: ChannelType) => {
 			setTestingState(true);
 			try {
@@ -542,6 +675,32 @@ function EditAlertChannels({
 						await testChannel({ data: prepareGoogleChatRequest(selectedConfig) });
 						break;
 					}
+					case ChannelType.Jira: {
+						const validationError = validateJiraConfig();
+						if (validationError !== '') {
+							notifications.error({
+								message: 'Error',
+								description: validationError,
+							});
+							setTestingState(false);
+							return;
+						}
+						await testChannel({ data: prepareJiraRequest(selectedConfig) });
+						break;
+					}
+					case ChannelType.JsmOps: {
+						const validationError = validateJsmOpsConfig();
+						if (validationError !== '') {
+							notifications.error({
+								message: 'Error',
+								description: validationError,
+							});
+							setTestingState(false);
+							return;
+						}
+						await testChannel({ data: prepareJsmOpsRequest(selectedConfig) });
+						break;
+					}
 					default:
 						notifications.error({
 							message: 'Error',
@@ -579,6 +738,8 @@ function EditAlertChannels({
 			t,
 			notifyError,
 			validateGoogleChatConfig,
+			validateJiraConfig,
+			validateJsmOpsConfig,
 			testChannel,
 			prepareWebhookRequest,
 			preparePagerRequest,

frontend/src/container/FormAlertChannels/Settings/Jira.tsx

@@ -0,0 +1,242 @@
+import { Dispatch, SetStateAction } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Collapse, Form, Input, Select } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+import { MarkdownRenderer } from 'components/MarkdownRenderer/MarkdownRenderer';
+
+import { JiraChannel } from '../../CreateAlertChannels/config';
+import {
+	isValidJiraReopenDuration,
+	isValidJiraSiteURL,
+} from '../../CreateAlertChannels/utils';
+
+function JiraSettings({ setSelectedConfig }: JiraProps): JSX.Element {
+	const { t } = useTranslation('channels');
+
+	const update = (patch: Partial<JiraChannel>): void =>
+		setSelectedConfig((value) => ({ ...value, ...patch }));
+
+	const advanced = (
+		<>
+			<Form.Item
+				name="priority"
+				label={t('field_jira_priority')}
+				help={t('help_jira_priority')}
+			>
+				<Input
+					placeholder={t('placeholder_jira_priority')}
+					onChange={(event): void => update({ priority: event.target.value })}
+					data-testid="jira-priority-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="labels"
+				label={t('field_jira_labels')}
+				help={t('help_jira_labels')}
+			>
+				<Select
+					mode="tags"
+					open={false}
+					placeholder={t('placeholder_jira_labels')}
+					onChange={(value): void => update({ labels: value as string[] })}
+					data-testid="jira-labels-select"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="resolve_transition"
+				label={t('field_jira_resolve_transition')}
+				help={t('help_jira_resolve_transition')}
+			>
+				<Input
+					placeholder={t('placeholder_jira_resolve_transition')}
+					onChange={(event): void =>
+						update({ resolve_transition: event.target.value })
+					}
+					data-testid="jira-resolve-transition-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="reopen_transition"
+				label={t('field_jira_reopen_transition')}
+				help={t('help_jira_reopen_transition')}
+			>
+				<Input
+					placeholder={t('placeholder_jira_reopen_transition')}
+					onChange={(event): void =>
+						update({ reopen_transition: event.target.value })
+					}
+					data-testid="jira-reopen-transition-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="reopen_duration"
+				label={t('field_jira_reopen_duration')}
+				extra={t('help_jira_reopen_duration')}
+				rules={[
+					{
+						validator: (_, value: string): Promise<void> =>
+							isValidJiraReopenDuration(value)
+								? Promise.resolve()
+								: Promise.reject(new Error(t('jira_reopen_duration_invalid'))),
+					},
+				]}
+				tooltip={{
+					title: (
+						<MarkdownRenderer
+							markdownContent={t('tooltip_jira_reopen_duration')}
+							variables={{}}
+						/>
+					),
+					overlayInnerStyle: { maxWidth: 400 },
+					placement: 'right',
+				}}
+			>
+				<Input
+					placeholder={t('placeholder_jira_reopen_duration')}
+					onChange={(event): void => update({ reopen_duration: event.target.value })}
+					data-testid="jira-reopen-duration-textbox"
+				/>
+			</Form.Item>
+		</>
+	);
+
+	return (
+		<>
+			<Typography.Text
+				color="muted"
+				size="sm"
+				testId="jira-service-account-tip"
+				style={{ display: 'block', marginBottom: 16 }}
+			>
+				{t('jira_service_account_tip')}{' '}
+				<Typography.Link
+					href="https://signoz.io/docs/alerts-management/notification-channel/jira/#use-a-service-account-recommended"
+					target="_blank"
+					rel="noopener noreferrer"
+				>
+					{t('jira_service_account_tip_link')}
+				</Typography.Link>
+			</Typography.Text>
+
+			<Form.Item
+				name="site"
+				label={t('field_jira_site')}
+				required
+				rules={[
+					{
+						validator: (_, value: string): Promise<void> =>
+							!value || isValidJiraSiteURL(value)
+								? Promise.resolve()
+								: Promise.reject(new Error(t('jira_site_invalid'))),
+					},
+				]}
+				tooltip={{
+					title: (
+						<MarkdownRenderer
+							markdownContent={t('tooltip_jira_site')}
+							variables={{}}
+						/>
+					),
+					overlayInnerStyle: { maxWidth: 400 },
+					placement: 'right',
+				}}
+			>
+				<Input
+					placeholder="https://your-domain.atlassian.net"
+					onChange={(event): void => update({ site: event.target.value })}
+					data-testid="jira-site-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="username"
+				label={t('field_jira_email')}
+				help={t('help_jira_email')}
+				required
+			>
+				<Input
+					onChange={(event): void => update({ username: event.target.value })}
+					data-testid="jira-email-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="password"
+				label={t('field_jira_api_token')}
+				help={t('help_jira_api_token')}
+				required
+			>
+				<Input
+					type="password"
+					onChange={(event): void => update({ password: event.target.value })}
+					data-testid="jira-api-token-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item name="project" label={t('field_jira_project')} required>
+				<Input
+					placeholder="e.g. OPS"
+					onChange={(event): void => update({ project: event.target.value })}
+					data-testid="jira-project-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="issue_type"
+				label={t('field_jira_issue_type')}
+				help={t('help_jira_issue_type')}
+				required
+			>
+				<Input
+					onChange={(event): void => update({ issue_type: event.target.value })}
+					data-testid="jira-issue-type-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="summary"
+				label={t('field_jira_summary')}
+				help={t('help_jira_summary')}
+			>
+				<Input.TextArea
+					rows={2}
+					onChange={(event): void => update({ summary: event.target.value })}
+					data-testid="jira-summary-textarea"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="description"
+				label={t('field_jira_description')}
+				help={t('help_jira_description')}
+			>
+				<Input.TextArea
+					rows={6}
+					onChange={(event): void => update({ description: event.target.value })}
+					data-testid="jira-description-textarea"
+				/>
+			</Form.Item>
+
+			<Collapse
+				ghost
+				items={[
+					{
+						key: 'advanced',
+						label: t('jira_advanced_section'),
+						children: advanced,
+					},
+				]}
+			/>
+		</>
+	);
+}
+
+interface JiraProps {
+	setSelectedConfig: Dispatch<SetStateAction<Partial<JiraChannel>>>;
+}
+
+export default JiraSettings;

frontend/src/container/FormAlertChannels/Settings/JsmOps.tsx

@@ -0,0 +1,117 @@
+import { Dispatch, SetStateAction } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Collapse, Form, Input, Select } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+
+import { JsmOpsChannel } from '../../CreateAlertChannels/config';
+
+function JsmOpsSettings({ setSelectedConfig }: JsmOpsProps): JSX.Element {
+	const { t } = useTranslation('channels');
+
+	const update = (patch: Partial<JsmOpsChannel>): void =>
+		setSelectedConfig((value) => ({ ...value, ...patch }));
+
+	const advanced = (
+		<>
+			<Form.Item
+				name="priority"
+				label={t('field_jsmops_priority')}
+				help={t('help_jsmops_priority')}
+			>
+				<Input.TextArea
+					rows={2}
+					onChange={(event): void => update({ priority: event.target.value })}
+					data-testid="jsmops-priority-textarea"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="tags"
+				label={t('field_jsmops_tags')}
+				help={t('help_jsmops_tags')}
+			>
+				<Select
+					mode="tags"
+					open={false}
+					placeholder={t('placeholder_jsmops_tags')}
+					onChange={(value): void => update({ tags: value as string[] })}
+					data-testid="jsmops-tags-select"
+				/>
+			</Form.Item>
+		</>
+	);
+
+	return (
+		<>
+			<Typography.Text
+				color="muted"
+				size="sm"
+				testId="jsmops-tip"
+				style={{ display: 'block', marginBottom: 16 }}
+			>
+				{t('jsmops_tip')}{' '}
+				<Typography.Link
+					href="https://signoz.io/docs/alerts-management/notification-channel/jsm-ops/"
+					target="_blank"
+					rel="noopener noreferrer"
+				>
+					{t('jsmops_tip_link')}
+				</Typography.Link>
+			</Typography.Text>
+
+			<Form.Item
+				name="api_key"
+				label={t('field_jsmops_api_key')}
+				help={t('help_jsmops_api_key')}
+				required
+			>
+				<Input
+					type="password"
+					onChange={(event): void => update({ api_key: event.target.value })}
+					data-testid="jsmops-api-key-textbox"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="message"
+				label={t('field_jsmops_message')}
+				help={t('help_jsmops_message')}
+			>
+				<Input.TextArea
+					rows={2}
+					onChange={(event): void => update({ message: event.target.value })}
+					data-testid="jsmops-message-textarea"
+				/>
+			</Form.Item>
+
+			<Form.Item
+				name="description"
+				label={t('field_jsmops_description')}
+				help={t('help_jsmops_description')}
+			>
+				<Input.TextArea
+					rows={6}
+					onChange={(event): void => update({ description: event.target.value })}
+					data-testid="jsmops-description-textarea"
+				/>
+			</Form.Item>
+
+			<Collapse
+				ghost
+				items={[
+					{
+						key: 'advanced',
+						label: t('jsmops_advanced_section'),
+						children: advanced,
+					},
+				]}
+			/>
+		</>
+	);
+}
+
+interface JsmOpsProps {
+	setSelectedConfig: Dispatch<SetStateAction<Partial<JsmOpsChannel>>>;
+}
+
+export default JsmOpsSettings;

frontend/src/container/FormAlertChannels/index.tsx

@@ -10,6 +10,8 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
 	OpsgenieChannel,
 	PagerChannel,
 	SlackChannel,
@@ -19,6 +21,8 @@ import history from 'lib/history';
 
 import EmailSettings from './Settings/Email';
 import GoogleChatSettings from './Settings/GoogleChat';
+import JiraSettings from './Settings/Jira';
+import JsmOpsSettings from './Settings/JsmOps';
 import MsTeamsSettings from './Settings/MsTeams';
 import OpsgenieSettings from './Settings/Opsgenie';
 import PagerSettings from './Settings/Pager';
@@ -53,6 +57,10 @@ function FormAlertChannels({
 				return <MsTeamsSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.GoogleChat:
 				return <GoogleChatSettings setSelectedConfig={setSelectedConfig} />;
+			case ChannelType.Jira:
+				return <JiraSettings setSelectedConfig={setSelectedConfig} />;
+			case ChannelType.JsmOps:
+				return <JsmOpsSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.Opsgenie:
 				return <OpsgenieSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.Email:
@@ -141,6 +149,14 @@ function FormAlertChannels({
 						>
 							Google Chat
 						</Select.Option>
+
+						<Select.Option value="jira" key="jira" data-testid="select-option">
+							Jira
+						</Select.Option>
+
+						<Select.Option value="jsmops" key="jsmops" data-testid="select-option">
+							Jira Service Management Ops
+						</Select.Option>
 					</Select>
 				</Form.Item>
 
@@ -189,7 +205,9 @@ interface FormAlertChannelsProps {
 					PagerChannel &
 					OpsgenieChannel &
 					EmailChannel &
-					GoogleChatChannel
+					GoogleChatChannel &
+					JiraChannel &
+					JsmOpsChannel
 			>
 		>
 	>;

frontend/src/container/InfraMonitoringK8sV2/Base/ColumnHeader.tsx

@@ -4,8 +4,9 @@ import { TooltipSimple } from '@signozhq/ui/tooltip';
 import styles from './ColumnHeader.module.scss';
 import cx from 'classnames';
 import { MouseEventHandler } from 'react';
+import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
+const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
 
 interface ColumnHeaderProps {
 	children?: React.ReactNode;
@@ -43,7 +44,7 @@ function ColumnHeader({
 						<div onClick={stopPropagationHandler}>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_BASE_URL}${docPath}`}
+								href={`${DOCS_ROOT}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={stopPropagationHandler}

frontend/src/container/InfraMonitoringK8sV2/Base/EntityGroupHeader.module.scss

@@ -2,7 +2,6 @@
 	display: flex;
 	align-items: center;
 	gap: var(--spacing-5);
-	padding-left: 4px;
 }
 
 .infoIcon {

frontend/src/container/InfraMonitoringK8sV2/Base/EntityGroupHeader.tsx

@@ -2,8 +2,9 @@ import { Group, Info } from '@signozhq/icons';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 
 import styles from './EntityGroupHeader.module.scss';
+import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
+const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
 
 interface EntityGroupHeaderProps {
 	title: string;
@@ -28,7 +29,7 @@ function EntityGroupHeader({
 						<>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_BASE_URL}${docPath}`}
+								href={`${DOCS_ROOT}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={(e): void => e.stopPropagation()}

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetails.tsx

@@ -1,12 +1,10 @@
 import { useCallback, useEffect, useMemo } from 'react';
 import { useQuery } from 'react-query';
-import { useCopyToClipboard } from 'react-use';
-import { Copy, X } from '@signozhq/icons';
+import { X } from '@signozhq/icons';
 import { Divider } from '@signozhq/ui/divider';
 import { Button } from '@signozhq/ui/button';
 import { DrawerWrapper, DrawerWrapperProps } from '@signozhq/ui/drawer';
 import { toast } from '@signozhq/ui/sonner';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import ErrorContent from 'components/ErrorModal/components/ErrorContent';
@@ -20,6 +18,7 @@ import {
 
 import { INFRA_MONITORING_K8S_PARAMS_KEYS } from '../constants';
 import { useInfraMonitoringSelectedItemParams } from '../hooks';
+import CopyButton from 'periscope/components/CopyButton/CopyButton';
 import LoadingContainer from '../LoadingContainer';
 
 import K8sBaseDetailsContent from './K8sBaseDetailsContent';
@@ -95,12 +94,14 @@ export default function K8sBaseDetails<T>({
 				selectedItem,
 				selectedItemParams.clusterName,
 				selectedItemParams.namespaceName,
+				selectedItemParams.containerName,
 			),
 		[
 			queryKeyPrefix,
 			selectedItem,
 			selectedItemParams.clusterName,
 			selectedItemParams.namespaceName,
+			selectedItemParams.containerName,
 			selectedTime,
 			getAutoRefreshQueryKey,
 		],
@@ -170,14 +171,9 @@ export default function K8sBaseDetails<T>({
 		[handleClose],
 	);
 
-	const [, copyToClipboard] = useCopyToClipboard();
-
 	const handleCopyId = useCallback((): void => {
-		if (selectedItem) {
-			copyToClipboard(selectedItem);
-			toast.success('ID copied to clipboard', { position: 'bottom-left' });
-		}
-	}, [copyToClipboard, selectedItem]);
+		toast.success('ID copied to clipboard', { position: 'bottom-left' });
+	}, []);
 
 	const entityName = entity ? getEntityName(entity) : '';
 
@@ -211,17 +207,13 @@ export default function K8sBaseDetails<T>({
 					(isEntityLoading && 'Loading...') ||
 					'-'}
 			</Typography.Text>
-			<TooltipSimple title="Copy ID">
-				<Button
-					variant="ghost"
-					size="sm"
-					color="secondary"
-					onClick={handleCopyId}
-					data-testid="copy-id-button"
-				>
-					<Copy size={14} />
-				</Button>
-			</TooltipSimple>
+			<CopyButton
+				value={selectedItem ?? ''}
+				ariaLabel="Copy ID"
+				className={styles.copyIdButton}
+				testId="copy-id-button"
+				onCopy={handleCopyId}
+			/>
 		</>
 	) as unknown as string;
 

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetailsContent.tsx

@@ -9,7 +9,6 @@ import {
 import { Button } from '@signozhq/ui/button';
 import { ToggleGroupSimple } from '@signozhq/ui/toggle-group';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
-import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import { combineInitialAndUserExpression } from 'components/QueryBuilderV2/QueryV2/QuerySearch/utils';
 import { InfraMonitoringEvents } from 'constants/events';
@@ -42,6 +41,7 @@ import {
 } from '../hooks';
 
 import { EntityCountsSection } from './components/EntityCountsSection/EntityCountsSection';
+import { EntityMetadataItem } from './components/EntityMetadataItem/EntityMetadataItem';
 import { K8sBaseDetailsContentProps } from './types';
 import { getDrawerDurationMs } from './useDrawerLifecycleStore';
 
@@ -239,41 +239,18 @@ export default function K8sBaseDetailsContent<T>({
 		<>
 			<div className={styles.entityDetailsEntity}>
 				<div className={styles.entityDetailsGrid}>
-					<div className={styles.labelsRow}>
-						{metadataConfig.map((config) => (
-							<Typography.Text
+					{metadataConfig.map((config) => {
+						const value = config.getValue(entity);
+
+						return (
+							<EntityMetadataItem
 								key={config.label}
-								color="muted"
-								size="small"
-								weight="medium"
-								className={styles.entityDetailsMetadataLabel}
-							>
-								{config.label}
-							</Typography.Text>
-						))}
-					</div>
-
-					<div className={styles.valuesRow}>
-						{metadataConfig.map((config) => {
-							const value = config.getValue(entity);
-
-							if (config.render) {
-								return config.render(value, entity);
-							}
-
-							const displayValue = String(value);
-							return (
-								<Typography.Text
-									key={config.label}
-									size="small"
-									weight="medium"
-									className={styles.entityDetailsMetadataValue}
-								>
-									{displayValue}
-								</Typography.Text>
-							);
-						})}
-					</div>
+								label={config.label}
+								value={String(value)}
+								renderedValue={config.render?.(value, entity)}
+							/>
+						);
+					})}
 				</div>
 
 				{countsConfig &&

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseList.tsx

@@ -296,6 +296,7 @@ export function K8sBaseList<
 						params.selectedItem,
 						params.clusterName,
 						params.namespaceName,
+						params.containerName,
 					);
 					queryClient.setQueryData(detailQueryKey, { data: record });
 				}
@@ -348,6 +349,12 @@ export function K8sBaseList<
 						params.namespaceName,
 					);
 				}
+				if (params.containerName) {
+					url.searchParams.set(
+						INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME,
+						params.containerName,
+					);
+				}
 			} else {
 				url.searchParams.set(
 					INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM,

frontend/src/container/InfraMonitoringK8sV2/Base/K8sExpandedRow.module.scss

@@ -19,6 +19,12 @@
 	& [data-hide-expanded='true'] {
 		display: none;
 	}
+
+	// The icon slot is rendered even when the icon inside it is hidden, and the
+	// header's flex gap then indents the title past the values below it.
+	& [data-slot='icon']:has([data-hide-expanded='true']) {
+		display: none;
+	}
 }
 
 .expandedTableFooter {

frontend/src/container/InfraMonitoringK8sV2/Base/K8sExpandedRow.tsx

@@ -214,6 +214,7 @@ export function K8sExpandedRow<
 					params.selectedItem,
 					params.clusterName,
 					params.namespaceName,
+					params.containerName,
 				);
 				queryClient.setQueryData(detailQueryKey, { data: row });
 			}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/EntityMetadataItem.module.scss

@@ -0,0 +1,44 @@
+.metadataItem {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-1);
+	min-width: 0;
+}
+
+.valueRow {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-1);
+	min-width: 0;
+}
+
+.label {
+	letter-spacing: 0.44px;
+	text-transform: uppercase;
+}
+
+// Single-line ellipsis rather than Typography's `truncate`, which line-clamps:
+// clamping still wraps the text, so a value breaking at a hyphen ends its line
+// early and leaves a gap between the ellipsis and the copy button.
+//
+// This has to be a block: overflow and text-overflow do not apply to inline
+// boxes, and Typography.Text renders an inline span.
+.value {
+	display: block;
+	min-width: 0;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.valueText {
+	font-family: var(--periscope-font-family-mono);
+}
+
+// Sized to the icon rather than the default 2rem tap target, so it sits flush
+// against the value instead of floating in its own block of padding.
+.copyButton {
+	--button-padding: 2px;
+	--button-height: auto;
+	--button-width: auto;
+}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/EntityMetadataItem.tsx

@@ -0,0 +1,63 @@
+import { ReactNode, useCallback } from 'react';
+import { toast } from '@signozhq/ui/sonner';
+import { TooltipSimple } from '@signozhq/ui/tooltip';
+import { Typography } from '@signozhq/ui/typography';
+import CopyButton from 'periscope/components/CopyButton/CopyButton';
+
+import styles from './EntityMetadataItem.module.scss';
+
+export interface EntityMetadataItemProps {
+	label: string;
+	value: string;
+	/** An entity-supplied renderer, which opts out of clamping, tooltip and copy. */
+	renderedValue?: ReactNode;
+}
+
+export function EntityMetadataItem({
+	label,
+	value,
+	renderedValue,
+}: EntityMetadataItemProps): JSX.Element {
+	const handleCopy = useCallback((): void => {
+		toast.success(`${label} copied to clipboard`, { position: 'bottom-left' });
+	}, [label]);
+
+	return (
+		<div className={styles.metadataItem}>
+			<Typography.Text
+				color="muted"
+				size="small"
+				weight="medium"
+				className={styles.label}
+			>
+				{label}
+			</Typography.Text>
+
+			{renderedValue ?? (
+				<div className={styles.valueRow}>
+					<TooltipSimple title={value} arrow side="bottom" align="start">
+						<span className={styles.value}>
+							<Typography.Text
+								size="small"
+								weight="medium"
+								className={styles.valueText}
+							>
+								{value}
+							</Typography.Text>
+						</span>
+					</TooltipSimple>
+					{!!value && (
+						<CopyButton
+							value={value}
+							size={10}
+							ariaLabel={`Copy ${label}`}
+							className={styles.copyButton}
+							testId={`copy-metadata-${label.toLowerCase().replace(/\s+/g, '-')}`}
+							onCopy={handleCopy}
+						/>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/__tests__/EntityMetadataItem.test.tsx

@@ -0,0 +1,110 @@
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+
+import { EntityMetadataItem } from '../EntityMetadataItem';
+
+const mockCopyToClipboard = jest.fn();
+
+jest.mock('react-use', () => ({
+	__esModule: true,
+	useCopyToClipboard: (): [unknown, jest.Mock] => [null, mockCopyToClipboard],
+}));
+
+const mockToastSuccess = jest.fn();
+
+jest.mock('@signozhq/ui/sonner', () => ({
+	...jest.requireActual('@signozhq/ui/sonner'),
+	toast: {
+		success: (...args: unknown[]): unknown => mockToastSuccess(...args),
+	},
+}));
+
+describe('EntityMetadataItem', () => {
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('renders the label and its value', () => {
+		render(<EntityMetadataItem label="Cluster Name" value="prod-cluster" />);
+
+		expect(screen.getByText('Cluster Name')).toBeInTheDocument();
+		expect(screen.getByText('prod-cluster')).toBeInTheDocument();
+	});
+
+	it('copies the full value and confirms which field was copied', async () => {
+		render(
+			<EntityMetadataItem
+				label="Image:Tag"
+				value="ghcr.io/open-telemetry/demo:1.12.0-loadgenerator"
+			/>,
+		);
+
+		await userEvent.click(screen.getByTestId('copy-metadata-image:tag'));
+
+		await waitFor(() => {
+			expect(mockCopyToClipboard).toHaveBeenCalledWith(
+				'ghcr.io/open-telemetry/demo:1.12.0-loadgenerator',
+			);
+		});
+		expect(mockToastSuccess).toHaveBeenCalledWith(
+			'Image:Tag copied to clipboard',
+			expect.anything(),
+		);
+	});
+
+	it('offers no copy control when the value is empty', () => {
+		render(<EntityMetadataItem label="Node" value="" />);
+
+		expect(screen.queryByTestId('copy-metadata-node')).not.toBeInTheDocument();
+	});
+
+	it('exposes the full value on hover', async () => {
+		render(
+			<EntityMetadataItem
+				label="Node"
+				value="gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t"
+			/>,
+		);
+
+		await userEvent.hover(
+			screen.getByText('gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t'),
+		);
+
+		await waitFor(() => {
+			expect(
+				screen.getAllByText('gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t').length,
+			).toBeGreaterThan(1);
+		});
+	});
+
+	it('never presents the value as clickable', () => {
+		render(<EntityMetadataItem label="Node" value="a-very-long-node-name" />);
+
+		const valueEl = screen.getByText('a-very-long-node-name');
+		expect(valueEl).not.toHaveAttribute('data-interactive');
+		expect(valueEl).not.toHaveAttribute('data-truncate');
+	});
+
+	it('triggers the tooltip from the wrapper, never from the text itself', () => {
+		render(<EntityMetadataItem label="Node" value="a-very-long-node-name" />);
+
+		// Radix merges its handlers onto the trigger, and Typography styles
+		// itself interactive off any merged onClick — so the trigger has to stay
+		// off the text.
+		const textEl = screen.getByText('a-very-long-node-name');
+		expect(textEl).not.toHaveAttribute('data-slot', 'tooltip-trigger');
+		expect(textEl.parentElement).toHaveAttribute('data-slot', 'tooltip-trigger');
+	});
+
+	it('leaves an entity-supplied renderer alone', () => {
+		render(
+			<EntityMetadataItem
+				label="Status"
+				value="running"
+				renderedValue={<span data-testid="custom">custom node</span>}
+			/>,
+		);
+
+		expect(screen.getByTestId('custom')).toBeInTheDocument();
+		expect(screen.queryByTestId('copy-metadata-status')).not.toBeInTheDocument();
+	});
+});

frontend/src/container/InfraMonitoringK8sV2/Base/entity.registry.ts

@@ -11,6 +11,7 @@ import { jobEntityConfig } from '../Jobs/entity.config';
 import { daemonSetEntityConfig } from '../DaemonSets/entity.config';
 import { statefulSetEntityConfig } from '../StatefulSets/entity.config';
 import { volumeEntityConfig } from '../Volumes/entity.config';
+import { containerEntityConfig } from '../Containers/entity.config';
 
 type AnyEntityConfig = K8sEntityConfig<
 	K8sEntityData,
@@ -34,6 +35,7 @@ export const entityRegistry: Record<string, AnyEntityConfig> = {
 	[K8sCategories.DAEMONSETS]: registerConfig(daemonSetEntityConfig),
 	[K8sCategories.STATEFULSETS]: registerConfig(statefulSetEntityConfig),
 	[K8sCategories.VOLUMES]: registerConfig(volumeEntityConfig),
+	[K8sCategories.CONTAINERS]: registerConfig(containerEntityConfig),
 };
 
 export function getEntityConfig(category: string): AnyEntityConfig | undefined {

frontend/src/container/InfraMonitoringK8sV2/Containers/__tests__/containers.test.ts

@@ -0,0 +1,142 @@
+import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
+import {
+	k8sContainerGetSelectedItemExpression,
+	k8sContainerInitialEventsExpression,
+	k8sContainerInitialLogTracesExpression,
+} from 'container/InfraMonitoringK8sV2/Containers/constants';
+import { getContainerMetricsQueryPayload } from 'container/InfraMonitoringK8sV2/Containers/metrics';
+import {
+	getK8sContainerItemKey,
+	getK8sContainerRowKey,
+} from 'container/InfraMonitoringK8sV2/Containers/table.config';
+import { getContainerImageWithTag } from 'container/InfraMonitoringK8sV2/Containers/utils';
+
+function makeContainer(
+	overrides: Partial<InframonitoringtypesContainerRecordDTO> = {},
+): InframonitoringtypesContainerRecordDTO {
+	return {
+		containerName: 'nginx',
+		podUID: 'pod-uid-1',
+		meta: {
+			'k8s.container.name': 'nginx',
+			'k8s.pod.uid': 'pod-uid-1',
+			'k8s.pod.name': 'web-0',
+			'k8s.namespace.name': 'production',
+			'k8s.cluster.name': 'prod-cluster',
+			'container.image.name': 'nginx',
+			'container.image.tag': '1.27',
+		},
+		...overrides,
+	} as InframonitoringtypesContainerRecordDTO;
+}
+
+describe('container identity', () => {
+	it('keys a row by the (pod UID, container name) pair', () => {
+		expect(getK8sContainerRowKey(makeContainer())).toBe('pod-uid-1/nginx');
+	});
+
+	it('carries the container name alongside the pod UID into the drawer params', () => {
+		expect(getK8sContainerItemKey(makeContainer())).toStrictEqual({
+			selectedItem: 'pod-uid-1',
+			containerName: 'nginx',
+			clusterName: null,
+			namespaceName: null,
+		});
+	});
+
+	it('falls back to meta when the record fields are empty', () => {
+		const container = makeContainer({ containerName: '', podUID: '' });
+
+		expect(getK8sContainerItemKey(container)).toStrictEqual({
+			selectedItem: 'pod-uid-1',
+			containerName: 'nginx',
+			clusterName: null,
+			namespaceName: null,
+		});
+	});
+
+	it('scopes the details fetch to both halves of the identity', () => {
+		expect(
+			k8sContainerGetSelectedItemExpression({
+				selectedItem: 'pod-uid-1',
+				containerName: 'nginx',
+			}),
+		).toBe("k8s.pod.uid = 'pod-uid-1' AND k8s.container.name = 'nginx'");
+	});
+});
+
+describe('getContainerImageWithTag', () => {
+	it('renders name and tag together', () => {
+		expect(getContainerImageWithTag(makeContainer())).toBe('nginx:1.27');
+	});
+
+	it('drops the tag when the image is not pinned', () => {
+		const container = makeContainer({
+			meta: { 'container.image.name': 'nginx' },
+		});
+
+		expect(getContainerImageWithTag(container)).toBe('nginx');
+	});
+
+	it('renders nothing when the image name is missing', () => {
+		expect(getContainerImageWithTag(makeContainer({ meta: {} }))).toBe('');
+	});
+});
+
+describe('container drawer expressions', () => {
+	it('scopes logs and traces to the container within its pod', () => {
+		expect(k8sContainerInitialLogTracesExpression(makeContainer())).toBe(
+			"k8s.pod.uid = 'pod-uid-1' AND k8s.cluster.name = 'prod-cluster' AND k8s.namespace.name = 'production' AND k8s.container.name = 'nginx'",
+		);
+	});
+
+	it('scopes events to the pod, since k8s emits events per pod', () => {
+		expect(k8sContainerInitialEventsExpression(makeContainer())).toBe(
+			"k8s.object.kind = 'Pod' AND k8s.object.name = 'web-0' AND k8s.cluster.name = 'prod-cluster' AND attribute.k8s.namespace.name = 'production'",
+		);
+	});
+});
+
+describe('getContainerMetricsQueryPayload', () => {
+	const payloads = getContainerMetricsQueryPayload(makeContainer(), 1000, 2000);
+
+	it('returns one payload per documented chart', () => {
+		expect(payloads).toHaveLength(10);
+	});
+
+	it('scopes every query to the selected container', () => {
+		payloads.forEach((payload) => {
+			payload.query.builder.queryData.forEach((query) => {
+				expect(query.filters?.items).toStrictEqual([
+					expect.objectContaining({
+						key: expect.objectContaining({ key: 'k8s.pod.uid' }),
+						op: '=',
+						value: 'pod-uid-1',
+					}),
+					expect.objectContaining({
+						key: expect.objectContaining({ key: 'k8s.container.name' }),
+						op: '=',
+						value: 'nginx',
+					}),
+				]);
+			});
+		});
+	});
+
+	it('derives cache memory from the working set and RSS queries', () => {
+		const memoryByState = payloads[4];
+
+		expect(
+			memoryByState.query.builder.queryData.map((query) => [
+				query.queryName,
+				query.aggregateAttribute?.key,
+			]),
+		).toStrictEqual([
+			['A', 'container.memory.rss'],
+			['B', 'container.memory.working_set'],
+		]);
+		expect(memoryByState.query.builder.queryFormulas).toStrictEqual([
+			expect.objectContaining({ expression: 'B - A', legend: 'Cache Memory' }),
+		]);
+	});
+});

frontend/src/container/InfraMonitoringK8sV2/Containers/constants.ts

@@ -0,0 +1,170 @@
+import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
+import { formatValueForExpression } from 'components/QueryBuilderV2/utils';
+
+import {
+	buildEventsExpression,
+	buildLogsTracesExpression,
+} from '../Base/utils';
+import { K8sDetailsMetadataConfig, K8sDetailsWidgetInfo } from '../Base/types';
+import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
+import { SelectedItemParams } from '../hooks';
+import {
+	CONTAINERS_DOC_PATH,
+	getContainerImageWithTag,
+	getContainerName,
+	getContainerPodUID,
+} from './utils';
+
+/** A container row is identified by the (pod UID, container name) pair. */
+export const k8sContainerGetSelectedItemExpression = (
+	params: SelectedItemParams,
+): string =>
+	[
+		`${INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID} = ${formatValueForExpression(
+			params.selectedItem ?? '',
+		)}`,
+		`${INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME} = ${formatValueForExpression(
+			params.containerName ?? '',
+		)}`,
+	].join(' AND ');
+
+export const k8sContainerGetEntityName = getContainerName;
+
+export const k8sContainerDetailsMetadataConfig: K8sDetailsMetadataConfig<InframonitoringtypesContainerRecordDTO>[] =
+	[
+		{
+			label: 'Pod',
+			getValue: (c): string =>
+				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
+		},
+		{
+			label: 'NAMESPACE',
+			getValue: (c): string =>
+				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME] || '',
+		},
+		{
+			label: 'Node',
+			getValue: (c): string =>
+				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME] || '',
+		},
+		{
+			label: 'Cluster Name',
+			getValue: (c): string =>
+				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME] || '',
+		},
+		{
+			label: 'Image:Tag',
+			getValue: getContainerImageWithTag,
+		},
+	];
+
+export const k8sContainerInitialLogTracesExpression = (
+	container: InframonitoringtypesContainerRecordDTO,
+): string => {
+	const base = buildLogsTracesExpression({
+		mainAttributeKey: INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID,
+		mainAttributeValue: getContainerPodUID(container),
+		clusterName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME],
+		namespaceName:
+			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME],
+	});
+
+	const containerName = getContainerName(container);
+	if (!containerName) {
+		return base;
+	}
+
+	const containerClause = `${
+		INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME
+	} = ${formatValueForExpression(containerName)}`;
+
+	return base ? `${base} AND ${containerClause}` : containerClause;
+};
+
+/**
+ * Kubernetes emits events against the pod, not the container, so the events tab
+ * is scoped to the container's pod.
+ */
+export const k8sContainerInitialEventsExpression = (
+	container: InframonitoringtypesContainerRecordDTO,
+): string =>
+	buildEventsExpression({
+		objectKind: 'Pod',
+		objectName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
+		clusterName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME],
+		namespaceName:
+			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME],
+	});
+
+export const containerWidgetInfo: K8sDetailsWidgetInfo[] = [
+	{
+		title: 'CPU Usage (cores)',
+		yAxisUnit: '',
+		docPath: `${CONTAINERS_DOC_PATH}#cpu-usage-cores-1`,
+		description:
+			'Avg, max and min CPU consumption of the container in cores, showing how bursty it is.',
+	},
+	{
+		title: 'CPU Request, Limit Utilization',
+		yAxisUnit: 'percentunit',
+		docPath: `${CONTAINERS_DOC_PATH}#cpu-request-limit-utilization`,
+		description:
+			'Container CPU usage as a fraction of its own CPU request and limit; limit lines near 100% mean throttling.',
+	},
+	{
+		title: 'Memory Usage (bytes)',
+		yAxisUnit: 'bytes',
+		docPath: `${CONTAINERS_DOC_PATH}#memory-usage-bytes`,
+		description:
+			'Total memory charged to the container, including reclaimable page cache, against the headroom left before its limit.',
+	},
+	{
+		title: 'Memory Request, Limit Utilization',
+		yAxisUnit: 'percentunit',
+		docPath: `${CONTAINERS_DOC_PATH}#memory-request-limit-utilization`,
+		description:
+			'Container memory usage as a fraction of its own memory request and limit; limit lines near 100% risk an OOMKill.',
+	},
+	{
+		title: 'Memory by State',
+		yAxisUnit: 'bytes',
+		docPath: `${CONTAINERS_DOC_PATH}#memory-by-state`,
+		description:
+			'RSS, working set and cache memory of the container, separating heap growth from file cache.',
+	},
+	{
+		title: 'Memory Major Page Faults',
+		yAxisUnit: '',
+		docPath: `${CONTAINERS_DOC_PATH}#memory-major-page-faults`,
+		description:
+			'Major page fault rate of the container; sustained values mean the working set is paging to disk.',
+	},
+	{
+		title: 'File System (bytes)',
+		yAxisUnit: 'bytes',
+		docPath: `${CONTAINERS_DOC_PATH}#file-system-bytes`,
+		description:
+			'Capacity, available and used bytes of the container filesystem.',
+	},
+	{
+		title: 'Container Uptime',
+		yAxisUnit: 's',
+		docPath: `${CONTAINERS_DOC_PATH}#container-uptime`,
+		description:
+			'Time since the container last started; a sawtooth of resets means it is restarting repeatedly.',
+	},
+	{
+		title: 'Node CPU Utilization by Container',
+		yAxisUnit: 'percentunit',
+		docPath: `${CONTAINERS_DOC_PATH}#node-cpu-utilization-by-container`,
+		description:
+			"The container's CPU usage as a fraction of the whole node's capacity, to spot noisy neighbours.",
+	},
+	{
+		title: 'Node Memory Utilization by Container',
+		yAxisUnit: 'percentunit',
+		docPath: `${CONTAINERS_DOC_PATH}#node-memory-utilization-by-container`,
+		description:
+			"The container's memory usage as a fraction of the whole node's capacity.",
+	},
+];

frontend/src/container/InfraMonitoringK8sV2/Containers/entity.config.ts

@@ -0,0 +1,140 @@
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { listContainers } from 'api/generated/services/inframonitoring';
+import {
+	InframonitoringtypesContainerRecordDTO,
+	InframonitoringtypesResponseTypeDTO,
+	Querybuildertypesv5OrderDirectionDTO,
+	RenderErrorResponseDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
+import { InfraMonitoringEvents } from 'constants/events';
+
+import { K8sEntityConfig } from '../Base/entity.config.types';
+import { K8sBaseFilters, K8sDetailsFilters } from '../Base/types';
+import { InfraMonitoringEntity } from '../constants';
+import { SelectedItemParams } from '../hooks';
+import {
+	containerWidgetInfo,
+	k8sContainerDetailsMetadataConfig,
+	k8sContainerGetEntityName,
+	k8sContainerGetSelectedItemExpression,
+	k8sContainerInitialEventsExpression,
+	k8sContainerInitialLogTracesExpression,
+} from './constants';
+import { getContainerMetricsQueryPayload } from './metrics';
+import {
+	getK8sContainerItemKey,
+	getK8sContainerRowKey,
+	k8sContainerColumnsConfig,
+} from './table.config';
+
+async function fetchListData(
+	filters: K8sBaseFilters,
+	signal?: AbortSignal,
+): ReturnType<
+	K8sEntityConfig<
+		InframonitoringtypesContainerRecordDTO,
+		SelectedItemParams
+	>['list']['fetchListData']
+> {
+	try {
+		const response = await listContainers(
+			{
+				filter: { expression: filters.filter.expression },
+				groupBy: filters.groupBy?.map((g) => ({ name: g.name })),
+				offset: filters.offset,
+				limit: filters.limit ?? 10,
+				start: filters.start,
+				end: filters.end,
+				orderBy: filters.orderBy
+					? {
+							key: { name: filters.orderBy.key.name },
+							direction:
+								filters.orderBy.direction === 'asc'
+									? Querybuildertypesv5OrderDirectionDTO.asc
+									: Querybuildertypesv5OrderDirectionDTO.desc,
+						}
+					: undefined,
+			},
+			signal,
+		);
+
+		const data = response.data;
+		return {
+			type:
+				data.type === InframonitoringtypesResponseTypeDTO.grouped_list
+					? ('grouped_list' as const)
+					: ('list' as const),
+			records: data.records,
+			total: data.total,
+			endTimeBeforeRetention: data.endTimeBeforeRetention,
+			warning: data.warning,
+		};
+	} catch (error) {
+		return {
+			type: 'list' as const,
+			records: [] as InframonitoringtypesContainerRecordDTO[],
+			total: 0,
+			error:
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) ?? null,
+		};
+	}
+}
+
+async function fetchEntityData(
+	filters: K8sDetailsFilters,
+	signal?: AbortSignal,
+): ReturnType<
+	K8sEntityConfig<InframonitoringtypesContainerRecordDTO>['details']['fetchEntityData']
+> {
+	try {
+		const response = await listContainers(
+			{
+				filter: { expression: filters.filter.expression },
+				start: filters.start,
+				end: filters.end,
+				limit: 1,
+				offset: 0,
+			},
+			signal,
+		);
+
+		return {
+			data: response.data.records.length > 0 ? response.data.records[0] : null,
+		};
+	} catch (error) {
+		return {
+			data: null,
+			error:
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) ?? null,
+		};
+	}
+}
+
+export const containerEntityConfig: K8sEntityConfig<
+	InframonitoringtypesContainerRecordDTO,
+	SelectedItemParams
+> = {
+	list: {
+		entity: InfraMonitoringEntity.CONTAINERS,
+		eventCategory: InfraMonitoringEvents.Container,
+		tableColumns: k8sContainerColumnsConfig,
+		fetchListData,
+		getRowKey: getK8sContainerRowKey,
+		getItemKey: getK8sContainerItemKey,
+		detailsQueryKeyPrefix: 'container',
+	},
+	details: {
+		category: InfraMonitoringEntity.CONTAINERS,
+		eventCategory: InfraMonitoringEvents.Container,
+		queryKeyPrefix: 'container',
+		getSelectedItemExpression: k8sContainerGetSelectedItemExpression,
+		fetchEntityData,
+		getEntityName: k8sContainerGetEntityName,
+		getInitialLogTracesExpression: k8sContainerInitialLogTracesExpression,
+		getInitialEventsExpression: k8sContainerInitialEventsExpression,
+		metadataConfig: k8sContainerDetailsMetadataConfig,
+		entityWidgetInfo: containerWidgetInfo,
+		getEntityQueryPayload: getContainerMetricsQueryPayload,
+	},
+};

frontend/src/container/InfraMonitoringK8sV2/Containers/metrics.ts

@@ -0,0 +1,275 @@
+import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+import { EQueryType } from 'types/common/dashboard';
+import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
+import { v4 } from 'uuid';
+
+import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
+import { getContainerName, getContainerPodUID } from './utils';
+
+const QUERY_NAMES = ['A', 'B', 'C', 'D', 'E', 'F'];
+const STEP_INTERVAL = 60;
+
+type TimeAggregation = 'avg' | 'max' | 'min' | 'latest';
+type SpaceAggregation = 'sum' | 'avg' | 'max';
+
+interface SeriesSpec {
+	metricKey: string;
+	legend: string;
+	timeAggregation: TimeAggregation;
+	spaceAggregation: SpaceAggregation;
+}
+
+interface FormulaSpec {
+	expression: string;
+	legend: string;
+}
+
+/**
+ * Every panel is scoped to a single container by the (k8s.pod.uid,
+ * k8s.container.name) pair that identifies its row in the list.
+ */
+function buildScopeFilters(
+	container: InframonitoringtypesContainerRecordDTO,
+): TagFilter {
+	return {
+		items: [
+			{
+				id: 'pod-uid',
+				key: {
+					dataType: DataTypes.String,
+					id: `k8s_pod_uid--string--tag--false`,
+					key: INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID,
+					type: 'tag',
+				},
+				op: '=',
+				value: getContainerPodUID(container),
+			},
+			{
+				id: 'container-name',
+				key: {
+					dataType: DataTypes.String,
+					id: `k8s_container_name--string--tag--false`,
+					key: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
+					type: 'tag',
+				},
+				op: '=',
+				value: getContainerName(container),
+			},
+		],
+		op: 'AND',
+	};
+}
+
+function buildQuery(
+	container: InframonitoringtypesContainerRecordDTO,
+	start: number,
+	end: number,
+	series: SeriesSpec[],
+	formulas: FormulaSpec[] = [],
+): GetQueryResultsProps {
+	const filters = buildScopeFilters(container);
+
+	return {
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: series.map((spec, index) => ({
+					aggregateAttribute: {
+						dataType: DataTypes.Float64,
+						id: `${spec.metricKey.replace(/\./g, '_')}--float64--Gauge--true`,
+						key: spec.metricKey,
+						type: 'Gauge',
+					},
+					aggregateOperator: spec.timeAggregation,
+					dataSource: DataSource.METRICS,
+					disabled: false,
+					expression: QUERY_NAMES[index],
+					filters,
+					functions: [],
+					groupBy: [],
+					having: [],
+					legend: spec.legend,
+					limit: null,
+					orderBy: [],
+					queryName: QUERY_NAMES[index],
+					reduceTo: ReduceOperators.AVG,
+					spaceAggregation: spec.spaceAggregation,
+					stepInterval: STEP_INTERVAL,
+					timeAggregation: spec.timeAggregation,
+				})),
+				queryFormulas: formulas.map((formula, index) => ({
+					disabled: false,
+					expression: formula.expression,
+					legend: formula.legend,
+					queryName: `F${index + 1}`,
+				})),
+				queryTraceOperator: [],
+			},
+			clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
+			id: v4(),
+			promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	};
+}
+
+/** Absolute usage metrics are summed across series, ratios are averaged. */
+function usageSeries(metricKey: string, legendPrefix = ''): SeriesSpec[] {
+	const prefix = legendPrefix ? `${legendPrefix} - ` : '';
+	return [
+		{
+			metricKey,
+			legend: `${prefix}Avg`,
+			timeAggregation: 'avg',
+			spaceAggregation: 'sum',
+		},
+		{
+			metricKey,
+			legend: `${prefix}Max`,
+			timeAggregation: 'max',
+			spaceAggregation: 'sum',
+		},
+		{
+			metricKey,
+			legend: `${prefix}Min`,
+			timeAggregation: 'min',
+			spaceAggregation: 'sum',
+		},
+	];
+}
+
+function utilizationSeries(
+	metricKey: string,
+	legendPrefix: string,
+): SeriesSpec[] {
+	return (['avg', 'max', 'min'] as TimeAggregation[]).map((timeAggregation) => ({
+		metricKey,
+		legend: `${legendPrefix} - ${
+			timeAggregation.charAt(0).toUpperCase() + timeAggregation.slice(1)
+		}`,
+		timeAggregation,
+		spaceAggregation: 'avg' as const,
+	}));
+}
+
+export const getContainerMetricsQueryPayload = (
+	container: InframonitoringtypesContainerRecordDTO,
+	start: number,
+	end: number,
+): GetQueryResultsProps[] => {
+	const query = (
+		series: SeriesSpec[],
+		formulas?: FormulaSpec[],
+	): GetQueryResultsProps => buildQuery(container, start, end, series, formulas);
+
+	return [
+		query(usageSeries(INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE)),
+		query([
+			...utilizationSeries(
+				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_REQUEST_UTILIZATION,
+				'Request util %',
+			),
+			...utilizationSeries(
+				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_LIMIT_UTILIZATION,
+				'Limit util %',
+			),
+		]),
+		query([
+			...usageSeries(INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_USAGE, 'Usage'),
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_AVAILABLE,
+				legend: 'Available',
+				timeAggregation: 'avg',
+				spaceAggregation: 'sum',
+			},
+		]),
+		query([
+			...utilizationSeries(
+				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_REQUEST_UTILIZATION,
+				'Request util %',
+			),
+			...utilizationSeries(
+				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_LIMIT_UTILIZATION,
+				'Limit util %',
+			),
+		]),
+		query(
+			[
+				{
+					metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_RSS,
+					legend: 'RSS Memory',
+					timeAggregation: 'avg',
+					spaceAggregation: 'sum',
+				},
+				{
+					metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_WORKING_SET,
+					legend: 'Working Set Memory',
+					timeAggregation: 'avg',
+					spaceAggregation: 'sum',
+				},
+			],
+			[{ expression: 'B - A', legend: 'Cache Memory' }],
+		),
+		query([
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_MAJOR_PAGE_FAULTS,
+				legend: 'Major Page Faults',
+				timeAggregation: 'avg',
+				spaceAggregation: 'sum',
+			},
+		]),
+		query([
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_CAPACITY,
+				legend: 'Capacity',
+				timeAggregation: 'avg',
+				spaceAggregation: 'sum',
+			},
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_AVAILABLE,
+				legend: 'Available',
+				timeAggregation: 'avg',
+				spaceAggregation: 'sum',
+			},
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_USAGE,
+				legend: 'Usage',
+				timeAggregation: 'avg',
+				spaceAggregation: 'sum',
+			},
+		]),
+		query([
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_UPTIME,
+				legend: 'Uptime',
+				timeAggregation: 'latest',
+				spaceAggregation: 'sum',
+			},
+		]),
+		query([
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_NODE_UTILIZATION,
+				legend: 'Node CPU Utilization',
+				timeAggregation: 'avg',
+				spaceAggregation: 'avg',
+			},
+		]),
+		query([
+			{
+				metricKey: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_NODE_UTILIZATION,
+				legend: 'Node Memory Utilization',
+				timeAggregation: 'avg',
+				spaceAggregation: 'avg',
+			},
+		]),
+	];
+};

frontend/src/container/InfraMonitoringK8sV2/Containers/table.config.tsx

@@ -0,0 +1,470 @@
+import { Container } from '@signozhq/icons';
+import { Badge } from '@signozhq/ui/badge';
+import {
+	InframonitoringtypesContainerReadyDTO,
+	InframonitoringtypesContainerRecordDTO,
+	InframonitoringtypesContainerStatusDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import TanStackTable, { TableColumnDef } from 'components/TanStackTableView';
+import { ExpandButtonWrapper } from 'container/InfraMonitoringK8sV2/components';
+
+import ColumnHeader from '../Base/ColumnHeader';
+import EntityGroupHeader from '../Base/EntityGroupHeader';
+import K8sGroupCell from '../Base/K8sGroupCell';
+import { formatBytes } from '../commonUtils';
+import {
+	EntityProgressBar,
+	EntityProgressThresholds,
+	GroupedStatusCounts,
+	TextNoData,
+	ValidateColumnValueWrapper,
+} from '../components';
+import {
+	INFRA_MONITORING_ATTR_KEYS,
+	InfraMonitoringEntity,
+} from '../constants';
+import { SelectedItemParams } from '../hooks';
+import {
+	CONTAINER_READY_COLORS,
+	CONTAINER_READY_LABELS,
+	CONTAINER_STATUS_COLORS,
+	CONTAINER_STATUS_LABELS,
+	CONTAINERS_DOC_PATH,
+	getContainerImageWithTag,
+	getContainerReadyItems,
+	getContainerStatusItems,
+} from './utils';
+
+export function getK8sContainerRowKey(
+	container: InframonitoringtypesContainerRecordDTO,
+): string {
+	return (
+		[container.podUID, container.containerName].filter(Boolean).join('/') ||
+		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
+		''
+	);
+}
+
+export function getK8sContainerItemKey(
+	container: InframonitoringtypesContainerRecordDTO,
+): SelectedItemParams {
+	return {
+		selectedItem:
+			container.podUID ||
+			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID] ||
+			null,
+		containerName:
+			container.containerName ||
+			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
+			null,
+		clusterName: null,
+		namespaceName: null,
+	};
+}
+
+export type ContainerTableColumnConfig =
+	TableColumnDef<InframonitoringtypesContainerRecordDTO>;
+
+/**
+ * The grouped table and its nested rows are separate tables, so a column and the
+ * one that replaces it while grouped share a width to keep the two aligned.
+ */
+const NAME_COLUMN_WIDTH = 220;
+const STATUS_COLUMN_WIDTH = 250;
+
+export const k8sContainerColumnsConfig: ContainerTableColumnConfig[] = [
+	{
+		id: 'containerGroup',
+		header: (): React.ReactNode => <EntityGroupHeader title="Container Group" />,
+		accessorFn: (row): string => row.containerName || '',
+		width: { min: NAME_COLUMN_WIDTH },
+		enableSort: false,
+		enableRemove: false,
+		enableMove: false,
+		pin: 'left',
+		visibilityBehavior: 'hidden-on-collapse',
+		cell: ({ isExpanded, toggleExpanded, row }): JSX.Element | null => (
+			<ExpandButtonWrapper isExpanded={isExpanded} toggleExpanded={toggleExpanded}>
+				<K8sGroupCell row={row} />
+			</ExpandButtonWrapper>
+		),
+	},
+	{
+		id: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
+		header: (): React.ReactNode => (
+			<EntityGroupHeader
+				title="Container Name"
+				icon={<Container data-hide-expanded="true" size={14} />}
+				docPath={`${CONTAINERS_DOC_PATH}#container-name`}
+			/>
+		),
+		accessorFn: (row): string =>
+			row.containerName ||
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
+			'',
+		width: { min: NAME_COLUMN_WIDTH },
+		enableSort: true,
+		enableRemove: false,
+		enableMove: false,
+		pin: 'left',
+		visibilityBehavior: 'hidden-on-expand',
+		cell: ({ value }): React.ReactNode => (
+			<TanStackTable.Text>{value as string}</TanStackTable.Text>
+		),
+	},
+	{
+		id: 'podName',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#pod-name`}>
+				Pod Name
+			</ColumnHeader>
+		),
+		accessorFn: (row): string =>
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
+		width: { min: 260 },
+		enableSort: false,
+		cell: ({ value }): React.ReactNode => {
+			const podName = value as string;
+			if (!podName) {
+				return <TextNoData type="tanstack" />;
+			}
+			return <TanStackTable.Text>{podName}</TanStackTable.Text>;
+		},
+	},
+	{
+		id: 'namespace',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
+				Namespace
+			</ColumnHeader>
+		),
+		accessorFn: (row): string =>
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME] || '',
+		width: { min: 160 },
+		enableSort: false,
+		cell: ({ value }): React.ReactNode => (
+			<TanStackTable.Text>{value as string}</TanStackTable.Text>
+		),
+	},
+	{
+		id: 'image',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#imagetag`}>
+				Image:Tag
+			</ColumnHeader>
+		),
+		accessorFn: (row): string => getContainerImageWithTag(row),
+		width: { min: 240 },
+		enableSort: false,
+		cell: ({ value }): React.ReactNode => {
+			const image = value as string;
+			if (!image) {
+				return <TextNoData type="tanstack" />;
+			}
+			return <TanStackTable.Text>{image}</TanStackTable.Text>;
+		},
+	},
+	{
+		id: 'containerStatus',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#status`}>Status</ColumnHeader>
+		),
+		accessorFn: (row): string => row.status,
+		width: { min: STATUS_COLUMN_WIDTH },
+		enableSort: false,
+		visibilityBehavior: 'hidden-on-expand',
+		cell: ({ row }): React.ReactNode => {
+			if (
+				!row.status ||
+				row.status === InframonitoringtypesContainerStatusDTO.no_data
+			) {
+				return <TextNoData type="tanstack" />;
+			}
+
+			return (
+				<Badge color={CONTAINER_STATUS_COLORS[row.status]} variant="outline">
+					{CONTAINER_STATUS_LABELS[row.status]}
+				</Badge>
+			);
+		},
+	},
+	{
+		id: 'containerCountsByStatus',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#status`}>Status</ColumnHeader>
+		),
+		accessorFn: (
+			row,
+		): InframonitoringtypesContainerRecordDTO['containerCountsByStatus'] =>
+			row.containerCountsByStatus,
+		width: { min: STATUS_COLUMN_WIDTH },
+		enableSort: false,
+		visibilityBehavior: 'hidden-on-collapse',
+		cell: ({ row, rowId }): React.ReactNode => {
+			if (!row.containerCountsByStatus) {
+				return <TextNoData type="tanstack" />;
+			}
+			return (
+				<GroupedStatusCounts
+					items={getContainerStatusItems(row.containerCountsByStatus)}
+					rowId={rowId}
+				/>
+			);
+		},
+	},
+	{
+		id: 'containerReady',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#ready`}>Ready</ColumnHeader>
+		),
+		accessorFn: (row): string => row.ready,
+		width: { min: 130 },
+		enableSort: false,
+		visibilityBehavior: 'hidden-on-expand',
+		cell: ({ row }): React.ReactNode => {
+			if (
+				!row.ready ||
+				row.ready === InframonitoringtypesContainerReadyDTO.no_data
+			) {
+				return <TextNoData type="tanstack" />;
+			}
+
+			return (
+				<Badge color={CONTAINER_READY_COLORS[row.ready]} variant="outline">
+					{CONTAINER_READY_LABELS[row.ready]}
+				</Badge>
+			);
+		},
+	},
+	{
+		id: 'containerCountsByReady',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#ready`}>Ready</ColumnHeader>
+		),
+		accessorFn: (
+			row,
+		): InframonitoringtypesContainerRecordDTO['containerCountsByReady'] =>
+			row.containerCountsByReady,
+		width: { min: 130 },
+		enableSort: false,
+		visibilityBehavior: 'hidden-on-collapse',
+		cell: ({ row, rowId }): React.ReactNode => {
+			if (!row.containerCountsByReady) {
+				return <TextNoData type="tanstack" />;
+			}
+			return (
+				<GroupedStatusCounts
+					items={getContainerReadyItems(row.containerCountsByReady)}
+					rowId={rowId}
+				/>
+			);
+		},
+	},
+	{
+		id: 'containerRestarts',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#restarts`}>
+				Restarts
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.restarts,
+		width: { min: 130 },
+		enableSort: false,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="Restarts"
+			>
+				<TanStackTable.Text>{value as number}</TanStackTable.Text>
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'cpu_request',
+		header: (): React.ReactNode => (
+			<ColumnHeader
+				docPath={`${CONTAINERS_DOC_PATH}#cpu-req-usage-`}
+				tooltip={<EntityProgressThresholds type="cpu-request" />}
+			>
+				CPU Request Usage (%)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.cpuRequestUtilization,
+		width: { min: 210 },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="CPU Request"
+			>
+				<EntityProgressBar value={value as number} type="cpu-request" />
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'cpu_limit',
+		header: (): React.ReactNode => (
+			<ColumnHeader
+				docPath={`${CONTAINERS_DOC_PATH}#cpu-limit-usage-`}
+				tooltip={<EntityProgressThresholds type="cpu-limit" />}
+			>
+				CPU Limit Usage (%)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.cpuLimitUtilization,
+		width: { min: 220 },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="CPU Limit"
+			>
+				<EntityProgressBar value={value as number} type="cpu-limit" />
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'cpu',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#cpu-usage-cores`}>
+				CPU Usage (cores)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.cpu,
+		width: { min: 160 },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={Number(value)}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="CPU metric"
+			>
+				<TanStackTable.Text>{Number(value).toFixed(2)}</TanStackTable.Text>
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'memory_request',
+		header: (): React.ReactNode => (
+			<ColumnHeader
+				docPath={`${CONTAINERS_DOC_PATH}#mem-req-usage-`}
+				tooltip={<EntityProgressThresholds type="memory-request" />}
+			>
+				Memory Request Usage (%)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.memoryRequestUtilization,
+		width: { min: 210 },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="Memory Request"
+			>
+				<EntityProgressBar value={value as number} type="memory-request" />
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'memory_limit',
+		header: (): React.ReactNode => (
+			<ColumnHeader
+				docPath={`${CONTAINERS_DOC_PATH}#mem-limit-usage-`}
+				tooltip={<EntityProgressThresholds type="memory-limit" />}
+			>
+				Memory Limit Usage (%)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.memoryLimitUtilization,
+		width: { min: 220 },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="Memory Limit"
+			>
+				<EntityProgressBar value={value as number} type="memory-limit" />
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'memory',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#mem-usage-wss`}>
+				Memory Usage (WSS)
+			</ColumnHeader>
+		),
+		accessorFn: (row): number => row.memory,
+		width: { min: 210, default: '100%' },
+		enableSort: true,
+		cell: ({ value, rowId }): React.ReactNode => (
+			<ValidateColumnValueWrapper
+				rowId={rowId}
+				value={value as number}
+				entity={InfraMonitoringEntity.CONTAINERS}
+				attribute="memory metric"
+			>
+				<TanStackTable.Text>{formatBytes(value as number)}</TanStackTable.Text>
+			</ValidateColumnValueWrapper>
+		),
+	},
+	{
+		id: 'node',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
+				Node
+			</ColumnHeader>
+		),
+		accessorFn: (row): string =>
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME] || '',
+		width: { default: 100 },
+		enableSort: false,
+		defaultVisibility: false,
+		cell: ({ value }): React.ReactNode => (
+			<TanStackTable.Text>{value as string}</TanStackTable.Text>
+		),
+	},
+	{
+		id: 'cluster',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
+				Cluster
+			</ColumnHeader>
+		),
+		accessorFn: (row): string =>
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME] || '',
+		width: { default: 100 },
+		enableSort: false,
+		defaultVisibility: false,
+		cell: ({ value }): React.ReactNode => (
+			<TanStackTable.Text>{value as string}</TanStackTable.Text>
+		),
+	},
+	{
+		id: 'deployment',
+		header: (): React.ReactNode => (
+			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
+				Deployment
+			</ColumnHeader>
+		),
+		accessorFn: (row): string =>
+			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME] || '',
+		width: { default: 100 },
+		enableSort: false,
+		defaultVisibility: false,
+		cell: ({ value }): React.ReactNode => (
+			<TanStackTable.Text>{value as string}</TanStackTable.Text>
+		),
+	},
+];

frontend/src/container/InfraMonitoringK8sV2/Containers/utils.ts

@@ -0,0 +1,169 @@
+import { Color } from '@signozhq/design-tokens';
+import { BadgeColor } from '@signozhq/ui/badge';
+import {
+	InframonitoringtypesContainerCountsByReadyDTO,
+	InframonitoringtypesContainerCountsByStatusDTO,
+	InframonitoringtypesContainerReadyDTO,
+	InframonitoringtypesContainerRecordDTO,
+	InframonitoringtypesContainerStatusDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import { StatusCountItem } from '../components/GroupedStatusCounts';
+import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
+
+export const CONTAINERS_DOC_PATH =
+	'/infrastructure-monitoring/kubernetes/containers';
+
+/** Renders as `name:tag`; the tag is dropped when the image is not pinned. */
+export function getContainerImageWithTag(
+	container: InframonitoringtypesContainerRecordDTO,
+): string {
+	const name = container.meta?.[INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME];
+	const tag = container.meta?.[INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_TAG];
+
+	if (!name) {
+		return '';
+	}
+
+	return tag ? `${name}:${tag}` : name;
+}
+
+export function getContainerName(
+	container: InframonitoringtypesContainerRecordDTO,
+): string {
+	return (
+		container.containerName ||
+		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
+		''
+	);
+}
+
+export function getContainerPodUID(
+	container: InframonitoringtypesContainerRecordDTO,
+): string {
+	return (
+		container.podUID ||
+		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID] ||
+		''
+	);
+}
+
+export const CONTAINER_STATUS_COLORS: Record<
+	InframonitoringtypesContainerStatusDTO,
+	BadgeColor
+> = {
+	[InframonitoringtypesContainerStatusDTO.running]: 'forest',
+	[InframonitoringtypesContainerStatusDTO.completed]: 'robin',
+	[InframonitoringtypesContainerStatusDTO.waiting]: 'amber',
+	[InframonitoringtypesContainerStatusDTO.containercreating]: 'amber',
+	[InframonitoringtypesContainerStatusDTO.terminated]: 'sienna',
+	[InframonitoringtypesContainerStatusDTO.unknown]: 'vanilla',
+	[InframonitoringtypesContainerStatusDTO.no_data]: 'vanilla',
+	[InframonitoringtypesContainerStatusDTO.crashloopbackoff]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.imagepullbackoff]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.errimagepull]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.createcontainerconfigerror]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.oomkilled]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.error]: 'cherry',
+	[InframonitoringtypesContainerStatusDTO.containercannotrun]: 'cherry',
+};
+
+/** kubectl prints these as single CamelCase words, so the enum value alone is not a usable label. */
+export const CONTAINER_STATUS_LABELS: Record<
+	InframonitoringtypesContainerStatusDTO,
+	string
+> = {
+	[InframonitoringtypesContainerStatusDTO.running]: 'Running',
+	[InframonitoringtypesContainerStatusDTO.completed]: 'Completed',
+	[InframonitoringtypesContainerStatusDTO.waiting]: 'Waiting',
+	[InframonitoringtypesContainerStatusDTO.containercreating]:
+		'ContainerCreating',
+	[InframonitoringtypesContainerStatusDTO.terminated]: 'Terminated',
+	[InframonitoringtypesContainerStatusDTO.unknown]: 'Unknown',
+	[InframonitoringtypesContainerStatusDTO.no_data]: 'No data',
+	[InframonitoringtypesContainerStatusDTO.crashloopbackoff]: 'CrashLoopBackOff',
+	[InframonitoringtypesContainerStatusDTO.imagepullbackoff]: 'ImagePullBackOff',
+	[InframonitoringtypesContainerStatusDTO.errimagepull]: 'ErrImagePull',
+	[InframonitoringtypesContainerStatusDTO.createcontainerconfigerror]:
+		'CreateContainerConfigError',
+	[InframonitoringtypesContainerStatusDTO.oomkilled]: 'OOMKilled',
+	[InframonitoringtypesContainerStatusDTO.error]: 'Error',
+	[InframonitoringtypesContainerStatusDTO.containercannotrun]:
+		'ContainerCannotRun',
+};
+
+const CONTAINER_ERROR_STATUS_LABELS: Partial<
+	Record<keyof InframonitoringtypesContainerCountsByStatusDTO, string>
+> = {
+	crashLoopBackOff: 'CrashLoopBackOff',
+	imagePullBackOff: 'ImagePullBackOff',
+	errImagePull: 'ErrImagePull',
+	createContainerConfigError: 'CreateContainerConfigError',
+	oomKilled: 'OOMKilled',
+	error: 'Error',
+	containerCannotRun: 'ContainerCannotRun',
+};
+
+export function getContainerStatusItems(
+	counts: InframonitoringtypesContainerCountsByStatusDTO,
+): StatusCountItem[] {
+	const errorKeys = Object.keys(CONTAINER_ERROR_STATUS_LABELS) as Array<
+		keyof typeof CONTAINER_ERROR_STATUS_LABELS
+	>;
+
+	return [
+		{ value: counts.running, label: 'Running', color: Color.BG_FOREST_500 },
+		{ value: counts.completed, label: 'Completed', color: Color.BG_ROBIN_500 },
+		{
+			value: counts.waiting + counts.containerCreating,
+			label: 'Waiting',
+			color: Color.BG_AMBER_500,
+			breakdown: [
+				{ label: 'Waiting', value: counts.waiting },
+				{ label: 'ContainerCreating', value: counts.containerCreating },
+			],
+		},
+		{
+			value: counts.terminated,
+			label: 'Terminated',
+			color: Color.BG_SIENNA_500,
+		},
+		{ value: counts.unknown, label: 'Unknown', color: Color.BG_SLATE_400 },
+		{
+			value: errorKeys.reduce((sum, key) => sum + counts[key], 0),
+			label: 'Error Status',
+			color: Color.BG_CHERRY_500,
+			breakdown: errorKeys.map((key) => ({
+				label: CONTAINER_ERROR_STATUS_LABELS[key] as string,
+				value: counts[key],
+			})),
+		},
+	];
+}
+
+export const CONTAINER_READY_COLORS: Record<
+	InframonitoringtypesContainerReadyDTO,
+	BadgeColor
+> = {
+	[InframonitoringtypesContainerReadyDTO.ready]: 'forest',
+	[InframonitoringtypesContainerReadyDTO.not_ready]: 'cherry',
+	[InframonitoringtypesContainerReadyDTO.no_data]: 'vanilla',
+};
+
+export const CONTAINER_READY_LABELS: Record<
+	InframonitoringtypesContainerReadyDTO,
+	string
+> = {
+	[InframonitoringtypesContainerReadyDTO.ready]: 'Ready',
+	[InframonitoringtypesContainerReadyDTO.not_ready]: 'Not Ready',
+	[InframonitoringtypesContainerReadyDTO.no_data]: 'No data',
+};
+
+export function getContainerReadyItems(
+	counts: InframonitoringtypesContainerCountsByReadyDTO,
+): StatusCountItem[] {
+	return [
+		{ value: counts.ready, label: 'Ready', color: Color.BG_FOREST_500 },
+		{ value: counts.notReady, label: 'Not Ready', color: Color.BG_CHERRY_500 },
+	];
+}

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityMetrics/ChartHeader.tsx

@@ -3,8 +3,9 @@ import { Compass, Info } from '@signozhq/icons';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 
 import styles from './ChartHeader.module.scss';
+import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
+const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
 
 interface ChartHeaderProps {
 	title: string;
@@ -33,7 +34,7 @@ function ChartHeader({
 						<>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_BASE_URL}${docPath}`}
+								href={`${DOCS_ROOT}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={(e): void => e.stopPropagation()}

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/entityDetails.module.scss

@@ -37,7 +37,15 @@
 .title {
 	font-family: var(--periscope-font-family-mono);
 
-	--typography-margin: 0px var(--spacing-4) 0px 0px;
+	--typography-margin: 0px var(--spacing-1) 0px 0px;
+}
+
+// Sized to the icon rather than the default tap target, so it sits beside the
+// entity name instead of a gap away from it.
+.copyIdButton {
+	--button-padding: 2px;
+	--button-height: auto;
+	--button-width: auto;
 }
 
 .entityDetailsEntity {
@@ -45,30 +53,12 @@
 	flex-direction: column;
 }
 
+// Tracks size to the entity's field count instead of a fixed four, so entities
+// with more fields stay on one row rather than spilling a near-empty second one.
 .entityDetailsGrid {
-	display: flex;
-	flex-direction: column;
-}
-
-.labelsRow,
-.valuesRow {
 	display: grid;
-	grid-template-columns: 1.5fr 1.5fr 1.5fr 1.5fr;
-	gap: 30px;
-	align-items: center;
-}
-
-.labelsRow {
-	margin-bottom: var(--spacing-4);
-}
-
-.entityDetailsMetadataLabel {
-	letter-spacing: 0.44px;
-	text-transform: uppercase;
-}
-
-.entityDetailsMetadataValue {
-	font-family: var(--periscope-font-family-mono);
+	grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+	gap: var(--spacing-4) var(--spacing-6);
 }
 
 .viewsTabsContainer {

frontend/src/container/InfraMonitoringK8sV2/InfraMonitoringK8s.tsx

@@ -16,6 +16,7 @@ import {
 	ArrowUpDown,
 	ArrowUpToLine,
 	Bolt,
+	Box,
 	Boxes,
 	Computer,
 	Container,
@@ -31,6 +32,7 @@ import { DataSource } from 'types/common/queryBuilder';
 import { K8sDynamicList } from './Base/K8sDynamicList';
 import {
 	GetClustersQuickFiltersConfig,
+	GetContainersQuickFiltersConfig,
 	GetDaemonsetsQuickFiltersConfig,
 	GetDeploymentsQuickFiltersConfig,
 	GetJobsQuickFiltersConfig,
@@ -152,6 +154,12 @@ export default function InfraMonitoringK8s(): JSX.Element {
 
 	const categories = useMemo(
 		() => [
+			{
+				key: K8sCategories.CONTAINERS,
+				label: 'Containers',
+				icon: <Box size={14} />,
+				config: GetContainersQuickFiltersConfig(),
+			},
 			{
 				key: K8sCategories.PODS,
 				label: 'Pods',

frontend/src/container/InfraMonitoringK8sV2/constants.ts

@@ -61,10 +61,26 @@ export const INFRA_MONITORING_ATTR_KEYS = {
 	K8S_CONTAINER_CPU_LIMIT: 'k8s.container.cpu_limit',
 	K8S_CONTAINER_MEMORY_REQUEST: 'k8s.container.memory_request',
 	K8S_CONTAINER_MEMORY_LIMIT: 'k8s.container.memory_limit',
+	K8S_CONTAINER_CPU_REQUEST_UTILIZATION: 'k8s.container.cpu_request_utilization',
+	K8S_CONTAINER_CPU_LIMIT_UTILIZATION: 'k8s.container.cpu_limit_utilization',
+	K8S_CONTAINER_MEMORY_REQUEST_UTILIZATION:
+		'k8s.container.memory_request_utilization',
+	K8S_CONTAINER_MEMORY_LIMIT_UTILIZATION:
+		'k8s.container.memory_limit_utilization',
+	K8S_CONTAINER_CPU_NODE_UTILIZATION: 'k8s.container.cpu.node.utilization',
+	K8S_CONTAINER_MEMORY_NODE_UTILIZATION: 'k8s.container.memory.node.utilization',
 	CONTAINER_CPU_USAGE: 'container.cpu.usage',
 	CONTAINER_MEMORY_USAGE: 'container.memory.usage',
+	CONTAINER_MEMORY_AVAILABLE: 'container.memory.available',
 	CONTAINER_MEMORY_WORKING_SET: 'container.memory.working_set',
 	CONTAINER_MEMORY_RSS: 'container.memory.rss',
+	CONTAINER_MEMORY_MAJOR_PAGE_FAULTS: 'container.memory.major_page_faults',
+	CONTAINER_FILESYSTEM_AVAILABLE: 'container.filesystem.available',
+	CONTAINER_FILESYSTEM_CAPACITY: 'container.filesystem.capacity',
+	CONTAINER_FILESYSTEM_USAGE: 'container.filesystem.usage',
+	CONTAINER_UPTIME: 'container.uptime',
+	CONTAINER_IMAGE_NAME: 'container.image.name',
+	CONTAINER_IMAGE_TAG: 'container.image.tag',
 
 	// Deployment
 	K8S_DEPLOYMENT_NAME: 'k8s.deployment.name',
@@ -165,6 +181,9 @@ export const K8sCategories = {
 	VOLUMES: 'volumes',
 };
 
+/** The section the Kubernetes view opens on when a link names none. */
+export const DEFAULT_K8S_CATEGORY = K8sCategories.CONTAINERS;
+
 const dotMap = {
 	[InfraMonitoringEntity.HOSTS]:
 		INFRA_MONITORING_ATTR_KEYS.SYSTEM_CPU_LOAD_AVERAGE_15M,
@@ -181,7 +200,7 @@ const dotMap = {
 	[InfraMonitoringEntity.DAEMONSETS]:
 		INFRA_MONITORING_ATTR_KEYS.K8S_POD_CPU_USAGE,
 	[InfraMonitoringEntity.CONTAINERS]:
-		INFRA_MONITORING_ATTR_KEYS.K8S_POD_CPU_USAGE,
+		INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
 	[InfraMonitoringEntity.JOBS]:
 		INFRA_MONITORING_ATTR_KEYS.K8S_JOB_DESIRED_SUCCESSFUL_PODS,
 	[InfraMonitoringEntity.VOLUMES]:
@@ -321,6 +340,161 @@ export function GetPodsQuickFiltersConfig(): IQuickFiltersConfig[] {
 	];
 }
 
+export function GetContainersQuickFiltersConfig(): IQuickFiltersConfig[] {
+	return [
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Container',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: true,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Pod',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: true,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Namespace',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Node',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Cluster',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Image',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Deployment',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Statefulset',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_STATEFULSET_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_STATEFULSET_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'DaemonSet',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_DAEMONSET_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_DAEMONSET_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Job',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.K8S_JOB_NAME,
+				dataType: DataTypes.String,
+				type: 'resource',
+				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_JOB_NAME}--string--resource--false`,
+			},
+			aggregateOperator: 'noop',
+			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+			dataSource: DataSource.METRICS,
+			defaultOpen: false,
+		},
+		{
+			type: FiltersType.CHECKBOX,
+			title: 'Environment',
+			attributeKey: {
+				key: INFRA_MONITORING_ATTR_KEYS.DEPLOYMENT_ENVIRONMENT,
+				dataType: DataTypes.String,
+				type: 'resource',
+			},
+			defaultOpen: true,
+		},
+	];
+}
+
 export function GetNodesQuickFiltersConfig(): IQuickFiltersConfig[] {
 	return [
 		{
@@ -767,6 +941,7 @@ export const INFRA_MONITORING_K8S_PARAMS_KEYS = {
 	SELECTED_ITEM: 'selectedItem',
 	SELECTED_ITEM_CLUSTER_NAME: 'selectedItemClusterName',
 	SELECTED_ITEM_NAMESPACE_NAME: 'selectedItemNamespaceName',
+	SELECTED_ITEM_CONTAINER_NAME: 'selectedItemContainerName',
 	DETAIL_RELATIVE_TIME: 'detailRelativeTime',
 	DETAIL_START_TIME: 'detailStartTime',
 	DETAIL_END_TIME: 'detailEndTime',
@@ -783,7 +958,7 @@ export const METRIC_NAMESPACE_BY_ENTITY: Record<InfraMonitoringEntity, string> =
 		[InfraMonitoringEntity.DEPLOYMENTS]: 'k8s.',
 		[InfraMonitoringEntity.STATEFULSETS]: 'k8s.',
 		[InfraMonitoringEntity.DAEMONSETS]: 'k8s.',
-		[InfraMonitoringEntity.CONTAINERS]: 'k8s.pod.',
+		[InfraMonitoringEntity.CONTAINERS]: 'k8s.container.',
 		[InfraMonitoringEntity.JOBS]: 'k8s.',
 		[InfraMonitoringEntity.VOLUMES]: 'k8s.volume.',
 	};

frontend/src/container/InfraMonitoringK8sV2/hooks.ts

@@ -16,8 +16,8 @@ import {
 import { parseAsJsonNoValidate } from 'utils/nuqsParsers';
 
 import {
+	DEFAULT_K8S_CATEGORY,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategories,
 	VIEWS,
 } from './constants';
 import { orderBySchema, OrderBySchemaType } from './schemas';
@@ -130,19 +130,23 @@ export const useInfraMonitoringCategory = (): UseQueryStateReturn<
 > =>
 	useQueryState(
 		INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY,
-		parseAsString.withDefault(K8sCategories.PODS).withOptions(defaultNuqsOptions),
+		parseAsString
+			.withDefault(DEFAULT_K8S_CATEGORY)
+			.withOptions({ ...defaultNuqsOptions, clearOnDefault: false }),
 	);
 
 export interface SelectedItemParams {
 	selectedItem: string | null;
 	clusterName?: string | null;
 	namespaceName?: string | null;
+	containerName?: string | null;
 }
 
 const selectedItemParamsParsers = {
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM]: parseAsString,
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CLUSTER_NAME]: parseAsString,
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]: parseAsString,
+	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]: parseAsString,
 };
 
 export type UseSelectedItemParamsReturn = [
@@ -167,6 +171,9 @@ export const useInfraMonitoringSelectedItemParams =
 				namespaceName:
 					rawParams[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME] ??
 					null,
+				containerName:
+					rawParams[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME] ??
+					null,
 			}),
 			[rawParams],
 		);
@@ -178,6 +185,7 @@ export const useInfraMonitoringSelectedItemParams =
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM]: null,
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CLUSTER_NAME]: null,
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]: null,
+						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]: null,
 					});
 					return;
 				}
@@ -189,6 +197,8 @@ export const useInfraMonitoringSelectedItemParams =
 						newParams.clusterName ?? null,
 					[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]:
 						newParams.namespaceName ?? null,
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]:
+						newParams.containerName ?? null,
 				});
 			},
 			[setRawParams],

frontend/src/pages/ChannelsEdit/index.tsx

@@ -11,6 +11,8 @@ import ROUTES from 'constants/routes';
 import {
 	ChannelType,
 	GoogleChatChannel,
+	JiraChannel,
+	JsmOpsChannel,
 	MsTeamsChannel,
 	PagerChannel,
 	SlackChannel,
@@ -60,17 +62,25 @@ function ChannelsEdit(): JSX.Element {
 
 	const prepChannelConfig = (): {
 		type: string;
-		channel: SlackChannel &
-			WebhookChannel &
-			PagerChannel &
-			MsTeamsChannel &
-			GoogleChatChannel;
+		channel: Partial<
+			SlackChannel &
+				WebhookChannel &
+				PagerChannel &
+				MsTeamsChannel &
+				GoogleChatChannel &
+				JiraChannel &
+				JsmOpsChannel
+		>;
 	} => {
-		let channel: SlackChannel &
-			WebhookChannel &
-			PagerChannel &
-			MsTeamsChannel &
-			GoogleChatChannel = {
+		let channel: Partial<
+			SlackChannel &
+				WebhookChannel &
+				PagerChannel &
+				MsTeamsChannel &
+				GoogleChatChannel &
+				JiraChannel &
+				JsmOpsChannel
+		> = {
 			name: '',
 		};
 
@@ -101,6 +111,19 @@ function ChannelsEdit(): JSX.Element {
 			};
 		}
 
+		if (value && 'jira_configs' in value) {
+			const [jiraConfig] = value.jira_configs;
+			channel = jiraConfig;
+			if (jiraConfig.http_config?.basic_auth) {
+				channel.username = jiraConfig.http_config.basic_auth.username;
+				channel.password = jiraConfig.http_config.basic_auth.password;
+			}
+			return {
+				type: ChannelType.Jira,
+				channel,
+			};
+		}
+
 		if (value && 'pagerduty_configs' in value) {
 			const pagerConfig = value.pagerduty_configs[0];
 			channel = pagerConfig;
@@ -112,6 +135,22 @@ function ChannelsEdit(): JSX.Element {
 			};
 		}
 
+		if (value && 'jsmops_configs' in value) {
+			const [jsmopsConfig] = value.jsmops_configs;
+			channel = jsmopsConfig;
+			// backend stores tags as a comma-separated string; the form uses chips
+			channel.tags = jsmopsConfig.tags
+				? String(jsmopsConfig.tags)
+						.split(',')
+						.map((tag: string) => tag.trim())
+						.filter(Boolean)
+				: [];
+			return {
+				type: ChannelType.JsmOps,
+				channel,
+			};
+		}
+
 		if (value && 'opsgenie_configs' in value) {
 			const opsgenieConfig = value.opsgenie_configs[0];
 			channel = opsgenieConfig;

frontend/src/pages/InfrastructureMonitoring/constants.tsx

@@ -2,6 +2,10 @@ import { TabRoutes } from 'components/RouteTab/types';
 import ROUTES from 'constants/routes';
 import InfraMonitoringHostsV2 from 'container/InfraMonitoringHostsV2';
 import InfraMonitoringK8sV2 from 'container/InfraMonitoringK8sV2';
+import {
+	DEFAULT_K8S_CATEGORY,
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+} from 'container/InfraMonitoringK8sV2/constants';
 import { Inbox } from '@signozhq/icons';
 
 function HostsContainer(): JSX.Element {
@@ -30,6 +34,6 @@ export const Kubernetes: TabRoutes = {
 			<Inbox size={16} /> Kubernetes
 		</div>
 	),
-	route: ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES,
+	route: `${ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES}?${INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY}=${DEFAULT_K8S_CATEGORY}`,
 	key: ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES,
 };

pkg/apiserver/signozapiserver/provider.go

@@ -24,7 +24,6 @@ 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"
@@ -83,8 +82,6 @@ type provider struct {
 	llmPricingRuleHandler      llmpricingrule.Handler
 	statsHandler               statsreporter.Handler
 	savedViewHandler           savedview.Handler
-	quickFilterModule          quickfilter.Module
-	quickFilterHandler         quickfilter.Handler
 }
 
 func NewFactory(
@@ -124,8 +121,6 @@ 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(
@@ -168,8 +163,6 @@ func NewFactory(
 			rulerHandler,
 			statsHandler,
 			savedViewHandler,
-			quickFilterModule,
-			quickFilterHandler,
 		)
 	})
 }
@@ -214,8 +207,6 @@ 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()
@@ -259,8 +250,6 @@ func newProvider(
 		llmPricingRuleHandler:      llmPricingRuleHandler,
 		statsHandler:               statsHandler,
 		savedViewHandler:           savedViewHandler,
-		quickFilterModule:          quickFilterModule,
-		quickFilterHandler:         quickFilterHandler,
 	}
 
 	provider.authzMiddleware = middleware.NewAuthZ(settings.Logger(), orgGetter, authzService)
@@ -405,10 +394,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addQuickFilterRoutes(router); err != nil {
-		return err
-	}
-
 	return nil
 }
 

pkg/apiserver/signozapiserver/quickfilter.go

@@ -1,120 +0,0 @@
-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:            new([]*quickfiltertypes.SourceFilters),
-			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
-}

pkg/modules/quickfilter/implquickfilter/handler.go

@@ -4,13 +4,10 @@ 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"
 )
@@ -23,13 +20,6 @@ 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 {
@@ -37,41 +27,13 @@ func (handler *handler) GetQuickFilters(rw http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), quickfiltertypes.Source{})
+	filters, err := handler.module.GetQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID))
 	if err != nil {
 		render.Error(rw, err)
 		return
 	}
 
-	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)))
+	render.Success(rw, http.StatusOK, filters)
 }
 
 func (handler *handler) UpdateQuickFilters(rw http.ResponseWriter, r *http.Request) {
@@ -81,19 +43,14 @@ 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)
+	var req quickfiltertypes.UpdatableQuickFilters
+	decodeErr := json.NewDecoder(r.Body).Decode(&req)
+	if decodeErr != nil {
+		render.Error(rw, decodeErr)
 		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)
+	err = handler.module.UpdateQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), req.Signal, req.Filters)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -102,14 +59,21 @@ func (handler *handler) UpdateQuickFilters(rw http.ResponseWriter, r *http.Reque
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-func (handler *handler) ListQuickFiltersV2(rw http.ResponseWriter, r *http.Request) {
+func (handler *handler) GetSignalFilters(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{})
+	signal := mux.Vars(r)["signal"]
+	validatedSignal, err := quickfiltertypes.NewSignal(signal)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	filters, err := handler.module.GetSignalFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSignal)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -117,141 +81,3 @@ func (handler *handler) ListQuickFiltersV2(rw http.ResponseWriter, r *http.Reque
 
 	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
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = handler.module.UpsertQuickFilters(r.Context(), valuer.MustNewUUID(claims.OrgID), validatedSource, req.Filters)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) GetQuickFiltersV2(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
-	}
-
-	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, 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,
-	}
-}

pkg/modules/quickfilter/implquickfilter/handler_test.go

@@ -1,62 +0,0 @@
-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])
-}

pkg/modules/quickfilter/implquickfilter/module.go

@@ -2,11 +2,12 @@ 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"
 )
 
@@ -18,54 +19,91 @@ func NewModule(store quickfiltertypes.QuickFilterStore) quickfilter.Module {
 	return &module{store: store}
 }
 
-func (module *module) Get(ctx context.Context, orgID valuer.UUID, source quickfiltertypes.Source) (*quickfiltertypes.StorableQuickFilter, error) {
-	return module.store.GetBySource(ctx, orgID, source.StringValue())
-}
-
-// 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 fetching organization filters")
-		}
-
-		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)
-		}
-
-		return result, nil
+// 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")
 	}
 
-	storedFilter, err := module.store.GetBySource(ctx, orgID, source.StringValue())
-	if err != nil {
-		if errors.Ast(err, errors.TypeNotFound) {
-			return []*quickfiltertypes.SourceFilters{}, nil
+	result := make([]*quickfiltertypes.SignalFilters, 0, len(storedFilters))
+	for _, storedFilter := range storedFilters {
+		signalFilter, err := quickfiltertypes.NewSignalFilterFromStorableQuickFilter(storedFilter)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for signal: %s", storedFilter.Signal)
 		}
+		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
 	}
 
-	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)
+	// 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 []*quickfiltertypes.SourceFilters{sourceFilter}, nil
+	// Convert stored filter to signal filter
+	signalFilter, err := quickfiltertypes.NewSignalFilterFromStorableQuickFilter(storedFilter)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error processing filter for signal: %s", storedFilter.Signal)
+	}
+
+	return signalFilter, 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)
+// 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)
+		}
+	}
+
+	// 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())
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error checking existing filters")
+	}
+
+	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")
+		}
+	}
+
+	// Persist filter
+	if err := module.store.Upsert(ctx, filter); err != nil {
 		return err
 	}
 
-	return module.store.Upsert(ctx, filter)
+	return nil
 }
 
 func (module *module) SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error {

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("source ASC").
+		Order("signal 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) GetBySource(ctx context.Context, orgID valuer.UUID, source string) (*quickfiltertypes.StorableQuickFilter, error) {
+func (s *store) GetBySignal(ctx context.Context, orgID valuer.UUID, signal string) (*quickfiltertypes.StorableQuickFilter, error) {
 	filter := new(quickfiltertypes.StorableQuickFilter)
 
 	err := s.store.
@@ -44,12 +44,12 @@ func (s *store) GetBySource(ctx context.Context, orgID valuer.UUID, source strin
 		NewSelect().
 		Model(filter).
 		Where("org_id = ?", orgID).
-		Where("source = ?", source).
+		Where("signal = ?", signal).
 		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()+" source: "+source)
+			return nil, s.store.WrapNotFoundErrf(err, errors.CodeNotFound, "No rows found for org_id: "+orgID.StringValue()+" signal: "+signal)
 		}
 		return nil, err
 	}
@@ -62,7 +62,7 @@ func (s *store) Upsert(ctx context.Context, filter *quickfiltertypes.StorableQui
 		BunDB().
 		NewInsert().
 		Model(filter).
-		On("CONFLICT (org_id, source) DO UPDATE").
+		On("CONFLICT (id) 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, source) DO NOTHING").
+		On("CONFLICT (org_id, signal) DO NOTHING").
 		Exec(ctx)
 
 	if err != nil {

pkg/modules/quickfilter/quickfilter.go

@@ -4,27 +4,20 @@ 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 {
-	// 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
+	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)
 	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)
-	GetSourceFilters(http.ResponseWriter, *http.Request)
-
-	ListQuickFiltersV2(http.ResponseWriter, *http.Request)
-	GetQuickFiltersV2(http.ResponseWriter, *http.Request)
-	UpdateQuickFiltersV2(http.ResponseWriter, *http.Request)
+	GetSignalFilters(http.ResponseWriter, *http.Request)
 }

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 (v1 routes serve the legacy v3 shape; v2 lives in signozapiserver)
+	// Quick Filters
 	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.GetSourceFilters)).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", am.AdminAccess(aH.Signoz.Handlers.QuickFilter.UpdateQuickFilters)).Methods(http.MethodPut)
 
 	router.HandleFunc("/api/v1/register", am.OpenAccess(aH.registerUser)).Methods(http.MethodPost)

pkg/signoz/openapi.go

@@ -29,7 +29,6 @@ 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"
@@ -96,8 +95,6 @@ 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

pkg/signoz/provider.go

@@ -246,8 +246,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddAuthDomainTuplesFactory(sqlstore),
 		sqlmigration.NewAddDeploymentHostTuplesFactory(sqlstore),
 		sqlmigration.NewAddSystemDashboardFactory(sqlstore, sqlschema),
-		sqlmigration.NewMigrateQuickFiltersFactory(sqlstore),
-		sqlmigration.NewAddQuickFilterTuplesFactory(sqlstore),
 	)
 }
 
@@ -352,8 +350,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RulerHandler,
 			handlers.StatsHandler,
 			handlers.SavedView,
-			modules.QuickFilter,
-			handlers.QuickFilter,
 		),
 	)
 }

pkg/sqlmigration/120_migrate_quick_filters.go

@@ -1,180 +0,0 @@
-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))]
-}

pkg/sqlmigration/121_add_quick_filter_tuples.go

@@ -1,139 +0,0 @@
-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
-}

pkg/types/coretypes/registry_resource.go

@@ -62,7 +62,7 @@ var (
 	ResourceMetaResourcePipeline                         = NewResourceMetaResource(KindPipeline)
 	ResourceMetaResourceUserPreference                   = NewResourceMetaResource(KindUserPreference)
 	ResourceMetaResourceOrgPreference                    = NewResourceMetaResource(KindOrgPreference)
-	ResourceMetaResourceQuickFilter                      = NewResourceMetaResource(KindQuickFilter, VerbList, VerbRead, VerbUpdate)
+	ResourceMetaResourceQuickFilter                      = NewResourceMetaResource(KindQuickFilter)
 	ResourceMetaResourceTTLSetting                       = NewResourceMetaResource(KindTTLSetting)
 	ResourceMetaResourceRule                             = NewResourceMetaResource(KindRule)
 	ResourceMetaResourcePlannedMaintenance               = NewResourceMetaResource(KindPlannedMaintenance)

pkg/types/quickfiltertypes/filter.go

@@ -5,58 +5,58 @@ 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 Source struct {
+type Signal struct {
 	valuer.String
 }
 
-func (enum *Source) UnmarshalJSON(data []byte) error {
+func (enum *Signal) UnmarshalJSON(data []byte) error {
 	var str string
 	if err := json.Unmarshal(data, &str); err != nil {
 		return err
 	}
 
-	source, err := NewSource(str)
+	signal, err := NewSignal(str)
 	if err != nil {
 		return err
 	}
 
-	*enum = source
+	*enum = signal
 	return nil
 }
 
 var (
-	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")}
+	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")}
 )
 
-// NewSource creates a Source from a string.
-func NewSource(s string) (Source, error) {
+// NewSignal creates a Signal from a string.
+func NewSignal(s string) (Signal, error) {
 	switch s {
 	case "traces":
-		return SourceTraces, nil
+		return SignalTraces, nil
 	case "logs":
-		return SourceLogs, nil
+		return SignalLogs, nil
 	case "api_monitoring":
-		return SourceApiMonitoring, nil
+		return SignalApiMonitoring, nil
 	case "exceptions":
-		return SourceExceptions, nil
+		return SignalExceptions, nil
 	case "meter":
-		return SourceMeter, nil
+		return SignalMeter, nil
 	case "ai_observability":
-		return SourceAiObservability, nil
+		return SignalAiObservability, nil
 	default:
-		return Source{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid source: %s", s)
+		return Signal{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid signal: %s", s)
 	}
 }
 
@@ -65,46 +65,33 @@ type StorableQuickFilter struct {
 	types.Identifiable
 	OrgID  valuer.UUID `bun:"org_id,type:text,notnull"`
 	Filter string      `bun:"filter,type:text,notnull"`
-	Source Source      `bun:"source,type:text,notnull"`
+	Signal Signal      `bun:"signal,type:text,notnull"`
 	types.TimeAuditable
 }
 
-type SourceFilters struct {
-	types.Identifiable
-	types.TimeAuditable
-
-	OrgID   valuer.UUID                        `json:"orgId"`
-	Source  Source                             `json:"source"`
-	Filters []telemetrytypes.TelemetryFieldKey `json:"filters" required:"true" nullable:"false"`
+type SignalFilters struct {
+	Signal  Signal            `json:"signal"`
+	Filters []v3.AttributeKey `json:"filters"`
 }
 
 type UpdatableQuickFilters struct {
-	Filters []telemetrytypes.TelemetryFieldKey `json:"filters" required:"true" nullable:"false"`
+	Signal  Signal            `json:"signal"`
+	Filters []v3.AttributeKey `json:"filters"`
 }
 
 // NewStorableQuickFilter creates a new StorableQuickFilter after validation.
-func NewStorableQuickFilter(orgID valuer.UUID, source Source, filters []telemetrytypes.TelemetryFieldKey) (*StorableQuickFilter, error) {
-	if orgID.IsZero() {
+func NewStorableQuickFilter(orgID valuer.UUID, signal Signal, filterJSON []byte) (*StorableQuickFilter, error) {
+	if orgID.StringValue() == "" {
 		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgID is required")
 	}
 
-	if _, err := NewSource(source.StringValue()); err != nil {
+	if _, err := NewSignal(signal.StringValue()); err != nil {
 		return nil, err
 	}
 
-	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")
+	var filters []v3.AttributeKey
+	if err := json.Unmarshal(filterJSON, &filters); err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid filter JSON")
 	}
 
 	now := time.Now()
@@ -113,7 +100,7 @@ func NewStorableQuickFilter(orgID valuer.UUID, source Source, filters []telemetr
 			ID: valuer.GenerateUUID(),
 		},
 		OrgID:  orgID,
-		Source: source,
+		Signal: signal,
 		Filter: string(filterJSON),
 		TimeAuditable: types.TimeAuditable{
 			CreatedAt: now,
@@ -122,21 +109,25 @@ func NewStorableQuickFilter(orgID valuer.UUID, source Source, filters []telemetr
 	}, nil
 }
 
-// NewSourceFiltersFromSource creates a SourceFilters with no filters for a source.
-func NewSourceFiltersFromSource(source Source) *SourceFilters {
-	return &SourceFilters{
-		Source:  source,
-		Filters: []telemetrytypes.TelemetryFieldKey{},
+// 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")
 	}
+
+	quickfilter.Filter = string(filterJSON)
+	quickfilter.UpdatedAt = time.Now()
+	return nil
 }
 
-// NewSourceFilterFromStorableQuickFilter converts a StorableQuickFilter to a SourceFilters object.
-func NewSourceFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFilter) (*SourceFilters, error) {
+// NewSignalFilterFromStorableQuickFilter converts a StorableQuickFilter to a SignalFilters object.
+func NewSignalFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFilter) (*SignalFilters, error) {
 	if storableQuickFilter == nil {
 		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "storableQuickFilter cannot be nil")
 	}
 
-	filters := []telemetrytypes.TelemetryFieldKey{}
+	var filters []v3.AttributeKey
 	if storableQuickFilter.Filter != "" {
 		err := json.Unmarshal([]byte(storableQuickFilter.Filter), &filters)
 		if err != nil {
@@ -144,114 +135,178 @@ func NewSourceFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFi
 		}
 	}
 
-	// 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,
+	return &SignalFilters{
+		Signal:  storableQuickFilter.Signal,
+		Filters: filters,
 	}, nil
 }
 
-// NewDefaultQuickFilter generates default filters for all supported sources.
+// NewDefaultQuickFilter generates default filters for all supported signals.
 func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
-	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},
+	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"},
 	}
 
-	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},
+	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"},
 	}
 
-	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},
+	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"},
 	}
 
-	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},
+	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"},
 	}
 
-	// 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},
+	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"},
 	}
 
 	// AI observability (builder_ai_query trace explorer), ordered by expected
 	// usage: env scoping, the LLM identity keys, then service and the rest.
-	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},
+	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"},
 	}
 
-	defaults := []struct {
-		source  Source
-		filters []telemetrytypes.TelemetryFieldKey
-	}{
-		{SourceTraces, tracesFilters},
-		{SourceLogs, logsFilters},
-		{SourceApiMonitoring, apiMonitoringFilters},
-		{SourceExceptions, exceptionsFilters},
-		{SourceMeter, meterFilters},
-		{SourceAiObservability, aiObservabilityFilters},
+	tracesJSON, err := json.Marshal(tracesFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal traces 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)
+	logsJSON, err := json.Marshal(logsFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal logs filters")
 	}
 
-	return storableQuickFilters, nil
-}
-
-func validateFilters(filters []telemetrytypes.TelemetryFieldKey) error {
-	for _, filter := range filters {
-		if filter.Name == "" {
-			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "filter name is required")
-		}
-	}
-	return nil
+	apiMonitoringJSON, err := json.Marshal(apiMonitoringFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal api monitoring filters")
+	}
+
+	exceptionsJSON, err := json.Marshal(exceptionsFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal exceptions filters")
+	}
+
+	meterJSON, err := json.Marshal(meterFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal meter filters")
+	}
+
+	aiObservabilityJSON, err := json.Marshal(aiObservabilityFilters)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal ai observability filters")
+	}
+
+	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
 }

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)
 
-	// GetBySource retrieves filters for a specific source in an organization
-	GetBySource(ctx context.Context, orgID valuer.UUID, source string) (*StorableQuickFilter, error)
+	// GetBySignal retrieves filters for a specific signal in an organization
+	GetBySignal(ctx context.Context, orgID valuer.UUID, signal string) (*StorableQuickFilter, error)
 
-	// Upsert inserts or updates filters for an organization and source
+	// Upsert inserts or updates filters for an organization and signal
 	Upsert(ctx context.Context, filter *StorableQuickFilter) error
 	Create(ctx context.Context, filter []*StorableQuickFilter) error
 }

tests/integration/tests/quickfilter/01_quick_filter.py

@@ -1,276 +0,0 @@
-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