test(fields): parametrize the fields keys and values integration cases

- keys by context for every log and span context, including scope and
  attribute, and the span context keeping attributes
- keys by data type, with number, int64 and float64 as one family
- case-insensitive search with and without a context prefix
- bool values for the calculated span field, a stored bool attribute and a
  caller-declared bool type; start filter for logs and traces

Assisted-by: Claude Fable 5.1
Claude-Session: https://claude.ai/code/session_01NNQrizqt5XQ1N2NNAcuAi8

docs/api/openapi.yml

@@ -109,6 +109,57 @@ components:
         webhook_url:
           $ref: '#/components/schemas/ConfigSecretURL'
       type: object
+    AlertmanagertypesJSMOpsReceiverConfig:
+      properties:
+        api_key:
+          type: string
+        description:
+          type: string
+        http_config:
+          $ref: '#/components/schemas/ConfigHTTPClientConfig'
+        message:
+          type: string
+        priority:
+          type: string
+        send_resolved:
+          type: boolean
+        tags:
+          type: string
+      type: object
+    AlertmanagertypesJiraReceiverConfig:
+      properties:
+        custom_fields:
+          additionalProperties: {}
+          type: object
+        description:
+          type: string
+        http_config:
+          $ref: '#/components/schemas/ConfigHTTPClientConfig'
+        issue_type:
+          type: string
+        labels:
+          items:
+            type: string
+          type: array
+        priority:
+          type: string
+        project:
+          type: string
+        reopen_duration:
+          $ref: '#/components/schemas/ModelDuration'
+        reopen_transition:
+          type: string
+        resolve_transition:
+          type: string
+        send_resolved:
+          type: boolean
+        site:
+          type: string
+        summary:
+          type: string
+        wont_fix_resolution:
+          type: string
+      type: object
     AlertmanagertypesMaintenanceKind:
       enum:
       - fixed
@@ -162,6 +213,10 @@ components:
       oneOf:
       - required:
         - googlechat_configs
+      - required:
+        - jira_configs
+      - required:
+        - jsmops_configs
       - required:
         - discord_configs
       - required:
@@ -192,8 +247,6 @@ components:
         - msteams_configs
       - required:
         - msteamsv2_configs
-      - required:
-        - jira_configs
       - required:
         - rocketchat_configs
       - required:
@@ -217,7 +270,11 @@ components:
           type: array
         jira_configs:
           items:
-            $ref: '#/components/schemas/ConfigJiraConfig'
+            $ref: '#/components/schemas/AlertmanagertypesJiraReceiverConfig'
+          type: array
+        jsmops_configs:
+          items:
+            $ref: '#/components/schemas/AlertmanagertypesJSMOpsReceiverConfig'
           type: array
         mattermost_configs:
           items:
@@ -344,7 +401,11 @@ components:
           type: array
         jira_configs:
           items:
-            $ref: '#/components/schemas/ConfigJiraConfig'
+            $ref: '#/components/schemas/AlertmanagertypesJiraReceiverConfig'
+          type: array
+        jsmops_configs:
+          items:
+            $ref: '#/components/schemas/AlertmanagertypesJSMOpsReceiverConfig'
           type: array
         mattermost_configs:
           items:

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/sigNoz.schemas.ts

@@ -385,6 +385,93 @@ export interface AlertmanagertypesGoogleChatReceiverConfigDTO {
 	webhook_url?: ConfigSecretURLDTO;
 }
 
+export interface AlertmanagertypesJSMOpsReceiverConfigDTO {
+	/**
+	 * @type string
+	 */
+	api_key?: string;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	http_config?: ConfigHTTPClientConfigDTO;
+	/**
+	 * @type string
+	 */
+	message?: string;
+	/**
+	 * @type string
+	 */
+	priority?: string;
+	/**
+	 * @type boolean
+	 */
+	send_resolved?: boolean;
+	/**
+	 * @type string
+	 */
+	tags?: string;
+}
+
+export type AlertmanagertypesJiraReceiverConfigDTOCustomFields = {
+	[key: string]: unknown;
+};
+
+export type ModelDurationDTO = number;
+
+export interface AlertmanagertypesJiraReceiverConfigDTO {
+	/**
+	 * @type object
+	 */
+	custom_fields?: AlertmanagertypesJiraReceiverConfigDTOCustomFields;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	http_config?: ConfigHTTPClientConfigDTO;
+	/**
+	 * @type string
+	 */
+	issue_type?: string;
+	/**
+	 * @type array
+	 */
+	labels?: string[];
+	/**
+	 * @type string
+	 */
+	priority?: string;
+	/**
+	 * @type string
+	 */
+	project?: string;
+	reopen_duration?: ModelDurationDTO;
+	/**
+	 * @type string
+	 */
+	reopen_transition?: string;
+	/**
+	 * @type string
+	 */
+	resolve_transition?: string;
+	/**
+	 * @type boolean
+	 */
+	send_resolved?: boolean;
+	/**
+	 * @type string
+	 */
+	site?: string;
+	/**
+	 * @type string
+	 */
+	summary?: string;
+	/**
+	 * @type string
+	 */
+	wont_fix_resolution?: string;
+}
+
 export enum AlertmanagertypesMaintenanceKindDTO {
 	fixed = 'fixed',
 	recurring = 'recurring',
@@ -631,69 +718,6 @@ export interface ConfigIncidentioConfigDTO {
 	url_file?: string;
 }
 
-export interface ConfigJiraFieldConfigDTO {
-	/**
-	 * @type boolean,null
-	 */
-	enable_update?: boolean | null;
-	/**
-	 * @type string
-	 */
-	template?: string;
-}
-
-export type ModelDurationDTO = number;
-
-export type ConfigJiraConfigDTOCustomFields = { [key: string]: unknown };
-
-export interface ConfigJiraConfigDTO {
-	/**
-	 * @type string
-	 */
-	api_type?: string;
-	api_url?: ConfigURLType2DTO;
-	/**
-	 * @type object
-	 */
-	custom_fields?: ConfigJiraConfigDTOCustomFields;
-	description?: ConfigJiraFieldConfigDTO;
-	http_config?: ConfigHTTPClientConfigDTO;
-	/**
-	 * @type string
-	 */
-	issue_type?: string;
-	/**
-	 * @type array
-	 */
-	labels?: string[];
-	/**
-	 * @type string
-	 */
-	priority?: string;
-	/**
-	 * @type string
-	 */
-	project?: string;
-	reopen_duration?: ModelDurationDTO;
-	/**
-	 * @type string
-	 */
-	reopen_transition?: string;
-	/**
-	 * @type string
-	 */
-	resolve_transition?: string;
-	/**
-	 * @type boolean
-	 */
-	send_resolved?: boolean;
-	summary?: ConfigJiraFieldConfigDTO;
-	/**
-	 * @type string
-	 */
-	wont_fix_resolution?: string;
-}
-
 export interface ConfigMattermostFieldDTO {
 	/**
 	 * @type boolean,null
@@ -1652,7 +1676,11 @@ export type AlertmanagertypesPostableChannelDTO = unknown & {
 	/**
 	 * @type array
 	 */
-	jira_configs?: ConfigJiraConfigDTO[];
+	jira_configs?: AlertmanagertypesJiraReceiverConfigDTO[];
+	/**
+	 * @type array
+	 */
+	jsmops_configs?: AlertmanagertypesJSMOpsReceiverConfigDTO[];
 	/**
 	 * @type array
 	 */
@@ -1779,7 +1807,11 @@ export interface AlertmanagertypesReceiverDTO {
 	/**
 	 * @type array
 	 */
-	jira_configs?: ConfigJiraConfigDTO[];
+	jira_configs?: AlertmanagertypesJiraReceiverConfigDTO[];
+	/**
+	 * @type array
+	 */
+	jsmops_configs?: AlertmanagertypesJSMOpsReceiverConfigDTO[];
 	/**
 	 * @type array
 	 */
@@ -3268,6 +3300,67 @@ export interface CommonJSONRefDTO {
 	$ref?: string;
 }
 
+export type ConfigJiraConfigDTOCustomFields = { [key: string]: unknown };
+
+export interface ConfigJiraFieldConfigDTO {
+	/**
+	 * @type boolean,null
+	 */
+	enable_update?: boolean | null;
+	/**
+	 * @type string
+	 */
+	template?: string;
+}
+
+export interface ConfigJiraConfigDTO {
+	/**
+	 * @type string
+	 */
+	api_type?: string;
+	api_url?: ConfigURLType2DTO;
+	/**
+	 * @type object
+	 */
+	custom_fields?: ConfigJiraConfigDTOCustomFields;
+	description?: ConfigJiraFieldConfigDTO;
+	http_config?: ConfigHTTPClientConfigDTO;
+	/**
+	 * @type string
+	 */
+	issue_type?: string;
+	/**
+	 * @type array
+	 */
+	labels?: string[];
+	/**
+	 * @type string
+	 */
+	priority?: string;
+	/**
+	 * @type string
+	 */
+	project?: string;
+	reopen_duration?: ModelDurationDTO;
+	/**
+	 * @type string
+	 */
+	reopen_transition?: string;
+	/**
+	 * @type string
+	 */
+	resolve_transition?: string;
+	/**
+	 * @type boolean
+	 */
+	send_resolved?: boolean;
+	summary?: ConfigJiraFieldConfigDTO;
+	/**
+	 * @type string
+	 */
+	wont_fix_resolution?: string;
+}
+
 export interface DashboardGridItemDTO {
 	content?: CommonJSONRefDTO;
 	/**

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/alertmanager/alertmanagernotify/jira/jira.go

@@ -0,0 +1,557 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// Copyright 2023 Prometheus Team
+// SPDX-License-Identifier: Apache-2.0
+
+package jira
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+	"unicode/utf16"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/adf"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+)
+
+const Integration = "jira"
+
+const (
+	maxSummaryLenRunes     = 255
+	maxDescriptionLenRunes = 32767
+)
+
+// Notifier implements notify.Notifier for Jira.
+type Notifier struct {
+	conf      *alertmanagertypes.JiraReceiverConfig
+	logger    *slog.Logger
+	client    *http.Client
+	retrier   *notify.Retrier
+	templater alertmanagertypes.Templater
+}
+
+func New(conf *alertmanagertypes.JiraReceiverConfig, _ *template.Template, l *slog.Logger, templater alertmanagertypes.Templater) (*Notifier, error) {
+	if conf.HTTPConfig == nil {
+		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira http_config is nil")
+	}
+	client, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration)
+	if err != nil {
+		return nil, err
+	}
+	return &Notifier{
+		conf:      conf,
+		logger:    l,
+		client:    client,
+		retrier:   &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
+		templater: templater,
+	}, nil
+}
+
+func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
+	key, err := notify.ExtractGroupKey(ctx)
+	if err != nil {
+		return false, err
+	}
+	groupID := key.Hash()
+	firing := types.Alerts(as...).HasFiring()
+	n.logger.DebugContext(ctx, "sending jira notification", slog.String("group_key", key.String()), slog.Bool("firing", firing))
+
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(as)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Summary,
+		DefaultBodyTemplate:  n.conf.Description,
+	}, as)
+	if err != nil {
+		return false, err
+	}
+	summary := truncateRunes(result.Title, maxSummaryLenRunes)
+
+	var parts []string
+	for _, body := range result.Body {
+		if body != "" {
+			parts = append(parts, body)
+		}
+	}
+	// custom body templates render per alert; join them under ADF rule dividers.
+	// The default body is a single combined part, so the join is a no-op there.
+	descText := truncateRunes(strings.Join(parts, "\n\n---\n\n"), maxDescriptionLenRunes)
+
+	baseURL, retry, err := n.resolveAPIBaseURL(ctx)
+	if err != nil {
+		return retry, err
+	}
+
+	existing, retry, err := n.searchIssue(ctx, baseURL, groupID, firing)
+	if err != nil {
+		return retry, err
+	}
+
+	fields := n.buildFields(groupID, summary, descText, as, firing)
+
+	// No existing issue: create for firing groups; never create for resolved-only.
+	if existing == nil {
+		if !firing {
+			return false, nil
+		}
+		return n.createIssue(ctx, baseURL, fields)
+	}
+
+	// Existing issue: refresh it, then transition + comment based on the new state.
+	if retry, err := n.updateIssue(ctx, baseURL, existing, fields); err != nil {
+		return retry, err
+	}
+
+	// Each state-change comment carries the same rich snapshot as the description
+	// (panel + details + deep-links), so the comment timeline mirrors the card
+	// Google Chat re-posts on every notification.
+	switch {
+	case firing && existing.isDone(): // re-fired after resolution → reopen
+		if retry, err := n.applyTransition(ctx, baseURL, existing.Key, false, n.conf.ReopenTransition); err != nil {
+			return retry, err
+		}
+	case !firing: // resolved (search returns only open issues, so this one is open)
+		if retry, err := n.applyTransition(ctx, baseURL, existing.Key, true, n.conf.ResolveTransition); err != nil {
+			return retry, err
+		}
+	}
+	// firing && !isDone (still firing) needs no transition.
+	return n.addComment(ctx, baseURL, existing.Key, fields.Description)
+}
+
+func (n *Notifier) buildFields(groupID, summary, descText string, alerts []*types.Alert, firing bool) *issueFields {
+	f := &issueFields{
+		Project:     &idKey{Key: n.conf.Project},
+		Issuetype:   &idName{Name: n.conf.IssueType},
+		Summary:     summary,
+		Labels:      n.labels(groupID),
+		Description: n.buildBoundedDescription(descText, alerts, firing),
+	}
+	if n.conf.Priority != "" {
+		f.Priority = &idName{Name: n.conf.Priority}
+	}
+	return f
+}
+
+// buildBoundedDescription builds the ADF issue body and keeps it within Jira's
+// description limit, which counts text characters plus per-node overhead — so a
+// text-only markdown cap is not enough. Over-limit bodies are shrunk at the
+// markdown level and rebuilt; the panel and deep-links are part of the measured
+// document, so the result always fits.
+func (n *Notifier) buildBoundedDescription(descText string, alerts []*types.Alert, firing bool) map[string]any {
+	doc := n.buildDescription(descText, alerts, firing)
+	for range 4 {
+		size := adfDocLen(doc)
+		if size <= maxDescriptionLenRunes {
+			return doc
+		}
+		runes := []rune(descText)
+		keep := len(runes) * maxDescriptionLenRunes / size * 9 / 10
+		if keep >= len(runes) {
+			keep = len(runes) - 1
+		}
+		if keep <= 0 {
+			break
+		}
+		descText = string(runes[:keep]) + "…"
+		doc = n.buildDescription(descText, alerts, firing)
+	}
+	if adfDocLen(doc) <= maxDescriptionLenRunes {
+		return doc
+	}
+	// still over after shrinking: keep just the panel and deep-links
+	return n.buildDescription("", alerts, firing)
+}
+
+// adfDocLen approximates how Jira measures an ADF document against the 32767
+// limit: text length in UTF-16 code units, plus per-node overhead (block
+// boundaries count like newlines), plus link targets. Deliberately counts on
+// the high side so a passing measurement never 400s.
+func adfDocLen(node any) int {
+	m, ok := node.(map[string]any)
+	if !ok {
+		return 0
+	}
+	size := 2
+	if text, ok := m["text"].(string); ok {
+		for _, r := range text {
+			size += utf16.RuneLen(r)
+		}
+	}
+	if marks, ok := m["marks"].([]any); ok {
+		for _, mark := range marks {
+			if mm, ok := mark.(map[string]any); ok {
+				if attrs, ok := mm["attrs"].(map[string]any); ok {
+					if href, ok := attrs["href"].(string); ok {
+						size += len(href)
+					}
+				}
+			}
+		}
+	}
+	if content, ok := m["content"].([]any); ok {
+		for _, child := range content {
+			size += adfDocLen(child)
+		}
+	}
+	return size
+}
+
+// buildDescription assembles the ADF issue body: a firing/resolved status panel,
+// the rendered markdown body, and SigNoz deep-links.
+func (n *Notifier) buildDescription(descText string, alerts []*types.Alert, firing bool) map[string]any {
+	content := []any{statusPanel(firing)}
+	content = append(content, adf.Render(descText)...)
+	if links := deepLinks(alerts); links != nil {
+		content = append(content, links)
+	}
+	return map[string]any{"type": "doc", "version": 1, "content": content}
+}
+
+func statusPanel(firing bool) map[string]any {
+	panelType, label := "success", "🟢 RESOLVED"
+	if firing {
+		panelType, label = "error", "🔴 FIRING"
+	}
+	return map[string]any{
+		"type":  "panel",
+		"attrs": map[string]any{"panelType": panelType},
+		"content": []any{map[string]any{
+			"type":    "paragraph",
+			"content": []any{map[string]any{"type": "text", "text": label, "marks": []any{map[string]any{"type": "strong"}}}},
+		}},
+	}
+}
+
+// deepLinks builds a paragraph of SigNoz links from the per-rule ruleSource label
+// and the related-logs/traces annotations. Returns nil when none are present.
+func deepLinks(alerts []*types.Alert) map[string]any {
+	if len(alerts) == 0 {
+		return nil
+	}
+	a := alerts[0]
+	var parts []any
+	add := func(label, url string) {
+		if url == "" {
+			return
+		}
+		if len(parts) > 0 {
+			parts = append(parts, map[string]any{"type": "text", "text": " · "})
+		}
+		parts = append(parts, map[string]any{
+			"type":  "text",
+			"text":  label,
+			"marks": []any{map[string]any{"type": "link", "attrs": map[string]any{"href": url}}},
+		})
+	}
+	add("Open in SigNoz", string(a.Labels[ruletypes.LabelRuleSource]))
+	add("View Related Logs", string(a.Annotations[ruletypes.AnnotationRelatedLogs]))
+	add("View Related Traces", string(a.Annotations[ruletypes.AnnotationRelatedTraces]))
+	if len(parts) == 0 {
+		return nil
+	}
+	return map[string]any{"type": "paragraph", "content": parts}
+}
+
+func (n *Notifier) labels(groupID string) []string {
+	out := append([]string{}, n.conf.Labels...)
+	out = append(out, "signoz-alert", fmt.Sprintf("ALERT{%s}", groupID))
+	sort.Strings(out)
+	return out
+}
+
+func (n *Notifier) searchIssue(ctx context.Context, baseURL, groupID string, firing bool) (*issue, bool, error) {
+	var jql strings.Builder
+	if n.conf.WontFixResolution != "" {
+		// != alone also drops unresolved (EMPTY) issues, so keep those explicitly.
+		fmt.Fprintf(&jql, `(resolution is EMPTY or resolution != %q) and `, n.conf.WontFixResolution)
+	}
+	if reopenMin := int64(time.Duration(n.conf.ReopenDuration).Minutes()); firing && reopenMin > 0 {
+		fmt.Fprintf(&jql, `(resolutiondate is EMPTY OR resolutiondate >= -%dm) and `, reopenMin)
+	} else {
+		jql.WriteString(`statusCategory != Done and `)
+	}
+	fmt.Fprintf(&jql, `project=%q and labels=%q order by status ASC, resolutiondate DESC`, n.conf.Project, fmt.Sprintf("ALERT{%s}", groupID))
+
+	body, retry, err := n.callAPI(ctx, http.MethodPost, baseURL+"/search/jql", searchRequest{
+		JQL: jql.String(), MaxResults: 2, Fields: []string{"status", "labels"},
+	})
+	if err != nil {
+		return nil, retry, err
+	}
+	var res searchResult
+	if err := json.Unmarshal(body, &res); err != nil {
+		return nil, false, err
+	}
+	if len(res.Issues) == 0 {
+		return nil, false, nil
+	}
+	// the JQL order is not category-aware, so prefer an open issue over a done
+	// one; all done falls back to the most recently resolved (resolutiondate DESC)
+	for i := range res.Issues {
+		if !res.Issues[i].isDone() {
+			return &res.Issues[i], false, nil
+		}
+	}
+	return &res.Issues[0], false, nil
+}
+
+func (n *Notifier) createIssue(ctx context.Context, baseURL string, fields *issueFields) (bool, error) {
+	_, retry, err := n.callAPI(ctx, http.MethodPost, baseURL+"/issue", issue{Fields: fields})
+	return retry, err
+}
+
+func (n *Notifier) updateIssue(ctx context.Context, baseURL string, existing *issue, fields *issueFields) (bool, error) {
+	// project and issue type are set at creation and cannot be edited.
+	upd := *fields
+	upd.Project = nil
+	upd.Issuetype = nil
+	// Jira replaces the labels array wholesale, so union in the labels already
+	// on the issue to keep user-added ones.
+	if existing.Fields != nil {
+		upd.Labels = mergeLabels(existing.Fields.Labels, fields.Labels)
+	}
+	_, retry, err := n.callAPI(ctx, http.MethodPut, n.issueURL(baseURL, existing.Key, ""), issue{Fields: &upd})
+	return retry, err
+}
+
+func mergeLabels(existing, ours []string) []string {
+	seen := make(map[string]bool, len(existing)+len(ours))
+	var merged []string
+	for _, label := range append(append([]string{}, existing...), ours...) {
+		if !seen[label] {
+			seen[label] = true
+			merged = append(merged, label)
+		}
+	}
+	sort.Strings(merged)
+	return merged
+}
+
+// applyTransition moves the issue into (toDone) or out of (!toDone) the "done"
+// status category, preferring the named override, else the first matching
+// transition, else skipping without error when none is available.
+func (n *Notifier) applyTransition(ctx context.Context, baseURL, key string, toDone bool, override string) (bool, error) {
+	transitions, retry, err := n.getTransitions(ctx, baseURL, key)
+	if err != nil {
+		return retry, err
+	}
+	id := selectTransition(transitions, toDone, override)
+	if id == "" {
+		n.logger.WarnContext(ctx, "jira: no matching transition, leaving issue as-is", slog.String("issue", key), slog.Bool("to_done", toDone))
+		return false, nil
+	}
+	_, retry, err = n.callAPI(ctx, http.MethodPost, n.issueURL(baseURL, key, "transitions"), issue{Transition: &idName{ID: id}})
+	return retry, err
+}
+
+func (n *Notifier) getTransitions(ctx context.Context, baseURL, key string) ([]jiraTransition, bool, error) {
+	body, retry, err := n.callAPI(ctx, http.MethodGet, n.issueURL(baseURL, key, "transitions"), nil)
+	if err != nil {
+		return nil, retry, err
+	}
+	var tr transitionsResponse
+	if err := json.Unmarshal(body, &tr); err != nil {
+		return nil, false, err
+	}
+	return tr.Transitions, false, nil
+}
+
+func (n *Notifier) addComment(ctx context.Context, baseURL, key string, body any) (bool, error) {
+	_, retry, err := n.callAPI(ctx, http.MethodPost, n.issueURL(baseURL, key, "comment"), comment{Body: body})
+	return retry, err
+}
+
+func (n *Notifier) issueURL(baseURL, key, sub string) string {
+	u := baseURL + "/issue/" + key
+	if sub != "" {
+		u += "/" + sub
+	}
+	return u
+}
+
+func (n *Notifier) callAPI(ctx context.Context, method, url string, reqBody any) ([]byte, bool, error) {
+	var body io.Reader
+	if reqBody != nil {
+		var buf bytes.Buffer
+		if err := json.NewEncoder(&buf).Encode(reqBody); err != nil {
+			return nil, false, err
+		}
+		body = &buf
+	}
+	req, err := http.NewRequestWithContext(ctx, method, url, body)
+	if err != nil {
+		return nil, false, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := n.client.Do(req) //nolint:bodyclose // notify.Drain closes the body
+	if err != nil {
+		return nil, true, notify.RedactURL(err)
+	}
+	defer notify.Drain(resp)
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, false, err
+	}
+	shouldRetry, err := n.retrier.Check(resp.StatusCode, bytes.NewReader(respBody))
+	if err != nil {
+		return respBody, shouldRetry, notify.NewErrorWithReason(notify.GetFailureReasonFromStatusCode(resp.StatusCode), err)
+	}
+	return respBody, false, nil
+}
+
+// resolveAPIBaseURL resolves the service-account cloud id per notification (it
+// is never persisted); personal API tokens use the site host directly.
+func (n *Notifier) resolveAPIBaseURL(ctx context.Context) (string, bool, error) {
+	if !n.conf.IsServiceAccount() {
+		return n.conf.APIBaseURL(""), false, nil
+	}
+	cloudID, retry, err := n.resolveCloudID(ctx)
+	if err != nil {
+		return "", retry, err
+	}
+	return n.conf.APIBaseURL(cloudID), false, nil
+}
+
+// resolveCloudID fetches the site's cloud id from its unauthenticated
+// tenant_info endpoint; transport failures are retryable, bad responses are not.
+func (n *Notifier) resolveCloudID(ctx context.Context) (string, bool, error) {
+	url := strings.TrimRight(n.conf.Site, "/") + "/_edge/tenant_info"
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return "", false, err
+	}
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := n.client.Do(req)
+	if err != nil {
+		return "", true, errors.WrapInternalf(err, errors.CodeInternal, "failed to fetch jira cloud id")
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", true, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", false, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to resolve jira cloud id from %s: status %d", url, resp.StatusCode)
+	}
+
+	var out struct {
+		CloudID string `json:"cloudId"`
+	}
+	if err := json.Unmarshal(body, &out); err != nil {
+		return "", false, errors.WrapInternalf(err, errors.CodeInternal, "failed to parse jira tenant_info response")
+	}
+	if out.CloudID == "" {
+		return "", false, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira tenant_info returned an empty cloud id for %s", n.conf.Site)
+	}
+	return out.CloudID, false, nil
+}
+
+// selectTransition returns the id of the transition whose target status category
+// matches toDone, preferring one named override when present.
+func selectTransition(transitions []jiraTransition, toDone bool, override string) string {
+	if override != "" {
+		for _, t := range transitions {
+			if t.Name == override {
+				return t.ID
+			}
+		}
+	}
+	for _, t := range transitions {
+		if (t.To.StatusCategory.Key == "done") == toDone {
+			return t.ID
+		}
+	}
+	return ""
+}
+
+// Jira API types.
+type issue struct {
+	Key        string       `json:"key,omitempty"`
+	Fields     *issueFields `json:"fields,omitempty"`
+	Transition *idName      `json:"transition,omitempty"`
+}
+
+type issueFields struct {
+	Project     *idKey       `json:"project,omitempty"`
+	Issuetype   *idName      `json:"issuetype,omitempty"`
+	Summary     string       `json:"summary,omitempty"`
+	Labels      []string     `json:"labels,omitempty"`
+	Priority    *idName      `json:"priority,omitempty"`
+	Description any          `json:"description,omitempty"`
+	Status      *issueStatus `json:"status,omitempty"`
+}
+
+type idKey struct {
+	Key string `json:"key"`
+}
+
+type idName struct {
+	ID   string `json:"id,omitempty"`
+	Name string `json:"name,omitempty"`
+}
+
+type issueStatus struct {
+	StatusCategory struct {
+		Key string `json:"key"`
+	} `json:"statusCategory"`
+}
+
+func (i *issue) isDone() bool {
+	return i.Fields != nil && i.Fields.Status != nil && i.Fields.Status.StatusCategory.Key == "done"
+}
+
+type searchRequest struct {
+	JQL        string   `json:"jql"`
+	MaxResults int      `json:"maxResults"`
+	Fields     []string `json:"fields"`
+}
+
+type searchResult struct {
+	Issues []issue `json:"issues"`
+}
+
+type transitionsResponse struct {
+	Transitions []jiraTransition `json:"transitions"`
+}
+
+type jiraTransition struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	To   struct {
+		StatusCategory struct {
+			Key string `json:"key"`
+		} `json:"statusCategory"`
+	} `json:"to"`
+}
+
+type comment struct {
+	Body any `json:"body"`
+}
+
+func truncateRunes(s string, max int) string {
+	r := []rune(s)
+	if len(r) <= max {
+		return s
+	}
+	return string(r[:max])
+}

pkg/alertmanager/alertmanagernotify/jira/jira_test.go

@@ -0,0 +1,489 @@
+package jira
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/notify/test"
+	"github.com/prometheus/alertmanager/types"
+	commoncfg "github.com/prometheus/common/config"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type mockReq struct {
+	method string
+	path   string
+	body   map[string]any
+}
+
+type mockJira struct {
+	srv          *httptest.Server
+	mu           sync.Mutex
+	reqs         []mockReq
+	searchIssues []issue
+	transitions  []jiraTransition
+	createStatus int
+}
+
+func newMockJira(t *testing.T) *mockJira {
+	t.Helper()
+	m := &mockJira{}
+	m.srv = httptest.NewServer(http.HandlerFunc(m.handle))
+	t.Cleanup(m.srv.Close)
+	return m
+}
+
+func (m *mockJira) handle(w http.ResponseWriter, r *http.Request) {
+	var body map[string]any
+	_ = json.NewDecoder(r.Body).Decode(&body)
+	m.mu.Lock()
+	m.reqs = append(m.reqs, mockReq{r.Method, r.URL.Path, body})
+	m.mu.Unlock()
+
+	p := r.URL.Path
+	switch {
+	case strings.HasSuffix(p, "/search/jql"):
+		_ = json.NewEncoder(w).Encode(searchResult{Issues: m.searchIssues})
+	case strings.HasSuffix(p, "/transitions") && r.Method == http.MethodGet:
+		_ = json.NewEncoder(w).Encode(transitionsResponse{Transitions: m.transitions})
+	case strings.HasSuffix(p, "/transitions"):
+		w.WriteHeader(http.StatusNoContent)
+	case strings.HasSuffix(p, "/comment"):
+		w.WriteHeader(http.StatusCreated)
+		_, _ = w.Write([]byte(`{"id":"1"}`))
+	case strings.HasSuffix(p, "/issue") && r.Method == http.MethodPost:
+		st := m.createStatus
+		if st == 0 {
+			st = http.StatusCreated
+		}
+		w.WriteHeader(st)
+		_, _ = w.Write([]byte(`{"key":"KAN-1"}`))
+	case r.Method == http.MethodPut:
+		w.WriteHeader(http.StatusNoContent)
+	default:
+		w.WriteHeader(http.StatusNotFound)
+	}
+}
+
+func (m *mockJira) countPost(suffix string) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	c := 0
+	for _, r := range m.reqs {
+		if r.method == http.MethodPost && strings.HasSuffix(r.path, suffix) {
+			c++
+		}
+	}
+	return c
+}
+
+func (m *mockJira) countPuts() int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	c := 0
+	for _, r := range m.reqs {
+		if r.method == http.MethodPut {
+			c++
+		}
+	}
+	return c
+}
+
+func newNotifier(t *testing.T, m *mockJira) *Notifier {
+	t.Helper()
+	tmpl := test.CreateTmpl(t)
+	n, err := New(&alertmanagertypes.JiraReceiverConfig{
+		Site:           m.srv.URL,
+		Project:        "KAN",
+		IssueType:      "Task",
+		Summary:        alertmanagertypes.DefaultJiraSummaryTemplate,
+		Description:    alertmanagertypes.DefaultJiraDescriptionTemplate,
+		HTTPConfig:     &commoncfg.HTTPClientConfig{},
+		ReopenDuration: model.Duration(3 * 24 * time.Hour),
+	}, tmpl, slog.New(slog.DiscardHandler), alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler)))
+	require.NoError(t, err)
+	return n
+}
+
+func alert(firing bool) *types.Alert {
+	a := &types.Alert{Alert: model.Alert{
+		Labels:      model.LabelSet{"alertname": "HighCPU", "severity": "critical"},
+		Annotations: model.LabelSet{"summary": "cpu high"},
+		StartsAt:    time.Now().Add(-time.Minute),
+	}}
+	if firing {
+		a.EndsAt = time.Now().Add(time.Hour)
+	} else {
+		a.EndsAt = time.Now().Add(-time.Minute)
+	}
+	return a
+}
+
+func ctx() context.Context {
+	return notify.WithGroupKey(context.Background(), "test-jira")
+}
+
+func doneIssue() issue {
+	i := issue{Key: "KAN-1", Fields: &issueFields{Status: &issueStatus{}}}
+	i.Fields.Status.StatusCategory.Key = "done"
+	return i
+}
+
+func openIssue() issue {
+	i := issue{Key: "KAN-1", Fields: &issueFields{Status: &issueStatus{}}}
+	i.Fields.Status.StatusCategory.Key = "new"
+	return i
+}
+
+func transition(id, name, category string) jiraTransition {
+	tr := jiraTransition{ID: id, Name: name}
+	tr.To.StatusCategory.Key = category
+	return tr
+}
+
+func TestNotifyCreatesWhenNoExistingIssue(t *testing.T) {
+	m := newMockJira(t)
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 1, m.countPost("/issue"))
+	assert.Equal(t, 0, m.countPost("/comment")) // no comment on create
+	assert.Equal(t, 0, m.countPuts())           // no update
+}
+
+func TestNotifyResolvedOnlyWithNoIssueIsNoop(t *testing.T) {
+	m := newMockJira(t)
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(false))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 1, m.countPost("/search/jql"))
+	assert.Equal(t, 0, m.countPost("/issue"))
+}
+
+func TestNotifyStillFiringUpdatesAndComments(t *testing.T) {
+	m := newMockJira(t)
+	m.searchIssues = []issue{openIssue()}
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 0, m.countPost("/issue")) // no create
+	assert.Equal(t, 1, m.countPuts())         // update
+	assert.Equal(t, 1, m.countPost("/comment"))
+	assert.Equal(t, 0, m.countPost("/transitions")) // still open, no transition
+
+	// comment carries the full rich snapshot (panel + labeled body), not a one-liner.
+	cjs, err := json.Marshal(m.lastBody(t, "/comment"))
+	require.NoError(t, err)
+	assert.Contains(t, string(cjs), `"panel"`)
+	assert.Contains(t, string(cjs), "Summary:")
+}
+
+func TestNotifyResolveTransitionsToDoneAndComments(t *testing.T) {
+	m := newMockJira(t)
+	m.searchIssues = []issue{openIssue()}
+	m.transitions = []jiraTransition{transition("11", "To Do", "new"), transition("41", "Done", "done")}
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(false))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 1, m.countPuts())               // update
+	assert.Equal(t, 1, m.countPost("/transitions")) // resolve transition
+	assert.Equal(t, 1, m.countPost("/comment"))
+}
+
+func TestNotifyReopensDoneIssue(t *testing.T) {
+	m := newMockJira(t)
+	m.searchIssues = []issue{doneIssue()}
+	m.transitions = []jiraTransition{transition("11", "To Do", "new"), transition("41", "Done", "done")}
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 1, m.countPost("/transitions")) // reopen transition
+	assert.Equal(t, 1, m.countPost("/comment"))
+}
+
+func TestNotifySafeSkipsWhenNoMatchingTransition(t *testing.T) {
+	m := newMockJira(t)
+	m.searchIssues = []issue{openIssue()}
+	m.transitions = []jiraTransition{transition("11", "To Do", "new")} // no done-category transition
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(false))
+	require.NoError(t, err) // must not error
+	assert.False(t, retry)
+	assert.Equal(t, 0, m.countPost("/transitions")) // skipped
+	assert.Equal(t, 1, m.countPost("/comment"))     // comment still posted
+}
+
+func TestNotifyPrefersOpenIssueOverRecentlyDone(t *testing.T) {
+	m := newMockJira(t)
+	open := openIssue()
+	open.Key = "KAN-2"
+	// the JQL order can put a recently-done issue first; the open one must win
+	m.searchIssues = []issue{doneIssue(), open}
+
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+	assert.False(t, retry)
+	assert.Equal(t, 0, m.countPost("/issue"))       // no duplicate create
+	assert.Equal(t, 0, m.countPost("/transitions")) // open issue → no reopen
+	assert.Equal(t, 1, m.countPuts())
+	assert.Equal(t, 1, m.countPost("/comment"))
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for _, r := range m.reqs {
+		if r.method == http.MethodPut || strings.HasSuffix(r.path, "/comment") {
+			assert.Contains(t, r.path, "KAN-2")
+		}
+	}
+}
+
+func TestNotifyRetriesOn429(t *testing.T) {
+	m := newMockJira(t)
+	m.createStatus = http.StatusTooManyRequests
+	retry, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.Error(t, err)
+	assert.True(t, retry)
+}
+
+func (m *mockJira) lastBody(t *testing.T, suffix string) map[string]any {
+	t.Helper()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for i := len(m.reqs) - 1; i >= 0; i-- {
+		if m.reqs[i].method == http.MethodPost && strings.HasSuffix(m.reqs[i].path, suffix) {
+			return m.reqs[i].body
+		}
+	}
+	t.Fatalf("no POST request to %s", suffix)
+	return nil
+}
+
+func TestNotifyRichDescriptionPanelAndLinks(t *testing.T) {
+	m := newMockJira(t)
+	a := alert(true)
+	a.Labels[ruletypes.LabelRuleSource] = model.LabelValue("https://app.signoz.io/alerts?ruleId=1")
+	a.Annotations[ruletypes.AnnotationRelatedLogs] = model.LabelValue("https://app.signoz.io/logs")
+
+	_, err := newNotifier(t, m).Notify(ctx(), a)
+	require.NoError(t, err)
+
+	body := m.lastBody(t, "/issue")
+	js, err := json.Marshal(body)
+	require.NoError(t, err)
+	s := string(js)
+	assert.Contains(t, s, `"panel"`)                               // status panel present
+	assert.Contains(t, s, `"error"`)                               // firing → error panel
+	assert.Contains(t, s, "Open in SigNoz")                        // rule deep-link
+	assert.Contains(t, s, "https://app.signoz.io/alerts?ruleId=1") // rule url
+	assert.Contains(t, s, "View Related Logs")                     // related-logs deep-link
+	assert.Contains(t, s, "Summary:")                              // labeled body section
+	assert.Contains(t, s, "cpu high")                              // rendered annotation
+}
+
+func TestNotifyCustomTemplateAnnotationsOverrideDefaults(t *testing.T) {
+	m := newMockJira(t)
+	a1 := alert(true)
+	a1.Labels["service"] = "payment"
+	a1.Labels["namespace"] = "ns-one"
+	a1.Annotations[ruletypes.AnnotationTitleTemplate] = "High throughput for $service"
+	a1.Annotations[ruletypes.AnnotationBodyTemplate] = "Firing in NS: $labels.namespace"
+	a2 := alert(true)
+	a2.Labels["service"] = "payment"
+	a2.Labels["namespace"] = "ns-two"
+	a2.Annotations[ruletypes.AnnotationTitleTemplate] = "High throughput for $service"
+	a2.Annotations[ruletypes.AnnotationBodyTemplate] = "Firing in NS: $labels.namespace"
+
+	_, err := newNotifier(t, m).Notify(ctx(), a1, a2)
+	require.NoError(t, err)
+
+	body := m.lastBody(t, "/issue")
+	fields, ok := body["fields"].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, "High throughput for payment", fields["summary"])
+
+	js, err := json.Marshal(fields["description"])
+	require.NoError(t, err)
+	s := string(js)
+	assert.Contains(t, s, "Firing in NS: ns-one")
+	assert.Contains(t, s, "Firing in NS: ns-two")
+	// per-alert custom bodies are separated by an ADF rule divider
+	assert.Contains(t, s, `"rule"`)
+	assert.NotContains(t, s, "Summary:") // default body template not used
+}
+
+// Jira replaces labels wholesale on PUT, so the update must union in the
+// labels already on the issue or user-added ones get wiped.
+func TestNotifyUpdatePreservesUserAddedLabels(t *testing.T) {
+	m := newMockJira(t)
+	existing := openIssue()
+	existing.Fields.Labels = []string{"user-added-label", "signoz-alert"}
+	m.searchIssues = []issue{existing}
+
+	_, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+
+	search := m.lastBody(t, "/search/jql")
+	assert.Contains(t, search["fields"], "labels")
+
+	m.mu.Lock()
+	var putLabels []any
+	for _, r := range m.reqs {
+		if r.method == http.MethodPut {
+			putLabels, _ = r.body["fields"].(map[string]any)["labels"].([]any)
+		}
+	}
+	m.mu.Unlock()
+	assert.Contains(t, putLabels, "user-added-label")
+	assert.Contains(t, putLabels, "signoz-alert")
+	assert.Equal(t, 1, strings.Count(fmt.Sprint(putLabels), "signoz-alert")) // no duplicates
+	// the dedup label is re-asserted
+	found := false
+	for _, l := range putLabels {
+		if s, ok := l.(string); ok && strings.HasPrefix(s, "ALERT{") {
+			found = true
+		}
+	}
+	assert.True(t, found)
+}
+
+func TestADFDocLen(t *testing.T) {
+	text := func(s string) map[string]any { return map[string]any{"type": "text", "text": s} }
+	para := func(children ...any) map[string]any {
+		return map[string]any{"type": "paragraph", "content": children}
+	}
+	cases := []struct {
+		name string
+		node any
+		want int
+	}{
+		{"text node", text("hello"), 7},               // 5 utf16 + 2 overhead
+		{"emoji counts utf16", text("🔴"), 4},          // 2 utf16 units + 2 overhead
+		{"paragraph wraps text", para(text("hi")), 6}, // 2 + (2+2)
+		{"link href counted", map[string]any{"type": "text", "text": "a", "marks": []any{map[string]any{"type": "link", "attrs": map[string]any{"href": "https://x"}}}}, 12}, // 1 + 9 href + 2
+		{"non-map is zero", "junk", 0},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.Equal(t, c.want, adfDocLen(c.node))
+		})
+	}
+}
+
+// 30 fat custom bodies overflow Jira's description accounting (text + per-node
+// overhead); the built doc must be shrunk under the limit, never rejected.
+func TestNotifyDescriptionShrunkUnderJiraLimit(t *testing.T) {
+	m := newMockJira(t)
+	filler := strings.Repeat("This is a long runbook detail line used to inflate the alert body. ", 25)
+	alerts := make([]*types.Alert, 0, 30)
+	for i := range 30 {
+		a := alert(true)
+		a.Labels["service"] = model.LabelValue(strings.Repeat("s", 3) + string(rune('a'+i%26)))
+		a.Annotations[ruletypes.AnnotationTitleTemplate] = "overflow probe"
+		a.Annotations[ruletypes.AnnotationBodyTemplate] = model.LabelValue("**Alert in service** $labels.service\n\n" + filler)
+		alerts = append(alerts, a)
+	}
+
+	_, err := newNotifier(t, m).Notify(ctx(), alerts...)
+	require.NoError(t, err)
+
+	body := m.lastBody(t, "/issue")
+	fields, ok := body["fields"].(map[string]any)
+	require.True(t, ok)
+	desc := fields["description"]
+	assert.LessOrEqual(t, adfDocLen(desc), maxDescriptionLenRunes)
+
+	js, err := json.Marshal(desc)
+	require.NoError(t, err)
+	assert.Contains(t, string(js), "FIRING") // status panel survives the shrink
+	assert.Contains(t, string(js), "…")      // body ends with the shrink marker
+}
+
+func TestFiringSearchJQLHasReopenWindow(t *testing.T) {
+	m := newMockJira(t)
+	_, err := newNotifier(t, m).Notify(ctx(), alert(true))
+	require.NoError(t, err)
+
+	body := m.lastBody(t, "/search/jql")
+	jql, ok := body["jql"].(string)
+	require.True(t, ok)
+	// newNotifier uses a 3d window → 4320 minutes.
+	assert.Contains(t, jql, "resolutiondate >= -4320m")
+}
+
+func TestSelectTransition(t *testing.T) {
+	ts := []jiraTransition{
+		transition("41", "Done", "done"),
+		transition("51", "Won't Do", "done"),
+		transition("11", "To Do", "new"),
+	}
+	assert.Equal(t, "41", selectTransition(ts, true, ""))                                               // first done-category
+	assert.Equal(t, "51", selectTransition(ts, true, "Won't Do"))                                       // named override
+	assert.Equal(t, "11", selectTransition(ts, false, ""))                                              // first non-done
+	assert.Equal(t, "41", selectTransition(ts, true, "Nonexistent"))                                    // bad override → fallback
+	assert.Equal(t, "", selectTransition([]jiraTransition{transition("11", "To Do", "new")}, true, "")) // none → skip
+}
+
+func TestResolveCloudID(t *testing.T) {
+	cases := []struct {
+		name      string
+		handler   http.HandlerFunc
+		want      string
+		wantErr   bool
+		wantRetry bool
+	}{
+		{
+			name: "success",
+			handler: func(w http.ResponseWriter, r *http.Request) {
+				assert.Equal(t, "/_edge/tenant_info", r.URL.Path)
+				_, _ = w.Write([]byte(`{"cloudId":"abc-123"}`))
+			},
+			want: "abc-123",
+		},
+		{
+			name:    "non-200 is not retryable",
+			handler: func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusNotFound) },
+			wantErr: true,
+		},
+		{
+			name:    "empty cloud id",
+			handler: func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(`{"cloudId":""}`)) },
+			wantErr: true,
+		},
+		{
+			name:    "bad json",
+			handler: func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(`not json`)) },
+			wantErr: true,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			srv := httptest.NewServer(c.handler)
+			defer srv.Close()
+
+			n, err := New(&alertmanagertypes.JiraReceiverConfig{Site: srv.URL, HTTPConfig: &commoncfg.HTTPClientConfig{}}, nil, slog.New(slog.DiscardHandler), nil)
+			require.NoError(t, err)
+
+			got, retry, err := n.resolveCloudID(context.Background())
+			if c.wantErr {
+				assert.Error(t, err)
+				assert.Equal(t, c.wantRetry, retry)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, c.want, got)
+		})
+	}
+}

pkg/alertmanager/alertmanagernotify/jsmops/jsmops.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2026 SigNoz, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Package jsmops delivers Jira Service Management Ops alerts by reusing the
+// Opsgenie notifier: JSM Ops is the ex-Opsgenie alert API, so we map the JSM
+// config onto config.OpsGenieConfig with APIURL pinned to the JSM native
+// integration-events gateway.
+package jsmops
+
+import (
+	"log/slog"
+	"net/url"
+
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/opsgenie"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/alertmanager/config"
+	"github.com/prometheus/alertmanager/template"
+	commoncfg "github.com/prometheus/common/config"
+)
+
+const (
+	Integration = "jsmops"
+	source      = "SigNoz"
+)
+
+// New builds an Opsgenie notifier pointed at the JSM native endpoint.
+// advancedFeatures enables the rich treatment: HTML body and a note timeline
+// (per fire and on resolve).
+func New(c *alertmanagertypes.JSMOpsReceiverConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, advancedFeatures bool) (*opsgenie.Notifier, error) {
+	conf, err := toOpsGenieConfig(c)
+	if err != nil {
+		return nil, err
+	}
+	return opsgenie.New(conf, t, l, templater, advancedFeatures)
+}
+
+// toOpsGenieConfig maps the JSM config onto config.OpsGenieConfig with APIURL
+// pinned to the JSM native gateway.
+func toOpsGenieConfig(c *alertmanagertypes.JSMOpsReceiverConfig) (*config.OpsGenieConfig, error) {
+	apiURL, err := url.Parse(alertmanagertypes.JSMOpsAPIBaseURL)
+	if err != nil {
+		return nil, err
+	}
+
+	httpConfig := c.HTTPConfig
+	if httpConfig == nil {
+		httpConfig = &commoncfg.HTTPClientConfig{}
+	}
+
+	return &config.OpsGenieConfig{
+		NotifierConfig: c.NotifierConfig,
+		HTTPConfig:     httpConfig,
+		APIKey:         c.APIKey,
+		APIURL:         &config.URL{URL: apiURL},
+		Message:        c.Message,
+		Description:    c.Description,
+		Priority:       c.Priority,
+		Tags:           c.Tags,
+		Source:         source,
+	}, nil
+}

pkg/alertmanager/alertmanagernotify/jsmops/jsmops_test.go

@@ -0,0 +1,41 @@
+package jsmops
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	commoncfg "github.com/prometheus/common/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestToOpsGenieConfig(t *testing.T) {
+	c := &alertmanagertypes.JSMOpsReceiverConfig{
+		APIKey:      "key-123",
+		Message:     "msg",
+		Description: "desc",
+		Priority:    "P1",
+		Tags:        "signoz",
+		HTTPConfig:  &commoncfg.HTTPClientConfig{},
+	}
+
+	og, err := toOpsGenieConfig(c)
+	require.NoError(t, err)
+
+	// Trailing slash is required: the Opsgenie notifier appends "v2/alerts..."
+	// with no separator, yielding /jsm/ops/integration/v2/alerts.
+	assert.Equal(t, "https://api.atlassian.com/jsm/ops/integration/", og.APIURL.String())
+	assert.Equal(t, "key-123", string(og.APIKey))
+	assert.Equal(t, "msg", og.Message)
+	assert.Equal(t, "desc", og.Description)
+	assert.Equal(t, "P1", og.Priority)
+	assert.Equal(t, "signoz", og.Tags)
+	assert.Equal(t, source, og.Source)
+	assert.Same(t, c.HTTPConfig, og.HTTPConfig)
+}
+
+func TestToOpsGenieConfigNilHTTPConfig(t *testing.T) {
+	og, err := toOpsGenieConfig(&alertmanagertypes.JSMOpsReceiverConfig{APIKey: "k"})
+	require.NoError(t, err)
+	assert.NotNil(t, og.HTTPConfig)
+}

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie.go

@@ -14,6 +14,7 @@ import (
 	"net/http"
 	"os"
 	"strings"
+	"unicode/utf8"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -32,8 +33,13 @@ const (
 	Integration = "opsgenie"
 )
 
-// https://docs.opsgenie.com/docs/alert-api - 130 characters meaning runes.
-const maxMessageLenRunes = 130
+// https://support.atlassian.com/opsgenie/docs/alert-fields/ - message 130,
+// description 15000, note 25000 runes.
+const (
+	maxMessageLenRunes     = 130
+	maxDescriptionLenRunes = 15000
+	maxNoteLenRunes        = 25000
+)
 
 // Notifier implements a Notifier for OpsGenie notifications.
 type Notifier struct {
@@ -43,21 +49,29 @@ type Notifier struct {
 	client    *http.Client
 	retrier   *notify.Retrier
 	templater alertmanagertypes.Templater
+	// advancedFeatures bundles the JSM Ops enrichments: render the default body as
+	// HTML (markdown -> HTML), and post a note per fire and on resolve to build an
+	// immutable timeline. Off for plain OpsGenie. The alert-refresh-on-refire part
+	// rides on the upstream UpdateAlerts config flag, set alongside this.
+	advancedFeatures bool
 }
 
-// New returns a new OpsGenie notifier.
-func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+// New returns a new OpsGenie notifier. advancedFeatures enables the JSM Ops
+// enrichments (HTML default body + a note timeline per fire and on resolve);
+// pass false for plain OpsGenie.
+func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, advancedFeatures bool, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return &Notifier{
-		conf:      c,
-		tmpl:      t,
-		logger:    l,
-		client:    client,
-		retrier:   &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
-		templater: templater,
+		conf:             c,
+		tmpl:             t,
+		logger:           l,
+		client:           client,
+		retrier:          &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
+		templater:        templater,
+		advancedFeatures: advancedFeatures,
 	}, nil
 }
 
@@ -94,6 +108,30 @@ type opsGenieUpdateDescriptionMessage struct {
 	Description string `json:"description,omitempty"`
 }
 
+type opsGenieAddNoteMessage struct {
+	Note   string `json:"note"`
+	Source string `json:"source"`
+}
+
+// noteRequest builds a POST to the alert's notes endpoint (append-only timeline).
+func (n *Notifier) noteRequest(ctx context.Context, alias, note, source string) (*http.Request, error) {
+	noteEndpointURL := n.conf.APIURL.Copy()
+	noteEndpointURL.Path += fmt.Sprintf("v2/alerts/%s/notes", alias)
+	q := noteEndpointURL.Query()
+	q.Set("identifierType", "alias")
+	noteEndpointURL.RawQuery = q.Encode()
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(&opsGenieAddNoteMessage{Note: note, Source: source}); err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest("POST", noteEndpointURL.String(), &buf)
+	if err != nil {
+		return nil, err
+	}
+	return req.WithContext(ctx), nil
+}
+
 // Notify implements the Notifier interface.
 func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 	requests, retry, err := n.createRequests(ctx, as...)
@@ -110,12 +148,24 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		shouldRetry, err := n.retrier.Check(resp.StatusCode, resp.Body)
 		notify.Drain(resp)
 		if err != nil {
+			// notes are enrichment; a permanently-failed note (e.g. the first-fire
+			// note racing JSM's async alert create) must not fail the notification
+			if !shouldRetry && isNoteRequest(req) {
+				n.logger.WarnContext(ctx, "dropping failed note", slog.Int("status_code", resp.StatusCode), errors.Attr(err))
+				continue
+			}
 			return shouldRetry, notify.NewErrorWithReason(notify.GetFailureReasonFromStatusCode(resp.StatusCode), err)
 		}
 	}
 	return true, nil
 }
 
+// isNoteRequest reports whether req targets the notes endpoint, the only one
+// built by noteRequest.
+func isNoteRequest(req *http.Request) bool {
+	return strings.HasSuffix(req.URL.Path, "/notes")
+}
+
 // Like Split but filter out empty strings.
 func safeSplit(s, sep string) []string {
 	a := strings.Split(strings.TrimSpace(s), sep)
@@ -145,28 +195,13 @@ func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) (s
 	}
 
 	var description string
-	if result.IsDefaultBody {
+	if result.IsDefaultBody && !n.advancedFeatures {
 		description = strings.Join(result.Body, "\n")
 	} else {
-		var b strings.Builder
-		first := true
-		for _, part := range result.Body {
-			if part == "" {
-				continue
-			}
-			rendered, renderErr := markdownrenderer.RenderHTML(part)
-			if renderErr != nil {
-				return "", "", renderErr
-			}
-			if !first {
-				b.WriteString("<hr>")
-			}
-			b.WriteString("<div>")
-			b.WriteString(rendered)
-			b.WriteString("</div>")
-			first = false
+		description, err = buildHTMLDescription(result.Body, maxDescriptionLenRunes)
+		if err != nil {
+			return "", "", err
 		}
-		description = b.String()
 	}
 
 	title, truncated := notify.TruncateInRunes(result.Title, maxMessageLenRunes)
@@ -174,9 +209,141 @@ func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) (s
 		n.logger.WarnContext(ctx, "Truncated message", slog.Int("max_runes", maxMessageLenRunes))
 	}
 
+	// The API silently truncates over-limit descriptions, which would drop the
+	// trailing SigNoz link; cap here with an ellipsis instead. The HTML path is
+	// pre-fitted above, so this only ever cuts the plain-text default body.
+	description, descTruncated := notify.TruncateInRunes(description, maxDescriptionLenRunes)
+	if descTruncated {
+		n.logger.WarnContext(ctx, "Truncated description", slog.Int("max_runes", maxDescriptionLenRunes))
+	}
+
 	return title, description, nil
 }
 
+const (
+	// room reserved for the "+N more" trailer appended when parts are dropped.
+	descriptionTrailerReserveRunes = 80
+	// below this rendering budget a shrunk part carries no signal; drop it instead.
+	minShrinkBudgetRunes = 64
+)
+
+// buildHTMLDescription renders each markdown part to HTML (<div>-wrapped,
+// <hr>-joined) while keeping the total within budget runes. An over-budget part
+// is shrunk at the markdown level and re-rendered so the HTML stays well-formed;
+// fully dropped parts are summarized by a "+N more" trailer.
+func buildHTMLDescription(parts []string, budget int) (string, error) {
+	rendering := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if part != "" {
+			rendering = append(rendering, part)
+		}
+	}
+
+	budget -= descriptionTrailerReserveRunes
+	var b strings.Builder
+	used, included := 0, 0
+	for _, part := range rendering {
+		rendered, err := markdownrenderer.RenderHTML(part)
+		if err != nil {
+			return "", err
+		}
+		overhead := len("<div></div>")
+		if included > 0 {
+			overhead += len("<hr>")
+		}
+		if used+overhead+utf8.RuneCountInString(rendered) > budget {
+			rendered, err = shrinkMarkdownToFit(part, budget-used-overhead)
+			if err != nil {
+				return "", err
+			}
+			if rendered == "" {
+				break
+			}
+		}
+		if included > 0 {
+			b.WriteString("<hr>")
+		}
+		b.WriteString("<div>")
+		b.WriteString(rendered)
+		b.WriteString("</div>")
+		used += overhead + utf8.RuneCountInString(rendered)
+		included++
+	}
+	if dropped := len(rendering) - included; dropped > 0 {
+		fmt.Fprintf(&b, "<hr><div><i>…and %d more alerts. Open in SigNoz for the full list.</i></div>", dropped)
+	}
+	return b.String(), nil
+}
+
+// shrinkMarkdownToFit cuts markdown until its rendered HTML fits within budget
+// runes, returning "" when the budget is too small to carry anything useful.
+// Only the markdown is ever cut, never the rendered HTML, so goldmark always
+// emits balanced markup.
+func shrinkMarkdownToFit(md string, budget int) (string, error) {
+	if budget < minShrinkBudgetRunes {
+		return "", nil
+	}
+	for range 4 {
+		rendered, err := markdownrenderer.RenderHTML(md)
+		if err != nil {
+			return "", err
+		}
+		renderedLen := utf8.RuneCountInString(rendered)
+		if renderedLen <= budget {
+			return rendered, nil
+		}
+		runes := []rune(md)
+		keep := len(runes) * budget / renderedLen * 9 / 10
+		if keep >= len(runes) {
+			keep = len(runes) - 1
+		}
+		if keep < minShrinkBudgetRunes {
+			return "", nil
+		}
+		md = string(runes[:keep]) + "…"
+	}
+	return "", nil
+}
+
+// prepareNote renders the same body template as plain text for a timeline note.
+// JSM Ops notes render neither HTML nor markdown, so links flatten to
+// "text (url)" and all markers are stripped.
+func (n *Notifier) prepareNote(ctx context.Context, alerts []*types.Alert) (string, error) {
+	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
+	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
+		TitleTemplate:        customTitle,
+		BodyTemplate:         customBody,
+		DefaultTitleTemplate: n.conf.Message,
+		DefaultBodyTemplate:  n.conf.Description,
+	}, alerts)
+	if err != nil {
+		return "", err
+	}
+
+	var b strings.Builder
+	first := true
+	for _, part := range result.Body {
+		text, renderErr := markdownrenderer.RenderPlainText(part)
+		if renderErr != nil {
+			return "", renderErr
+		}
+		if text = strings.TrimSpace(text); text == "" {
+			continue
+		}
+		if !first {
+			b.WriteString("\n\n")
+		}
+		b.WriteString(text)
+		first = false
+	}
+
+	note, truncated := notify.TruncateInRunes(b.String(), maxNoteLenRunes)
+	if truncated {
+		n.logger.WarnContext(ctx, "Truncated note", slog.Int("max_runes", maxNoteLenRunes))
+	}
+	return note, nil
+}
+
 // Create requests for a list of alerts.
 func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*http.Request, bool, error) {
 	key, err := notify.ExtractGroupKey(ctx)
@@ -206,6 +373,21 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 	)
 	switch alerts.Status() {
 	case model.AlertResolved:
+		// Post the resolved snapshot to the timeline before closing (closed alerts
+		// reject notes), so the note lands first.
+		if n.advancedFeatures {
+			note, err := n.prepareNote(ctx, as)
+			if err != nil {
+				n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
+				return nil, false, err
+			}
+			noteReq, err := n.noteRequest(ctx, alias, note, tmpl(n.conf.Source))
+			if err != nil {
+				return nil, true, err
+			}
+			requests = append(requests, noteReq)
+		}
+
 		resolvedEndpointURL := n.conf.APIURL.Copy()
 		resolvedEndpointURL.Path += fmt.Sprintf("v2/alerts/%s/close", alias)
 		q := resolvedEndpointURL.Query()
@@ -322,6 +504,21 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 			}
 			requests = append(requests, req.WithContext(ctx))
 		}
+
+		// Append this fire's snapshot to the timeline (every fire, including the
+		// first, so no datapoint is lost when the description is overwritten).
+		// Notes are plain text, so this uses the plain-text render, not the HTML body.
+		if n.advancedFeatures {
+			note, err := n.prepareNote(ctx, as)
+			if err != nil {
+				return nil, false, err
+			}
+			noteReq, err := n.noteRequest(ctx, alias, note, tmpl(n.conf.Source))
+			if err != nil {
+				return nil, true, err
+			}
+			requests = append(requests, noteReq)
+		}
 	}
 
 	var apiKey string

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie_test.go

@@ -6,14 +6,18 @@ package opsgenie
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
+	"net/http/httptest"
 	"net/url"
 	"os"
+	"strings"
 	"testing"
 	"time"
+	"unicode/utf8"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
@@ -44,6 +48,7 @@ func TestOpsGenieRetry(t *testing.T) {
 		tmpl,
 		promslog.NewNopLogger(),
 		newTestTemplater(tmpl),
+		false,
 	)
 	require.NoError(t, err)
 
@@ -69,6 +74,7 @@ func TestOpsGenieRedactedURL(t *testing.T) {
 		tmpl,
 		promslog.NewNopLogger(),
 		newTestTemplater(tmpl),
+		false,
 	)
 	require.NoError(t, err)
 
@@ -96,6 +102,7 @@ func TestGettingOpsGegineApikeyFromFile(t *testing.T) {
 		tmpl,
 		promslog.NewNopLogger(),
 		newTestTemplater(tmpl),
+		false,
 	)
 	require.NoError(t, err)
 
@@ -216,7 +223,7 @@ func TestOpsGenie(t *testing.T) {
 		},
 	} {
 		t.Run(tc.title, func(t *testing.T) {
-			notifier, err := New(tc.cfg, tmpl, logger, newTestTemplater(tmpl))
+			notifier, err := New(tc.cfg, tmpl, logger, newTestTemplater(tmpl), false)
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -292,7 +299,7 @@ func TestOpsGenieWithUpdate(t *testing.T) {
 		APIURL:       &config.URL{URL: u},
 		HTTPConfig:   &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl), false)
 	alert := &types.Alert{
 		Alert: model.Alert{
 			StartsAt: time.Now(),
@@ -324,6 +331,111 @@ func TestOpsGenieWithUpdate(t *testing.T) {
 	assert.JSONEq(t, `{"description":"new description"}`, body2)
 }
 
+func TestOpsGenieAdvancedFeatures(t *testing.T) {
+	u, err := url.Parse("https://test-opsgenie-url")
+	require.NoError(t, err)
+	tmpl := test.CreateTmpl(t)
+	ctx := notify.WithGroupKey(context.Background(), "1")
+	key, _ := notify.ExtractGroupKey(ctx)
+	alias := key.Hash()
+
+	cfg := &config.OpsGenieConfig{
+		NotifierConfig: config.NotifierConfig{VSendResolved: true},
+		Message:        `{{ .CommonLabels.Message }}`,
+		Description:    `{{ .CommonLabels.Description }}`,
+		UpdateAlerts:   true,
+		APIKey:         "k",
+		APIURL:         &config.URL{URL: u},
+		HTTPConfig:     &commoncfg.HTTPClientConfig{},
+	}
+	notifier, err := New(cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl), true)
+	require.NoError(t, err)
+
+	firing := &types.Alert{Alert: model.Alert{
+		StartsAt: time.Now(),
+		EndsAt:   time.Now().Add(time.Hour),
+		Labels:   model.LabelSet{"Message": "m", "Description": "**Alert:** d [View](https://s.io/a)"},
+	}}
+
+	// Fire: create + update message + update description + a timeline note.
+	reqs, _, err := notifier.createRequests(ctx, firing)
+	require.NoError(t, err)
+	require.Len(t, reqs, 4)
+	assert.Equal(t, "https://test-opsgenie-url/v2/alerts", reqs[0].URL.String())
+	assert.Equal(t, fmt.Sprintf("https://test-opsgenie-url/v2/alerts/%s/notes?identifierType=alias", alias), reqs[3].URL.String())
+	assert.Equal(t, http.MethodPost, reqs[3].Method)
+
+	// the note body is the plain-text render: markers stripped, link flattened
+	var noteMsg opsGenieAddNoteMessage
+	require.NoError(t, json.Unmarshal([]byte(readBody(t, reqs[3])), &noteMsg))
+	assert.Equal(t, "Alert: d View (https://s.io/a)", noteMsg.Note)
+
+	// Resolve: note posted before the close.
+	resolved := &types.Alert{Alert: model.Alert{
+		StartsAt: time.Now().Add(-time.Hour),
+		EndsAt:   time.Now().Add(-time.Minute),
+		Labels:   model.LabelSet{"Message": "m", "Description": "d"},
+	}}
+	reqs, _, err = notifier.createRequests(ctx, resolved)
+	require.NoError(t, err)
+	require.Len(t, reqs, 2)
+	assert.Equal(t, fmt.Sprintf("https://test-opsgenie-url/v2/alerts/%s/notes?identifierType=alias", alias), reqs[0].URL.String())
+	assert.Equal(t, fmt.Sprintf("https://test-opsgenie-url/v2/alerts/%s/close?identifierType=alias", alias), reqs[1].URL.String())
+}
+
+func TestOpsGenieNotifyBestEffortNote(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
+	ctx := notify.WithGroupKey(context.Background(), "1")
+
+	firing := &types.Alert{Alert: model.Alert{
+		StartsAt: time.Now(),
+		EndsAt:   time.Now().Add(time.Hour),
+		Labels:   model.LabelSet{"Message": "m", "Description": "d"},
+	}}
+
+	for _, tc := range []struct {
+		name         string
+		createStatus int
+		noteStatus   int
+		wantErr      bool
+		wantRetry    bool
+	}{
+		{name: "note_404_is_dropped", createStatus: http.StatusAccepted, noteStatus: http.StatusNotFound, wantErr: false, wantRetry: true},
+		{name: "note_429_still_retries", createStatus: http.StatusAccepted, noteStatus: http.StatusTooManyRequests, wantErr: true, wantRetry: true},
+		{name: "create_404_still_fails", createStatus: http.StatusNotFound, noteStatus: http.StatusAccepted, wantErr: true, wantRetry: false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if strings.HasSuffix(r.URL.Path, "/notes") {
+					w.WriteHeader(tc.noteStatus)
+					return
+				}
+				w.WriteHeader(tc.createStatus)
+			}))
+			defer srv.Close()
+
+			u, err := url.Parse(srv.URL)
+			require.NoError(t, err)
+			notifier, err := New(&config.OpsGenieConfig{
+				Message:     `{{ .CommonLabels.Message }}`,
+				Description: `{{ .CommonLabels.Description }}`,
+				APIKey:      "k",
+				APIURL:      &config.URL{URL: u},
+				HTTPConfig:  &commoncfg.HTTPClientConfig{},
+			}, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl), true)
+			require.NoError(t, err)
+
+			retry, err := notifier.Notify(ctx, firing)
+			if tc.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+			assert.Equal(t, tc.wantRetry, retry)
+		})
+	}
+}
+
 func TestOpsGenieApiKeyFile(t *testing.T) {
 	u, err := url.Parse("https://test-opsgenie-url")
 	require.NoError(t, err)
@@ -335,7 +447,7 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 		APIURL:     &config.URL{URL: u},
 		HTTPConfig: &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl), false)
 
 	require.NoError(t, err)
 	requests, _, err := notifierWithUpdate.createRequests(ctx)
@@ -437,6 +549,109 @@ func TestPrepareContent(t *testing.T) {
 	})
 }
 
+func TestShrinkMarkdownToFit(t *testing.T) {
+	cases := []struct {
+		name      string
+		md        string
+		budget    int
+		wantEmpty bool
+	}{
+		{"fits untouched", "**bold** text", 1000, false},
+		{"shrinks to fit", strings.Repeat("lorem ipsum ", 500), 1000, false},
+		{"budget too small", strings.Repeat("lorem ipsum ", 500), 10, true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, err := shrinkMarkdownToFit(c.md, c.budget)
+			require.NoError(t, err)
+			if c.wantEmpty {
+				assert.Empty(t, got)
+				return
+			}
+			assert.NotEmpty(t, got)
+			assert.LessOrEqual(t, utf8.RuneCountInString(got), c.budget)
+			assert.Equal(t, strings.Count(got, "<p>"), strings.Count(got, "</p>"))
+		})
+	}
+}
+
+func TestBuildHTMLDescriptionOverflow(t *testing.T) {
+	bigPart := strings.Repeat("alpha beta gamma ", 100)
+	cases := []struct {
+		name        string
+		parts       []string
+		budget      int
+		wantTrailer bool
+	}{
+		{"all parts fit", []string{"**a**", "**b**"}, maxDescriptionLenRunes, false},
+		{"empty parts skipped", []string{"", "hello", ""}, maxDescriptionLenRunes, false},
+		{"overflow drops parts with trailer", repeatParts(bigPart, 12), maxDescriptionLenRunes, true},
+		{"single huge part shrunk without trailer", []string{strings.Repeat(bigPart, 20)}, maxDescriptionLenRunes, false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, err := buildHTMLDescription(c.parts, c.budget)
+			require.NoError(t, err)
+			assert.LessOrEqual(t, utf8.RuneCountInString(got), c.budget)
+			assert.Equal(t, strings.Count(got, "<div>"), strings.Count(got, "</div>"))
+			assert.True(t, strings.HasSuffix(got, "</div>"))
+			if c.wantTrailer {
+				assert.Regexp(t, `…and \d+ more alerts\. Open in SigNoz for the full list\.`, got)
+			} else {
+				assert.NotContains(t, got, "more alerts")
+			}
+		})
+	}
+}
+
+// prepareContent end-to-end: 40 custom-template alerts overflow the description
+// budget yet the posted HTML stays within limits and well-formed.
+func TestPrepareContentDescriptionOverflow(t *testing.T) {
+	tmpl := test.CreateTmpl(t)
+	notifier := &Notifier{
+		conf: &config.OpsGenieConfig{
+			Message:     `{{ .CommonLabels.alertname }}`,
+			Description: `{{ .CommonLabels.alertname }}`,
+		},
+		tmpl:             tmpl,
+		logger:           promslog.NewNopLogger(),
+		templater:        newTestTemplater(tmpl),
+		advancedFeatures: true,
+	}
+
+	bodyTemplate := "**Alert in** $labels.namespace\n\n" + strings.Repeat("detail line for the runbook ", 30)
+	alerts := make([]*types.Alert, 0, 40)
+	for i := range 40 {
+		alerts = append(alerts, &types.Alert{
+			Alert: model.Alert{
+				Labels: model.LabelSet{
+					"alertname": "overflow",
+					"namespace": model.LabelValue(fmt.Sprintf("ns-%d", i)),
+				},
+				Annotations: model.LabelSet{
+					ruletypes.AnnotationBodyTemplate: model.LabelValue(bodyTemplate),
+				},
+				StartsAt: time.Now(),
+				EndsAt:   time.Now().Add(time.Hour),
+			},
+		})
+	}
+
+	_, desc, err := notifier.prepareContent(notify.WithGroupKey(context.Background(), "1"), alerts)
+	require.NoError(t, err)
+	assert.LessOrEqual(t, utf8.RuneCountInString(desc), maxDescriptionLenRunes)
+	assert.Equal(t, strings.Count(desc, "<div>"), strings.Count(desc, "</div>"))
+	assert.Regexp(t, `…and \d+ more alerts\. Open in SigNoz for the full list\.`, desc)
+}
+
+func repeatParts(part string, n int) []string {
+	parts := make([]string, n)
+	for i := range parts {
+		parts[i] = part
+	}
+	return parts
+}
+
 func readBody(t *testing.T, r *http.Request) string {
 	t.Helper()
 	body, err := io.ReadAll(r.Body)

pkg/alertmanager/alertmanagernotify/receiver.go

@@ -6,6 +6,8 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/email"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/googlechat"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/jira"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/jsmops"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/msteamsv2"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/opsgenie"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/pagerduty"
@@ -26,6 +28,8 @@ var customNotifierIntegrations = []string{
 	slack.Integration,
 	msteamsv2.Integration,
 	googlechat.Integration,
+	jira.Integration,
+	jsmops.Integration,
 }
 
 func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {
@@ -66,7 +70,7 @@ func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Temp
 		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l, templater) })
 	}
 	for i, c := range nc.OpsGenieConfigs {
-		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l, templater) })
+		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l, templater, false) })
 	}
 	for i, c := range nc.SlackConfigs {
 		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l, templater) })
@@ -81,6 +85,16 @@ func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Temp
 			return googlechat.New(c, tmpl, l, templater)
 		})
 	}
+	for i, c := range nc.JiraConfigs {
+		add(jira.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
+			return jira.New(c, tmpl, l, templater)
+		})
+	}
+	for i, c := range nc.JSMOpsConfigs {
+		add(jsmops.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
+			return jsmops.New(c, tmpl, l, templater, true)
+		})
+	}
 
 	if errs.Len() > 0 {
 		return nil, &errs

pkg/modules/fields/implfields/handler.go

@@ -82,6 +82,7 @@ func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Reques
 
 	values := &telemetrytypes.TelemetryFieldValues{
 		StringValues:  allValues.StringValues,
+		BoolValues:    allValues.BoolValues,
 		NumberValues:  allValues.NumberValues,
 		RelatedValues: relatedValues,
 	}

pkg/sqlmigration/030_create_quick_filters.go

@@ -3,12 +3,13 @@ package sqlmigration
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"github.com/uptrace/bun/migrate"
@@ -39,6 +40,52 @@ func (m *createQuickFilters) Register(migrations *migrate.Migrations) error {
 }
 
 func (m *createQuickFilters) Up(ctx context.Context, db *bun.DB) error {
+	// Frozen copy of the defaults as this migration shipped (hence the old
+	// camelCase keys); migrations must not read live types. 031 replaces these rows.
+	defaultFilters := []struct {
+		signal  string
+		filters []map[string]any
+	}{
+		{"traces", []map[string]any{
+			{"key": "duration_nano", "dataType": "float64", "type": "tag"},
+			{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+			{"key": "hasError", "dataType": "bool", "type": "tag"},
+			{"key": "serviceName", "dataType": "string", "type": "tag"},
+			{"key": "name", "dataType": "string", "type": "resource"},
+			{"key": "rpcMethod", "dataType": "string", "type": "tag"},
+			{"key": "responseStatusCode", "dataType": "string", "type": "resource"},
+			{"key": "httpHost", "dataType": "string", "type": "tag"},
+			{"key": "httpMethod", "dataType": "string", "type": "tag"},
+			{"key": "httpRoute", "dataType": "string", "type": "tag"},
+			{"key": "httpUrl", "dataType": "string", "type": "tag"},
+			{"key": "traceID", "dataType": "string", "type": "tag"},
+		}},
+		{"logs", []map[string]any{
+			{"key": "severity_text", "dataType": "string", "type": "resource"},
+			{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+			{"key": "serviceName", "dataType": "string", "type": "tag"},
+			{"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"},
+		}},
+		{"api_monitoring", []map[string]any{
+			{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+			{"key": "serviceName", "dataType": "string", "type": "tag"},
+			{"key": "rpcMethod", "dataType": "string", "type": "tag"},
+		}},
+		{"exceptions", []map[string]any{
+			{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+			{"key": "serviceName", "dataType": "string", "type": "tag"},
+			{"key": "host.name", "dataType": "string", "type": "resource"},
+			{"key": "k8s.cluster.name", "dataType": "string", "type": "tag"},
+			{"key": "k8s.deployment.name", "dataType": "string", "type": "resource"},
+			{"key": "k8s.namespace.name", "dataType": "string", "type": "tag"},
+			{"key": "k8s.pod.name", "dataType": "string", "type": "tag"},
+		}},
+	}
+
 	tx, err := db.BeginTx(ctx, nil)
 	if err != nil {
 		return err
@@ -72,15 +119,31 @@ func (m *createQuickFilters) Up(ctx context.Context, db *bun.DB) error {
 		return err
 	}
 
-	// Get the default quick filters
-	storableQuickFilters, err := quickfiltertypes.NewDefaultQuickFilter(defaultOrg)
-	if err != nil {
-		return err
+	now := time.Now()
+	quickFilters := make([]*quickFilter, 0, len(defaultFilters))
+	for _, defaultFilter := range defaultFilters {
+		filterJSON, err := json.Marshal(defaultFilter.filters)
+		if err != nil {
+			return err
+		}
+
+		quickFilters = append(quickFilters, &quickFilter{
+			Identifiable: types.Identifiable{
+				ID: valuer.GenerateUUID(),
+			},
+			OrgID:  defaultOrg.StringValue(),
+			Filter: string(filterJSON),
+			Signal: defaultFilter.signal,
+			TimeAuditable: types.TimeAuditable{
+				CreatedAt: now,
+				UpdatedAt: now,
+			},
+		})
 	}
 
 	// Insert all filters at once
 	_, err = tx.NewInsert().
-		Model(&storableQuickFilters).
+		Model(&quickFilters).
 		Exec(ctx)
 
 	if err != nil {

pkg/sqlmigration/031_update_quick_filters.go

@@ -3,11 +3,13 @@ package sqlmigration
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
+	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"github.com/uptrace/bun/migrate"
@@ -38,6 +40,61 @@ func (migration *updateQuickFilters) Register(migrations *migrate.Migrations) er
 }
 
 func (migration *updateQuickFilters) Up(ctx context.Context, db *bun.DB) error {
+	// Frozen copy of the defaults as this migration shipped; migrations must not
+	// read live types. api_monitoring's service.name is "tag" here — 035 fixes it.
+	defaultFilters := []struct {
+		signal  string
+		filters []map[string]any
+	}{
+		{"traces", []map[string]any{
+			{"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"},
+		}},
+		{"logs", []map[string]any{
+			{"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"},
+		}},
+		{"api_monitoring", []map[string]any{
+			{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+			{"key": "service.name", "dataType": "string", "type": "tag"},
+			{"key": "rpc.method", "dataType": "string", "type": "tag"},
+		}},
+		{"exceptions", []map[string]any{
+			{"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"},
+		}},
+	}
+
+	signalFilters := make([]struct{ signal, filter string }, 0, len(defaultFilters))
+	for _, defaultFilter := range defaultFilters {
+		filterJSON, err := json.Marshal(defaultFilter.filters)
+		if err != nil {
+			return err
+		}
+		signalFilters = append(signalFilters, struct{ signal, filter string }{defaultFilter.signal, string(filterJSON)})
+	}
+
 	tx, err := db.BeginTx(ctx, nil)
 	if err != nil {
 		return err
@@ -73,17 +130,28 @@ func (migration *updateQuickFilters) Up(ctx context.Context, db *bun.DB) error {
 		return err
 	}
 
-	// For each organization, create new quick filters with the updated NewDefaultQuickFilter function
+	// For each organization, create new quick filters with the updated defaults
 	for _, orgID := range orgIDs {
-		// Get the updated default quick filters
-		storableQuickFilters, err := quickfiltertypes.NewDefaultQuickFilter(valuer.MustNewUUID(orgID))
-		if err != nil {
-			return err
+		now := time.Now()
+		quickFilters := make([]*quickFilter, 0, len(signalFilters))
+		for _, signalFilter := range signalFilters {
+			quickFilters = append(quickFilters, &quickFilter{
+				Identifiable: types.Identifiable{
+					ID: valuer.GenerateUUID(),
+				},
+				OrgID:  orgID,
+				Filter: signalFilter.filter,
+				Signal: signalFilter.signal,
+				TimeAuditable: types.TimeAuditable{
+					CreatedAt: now,
+					UpdatedAt: now,
+				},
+			})
 		}
 
 		// Insert all filters for this organization
 		_, err = tx.NewInsert().
-			Model(&storableQuickFilters).
+			Model(&quickFilters).
 			Exec(ctx)
 
 		if err != nil {

pkg/sqlmigration/035_update_api_monitoring_filters.go

@@ -2,20 +2,16 @@ package sqlmigration
 
 import (
 	"context"
-	"database/sql"
+	"encoding/json"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/quickfiltertypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 	"github.com/uptrace/bun/migrate"
 )
 
-type updateApiMonitoringFilters struct {
-	store sqlstore.SQLStore
-}
+type updateApiMonitoringFilters struct{}
 
 func NewUpdateApiMonitoringFiltersFactory(store sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
 	return factory.NewProviderFactory(factory.MustNewName("update_api_monitoring_filters"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
@@ -23,10 +19,8 @@ func NewUpdateApiMonitoringFiltersFactory(store sqlstore.SQLStore) factory.Provi
 	})
 }
 
-func newUpdateApiMonitoringFilters(_ context.Context, _ factory.ProviderSettings, _ Config, store sqlstore.SQLStore) (SQLMigration, error) {
-	return &updateApiMonitoringFilters{
-		store: store,
-	}, nil
+func newUpdateApiMonitoringFilters(_ context.Context, _ factory.ProviderSettings, _ Config, _ sqlstore.SQLStore) (SQLMigration, error) {
+	return &updateApiMonitoringFilters{}, nil
 }
 
 func (migration *updateApiMonitoringFilters) Register(migrations *migrate.Migrations) error {
@@ -38,63 +32,29 @@ func (migration *updateApiMonitoringFilters) Register(migrations *migrate.Migrat
 }
 
 func (migration *updateApiMonitoringFilters) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
+	// Frozen copy of the api_monitoring defaults as this migration shipped; the
+	// change over 031 is service.name moving from "tag" to "resource".
+	apiMonitoringFilters := []map[string]any{
+		{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+		{"key": "service.name", "dataType": "string", "type": "resource"},
+		{"key": "rpc.method", "dataType": "string", "type": "tag"},
+	}
+
+	apiMonitoringFilterJSON, err := json.Marshal(apiMonitoringFilters)
 	if err != nil {
 		return err
 	}
 
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	// Get all organization IDs as strings
-	var orgIDs []string
-	err = tx.NewSelect().
-		Table("organizations").
-		Column("id").
-		Scan(ctx, &orgIDs)
+	// The filter JSON is org-independent, so one update covers every org's row.
+	_, err = db.NewUpdate().
+		Table("quick_filter").
+		Set("filter = ?, updated_at = ?", string(apiMonitoringFilterJSON), time.Now()).
+		Where("signal = ?", "api_monitoring").
+		Exec(ctx)
 	if err != nil {
-		if err == sql.ErrNoRows {
-			if err := tx.Commit(); err != nil {
-				return err
-			}
-			return nil
-		}
 		return err
 	}
 
-	for _, orgID := range orgIDs {
-		// Get the updated default quick filters which includes the new API monitoring filters
-		storableQuickFilters, err := quickfiltertypes.NewDefaultQuickFilter(valuer.MustNewUUID(orgID))
-		if err != nil {
-			return err
-		}
-
-		// Find the API monitoring filter from the storable quick filters
-		var apiMonitoringFilterJSON string
-		for _, filter := range storableQuickFilters {
-			if filter.Signal == quickfiltertypes.SignalApiMonitoring {
-				apiMonitoringFilterJSON = filter.Filter
-				break
-			}
-		}
-
-		if apiMonitoringFilterJSON != "" {
-			_, err = tx.NewUpdate().
-				Table("quick_filter").
-				Set("filter = ?, updated_at = ?", apiMonitoringFilterJSON, time.Now()).
-				Where("signal = ? AND org_id = ?", quickfiltertypes.SignalApiMonitoring, orgID).
-				Exec(ctx)
-
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	if err := tx.Commit(); err != nil {
-		return err
-	}
 	return nil
 }
 

pkg/telemetrymetadata/bool_values.go

@@ -0,0 +1,43 @@
+package telemetrymetadata
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// boolFieldValues is the suggestion set for a bool field, optionally narrowed
+// by the search text.
+func boolFieldValues(searchText string) *telemetrytypes.TelemetryFieldValues {
+	values := &telemetrytypes.TelemetryFieldValues{}
+	needle := strings.ToLower(searchText)
+	for _, v := range []bool{true, false} {
+		if needle == "" || strings.Contains(strconv.FormatBool(v), needle) {
+			values.BoolValues = append(values.BoolValues, v)
+		}
+	}
+	return values
+}
+
+// isKnownBoolField is true when the caller asked for the bool data type, or
+// when the name is one of the signal's static bool fields and the requested
+// context does not rule that static field out.
+func isKnownBoolField(selector *telemetrytypes.FieldValueSelector, staticFields ...map[string]telemetrytypes.TelemetryFieldKey) bool {
+	if selector.FieldDataType == telemetrytypes.FieldDataTypeBool {
+		return true
+	}
+	if selector.FieldDataType != telemetrytypes.FieldDataTypeUnspecified {
+		return false
+	}
+	for _, fields := range staticFields {
+		field, ok := fields[selector.Name]
+		if !ok || field.FieldDataType != telemetrytypes.FieldDataTypeBool {
+			continue
+		}
+		if selector.FieldContext == telemetrytypes.FieldContextUnspecified || selector.FieldContext == field.FieldContext {
+			return true
+		}
+	}
+	return false
+}

pkg/telemetrymetadata/metadata.go

@@ -187,8 +187,6 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 	).From(t.tracesDBName + "." + t.spanAttributesKeysTblName)
 	var limit int
 
-	searchTexts := []string{}
-
 	conds := []string{}
 	for _, fieldKeySelector := range fieldKeySelectors {
 
@@ -208,7 +206,6 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 			fieldKeyConds = append(fieldKeyConds, sb.ILike("tagKey", "%"+escapeForLike(fieldKeySelector.Name)+"%"))
 		}
 
-		searchTexts = append(searchTexts, fieldKeySelector.Name)
 		// now look at the field context
 		// we don't write most of intrinsic fields to keys table
 		// for this reason we don't want to apply tagType if the field context
@@ -288,41 +285,23 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 	// hit the limit? (only counting DB results)
 	complete := rowCount <= limit
 
-	staticKeys := []string{"isRoot", "isEntryPoint"}
-	staticKeys = append(staticKeys, maps.Keys(tracestelemetryschema.IntrinsicFields)...)
-	staticKeys = append(staticKeys, maps.Keys(tracestelemetryschema.CalculatedFields)...)
+	// Add the matching static fields: the span scope selectors, the intrinsic
+	// columns and the calculated columns. These don't count towards the limit
+	staticFields := []telemetrytypes.TelemetryFieldKey{
+		{Name: "isRoot", Signal: telemetrytypes.SignalTraces, FieldContext: telemetrytypes.FieldContextSpan, FieldDataType: telemetrytypes.FieldDataTypeBool},
+		{Name: "isEntryPoint", Signal: telemetrytypes.SignalTraces, FieldContext: telemetrytypes.FieldContextSpan, FieldDataType: telemetrytypes.FieldDataTypeBool},
+	}
+	staticFields = append(staticFields, maps.Values(tracestelemetryschema.IntrinsicFields)...)
+	staticFields = append(staticFields, maps.Values(tracestelemetryschema.CalculatedFields)...)
 
-	// Add matching intrinsic and matching calculated fields
-	// These don't count towards the limit
-	for _, key := range staticKeys {
-		found := false
-		for _, v := range searchTexts {
-			if v == "" || strings.Contains(key, v) {
-				found = true
-				break
-			}
+	for _, field := range staticFields {
+		if !staticFieldMatchesAny(field, fieldKeySelectors) {
+			continue
 		}
-
-		if found {
-			if field, exists := tracestelemetryschema.IntrinsicFields[key]; exists {
-				if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; !added {
-					keys = append(keys, &field)
-				}
-				continue
-			}
-
-			if field, exists := tracestelemetryschema.CalculatedFields[key]; exists {
-				if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; !added {
-					keys = append(keys, &field)
-				}
-				continue
-			}
-			keys = append(keys, &telemetrytypes.TelemetryFieldKey{
-				Name:         key,
-				FieldContext: telemetrytypes.FieldContextSpan,
-				Signal:       telemetrytypes.SignalTraces,
-			})
+		if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; added {
+			continue
 		}
+		keys = append(keys, &field)
 	}
 
 	if err = t.updateColumnEvolutionMetadataForKeys(ctx, keys); err != nil {
@@ -542,12 +521,6 @@ func (t *telemetryMetaStore) getLogsKeys(ctx context.Context, orgID valuer.UUID,
 		allArgs = append(allArgs, args...)
 	}
 
-	if len(queries) == 0 {
-		// No matching contexts, return empty result
-		return []*telemetrytypes.TelemetryFieldKey{}, true, nil
-	}
-
-	// Combine queries with UNION ALL
 	var limit int
 	for _, fieldKeySelector := range fieldKeySelectors {
 		limit += fieldKeySelector.Limit
@@ -556,7 +529,15 @@ func (t *telemetryMetaStore) getLogsKeys(ctx context.Context, orgID valuer.UUID,
 		limit = 1000
 	}
 
-	mainQuery := fmt.Sprintf(`
+	keys := []*telemetrytypes.TelemetryFieldKey{}
+	parentTypes := make(map[string][]telemetrytypes.FieldDataType)
+	rowCount := 0
+
+	// the log and scope contexts have no keys table; they are served by the
+	// static fields appended below
+	if len(queries) > 0 {
+		// Combine queries with UNION ALL
+		mainQuery := fmt.Sprintf(`
 		SELECT tag_key, tag_type, tag_data_type, max(priority) as priority
 		FROM (
 			%s
@@ -566,103 +547,75 @@ func (t *telemetryMetaStore) getLogsKeys(ctx context.Context, orgID valuer.UUID,
 		LIMIT %d
 	`, strings.Join(queries, " UNION ALL "), limit+1)
 
-	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, mainQuery, allArgs...)
-	if err != nil {
-		return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
-	}
-	defer rows.Close()
-
-	keys := []*telemetrytypes.TelemetryFieldKey{}
-	parentTypes := make(map[string][]telemetrytypes.FieldDataType)
-	rowCount := 0
-	searchTexts := []string{}
-
-	// Collect search texts for static field matching
-	for _, fieldKeySelector := range fieldKeySelectors {
-		searchTexts = append(searchTexts, fieldKeySelector.Name)
-	}
-
-	for rows.Next() {
-		rowCount++
-		// reached the limit, we know there are more results
-		if rowCount > limit {
-			break
-		}
-
-		var name string
-		var fieldContext telemetrytypes.FieldContext
-		var fieldDataType telemetrytypes.FieldDataType
-		var priority uint8
-		err = rows.Scan(&name, &fieldContext, &fieldDataType, &priority)
+		rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, mainQuery, allArgs...)
 		if err != nil {
 			return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
 		}
+		defer rows.Close()
 
-		// ArrayJSON/ArrayDynamic body rows for parent paths are needed by the JSON access plan
-		// builder (enrichJSONKeys). Always record them in parentTypes. Only skip adding to keys
-		// if the user did not also directly request this name — a field like "education" can be
-		// both a parent of "education[].name" and an explicitly queried field in its own right.
-		switch fieldDataType {
-		case telemetrytypes.FieldDataTypeArrayJSON, telemetrytypes.FieldDataTypeArrayDynamic:
-			if fieldContext == telemetrytypes.FieldContextBody && parentPaths[name] {
-				parentTypes[name] = append(parentTypes[name], fieldDataType)
-				if !mapOfRequestedSelectors[name] {
-					continue // skip; don't register the key.
+		for rows.Next() {
+			rowCount++
+			// reached the limit, we know there are more results
+			if rowCount > limit {
+				break
+			}
+
+			var name string
+			var fieldContext telemetrytypes.FieldContext
+			var fieldDataType telemetrytypes.FieldDataType
+			var priority uint8
+			err = rows.Scan(&name, &fieldContext, &fieldDataType, &priority)
+			if err != nil {
+				return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
+			}
+
+			// ArrayJSON/ArrayDynamic body rows for parent paths are needed by the JSON access plan
+			// builder (enrichJSONKeys). Always record them in parentTypes. Only skip adding to keys
+			// if the user did not also directly request this name — a field like "education" can be
+			// both a parent of "education[].name" and an explicitly queried field in its own right.
+			switch fieldDataType {
+			case telemetrytypes.FieldDataTypeArrayJSON, telemetrytypes.FieldDataTypeArrayDynamic:
+				if fieldContext == telemetrytypes.FieldContextBody && parentPaths[name] {
+					parentTypes[name] = append(parentTypes[name], fieldDataType)
+					if !mapOfRequestedSelectors[name] {
+						continue // skip; don't register the key.
+					}
 				}
 			}
-		}
 
-		key, ok := mapOfKeys[name+";"+fieldContext.StringValue()+";"+fieldDataType.StringValue()]
+			key, ok := mapOfKeys[name+";"+fieldContext.StringValue()+";"+fieldDataType.StringValue()]
 
-		// if there is no materialised column, create a key with the field context and data type
-		if !ok {
-			key = &telemetrytypes.TelemetryFieldKey{
-				Name:          name,
-				Signal:        telemetrytypes.SignalLogs,
-				FieldContext:  fieldContext,
-				FieldDataType: fieldDataType,
+			// if there is no materialised column, create a key with the field context and data type
+			if !ok {
+				key = &telemetrytypes.TelemetryFieldKey{
+					Name:          name,
+					Signal:        telemetrytypes.SignalLogs,
+					FieldContext:  fieldContext,
+					FieldDataType: fieldDataType,
+				}
 			}
+
+			keys = append(keys, key)
+			mapOfKeys[name+";"+fieldContext.StringValue()+";"+fieldDataType.StringValue()] = key
 		}
 
-		keys = append(keys, key)
-		mapOfKeys[name+";"+fieldContext.StringValue()+";"+fieldDataType.StringValue()] = key
-	}
-
-	if rows.Err() != nil {
-		return nil, false, errors.Wrap(rows.Err(), errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
+		if rows.Err() != nil {
+			return nil, false, errors.Wrap(rows.Err(), errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
+		}
 	}
 
 	// hit the limit? (only counting DB results)
 	complete := rowCount <= limit
 
-	staticKeys := []string{}
-	staticKeys = append(staticKeys, maps.Keys(logstelemetryschema.IntrinsicFields)...)
-
-	// Add matching intrinsic and matching calculated fields
-	// These don't count towards the limit
-	for _, key := range staticKeys {
-		found := false
-		for _, v := range searchTexts {
-			if v == "" || strings.Contains(key, v) {
-				found = true
-				break
-			}
+	// Add the matching intrinsic columns. These don't count towards the limit
+	for _, field := range maps.Values(logstelemetryschema.IntrinsicFields) {
+		if !staticFieldMatchesAny(field, fieldKeySelectors) {
+			continue
 		}
-
-		if found {
-			if field, exists := logstelemetryschema.IntrinsicFields[key]; exists {
-				if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; !added {
-					keys = append(keys, &field)
-				}
-				continue
-			}
-
-			keys = append(keys, &telemetrytypes.TelemetryFieldKey{
-				Name:         key,
-				FieldContext: telemetrytypes.FieldContextLog,
-				Signal:       telemetrytypes.SignalLogs,
-			})
+		if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; added {
+			continue
 		}
+		keys = append(keys, &field)
 	}
 
 	// enrich body keys with promoted paths, indexes, and JSON access plans
@@ -836,11 +789,6 @@ func (t *telemetryMetaStore) getAuditKeys(ctx context.Context, fieldKeySelectors
 
 	keys := []*telemetrytypes.TelemetryFieldKey{}
 	rowCount := 0
-	searchTexts := []string{}
-
-	for _, fieldKeySelector := range fieldKeySelectors {
-		searchTexts = append(searchTexts, fieldKeySelector.Name)
-	}
 
 	for rows.Next() {
 		rowCount++
@@ -877,24 +825,15 @@ func (t *telemetryMetaStore) getAuditKeys(ctx context.Context, fieldKeySelectors
 
 	complete := rowCount <= limit
 
-	// Add intrinsic audit fields (same as logs intrinsics: body, severity_text, etc.)
-	staticKeys := maps.Keys(audittelemetryschema.IntrinsicFields)
-	for _, key := range staticKeys {
-		found := false
-		for _, v := range searchTexts {
-			if v == "" || strings.Contains(key, v) {
-				found = true
-				break
-			}
+	// Add the matching intrinsic audit fields (same as logs intrinsics: body, severity_text, etc.)
+	for _, field := range maps.Values(audittelemetryschema.IntrinsicFields) {
+		if !staticFieldMatchesAny(field, fieldKeySelectors) {
+			continue
 		}
-
-		if found {
-			if field, exists := audittelemetryschema.IntrinsicFields[key]; exists {
-				if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; !added {
-					keys = append(keys, &field)
-				}
-			}
+		if _, added := mapOfKeys[field.Name+";"+field.FieldContext.StringValue()+";"+field.FieldDataType.StringValue()]; added {
+			continue
 		}
+		keys = append(keys, &field)
 	}
 
 	return keys, complete, nil
@@ -1091,9 +1030,12 @@ func (t *telemetryMetaStore) getMeterSourceMetricKeys(ctx context.Context, field
 		if err != nil {
 			return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetMeterKeys.Error())
 		}
+		// meter labels are stored as strings in the labels JSON and have no
+		// attribute context, so only the data type is known
 		keys = append(keys, &telemetrytypes.TelemetryFieldKey{
-			Name:   name,
-			Signal: telemetrytypes.SignalMetrics,
+			Name:          name,
+			Signal:        telemetrytypes.SignalMetrics,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
 		})
 	}
 
@@ -1512,12 +1454,24 @@ func (t *telemetryMetaStore) getSpanFieldValues(ctx context.Context, fieldValueS
 		limit = 50
 	}
 
-	sb := sqlbuilder.Select("DISTINCT string_value, number_value").From(t.tracesDBName + "." + t.tracesFieldsTblName)
+	// bool rows in the tag table carry no value; the two possible values are
+	// known without a query
+	if isKnownBoolField(fieldValueSelector, tracestelemetryschema.IntrinsicFields, tracestelemetryschema.CalculatedFields) {
+		return boolFieldValues(fieldValueSelector.Value), true, nil
+	}
+
+	sb := sqlbuilder.Select("DISTINCT string_value, number_value, tag_data_type").From(t.tracesDBName + "." + t.tracesFieldsTblName)
 
 	if fieldValueSelector.Name != "" {
 		sb.Where(sb.E("tag_key", fieldValueSelector.Name))
 	}
 
+	// unix_milli is the hour bucket a value was written in and rows are
+	// deduplicated per day, so this is a day-granular "seen since" filter
+	if fieldValueSelector.StartUnixMilli != 0 {
+		sb.Where(sb.GE("unix_milli", fieldValueSelector.StartUnixMilli))
+	}
+
 	// now look at the field context
 	if fieldValueSelector.FieldContext != telemetrytypes.FieldContextUnspecified {
 		sb.Where(sb.E("tag_type", fieldValueSelector.FieldContext.TagType()))
@@ -1565,10 +1519,20 @@ func (t *telemetryMetaStore) getSpanFieldValues(ctx context.Context, fieldValueS
 
 		var stringValue string
 		var numberValue float64
-		if err := rows.Scan(&stringValue, &numberValue); err != nil {
+		var tagDataType string
+		if err := rows.Scan(&stringValue, &numberValue, &tagDataType); err != nil {
 			return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
 		}
 
+		// bool rows carry no value; the key's presence is enough to know the
+		// two values it can take
+		if tagDataType == telemetrytypes.FieldDataTypeBool.TagDataType() {
+			if len(values.BoolValues) == 0 {
+				values.BoolValues = boolFieldValues(fieldValueSelector.Value).BoolValues
+			}
+			continue
+		}
+
 		// Only add values if we haven't hit the limit yet
 		if totalCount < limit {
 			if _, ok := seen[stringValue]; !ok && stringValue != "" {
@@ -1602,12 +1566,24 @@ func (t *telemetryMetaStore) getLogFieldValues(ctx context.Context, fieldValueSe
 		limit = 50
 	}
 
-	sb := sqlbuilder.Select("DISTINCT string_value, number_value").From(t.logsDBName + "." + t.logsFieldsTblName)
+	// bool rows in the tag table carry no value; the two possible values are
+	// known without a query
+	if isKnownBoolField(fieldValueSelector, logstelemetryschema.IntrinsicFields) {
+		return boolFieldValues(fieldValueSelector.Value), true, nil
+	}
+
+	sb := sqlbuilder.Select("DISTINCT string_value, number_value, tag_data_type").From(t.logsDBName + "." + t.logsFieldsTblName)
 
 	if fieldValueSelector.Name != "" {
 		sb.Where(sb.E("tag_key", fieldValueSelector.Name))
 	}
 
+	// unix_milli is the hour bucket a value was written in and rows are
+	// deduplicated per day, so this is a day-granular "seen since" filter
+	if fieldValueSelector.StartUnixMilli != 0 {
+		sb.Where(sb.GE("unix_milli", fieldValueSelector.StartUnixMilli))
+	}
+
 	if fieldValueSelector.FieldContext != telemetrytypes.FieldContextUnspecified {
 		sb.Where(sb.E("tag_type", fieldValueSelector.FieldContext.TagType()))
 	}
@@ -1653,10 +1629,20 @@ func (t *telemetryMetaStore) getLogFieldValues(ctx context.Context, fieldValueSe
 
 		var stringValue string
 		var numberValue float64
-		if err := rows.Scan(&stringValue, &numberValue); err != nil {
+		var tagDataType string
+		if err := rows.Scan(&stringValue, &numberValue, &tagDataType); err != nil {
 			return nil, false, errors.Wrap(err, errors.TypeInternal, errors.CodeInternal, ErrFailedToGetLogsKeys.Error())
 		}
 
+		// bool rows carry no value; the key's presence is enough to know the
+		// two values it can take
+		if tagDataType == telemetrytypes.FieldDataTypeBool.TagDataType() {
+			if len(values.BoolValues) == 0 {
+				values.BoolValues = boolFieldValues(fieldValueSelector.Value).BoolValues
+			}
+			continue
+		}
+
 		// Only add values if we haven't hit the limit yet
 		if totalCount < limit {
 			if _, ok := seen[stringValue]; !ok && stringValue != "" {
@@ -2097,6 +2083,18 @@ func populateAllUnspecifiedValues(allUnspecifiedValues *telemetrytypes.Telemetry
 		}
 	}
 
+	for _, value := range values.BoolValues {
+		if totalCount >= limit {
+			complete = false
+			break
+		}
+		if _, ok := mapOfValues[value]; !ok {
+			mapOfValues[value] = true
+			allUnspecifiedValues.BoolValues = append(allUnspecifiedValues.BoolValues, value)
+			totalCount++
+		}
+	}
+
 	for _, value := range values.RelatedValues {
 		if totalCount >= limit {
 			complete = false
@@ -2467,6 +2465,10 @@ func (k *telemetryMetaStore) fetchEvolutionEntryFromClickHouse(ctx context.Conte
 
 // updateColumnEvolutionMetadataForKeys updates the evolution field for keys.
 func (k *telemetryMetaStore) updateColumnEvolutionMetadataForKeys(ctx context.Context, keysToUpdate []*telemetrytypes.TelemetryFieldKey) error {
+	// an empty selector list would run the evolution query without a filter
+	if len(keysToUpdate) == 0 {
+		return nil
+	}
 
 	var metadataKeySelectors []*telemetrytypes.EvolutionSelector
 	for _, keySelector := range keysToUpdate {

pkg/telemetrymetadata/static_fields.go

@@ -0,0 +1,53 @@
+package telemetrymetadata
+
+import (
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+func staticFieldMatchesAny(field telemetrytypes.TelemetryFieldKey, selectors []*telemetrytypes.FieldKeySelector) bool {
+	for _, selector := range selectors {
+		if staticFieldMatches(field, selector) {
+			return true
+		}
+	}
+	return false
+}
+
+// staticFieldMatches mirrors the keys-table lookup for a static field: the
+// requested context and data type, when given, must agree with the field's,
+// and the name matches case-insensitively, as a substring for fuzzy selectors
+// and as the whole name for exact ones.
+func staticFieldMatches(field telemetrytypes.TelemetryFieldKey, selector *telemetrytypes.FieldKeySelector) bool {
+	if selector.FieldContext != telemetrytypes.FieldContextUnspecified && selector.FieldContext != field.FieldContext {
+		return false
+	}
+	if selector.FieldDataType != telemetrytypes.FieldDataTypeUnspecified && !sameDataTypeFamily(selector.FieldDataType, field.FieldDataType) {
+		return false
+	}
+	if selector.Name == "" {
+		return true
+	}
+	if selector.SelectorMatchType == telemetrytypes.FieldSelectorMatchTypeExact {
+		return strings.EqualFold(field.Name, selector.Name)
+	}
+	return strings.Contains(strings.ToLower(field.Name), strings.ToLower(selector.Name))
+}
+
+// sameDataTypeFamily treats the numeric types as one family: static fields
+// declare "number" while callers may ask for int64 or float64.
+func sameDataTypeFamily(requested, actual telemetrytypes.FieldDataType) bool {
+	if requested == actual {
+		return true
+	}
+	return isNumericDataType(requested) && isNumericDataType(actual)
+}
+
+func isNumericDataType(dataType telemetrytypes.FieldDataType) bool {
+	switch dataType {
+	case telemetrytypes.FieldDataTypeNumber, telemetrytypes.FieldDataTypeInt64, telemetrytypes.FieldDataTypeFloat64:
+		return true
+	}
+	return false
+}

pkg/templating/markdownrenderer/adf/adf.go

@@ -0,0 +1,173 @@
+// Package adf converts Markdown into Atlassian Document Format (ADF) nodes,
+// the JSON rich-text format used by Jira Cloud's v3 API.
+package adf
+
+import (
+	"strings"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/extension"
+	extast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/text"
+)
+
+// parser is stateless across Parse calls and safe for concurrent use; only
+// goldmark's renderers hold per-document state (which we don't use). Strikethrough
+// is included for the strike mark; linkify is deliberately omitted since it
+// fragments plain text into word tokens while scanning for bare URLs.
+var parser = goldmark.New(goldmark.WithExtensions(extension.Strikethrough)).Parser()
+
+// Render returns the ADF block nodes for markdown (without the doc wrapper),
+// so callers can embed them alongside their own nodes (panels, links, …).
+func Render(markdown string) []any {
+	src := []byte(markdown)
+	return blockChildren(parser.Parse(text.NewReader(src)), src)
+}
+
+func blockChildren(parent ast.Node, src []byte) []any {
+	var out []any
+	for c := parent.FirstChild(); c != nil; c = c.NextSibling() {
+		if b := block(c, src); b != nil {
+			out = append(out, b)
+		}
+	}
+	return out
+}
+
+func block(n ast.Node, src []byte) any {
+	switch node := n.(type) {
+	case *ast.Heading:
+		return map[string]any{"type": "heading", "attrs": map[string]any{"level": node.Level}, "content": inlineChildren(node, src, nil)}
+	case *ast.Paragraph:
+		return paragraph(inlineChildren(node, src, nil))
+	case *ast.TextBlock:
+		return paragraph(inlineChildren(node, src, nil))
+	case *ast.List:
+		typ := "bulletList"
+		if node.IsOrdered() {
+			typ = "orderedList"
+		}
+		return map[string]any{"type": typ, "content": blockChildren(node, src)}
+	case *ast.ListItem:
+		return map[string]any{"type": "listItem", "content": blockChildren(node, src)}
+	case *ast.Blockquote:
+		return map[string]any{"type": "blockquote", "content": blockChildren(node, src)}
+	case *ast.FencedCodeBlock:
+		return codeBlock(codeText(node, src), string(node.Language(src)))
+	case *ast.CodeBlock:
+		return codeBlock(codeText(node, src), "")
+	case *ast.ThematicBreak:
+		return map[string]any{"type": "rule"}
+	default:
+		return nil
+	}
+}
+
+func paragraph(content []any) map[string]any {
+	p := map[string]any{"type": "paragraph"}
+	if len(content) > 0 {
+		p["content"] = content
+	}
+	return p
+}
+
+func codeBlock(code, lang string) map[string]any {
+	cb := map[string]any{"type": "codeBlock"}
+	if lang != "" {
+		cb["attrs"] = map[string]any{"language": lang}
+	}
+	if code = strings.TrimRight(code, "\n"); code != "" {
+		cb["content"] = []any{map[string]any{"type": "text", "text": code}}
+	}
+	return cb
+}
+
+// inlineChildren flattens an inline subtree into ADF text nodes, carrying the
+// active marks (strong/em/code/strike/link) down the tree.
+func inlineChildren(parent ast.Node, src []byte, marks []any) []any {
+	var out []any
+	for c := parent.FirstChild(); c != nil; c = c.NextSibling() {
+		switch node := c.(type) {
+		case *ast.Text:
+			if t := string(node.Segment.Value(src)); t != "" {
+				out = append(out, textNode(t, marks))
+			}
+			if node.HardLineBreak() {
+				out = append(out, map[string]any{"type": "hardBreak"})
+			} else if node.SoftLineBreak() {
+				out = append(out, textNode(" ", marks))
+			}
+		case *ast.String:
+			if len(node.Value) > 0 {
+				out = append(out, textNode(string(node.Value), marks))
+			}
+		case *ast.CodeSpan:
+			if t := rawText(node, src); t != "" {
+				out = append(out, textNode(t, withMark(marks, mark("code"))))
+			}
+		case *ast.Emphasis:
+			m := "em"
+			if node.Level == 2 {
+				m = "strong"
+			}
+			out = append(out, inlineChildren(node, src, withMark(marks, mark(m)))...)
+		case *extast.Strikethrough:
+			out = append(out, inlineChildren(node, src, withMark(marks, mark("strike")))...)
+		case *ast.Link:
+			out = append(out, inlineChildren(node, src, withMark(marks, linkMark(string(node.Destination))))...)
+		case *ast.AutoLink:
+			if u := string(node.URL(src)); u != "" {
+				out = append(out, textNode(u, withMark(marks, linkMark(u))))
+			}
+		default:
+			out = append(out, inlineChildren(c, src, marks)...)
+		}
+	}
+	return out
+}
+
+func textNode(s string, marks []any) map[string]any {
+	tn := map[string]any{"type": "text", "text": s}
+	if len(marks) > 0 {
+		tn["marks"] = marks
+	}
+	return tn
+}
+
+func mark(typ string) any { return map[string]any{"type": typ} }
+
+func linkMark(href string) any {
+	return map[string]any{"type": "link", "attrs": map[string]any{"href": href}}
+}
+
+func withMark(marks []any, m any) []any {
+	out := make([]any, 0, len(marks)+1)
+	out = append(out, marks...)
+	return append(out, m)
+}
+
+func rawText(n ast.Node, src []byte) string {
+	var b strings.Builder
+	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+		switch t := c.(type) {
+		case *ast.Text:
+			b.Write(t.Segment.Value(src))
+		case *ast.String:
+			b.Write(t.Value)
+		default:
+			b.WriteString(rawText(c, src))
+		}
+	}
+	return b.String()
+}
+
+func codeText(n ast.Node, src []byte) string {
+	var b strings.Builder
+	lines := n.Lines()
+	for i := 0; i < lines.Len(); i++ {
+		seg := lines.At(i)
+		b.Write(seg.Value(src))
+	}
+	return b.String()
+}

pkg/templating/markdownrenderer/adf/adf_test.go

@@ -0,0 +1,85 @@
+package adf
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func toJSON(t *testing.T, v any) string {
+	t.Helper()
+	b, err := json.Marshal(v)
+	require.NoError(t, err)
+	return string(b)
+}
+
+func TestRenderInlineMarks(t *testing.T) {
+	js := toJSON(t, Render("**bold** and *em* and `code` and [txt](https://x.io)"))
+	assert.Contains(t, js, `"type":"strong"`)
+	assert.Contains(t, js, `"type":"em"`)
+	assert.Contains(t, js, `"type":"code"`)
+	assert.Contains(t, js, `"type":"link"`)
+	assert.Contains(t, js, `"href":"https://x.io"`)
+	assert.Contains(t, js, `"text":"bold"`)
+}
+
+func TestRenderHeadingAndList(t *testing.T) {
+	js := toJSON(t, Render("# Title\n\n- a\n- b"))
+	assert.Contains(t, js, `"type":"heading"`)
+	assert.Contains(t, js, `"level":1`)
+	assert.Contains(t, js, `"type":"bulletList"`)
+	assert.Contains(t, js, `"type":"listItem"`)
+}
+
+func TestRenderOrderedList(t *testing.T) {
+	js := toJSON(t, Render("1. one\n2. two"))
+	assert.Contains(t, js, `"type":"orderedList"`)
+}
+
+func TestRenderCodeBlock(t *testing.T) {
+	js := toJSON(t, Render("```go\nx := 1\n```"))
+	assert.Contains(t, js, `"type":"codeBlock"`)
+	assert.Contains(t, js, `"language":"go"`)
+	assert.Contains(t, js, `x := 1`)
+}
+
+func TestRenderStrikethrough(t *testing.T) {
+	js := toJSON(t, Render("~~gone~~"))
+	assert.Contains(t, js, `"type":"strike"`)
+	assert.Contains(t, js, `"text":"gone"`)
+}
+
+func TestRenderBlockquote(t *testing.T) {
+	js := toJSON(t, Render("> quoted"))
+	assert.Contains(t, js, `"type":"blockquote"`)
+	assert.Contains(t, js, `"text":"quoted"`)
+}
+
+func TestRenderAutoLink(t *testing.T) {
+	js := toJSON(t, Render("see <https://signoz.io>"))
+	assert.Contains(t, js, `"type":"link"`)
+	assert.Contains(t, js, `"href":"https://signoz.io"`)
+	assert.Contains(t, js, `"text":"https://signoz.io"`)
+}
+
+func TestRenderLineBreaks(t *testing.T) {
+	js := toJSON(t, Render("one  \ntwo"))
+	assert.Contains(t, js, `"type":"hardBreak"`)
+
+	// a soft break renders as a space, keeping the paragraph intact
+	js = toJSON(t, Render("one\ntwo"))
+	assert.NotContains(t, js, `"type":"hardBreak"`)
+	assert.Contains(t, js, `"text":" "`)
+}
+
+func TestRenderPlainText(t *testing.T) {
+	js := toJSON(t, Render("just text"))
+	assert.Contains(t, js, `"type":"paragraph"`)
+	assert.Contains(t, js, `"text":"just text"`)
+}
+
+func TestRenderEmptyIsEmpty(t *testing.T) {
+	assert.Empty(t, Render(""))
+}

pkg/templating/markdownrenderer/markdownrenderer.go

@@ -7,6 +7,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/blockkit"
 	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/mrkdwn"
+	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/plaintext"
 	"github.com/yuin/goldmark"
 	"github.com/yuin/goldmark/extension"
 )
@@ -32,6 +33,11 @@ var (
 			return goldmark.New(goldmark.WithExtensions(mrkdwn.Extender))
 		},
 	}
+	plaintextPool = sync.Pool{
+		New: func() any {
+			return goldmark.New(goldmark.WithExtensions(plaintext.Extender))
+		},
+	}
 )
 
 // RenderHTML converts markdown to HTML.
@@ -53,6 +59,14 @@ func RenderSlackMrkdwn(markdown string) (string, error) {
 	return render(md, markdown, "Slack mrkdwn")
 }
 
+// RenderPlainText converts markdown to plain text: no markers, links flattened
+// to "text (url)".
+func RenderPlainText(markdown string) (string, error) {
+	md := plaintextPool.Get().(goldmark.Markdown)
+	defer plaintextPool.Put(md)
+	return render(md, markdown, "plain text")
+}
+
 func render(md goldmark.Markdown, markdown string, format string) (string, error) {
 	var buf bytes.Buffer
 	if err := md.Convert([]byte(markdown), &buf); err != nil {

pkg/templating/markdownrenderer/plaintext/plaintext.go

@@ -0,0 +1,301 @@
+// Package plaintext provides a goldmark node renderer that emits plain text:
+// no markdown or HTML markers, and links flattened to "text (url)". It is used
+// for JSM Ops timeline notes, which render neither HTML nor markdown.
+package plaintext
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/extension"
+	extensionast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+// Extender registers the plain-text node renderer plus the GFM extensions it
+// handles (tables, strikethrough).
+var Extender goldmark.Extender = &extender{}
+
+type extender struct{}
+
+func (e *extender) Extend(m goldmark.Markdown) {
+	extension.Table.Extend(m)
+	extension.Strikethrough.Extend(m)
+	m.Renderer().AddOptions(
+		renderer.WithNodeRenderers(util.Prioritized(newRenderer(), 1)),
+	)
+}
+
+// nodeRenderer holds per-document nesting prefixes, so it is not safe for
+// concurrent Convert calls; callers pool one instance per goroutine.
+type nodeRenderer struct {
+	prefixes []string
+}
+
+func newRenderer() renderer.NodeRenderer {
+	return &nodeRenderer{}
+}
+
+func (r *nodeRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	// Blocks
+	reg.Register(ast.KindDocument, r.renderDocument)
+	reg.Register(ast.KindHeading, r.renderBlock)
+	reg.Register(ast.KindBlockquote, r.renderBlock)
+	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindFencedCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindHTMLBlock, r.renderHTMLBlock)
+	reg.Register(ast.KindList, r.renderList)
+	reg.Register(ast.KindListItem, r.renderListItem)
+	reg.Register(ast.KindParagraph, r.renderBlock)
+	reg.Register(ast.KindTextBlock, r.renderTextBlock)
+	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
+
+	// Inlines
+	reg.Register(ast.KindAutoLink, r.renderAutoLink)
+	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
+	reg.Register(ast.KindEmphasis, r.renderPassthrough)
+	reg.Register(ast.KindImage, r.renderLink)
+	reg.Register(ast.KindLink, r.renderLink)
+	reg.Register(ast.KindText, r.renderText)
+	reg.Register(ast.KindString, r.renderString)
+	reg.Register(ast.KindRawHTML, r.renderRawHTML)
+
+	// Extensions
+	reg.Register(extensionast.KindStrikethrough, r.renderPassthrough)
+	reg.Register(extensionast.KindTable, r.renderTable)
+}
+
+func (r *nodeRenderer) writePrefix(w util.BufWriter) {
+	for _, p := range r.prefixes {
+		_, _ = w.WriteString(p)
+	}
+}
+
+func (r *nodeRenderer) writeLineSeparator(w util.BufWriter) {
+	_ = w.WriteByte('\n')
+	r.writePrefix(w)
+}
+
+// writeBlockSeparator writes a blank line between block-level elements.
+func (r *nodeRenderer) writeBlockSeparator(w util.BufWriter) {
+	r.writeLineSeparator(w)
+	r.writeLineSeparator(w)
+}
+
+func (r *nodeRenderer) separateFromPrevious(w util.BufWriter, n ast.Node) {
+	if n.PreviousSibling() != nil {
+		r.writeBlockSeparator(w)
+	}
+}
+
+func (r *nodeRenderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		// The renderer is pooled; wipe any prefix stack left over from a prior
+		// document (e.g. one that errored mid-walk) before starting fresh.
+		r.prefixes = r.prefixes[:0]
+	}
+	return ast.WalkContinue, nil
+}
+
+// renderBlock separates block-level nodes (paragraph, heading, blockquote) from
+// their previous sibling with a blank line, emitting no markers of their own.
+func (r *nodeRenderer) renderBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, node)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderCodeBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+		l := n.Lines().Len()
+		for i := 0; i < l; i++ {
+			line := n.Lines().At(i)
+			_, _ = w.Write(line.Value(source))
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering && node.PreviousSibling() != nil {
+		r.writeLineSeparator(w)
+		if node.Parent() == nil || node.Parent().Kind() != ast.KindListItem {
+			r.writeLineSeparator(w)
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderListItem(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		if n.PreviousSibling() != nil {
+			r.writeLineSeparator(w)
+		}
+		parent := n.Parent().(*ast.List)
+		var prefixStr string
+		if parent.IsOrdered() {
+			index := parent.Start
+			for c := parent.FirstChild(); c != nil && c != n; c = c.NextSibling() {
+				index++
+			}
+			prefixStr = fmt.Sprintf("%d. ", index)
+		} else {
+			prefixStr = "- "
+		}
+		_, _ = w.WriteString(prefixStr)
+		r.prefixes = append(r.prefixes, "  ") // indent wrapped/nested lines
+	} else {
+		r.prefixes = r.prefixes[:len(r.prefixes)-1]
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderTextBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering && n.PreviousSibling() != nil {
+		r.writeLineSeparator(w)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderThematicBreak(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+		_, _ = w.WriteString("---")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.AutoLink)
+	url := string(n.URL(source))
+	if n.AutoLinkType == ast.AutoLinkEmail && !strings.HasPrefix(strings.ToLower(url), "mailto:") {
+		url = "mailto:" + url
+	}
+	_, _ = w.WriteString(url)
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+			segment := c.(*ast.Text).Segment
+			value := segment.Value(source)
+			if bytes.HasSuffix(value, []byte("\n")) {
+				_, _ = w.Write(value[:len(value)-1])
+				_ = w.WriteByte(' ')
+			} else {
+				_, _ = w.Write(value)
+			}
+		}
+		return ast.WalkSkipChildren, nil
+	}
+	return ast.WalkContinue, nil
+}
+
+// renderPassthrough emits no markers; the node's children render as plain text
+// (used for emphasis/strong and strikethrough).
+func (r *nodeRenderer) renderPassthrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	return ast.WalkContinue, nil
+}
+
+// renderLink flattens links and images to "text (url)": children render the
+// label, then the destination is appended in parentheses on exit.
+func (r *nodeRenderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	var dest []byte
+	switch n := node.(type) {
+	case *ast.Link:
+		dest = n.Destination
+	case *ast.Image:
+		dest = n.Destination
+	}
+	if !entering && len(dest) > 0 {
+		_, _ = fmt.Fprintf(w, " (%s)", dest)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.Text)
+	_, _ = w.Write(n.Segment.Value(source))
+	if n.HardLineBreak() || n.SoftLineBreak() {
+		r.writeLineSeparator(w)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderString(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_, _ = w.Write(node.(*ast.String).Value)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *nodeRenderer) renderRawHTML(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	// Drop inline raw HTML tags; a plain-text note should never carry markup.
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *nodeRenderer) renderHTMLBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	// Drop block-level raw HTML for the same reason as inline raw HTML.
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *nodeRenderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	r.separateFromPrevious(w, node)
+
+	first := true
+	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
+		if c.Kind() != extensionast.KindTableHeader && c.Kind() != extensionast.KindTableRow {
+			continue
+		}
+		if !first {
+			r.writeLineSeparator(w)
+		}
+		first = false
+		cellFirst := true
+		for cc := c.FirstChild(); cc != nil; cc = cc.NextSibling() {
+			if cc.Kind() != extensionast.KindTableCell {
+				continue
+			}
+			if !cellFirst {
+				_, _ = w.WriteString(" | ")
+			}
+			cellFirst = false
+			_, _ = w.WriteString(extractPlainText(cc, source))
+		}
+	}
+	return ast.WalkSkipChildren, nil
+}
+
+// extractPlainText collects the text content of a node.
+func extractPlainText(n ast.Node, source []byte) string {
+	var buf bytes.Buffer
+	_ = ast.Walk(n, func(node ast.Node, entering bool) (ast.WalkStatus, error) {
+		if !entering {
+			return ast.WalkContinue, nil
+		}
+		switch t := node.(type) {
+		case *ast.Text:
+			buf.Write(t.Segment.Value(source))
+		case *ast.String:
+			buf.Write(t.Value)
+		}
+		return ast.WalkContinue, nil
+	})
+	return strings.TrimSpace(buf.String())
+}

pkg/templating/markdownrenderer/plaintext/plaintext_test.go

@@ -0,0 +1,55 @@
+package plaintext
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/yuin/goldmark"
+)
+
+func render(t *testing.T, md string) string {
+	t.Helper()
+	var b []byte
+	buf := bytesBuffer{&b}
+	g := goldmark.New(goldmark.WithExtensions(Extender))
+	require.NoError(t, g.Convert([]byte(md), &buf))
+	return string(b)
+}
+
+// bytesBuffer is a tiny io.Writer so the test needs no extra imports.
+type bytesBuffer struct{ b *[]byte }
+
+func (w bytesBuffer) Write(p []byte) (int, error) {
+	*w.b = append(*w.b, p...)
+	return len(p), nil
+}
+
+func TestPlainText(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{"strips bold and italic", "**bold** and *italic*", "bold and italic"},
+		{"link becomes text (url)", "[View in SigNoz](https://signoz.io/alert)", "View in SigNoz (https://signoz.io/alert)"},
+		{"bold label kept, marker dropped", "**Alert:** name (critical)", "Alert: name (critical)"},
+		{"strikethrough stripped", "~~gone~~", "gone"},
+		{"inline code unwrapped", "run `foo bar`", "run foo bar"},
+		{"paragraphs separated by blank line", "one\n\ntwo", "one\n\ntwo"},
+		{"unordered list", "- a\n- b", "- a\n- b"},
+		{"ordered list keeps numbering", "1. a\n2. b", "1. a\n2. b"},
+		{"nested list indents under parent", "- a\n  - b", "- a\n  - b"},
+		{"fenced code block unwrapped", "```go\nx := 1\n```", "x := 1\n"},
+		{"table flattens to pipe-separated rows", "| h1 | h2 |\n|---|---|\n| a | b |\n| c | d |", "h1 | h2\na | b\nc | d"},
+		{"autolink kept as bare url", "see <https://signoz.io>", "see https://signoz.io"},
+		{"inline raw html dropped", "a <b>bold</b> word", "a bold word"},
+		{"html block dropped", "before\n\n<div>markup</div>\n\nafter", "before\n\nafter"},
+		{"hard break becomes newline", "one  \ntwo", "one\ntwo"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.Equal(t, c.want, render(t, c.in))
+		})
+	}
+}

pkg/types/alertmanagertypes/channel.go

@@ -216,13 +216,20 @@ func (PostableChannel) JSONSchema() (jsonschema.Schema, error) {
 	schema.WithRequired("name")
 
 	var oneOf []jsonschema.SchemaOrBool
-	// Walk both halves: native fields on Receiver, upstream on the embed.
+	seen := map[string]struct{}{}
+	// Walk both halves: native fields on Receiver, upstream on the embed. A native
+	// field can shadow an upstream one with the same tag (e.g. jira_configs), so
+	// dedupe to avoid emitting two identical oneOf branches.
 	collect := func(t reflect.Type) {
 		for i := 0; i < t.NumField(); i++ {
 			jsonTag := strings.Split(t.Field(i).Tag.Get("json"), ",")[0]
 			if !strings.HasSuffix(jsonTag, "_configs") {
 				continue
 			}
+			if _, ok := seen[jsonTag]; ok {
+				continue
+			}
+			seen[jsonTag] = struct{}{}
 			branch := (&jsonschema.Schema{}).WithRequired(jsonTag)
 			oneOf = append(oneOf, branch.ToSchemaOrBool())
 		}

pkg/types/alertmanagertypes/config.go

@@ -70,15 +70,19 @@ type Config struct {
 // on Receiver, and extensions to customConfigsOf + isEmpty.
 type customReceiverConfigs struct {
 	GoogleChat []*GoogleChatReceiverConfig
+	Jira       []*JiraReceiverConfig
+	JSMOps     []*JSMOpsReceiverConfig
 }
 
 func (c customReceiverConfigs) isEmpty() bool {
-	return len(c.GoogleChat) == 0
+	return len(c.GoogleChat) == 0 && len(c.Jira) == 0 && len(c.JSMOps) == 0
 }
 
 func customConfigsOf(receiver *Receiver) customReceiverConfigs {
 	return customReceiverConfigs{
 		GoogleChat: receiver.GoogleChatConfigs,
+		Jira:       receiver.JiraConfigs,
+		JSMOps:     receiver.JSMOpsConfigs,
 	}
 }
 
@@ -187,6 +191,8 @@ func extendedReceivers(c *config.Config, customConfigs map[string]customReceiver
 		receivers[i] = &Receiver{
 			Receiver:          &base,
 			GoogleChatConfigs: custom.GoogleChat,
+			JiraConfigs:       custom.Jira,
+			JSMOpsConfigs:     custom.JSMOps,
 		}
 	}
 
@@ -362,6 +368,8 @@ func (c *Config) GetReceiver(name string) (*Receiver, error) {
 			return &Receiver{
 				Receiver:          &base,
 				GoogleChatConfigs: custom.GoogleChat,
+				JiraConfigs:       custom.Jira,
+				JSMOpsConfigs:     custom.JSMOps,
 			}, nil
 		}
 	}
@@ -441,6 +449,16 @@ func (c *Config) applyNativeDefaults() {
 				gc.HTTPConfig = httpDefault
 			}
 		}
+		for _, jc := range custom.Jira {
+			if jc.HTTPConfig == nil {
+				jc.HTTPConfig = httpDefault
+			}
+		}
+		for _, jc := range custom.JSMOps {
+			if jc.HTTPConfig == nil {
+				jc.HTTPConfig = httpDefault
+			}
+		}
 	}
 }
 

pkg/types/alertmanagertypes/jira.go

@@ -0,0 +1,119 @@
+package alertmanagertypes
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/prometheus/alertmanager/config"
+	commoncfg "github.com/prometheus/common/config"
+	"github.com/prometheus/common/model"
+)
+
+const defaultJiraReopenDuration = model.Duration(3 * 24 * time.Hour)
+
+// Service accounts authenticate against the api.atlassian.com gateway (keyed by
+// cloud id) instead of the site host; they are identified by their email domain.
+const (
+	jiraCloudHostSuffix           = ".atlassian.net"
+	jiraServiceAccountEmailDomain = "@serviceaccount.atlassian.com"
+	jiraGatewayBaseURL            = "https://api.atlassian.com/ex/jira/"
+)
+
+// Default templates for the issue title and body. The body is rendered to
+// markdown and then wrapped in the ADF status panel + deep-links by the notifier.
+const (
+	DefaultJiraSummaryTemplate = `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`
+
+	DefaultJiraDescriptionTemplate = `{{ 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 }}`
+)
+
+// JiraReceiverConfig is the SigNoz Jira receiver. Fields are declared explicitly
+// instead of embedding upstream config.JiraConfig because that type's own
+// UnmarshalYAML would reset our defaults and drop sibling fields on the yaml
+// round-trip. Only Jira Cloud (v3/ADF) is supported, so api_url is derived from Site.
+type JiraReceiverConfig struct {
+	config.NotifierConfig `yaml:",inline"`
+
+	Site              string                      `json:"site,omitempty" yaml:"site,omitempty"`
+	Project           string                      `json:"project,omitempty" yaml:"project,omitempty"`
+	IssueType         string                      `json:"issue_type,omitempty" yaml:"issue_type,omitempty"`
+	Summary           string                      `json:"summary,omitempty" yaml:"summary,omitempty"`
+	Description       string                      `json:"description,omitempty" yaml:"description,omitempty"`
+	Priority          string                      `json:"priority,omitempty" yaml:"priority,omitempty"`
+	Labels            []string                    `json:"labels,omitempty" yaml:"labels,omitempty"`
+	ResolveTransition string                      `json:"resolve_transition,omitempty" yaml:"resolve_transition,omitempty"`
+	ReopenTransition  string                      `json:"reopen_transition,omitempty" yaml:"reopen_transition,omitempty"`
+	ReopenDuration    model.Duration              `json:"reopen_duration" yaml:"reopen_duration"`
+	WontFixResolution string                      `json:"wont_fix_resolution,omitempty" yaml:"wont_fix_resolution,omitempty"`
+	CustomFields      map[string]any              `json:"custom_fields,omitempty" yaml:"custom_fields,omitempty"`
+	HTTPConfig        *commoncfg.HTTPClientConfig `json:"http_config,omitempty" yaml:"http_config,omitempty"`
+}
+
+func (c *JiraReceiverConfig) UnmarshalYAML(unmarshal func(any) error) error {
+	type plain JiraReceiverConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+
+	if c.ReopenDuration <= 0 {
+		c.ReopenDuration = defaultJiraReopenDuration
+	}
+	// sub-minute windows truncate to 0 in the reopen JQL and silently disable
+	// reopening, so reject them.
+	if c.ReopenDuration < model.Duration(time.Minute) {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira reopen_duration must be at least 1m")
+	}
+	if c.Summary == "" {
+		c.Summary = DefaultJiraSummaryTemplate
+	}
+	if c.Description == "" {
+		c.Description = DefaultJiraDescriptionTemplate
+	}
+
+	site := strings.TrimRight(strings.TrimSpace(c.Site), "/")
+	u, err := url.Parse(site)
+	if site == "" || err != nil || u.Scheme != "https" || !strings.HasSuffix(strings.ToLower(u.Hostname()), jiraCloudHostSuffix) {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("jira site must be a Jira Cloud URL (https://<site>%s)", jiraCloudHostSuffix))
+	}
+	c.Site = site
+
+	if c.Project == "" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira project is required")
+	}
+	if c.IssueType == "" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira issue_type is required")
+	}
+	if c.HTTPConfig == nil || c.HTTPConfig.BasicAuth == nil {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jira requires basic auth (email + API token)")
+	}
+	return nil
+}
+
+// IsServiceAccount reports whether the basic-auth user is an Atlassian service
+// account, identified by its email domain. Service accounts must go through the
+// api.atlassian.com gateway; personal API tokens use the site host directly.
+func (c *JiraReceiverConfig) IsServiceAccount() bool {
+	if c.HTTPConfig == nil || c.HTTPConfig.BasicAuth == nil {
+		return false
+	}
+	return strings.HasSuffix(strings.ToLower(c.HTTPConfig.BasicAuth.Username), jiraServiceAccountEmailDomain)
+}
+
+// APIBaseURL returns the Jira Cloud REST v3 base URL: the api.atlassian.com
+// gateway when a cloud id is given (service accounts), else the site host.
+func (c *JiraReceiverConfig) APIBaseURL(cloudID string) string {
+	if cloudID != "" {
+		return fmt.Sprintf("%s%s/rest/api/3", jiraGatewayBaseURL, cloudID)
+	}
+	return fmt.Sprintf("%s/rest/api/3", strings.TrimRight(c.Site, "/"))
+}

pkg/types/alertmanagertypes/jira_test.go

@@ -0,0 +1,119 @@
+package alertmanagertypes
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	commoncfg "github.com/prometheus/common/config"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func jiraReceiverJSON(site, project, issueType string, withAuth bool) string {
+	auth := ""
+	if withAuth {
+		auth = `,"http_config":{"basic_auth":{"username":"me@acme.com","password":"token"}}`
+	}
+	return fmt.Sprintf(
+		`{"name":"jira","jira_configs":[{"site":%q,"project":%q,"issue_type":%q%s}]}`,
+		site, project, issueType, auth,
+	)
+}
+
+func TestJiraReceiverConfigDefaults(t *testing.T) {
+	r, err := NewReceiver(jiraReceiverJSON("https://acme.atlassian.net", "KAN", "Task", true))
+	require.NoError(t, err)
+	require.Len(t, r.JiraConfigs, 1)
+
+	jc := r.JiraConfigs[0]
+	assert.Equal(t, "https://acme.atlassian.net", jc.Site)
+	assert.Equal(t, "https://acme.atlassian.net/rest/api/3", jc.APIBaseURL(""))
+	assert.False(t, jc.SendResolved()) // default off when omitted, like other channels
+	assert.Equal(t, defaultJiraReopenDuration, jc.ReopenDuration)
+	assert.Equal(t, DefaultJiraSummaryTemplate, jc.Summary)
+	assert.Equal(t, DefaultJiraDescriptionTemplate, jc.Description)
+
+	ch, err := NewChannelFromReceiver(r, "org-1")
+	require.NoError(t, err)
+	assert.Equal(t, "jira", ch.Type)
+}
+
+func TestJiraReceiverConfigSendResolved(t *testing.T) {
+	withSendResolved := func(v bool) string {
+		return fmt.Sprintf(
+			`{"name":"j","jira_configs":[{"site":"https://acme.atlassian.net","project":"KAN","issue_type":"Task","send_resolved":%t,"http_config":{"basic_auth":{"username":"e","password":"t"}}}]}`,
+			v,
+		)
+	}
+	on, err := NewReceiver(withSendResolved(true))
+	require.NoError(t, err)
+	assert.True(t, on.JiraConfigs[0].SendResolved())
+
+	off, err := NewReceiver(withSendResolved(false))
+	require.NoError(t, err)
+	assert.False(t, off.JiraConfigs[0].SendResolved())
+}
+
+func TestJiraReceiverConfigReopenDurationMinimum(t *testing.T) {
+	withReopen := func(v string) string {
+		return fmt.Sprintf(
+			`{"name":"j","jira_configs":[{"site":"https://acme.atlassian.net","project":"KAN","issue_type":"Task","reopen_duration":%q,"http_config":{"basic_auth":{"username":"e","password":"t"}}}]}`,
+			v,
+		)
+	}
+	r, err := NewReceiver(withReopen("1m"))
+	require.NoError(t, err)
+	assert.Equal(t, model.Duration(time.Minute), r.JiraConfigs[0].ReopenDuration)
+
+	_, err = NewReceiver(withReopen("30s"))
+	assert.Error(t, err)
+}
+
+func TestJiraAPIBaseURL(t *testing.T) {
+	c := &JiraReceiverConfig{Site: "https://acme.atlassian.net"}
+	assert.Equal(t, "https://acme.atlassian.net/rest/api/3", c.APIBaseURL(""))
+	assert.Equal(t, "https://api.atlassian.com/ex/jira/09851b38-1a40-4c01-a36a-0a9336293200/rest/api/3", c.APIBaseURL("09851b38-1a40-4c01-a36a-0a9336293200"))
+}
+
+func TestJiraIsServiceAccount(t *testing.T) {
+	withUser := func(username string) *JiraReceiverConfig {
+		return &JiraReceiverConfig{HTTPConfig: &commoncfg.HTTPClientConfig{BasicAuth: &commoncfg.BasicAuth{Username: username}}}
+	}
+	assert.True(t, withUser("bot@serviceaccount.atlassian.com").IsServiceAccount())
+	assert.True(t, withUser("Bot@ServiceAccount.Atlassian.Com").IsServiceAccount())
+	assert.False(t, withUser("temp@signoz.io").IsServiceAccount())
+	assert.False(t, (&JiraReceiverConfig{}).IsServiceAccount())
+}
+
+func TestJiraReceiverConfigTrailingSlashSite(t *testing.T) {
+	r, err := NewReceiver(jiraReceiverJSON("https://acme.atlassian.net/", "KAN", "Task", true))
+	require.NoError(t, err)
+	assert.Equal(t, "https://acme.atlassian.net", r.JiraConfigs[0].Site)
+	assert.Equal(t, "https://acme.atlassian.net/rest/api/3", r.JiraConfigs[0].APIBaseURL(""))
+}
+
+func TestJiraReceiverConfigValidation(t *testing.T) {
+	cases := []struct {
+		name string
+		json string
+	}{
+		{"missing site", `{"name":"j","jira_configs":[{"project":"KAN","issue_type":"Task","http_config":{"basic_auth":{"username":"e","password":"t"}}}]}`},
+		{"http site", jiraReceiverJSON("http://acme.atlassian.net", "KAN", "Task", true)},
+		{"non-cloud host", jiraReceiverJSON("https://jira.acme.com", "KAN", "Task", true)},
+		{"lookalike host suffix", jiraReceiverJSON("https://www.iamnotatlassian.net", "KAN", "Task", true)},
+		{"bare atlassian.net", jiraReceiverJSON("https://atlassian.net", "KAN", "Task", true)},
+		{"missing project", jiraReceiverJSON("https://acme.atlassian.net", "", "Task", true)},
+		{"missing issue_type", jiraReceiverJSON("https://acme.atlassian.net", "KAN", "", true)},
+		{"missing basic auth", jiraReceiverJSON("https://acme.atlassian.net", "KAN", "Task", false)},
+		{"invalid reopen_duration format", `{"name":"j","jira_configs":[{"site":"https://acme.atlassian.net","project":"KAN","issue_type":"Task","reopen_duration":"3days","http_config":{"basic_auth":{"username":"e","password":"t"}}}]}`},
+		{"sub-minute reopen_duration", `{"name":"j","jira_configs":[{"site":"https://acme.atlassian.net","project":"KAN","issue_type":"Task","reopen_duration":"30s","http_config":{"basic_auth":{"username":"e","password":"t"}}}]}`},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, err := NewReceiver(c.json)
+			assert.Error(t, err)
+		})
+	}
+}

pkg/types/alertmanagertypes/jsmops.go

@@ -0,0 +1,75 @@
+package alertmanagertypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/prometheus/alertmanager/config"
+	commoncfg "github.com/prometheus/common/config"
+)
+
+// JSMOpsAPIBaseURL is the native JSM Ops integration-events gateway. It is a
+// single global host keyed by the integration API key (no region/cloud id in
+// the path). The trailing slash is required: the Opsgenie notifier appends
+// "v2/alerts..." to APIURL.Path with no separator.
+const JSMOpsAPIBaseURL = "https://api.atlassian.com/jsm/ops/integration/"
+
+// JSM Ops speaks the Opsgenie alert API, so a JSM alert description takes the
+// same HTML subset and 15,000-char limit; message caps at 130. The templates
+// mirror Google Chat / Jira for a consistent default across channels.
+const (
+	DefaultJSMOpsMessageTemplate = `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`
+
+	DefaultJSMOpsDescriptionTemplate = `{{ 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 }}`
+)
+
+// JSMOpsReceiverConfig is the SigNoz Jira Service Management Ops receiver. It is
+// delivered by reusing the Opsgenie notifier (JSM Ops is the ex-Opsgenie alert
+// API): the notifier package maps these fields onto config.OpsGenieConfig with
+// APIURL pinned to JSMOpsAPIBaseURL.
+type JSMOpsReceiverConfig struct {
+	config.NotifierConfig `yaml:",inline" json:",inline"`
+
+	HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"`
+
+	APIKey      config.Secret `yaml:"api_key,omitempty" json:"api_key,omitempty"`
+	Message     string        `yaml:"message,omitempty" json:"message,omitempty"`
+	Description string        `yaml:"description,omitempty" json:"description,omitempty"`
+	Priority    string        `yaml:"priority,omitempty" json:"priority,omitempty"`
+	Tags        string        `yaml:"tags,omitempty" json:"tags,omitempty"`
+}
+
+// send_resolved has no omitempty upstream, so a var default here is overwritten
+// by the yaml round-trip to the request value (false when omitted); the UI sends
+// it explicitly, defaulted on, so JSM alerts close on resolve.
+var DefaultJSMOpsReceiverConfig = JSMOpsReceiverConfig{
+	NotifierConfig: config.NotifierConfig{
+		VSendResolved: false,
+	},
+	Message:     DefaultJSMOpsMessageTemplate,
+	Description: DefaultJSMOpsDescriptionTemplate,
+	Tags:        "signoz",
+}
+
+func (c *JSMOpsReceiverConfig) UnmarshalYAML(unmarshal func(any) error) error {
+	*c = DefaultJSMOpsReceiverConfig
+	type plain JSMOpsReceiverConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+	if c.APIKey == "" {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "jsm ops api_key is required")
+	}
+	return nil
+}

pkg/types/alertmanagertypes/jsmops_test.go

@@ -0,0 +1,70 @@
+package alertmanagertypes
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJSMOpsReceiverConfigDefaults(t *testing.T) {
+	r, err := NewReceiver(`{"name":"jsm","jsmops_configs":[{"api_key":"key-123"}]}`)
+	require.NoError(t, err)
+	require.Len(t, r.JSMOpsConfigs, 1)
+
+	c := r.JSMOpsConfigs[0]
+	assert.Equal(t, "key-123", string(c.APIKey))
+	assert.Equal(t, DefaultJSMOpsMessageTemplate, c.Message)
+	assert.Equal(t, DefaultJSMOpsDescriptionTemplate, c.Description)
+	assert.Equal(t, "signoz", c.Tags)
+	assert.False(t, c.SendResolved()) // default off when omitted, like other channels
+
+	ch, err := NewChannelFromReceiver(r, "org-1")
+	require.NoError(t, err)
+	assert.Equal(t, "jsmops", ch.Type)
+}
+
+func TestJSMOpsReceiverConfigOverrides(t *testing.T) {
+	r, err := NewReceiver(`{"name":"jsm","jsmops_configs":[{"api_key":"k","message":"m","description":"d","priority":"P1","tags":"a,b","send_resolved":true}]}`)
+	require.NoError(t, err)
+	require.Len(t, r.JSMOpsConfigs, 1)
+
+	c := r.JSMOpsConfigs[0]
+	assert.Equal(t, "m", c.Message)
+	assert.Equal(t, "d", c.Description)
+	assert.Equal(t, "P1", c.Priority)
+	assert.Equal(t, "a,b", c.Tags)
+	assert.True(t, c.SendResolved())
+}
+
+func TestJSMOpsReceiverConfigSendResolved(t *testing.T) {
+	withSendResolved := func(v bool) string {
+		return fmt.Sprintf(`{"name":"jsm","jsmops_configs":[{"api_key":"k","send_resolved":%t}]}`, v)
+	}
+	on, err := NewReceiver(withSendResolved(true))
+	require.NoError(t, err)
+	require.Len(t, on.JSMOpsConfigs, 1)
+	assert.True(t, on.JSMOpsConfigs[0].SendResolved())
+
+	off, err := NewReceiver(withSendResolved(false))
+	require.NoError(t, err)
+	require.Len(t, off.JSMOpsConfigs, 1)
+	assert.False(t, off.JSMOpsConfigs[0].SendResolved())
+}
+
+func TestJSMOpsReceiverConfigValidation(t *testing.T) {
+	cases := []struct {
+		name string
+		json string
+	}{
+		{"missing api_key", `{"name":"jsm","jsmops_configs":[{"message":"m"}]}`},
+		{"empty api_key", `{"name":"jsm","jsmops_configs":[{"api_key":""}]}`},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, err := NewReceiver(c.json)
+			assert.Error(t, err)
+		})
+	}
+}

pkg/types/alertmanagertypes/receiver.go

@@ -23,6 +23,11 @@ import (
 type Receiver struct {
 	*config.Receiver
 	GoogleChatConfigs []*GoogleChatReceiverConfig `json:"googlechat_configs,omitempty" yaml:"googlechat_configs,omitempty"`
+	// Shadows upstream's jira_configs so our custom notifier (rich ADF, deep-links,
+	// lifecycle comments) handles it instead of upstream's plain Jira notifier.
+	JiraConfigs []*JiraReceiverConfig `json:"jira_configs,omitempty" yaml:"jira_configs,omitempty"`
+	// JSM Ops (ex-Opsgenie alert API); delivered by reusing the Opsgenie notifier.
+	JSMOpsConfigs []*JSMOpsReceiverConfig `json:"jsmops_configs,omitempty" yaml:"jsmops_configs,omitempty"`
 }
 
 // NewReceiver builds a Receiver from its JSON input, applying each notifier
@@ -51,6 +56,22 @@ func NewReceiver(input string) (*Receiver, error) {
 		receiver.GoogleChatConfigs[i] = defaulted
 	}
 
+	for i, jc := range receiver.JiraConfigs {
+		defaulted, err := defaultedNotifierConfig(jc)
+		if err != nil {
+			return nil, err
+		}
+		receiver.JiraConfigs[i] = defaulted
+	}
+
+	for i, jc := range receiver.JSMOpsConfigs {
+		defaulted, err := defaultedNotifierConfig(jc)
+		if err != nil {
+			return nil, err
+		}
+		receiver.JSMOpsConfigs[i] = defaulted
+	}
+
 	return receiver, nil
 }
 

tests/integration/tests/queriercommon/07_fields_keys_values.py

@@ -0,0 +1,235 @@
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
+
+import pytest
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.logs import Logs
+from fixtures.traces import Traces
+
+
+@pytest.mark.parametrize(
+    "signal,field_context,present,absent",
+    [
+        pytest.param("logs", "log", {"severity_text": "log", "body": "log", "trace_id": "log"}, ["code.file", "scope_name"], id="log_context_lists_log_intrinsics"),
+        pytest.param("logs", "scope", {"scope_name": "scope", "scope_version": "scope"}, ["severity_text", "body", "code.file"], id="scope_context_lists_scope_intrinsics_for_logs"),
+        pytest.param("logs", "attribute", {"code.file": "attribute"}, ["body", "scope_name"], id="attribute_context_excludes_log_intrinsics"),
+        pytest.param("traces", "span", {"name": "span", "has_error": "span", "isRoot": "span", "http.method": "attribute"}, ["scope.name"], id="span_context_lists_span_intrinsics_and_attributes"),
+        pytest.param("traces", "scope", {"scope.name": "scope", "scope.version": "scope"}, ["name", "has_error", "isRoot"], id="scope_context_lists_scope_intrinsics_for_traces"),
+        pytest.param("traces", "resource", {"host.name": "resource"}, ["name", "has_error", "isRoot", "http.method"], id="resource_context_excludes_span_intrinsics"),
+        pytest.param("traces", "attribute", {"http.method": "attribute"}, ["name", "has_error", "isRoot", "host.name"], id="attribute_context_excludes_span_intrinsics"),
+    ],
+)
+def test_fields_keys_by_context(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_logs: Callable[[list[Logs]], None],
+    insert_traces: Callable[[list[Traces]], None],
+    signal: str,
+    field_context: str,
+    present: dict[str, str],
+    absent: list[str],
+) -> None:
+    """
+    Setup:
+    Insert a log with a code.file attribute and a span with an http.method attribute and a host.name resource.
+
+    Tests:
+    1. Keys for a context list that context's intrinsic columns and the stored keys the context maps to,
+       each with its context; intrinsics of other contexts are not listed. The span context also keeps
+       listing attributes because `span.<attribute>` resolves attributes in queries.
+    """
+    now = datetime.now(tz=UTC)
+    insert_logs([Logs(timestamp=now, attributes={"code.file": "/opt/integration.go"}, body="a log line")])
+    insert_traces([Traces(timestamp=now, resources={"host.name": "linux-001"}, attributes={"http.method": "GET"})])
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/keys"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": signal, "fieldContext": field_context},
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    keys = response.json()["data"]["keys"]
+    listed = {name: [key["fieldContext"] for key in keys.get(name, [])] for name in present}
+    assert listed == {name: [context] for name, context in present.items()}, f"keys for the {field_context} context"
+    assert [name for name in absent if name in keys] == [], f"keys that do not belong to the {field_context} context"
+
+
+@pytest.mark.parametrize(
+    "signal,field_context,field_data_type,present,absent",
+    [
+        pytest.param("traces", "span", "float64", ["duration_nano", "status_code"], ["name", "has_error"], id="float64_matches_number_span_intrinsics"),
+        pytest.param("traces", "span", "int64", ["duration_nano", "status_code"], ["name", "has_error"], id="int64_matches_number_span_intrinsics"),
+        pytest.param("traces", "span", "bool", ["has_error", "isRoot", "isEntryPoint"], ["name", "duration_nano"], id="bool_matches_bool_span_intrinsics"),
+        pytest.param("traces", "span", "string", ["name", "http_method"], ["duration_nano", "has_error"], id="string_matches_string_span_intrinsics"),
+        pytest.param("logs", "log", "number", ["severity_number", "trace_flags"], ["severity_text", "body"], id="number_matches_number_log_intrinsics"),
+    ],
+)
+def test_fields_keys_by_data_type(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    signal: str,
+    field_context: str,
+    field_data_type: str,
+    present: list[str],
+    absent: list[str],
+) -> None:
+    """
+    Tests:
+    1. A data type filter keeps the intrinsic columns of that type; number, int64 and float64 are one family.
+    """
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/keys"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": signal, "fieldContext": field_context, "fieldDataType": field_data_type},
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    keys = response.json()["data"]["keys"]
+    assert [name for name in present if name not in keys] == [], f"intrinsics of type {field_data_type}"
+    assert [name for name in absent if name in keys] == [], f"intrinsics not of type {field_data_type}"
+
+
+@pytest.mark.parametrize(
+    "signal,search_text,present",
+    [
+        pytest.param("logs", "SEVERITY", ["severity_text", "severity_number"], id="upper_case_search_logs"),
+        pytest.param("traces", "HTTP_", ["http_method", "http_host", "http_url"], id="upper_case_search_traces"),
+        pytest.param("traces", "Duration", ["duration_nano"], id="mixed_case_search_traces"),
+        pytest.param("traces", "span.HAS_ERR", ["has_error"], id="context_prefix_with_upper_case_search"),
+    ],
+)
+def test_fields_keys_search_matches_intrinsics_case_insensitively(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    signal: str,
+    search_text: str,
+    present: list[str],
+) -> None:
+    """
+    Tests:
+    1. The search text matches intrinsic columns case-insensitively, as it does for stored keys,
+       with or without a context prefix.
+    """
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/keys"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": signal, "searchText": search_text},
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    keys = response.json()["data"]["keys"]
+    assert [name for name in present if name not in keys] == [], f"intrinsics matching {search_text!r}"
+
+
+@pytest.mark.parametrize(
+    "signal,params,expected",
+    [
+        pytest.param("traces", {"name": "has_error"}, [True, False], id="calculated_bool_span_field"),
+        pytest.param("traces", {"name": "has_error", "fieldContext": "span"}, [True, False], id="calculated_bool_span_field_with_context"),
+        pytest.param("traces", {"name": "has_error", "searchText": "tr"}, [True], id="search_text_narrows_bool_values"),
+        pytest.param("logs", {"name": "retry"}, [True, False], id="bool_attribute_from_tag_rows"),
+        pytest.param("logs", {"name": "retry", "fieldContext": "attribute"}, [True, False], id="bool_attribute_with_context"),
+        pytest.param("logs", {"name": "never_seen", "fieldDataType": "bool"}, [True, False], id="declared_bool_type_needs_no_rows"),
+    ],
+)
+def test_fields_values_bool_fields(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_logs: Callable[[list[Logs]], None],
+    signal: str,
+    params: dict[str, str],
+    expected: list[bool],
+) -> None:
+    """
+    Setup:
+    Insert a log with a bool attribute.
+
+    Tests:
+    1. Values for a bool field are true and false (narrowed by the search text): for the calculated span
+       field, for a stored bool attribute whose tag rows carry no value, and for a key the caller declares bool.
+    """
+    insert_logs([Logs(timestamp=datetime.now(tz=UTC), attributes={"retry": True}, body="retrying")])
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/values"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": signal, **params},
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["data"]["values"]["boolValues"] == expected
+    assert response.json()["data"]["complete"] is True
+
+
+@pytest.mark.parametrize("signal", [pytest.param("logs", id="logs"), pytest.param("traces", id="traces")])
+def test_fields_values_start_excludes_values_not_seen_since(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_logs: Callable[[list[Logs]], None],
+    insert_traces: Callable[[list[Traces]], None],
+    signal: str,
+) -> None:
+    """
+    Setup:
+    Insert a log and a span three days old and a log and a span now, with different service names.
+
+    Tests:
+    1. Values with startUnixMilli an hour ago contain only the service seen now.
+    2. Values without a start contain both services.
+    """
+    now = datetime.now(tz=UTC)
+    insert_logs(
+        [
+            Logs(timestamp=now - timedelta(days=3), resources={"service.name": "archived-service"}, body="old"),
+            Logs(timestamp=now, resources={"service.name": "live-service"}, body="new"),
+        ]
+    )
+    insert_traces(
+        [
+            Traces(timestamp=now - timedelta(days=3), resources={"service.name": "archived-service"}),
+            Traces(timestamp=now, resources={"service.name": "live-service"}),
+        ]
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/values"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={
+            "signal": signal,
+            "name": "service.name",
+            "startUnixMilli": int((now - timedelta(hours=1)).timestamp() * 1000),
+        },
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["data"]["values"]["stringValues"] == ["live-service"], "values last seen before the start must be dropped"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/values"),
+        timeout=2,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": signal, "name": "service.name"},
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert set(response.json()["data"]["values"]["stringValues"]) == {"archived-service", "live-service"}