@theholocron/holocron-plugin-sentry 5.0.0-alpha.227 → 5.0.0-alpha.229

package/dist/index.d.mts

@@ -82,6 +82,7 @@ declare function createContext(options: SentryPluginOptions): PluginContext;
 declare function errors(ctx: PluginContext): Errors;
 declare function createPlugin(options: SentryPluginOptions): {
   name: string;
+  probes: import("@theholocron/cli").PluginProbes;
   capabilities: {
     errors: () => Errors;
   };

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { AuthError, ProviderApiError, createFeatureResolver, createResolveToken } from "@theholocron/cli";
+import { randomUUID } from "node:crypto";
 import { createSentryClient } from "@theholocron/sentry-client";
 import { errorMessage } from "@theholocron/misc-utils";
 //#region src/auth.ts
@@ -300,6 +301,156 @@ function toSlug(name) {
 	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 //#endregion
+//#region src/probes/probe-deps.type.ts
+function requireOrg(deps) {
+	if (!deps.org) throw new Error("the Sentry probes need `org` in the sentry provider's options");
+	return deps.org;
+}
+//#endregion
+//#region src/probes/integrations.ts
+/** Where a webhook points, without a query string that could carry a token. */
+function where(url) {
+	if (!url) return "no webhook";
+	try {
+		const u = new URL(url);
+		return `${u.host}${u.pathname}`;
+	} catch {
+		return "an unreadable URL";
+	}
+}
+function integrationsProbe(deps) {
+	return {
+		summary: "List the custom integrations: scopes, alert action, webhook, and whether the client secret is visible.",
+		writes: false,
+		async run(probe) {
+			const apps = await deps.client().sentryApps.list(requireOrg(deps));
+			if (apps.length === 0) probe.say({
+				status: "info",
+				label: "no custom integrations"
+			});
+			for (const app of apps) {
+				probe.secret(app.clientSecret);
+				probe.say({
+					status: "ok",
+					label: `${app.name} (${app.slug})`,
+					detail: [
+						`scopes: ${app.scopes.join(", ") || "none"}`,
+						`alert action: ${app.isAlertable ? "on" : "off"}`,
+						`webhook: ${where(app.webhookUrl)}`,
+						`secret visible: ${app.clientSecret ? "yes" : "no"}`
+					].join(" | ")
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/probes/rules.ts
+function rulesProbe(deps) {
+	return {
+		summary: "List the alert rules: enabled, projects attached, and what each action sends to.",
+		writes: false,
+		async run(probe) {
+			const org = requireOrg(deps);
+			const client = deps.client();
+			const [workflows, apps] = await Promise.all([client.workflows.list(org), client.sentryApps.list(org)]);
+			const alertable = new Set(apps.filter((a) => a.isAlertable).map((a) => a.slug));
+			if (workflows.length === 0) probe.say({
+				status: "info",
+				label: "no alert rules"
+			});
+			for (const wf of workflows) {
+				const actions = wf.actionFilters.flatMap((f) => f.actions);
+				const described = actions.map((a) => {
+					const target = String(a.config["targetIdentifier"] ?? a.config["targetType"] ?? "");
+					return target ? `${a.type} ${target}` : a.type;
+				});
+				const problems = actions.flatMap((a) => {
+					if (a.type === "sentry_app") return [`a sentry_app action shows as an unknown integration`];
+					if (a.type === "webhook" && !alertable.has(String(a.config["targetIdentifier"]))) return [`webhook ${String(a.config["targetIdentifier"])} is not an alertable integration`];
+					return [];
+				});
+				probe.say({
+					status: problems.length > 0 || !wf.enabled ? "fail" : "ok",
+					label: wf.name,
+					detail: [
+						wf.enabled ? "enabled" : "DISABLED",
+						`detectors: ${wf.detectorIds.length}`,
+						`actions: ${described.join(", ") || "none"}`,
+						...problems
+					].join(" | ")
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/probes/send-error.ts
+/** Which DSN to send to: `SENTRY_DSN`, else the first client key of the project named in `HOLOCRON_SENTRY_PROBE_PROJECT`. */
+async function dsnFor(deps) {
+	const env = deps.env ?? process.env;
+	if (env["SENTRY_DSN"]) return env["SENTRY_DSN"];
+	const project = env["HOLOCRON_SENTRY_PROBE_PROJECT"];
+	if (!project) throw new Error("set SENTRY_DSN, or HOLOCRON_SENTRY_PROBE_PROJECT to a project slug, to say where to send the error");
+	const dsn = (await deps.client().projects.keys(requireOrg(deps), project))[0]?.dsn.public;
+	if (!dsn) throw new Error(`project \`${project}\` has no client key`);
+	return dsn;
+}
+function sendErrorProbe(deps) {
+	return {
+		summary: "Send one labelled test error to a project, to follow it through the alert rule to Discord.",
+		writes: true,
+		async run(probe) {
+			const dsn = new URL(await dsnFor(deps));
+			probe.secret(dsn.username);
+			const projectId = dsn.pathname.replace(/^\/+/, "");
+			const eventId = randomUUID().replaceAll("-", "");
+			const message = `Holocron probe: sent on purpose (${(/* @__PURE__ */ new Date()).toISOString()})`;
+			const envelope = [
+				JSON.stringify({
+					event_id: eventId,
+					sent_at: (/* @__PURE__ */ new Date()).toISOString()
+				}),
+				JSON.stringify({ type: "event" }),
+				JSON.stringify({
+					event_id: eventId,
+					level: "error",
+					platform: "node",
+					environment: "holocron-probe",
+					message: { formatted: message },
+					exception: { values: [{
+						type: "HolocronProbeError",
+						value: message
+					}] },
+					tags: { probe: "sentry.send-error" }
+				})
+			].join("\n");
+			if (await probe.write("send a test error", async () => {
+				const res = await (deps.fetch ?? fetch)(`${dsn.protocol}//${dsn.host}/api/${projectId}/envelope/?sentry_version=7&sentry_key=${dsn.username}&sentry_client=holocron-probe/1`, {
+					method: "POST",
+					headers: { "content-type": "application/x-sentry-envelope" },
+					body: envelope
+				});
+				if (!res.ok) throw new Error(`Sentry answered ${res.status}`);
+				return true;
+			})) probe.say({
+				status: "ok",
+				label: "sent HolocronProbeError",
+				detail: "look for it in the project's issues and, through the rule, in #errors; resolve the issue by hand (a probe cannot delete it)"
+			});
+		}
+	};
+}
+//#endregion
+//#region src/probes/index.ts
+function sentryProbes(deps) {
+	return {
+		integrations: integrationsProbe(deps),
+		rules: rulesProbe(deps),
+		"send-error": sendErrorProbe(deps)
+	};
+}
+//#endregion
 //#region src/verify-token.ts
 async function verifyToken(token, opts = {}) {
 	const client = createSentryClient({
@@ -348,6 +499,11 @@ function createPlugin(options) {
 	const ctx = createContext(options);
 	return {
 		name: "@theholocron/holocron-plugin-sentry",
+		probes: sentryProbes({
+			org: options.org,
+			client: ctx.relayClient,
+			fetch: options.fetch
+		}),
 		capabilities: { errors: () => errors(ctx) }
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/holocron-plugin-sentry",
-  "version": "5.0.0-alpha.227",
+  "version": "5.0.0-alpha.229",
   "description": "Holocron plugin for Sentry. Implements the errors capability against Sentry's management API — project provisioning and DSN retrieval.",
   "keywords": [
     "errors",
@@ -48,12 +48,12 @@
     "tsx": "4.23.15",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "@theholocron/cli": "5.0.0-alpha.227"
+    "@theholocron/cli": "5.0.0-alpha.229"
   },
   "peerDependencies": {
     "@theholocron/misc-utils": "^1.16.0",
     "@theholocron/sentry-client": "^1.54.0",
-    "@theholocron/cli": "5.0.0-alpha.227"
+    "@theholocron/cli": "5.0.0-alpha.229"
   },
   "peerDependenciesMeta": {
     "@theholocron/sentry-client": {}