@sentry/junior-sentry 0.242.0 → 0.243.0

package/README.md

@@ -36,7 +36,7 @@ Verified CLI surface (check live `sentry --help` before blocking):
 
 Set `SENTRY_READ_TOKEN` to a read-only internal integration token. Junior then uses it for Sentry API reads (`GET`, `HEAD`, `OPTIONS`), including Explore queries, scheduled tasks, and event automations. Writes and `/api/0/users/` requests still use the requesting user's OAuth token.
 
-## Issue webhooks
+## Issue and metric alert webhooks
 
 Use a **Sentry internal integration** (not a public app install flow):
 
@@ -44,6 +44,13 @@ Use a **Sentry internal integration** (not a public app install flow):
 2. Point it at `https://<junior-host>/api/webhooks/sentry`.
 3. Set the org slug as `SENTRY_WEBHOOK_ORG` and the integration client secret as `SENTRY_WEBHOOK_SECRET`, then redeploy.
 
-Junior verifies `Sentry-Hook-Signature`, rejects payloads outside `SENTRY_WEBHOOK_ORG`, and publishes `issue.created` for `org/project#issueId` and `org/project`. Create watches/event automations before the issue arrives; unmatched deliveries are not replayed.
+For metric alerts, also enable **Alert Rule Action** on the integration and add it as a `sentry_app` trigger action on each alert. Sentry sends metric alerts only to alert actions.
+
+Junior verifies `Sentry-Hook-Signature`, rejects payloads outside `SENTRY_WEBHOOK_ORG`, and publishes:
+
+- `issue.created` for `org/project#issueId` and `org/project`.
+- `metric_alert.critical`, `metric_alert.warning`, and `metric_alert.resolved` for `metric-alert:org/alertRuleId`.
+
+Create watches/event automations before the webhook arrives; unmatched deliveries are not replayed.
 
 Full guide: https://junior.sentry.dev/extend/sentry-plugin/

package/dist/{chunk-UITYE7V6.js → chunk-6VG4NPNH.js}

@@ -15,6 +15,28 @@ function sentryProjectResource(input) {
   };
 }
 
+// src/events/metric-alert.ts
+var SENTRY_METRIC_ALERT_EVENTS = [
+  "metric_alert.critical",
+  "metric_alert.warning",
+  "metric_alert.resolved"
+];
+var SENTRY_METRIC_ALERT_SUGGESTED_EVENTS = [
+  "metric_alert.critical",
+  "metric_alert.warning"
+];
+var SENTRY_METRIC_ALERT_IDENTIFIER = {
+  format: "metric-alert:org/alertRuleId",
+  pattern: /^metric-alert:[^\s/:#]+\/\d+$/
+};
+function sentryMetricAlertResource(input) {
+  return {
+    identifier: `metric-alert:${input.org}/${input.alertRuleId}`,
+    label: `Sentry metric alert ${input.org}/${input.alertRuleId}`,
+    namespace: "sentry"
+  };
+}
+
 // src/webhooks/events.ts
 import { z } from "zod";
 var issueWebhookSchema = z.object({
@@ -38,6 +60,19 @@ var issueWebhookSchema = z.object({
   }),
   installation: z.object({ uuid: z.string().min(1) }).passthrough()
 }).passthrough();
+var metricAlertWebhookSchema = z.object({
+  action: z.string(),
+  data: z.object({
+    description_text: z.string().optional(),
+    description_title: z.string().optional(),
+    metric_alert: z.object({
+      alert_rule: z.object({ id: z.coerce.string().min(1) }).passthrough(),
+      id: z.coerce.string().min(1)
+    }).passthrough(),
+    web_url: z.string().url()
+  }),
+  installation: z.object({ uuid: z.string().min(1) }).passthrough()
+}).passthrough();
 function organizationSlug(issueApiUrl) {
   try {
     const segments = new URL(issueApiUrl).pathname.split("/").filter(Boolean);
@@ -70,8 +105,13 @@ function issueText(issue) {
   ].filter((part) => part !== void 0);
   return parts.length > 0 ? parts.join("\n") : void 0;
 }
-function normalizeSentryEvents(input) {
-  if (input.hookResource !== "issue") return [];
+function webOrganizationSlug(webUrl) {
+  const fromPath = organizationSlug(webUrl);
+  if (fromPath) return fromPath;
+  const labels = new URL(webUrl).hostname.split(".");
+  return labels.length >= 3 ? labels[0] : void 0;
+}
+function normalizeIssueEvents(input) {
   const parsed = issueWebhookSchema.safeParse(input.body);
   if (!parsed.success || parsed.data.action !== "created") return [];
   const issue = parsed.data.data.issue;
@@ -103,6 +143,47 @@ function normalizeSentryEvents(input) {
     { ...event, identifier: projectResource.identifier }
   ];
 }
+function normalizeMetricAlertEvents(input) {
+  const parsed = metricAlertWebhookSchema.safeParse(input.body);
+  if (!parsed.success) return [];
+  const eventType = `metric_alert.${parsed.data.action}`;
+  if (!SENTRY_METRIC_ALERT_EVENTS.includes(eventType)) {
+    return [];
+  }
+  const { data } = parsed.data;
+  const org = webOrganizationSlug(data.web_url)?.toLowerCase();
+  if (!org || org !== input.webhookOrg.toLowerCase()) return [];
+  const alertRuleId = data.metric_alert.alert_rule.id;
+  const incidentId = data.metric_alert.id;
+  const resource = sentryMetricAlertResource({ alertRuleId, org });
+  const untrustedText = [
+    data.description_title,
+    data.description_text,
+    `URL: ${data.web_url}`
+  ].filter((part) => Boolean(part)).join("\n");
+  return [
+    {
+      // One event per incident state. Sentry retries get new Request-IDs.
+      eventKey: `sentry:${resource.identifier}:${incidentId}:${eventType}`,
+      eventType,
+      identifier: resource.identifier,
+      occurredAtMs: providerTime(input.hookTimestamp) ?? Date.now(),
+      trustedSummary: `${resource.label} is ${parsed.data.action}.`,
+      data: { alertRuleId, incidentId, url: data.web_url },
+      untrustedText
+    }
+  ];
+}
+function normalizeSentryEvents(input) {
+  switch (input.hookResource) {
+    case "issue":
+      return normalizeIssueEvents(input);
+    case "metric_alert":
+      return normalizeMetricAlertEvents(input);
+    default:
+      return [];
+  }
+}
 
 // src/webhooks/handler.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -176,6 +257,9 @@ export {
   SENTRY_ISSUE_EVENTS,
   sentryIssueResource,
   sentryProjectResource,
+  SENTRY_METRIC_ALERT_EVENTS,
+  SENTRY_METRIC_ALERT_SUGGESTED_EVENTS,
+  SENTRY_METRIC_ALERT_IDENTIFIER,
   normalizeSentryEvents,
   createSentryWebhookRoute,
   sentryWebhookSecret,

package/dist/events/metric-alert.d.ts

@@ -0,0 +1,14 @@
+import type { SubscribableResource } from "@sentry/junior-plugin-api";
+/** Metric alert states, named after Sentry's `metric_alert.<action>` webhooks. */
+export declare const SENTRY_METRIC_ALERT_EVENTS: readonly ["metric_alert.critical", "metric_alert.warning", "metric_alert.resolved"];
+export declare const SENTRY_METRIC_ALERT_SUGGESTED_EVENTS: string[];
+/** The identifier shape that `sentryMetricAlertResource` builds. */
+export declare const SENTRY_METRIC_ALERT_IDENTIFIER: {
+    format: string;
+    pattern: RegExp;
+};
+/** Build the stable Sentry metric alert identity shared by tools and webhooks. */
+export declare function sentryMetricAlertResource(input: {
+    alertRuleId: string;
+    org: string;
+}): Pick<SubscribableResource, "identifier" | "label" | "namespace">;

package/dist/index.d.ts

@@ -2,8 +2,8 @@
  * Sentry plugin runtime boundary.
  *
  * This package owns per-user Sentry OAuth, org read access, CLI setup,
- * internal-integration issue webhook normalization, and Sentry resource
- * identities. Junior core owns watches and event automations.
+ * internal-integration issue and metric alert webhook normalization, and
+ * Sentry resource identities. Junior core owns watches and event automations.
  */
 import { type PluginRegistration } from "@sentry/junior-plugin-api";
 /** Register Sentry runtime metadata and signed event ingress. */

package/dist/index.js

@@ -1,9 +1,12 @@
 import {
   SENTRY_ISSUE_EVENTS,
+  SENTRY_METRIC_ALERT_EVENTS,
+  SENTRY_METRIC_ALERT_IDENTIFIER,
+  SENTRY_METRIC_ALERT_SUGGESTED_EVENTS,
   createSentryWebhookRoute,
   sentryWebhookOrg,
   sentryWebhookSecret
-} from "./chunk-UITYE7V6.js";
+} from "./chunk-6VG4NPNH.js";
 
 // src/index.ts
 import {
@@ -79,6 +82,12 @@ function sentryPlugin() {
           type: "project",
           supportedEvents: [...SENTRY_ISSUE_EVENTS],
           suggestedEvents: [...SENTRY_ISSUE_EVENTS]
+        },
+        {
+          type: "metric_alert",
+          identifier: SENTRY_METRIC_ALERT_IDENTIFIER,
+          supportedEvents: [...SENTRY_METRIC_ALERT_EVENTS],
+          suggestedEvents: SENTRY_METRIC_ALERT_SUGGESTED_EVENTS
         }
       ],
       isEnabled: () => Boolean(sentryWebhookSecret()) && Boolean(sentryWebhookOrg()),
@@ -95,7 +104,7 @@ function sentryPlugin() {
         domains: SENTRY_API_DOMAINS,
         type: "oauth-bearer"
       },
-      description: "Investigate Sentry telemetry, manage alerting, and receive issue webhooks",
+      description: "Investigate Sentry telemetry, manage alerting, and receive issue and metric alert webhooks",
       displayName: "Sentry",
       envVars: {
         SENTRY_CLIENT_ID: {},

package/dist/testing.js

@@ -5,7 +5,7 @@ import {
   sentryProjectResource,
   sentryWebhookOrg,
   sentryWebhookSecret
-} from "./chunk-UITYE7V6.js";
+} from "./chunk-6VG4NPNH.js";
 export {
   createSentryWebhookRoute,
   normalizeSentryEvents,

package/dist/webhooks/events.d.ts

@@ -1,8 +1,10 @@
 import type { EventInput } from "@sentry/junior-plugin-api";
-/** Normalize one verified Sentry webhook into issue- and project-scoped events. */
-export declare function normalizeSentryEvents(input: {
+interface WebhookInput {
     body: unknown;
     hookResource: string;
     hookTimestamp?: string;
     webhookOrg: string;
-}): EventInput[];
+}
+/** Normalize one verified Sentry webhook into subscribable Sentry events. */
+export declare function normalizeSentryEvents(input: WebhookInput): EventInput[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-sentry",
-  "version": "0.242.0",
+  "version": "0.243.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "zod": "^4.5.4",
-    "@sentry/junior-plugin-api": "0.242.0"
+    "@sentry/junior-plugin-api": "0.243.0"
   },
   "devDependencies": {
     "@oxlint/plugins": "1.79.0",