bulletin-deploy 0.5.0 → 0.5.2

package/docs/superpowers/plans/2026-03-24-error-telemetry.md

@@ -0,0 +1,453 @@
+# Error Telemetry Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make deploy failures visible in Sentry Issues with full context, enabling alerting and dashboard-driven observability.
+
+**Architecture:** Enrich existing `withSpan`/`withDeploySpan` wrappers in telemetry.js with `captureException` + error attributes inside the `startSpan` callback. Add a `captureWarning` helper for transient failures at retry/fallback call sites. Close a span coverage gap in the DotNS registration flow.
+
+**Tech Stack:** `@sentry/node` ^9.14.0, Node.js `node:test` runner
+
+**Spec:** `docs/superpowers/specs/2026-03-24-error-telemetry-design.md`
+
+---
+
+## File Structure
+
+| File | Role | Change |
+|------|------|--------|
+| `src/telemetry.js` | Telemetry wrappers | Modify `withSpan`, `withDeploySpan`; add `captureWarning` |
+| `src/deploy.js` | Deploy flow / chunk uploads | Add `captureWarning` import and calls in chunk retry loop |
+| `src/dotns.js` | DotNS registration | Add `captureWarning` import and call in RPC fallback; wrap `getPriceAndValidate` in span; renumber finalize span |
+| `test/test.js` | Unit tests | Add tests for `captureWarning`, `withSpan` error propagation, `withDeploySpan` error propagation |
+
+---
+
+### Task 1: Add `captureWarning` helper
+
+**Files:**
+- Modify: `src/telemetry.js:70-73`
+- Test: `test/test.js`
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `test/test.js` — import `captureWarning` and test the no-op path (Sentry is null in test environment because `BULLETIN_DEPLOY_TELEMETRY=0` or `@sentry/node` isn't initialized):
+
+```js
+import { captureWarning } from "../src/telemetry.js";
+
+// ---------------------------------------------------------------------------
+// 6. captureWarning
+// ---------------------------------------------------------------------------
+describe("captureWarning", () => {
+  test("does not throw when Sentry is disabled", () => {
+    assert.doesNotThrow(() => captureWarning("test warning", { key: "value" }));
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: FAIL — `captureWarning` is not exported from telemetry.js
+
+- [ ] **Step 3: Implement `captureWarning`**
+
+Add before the `flush` export at the bottom of `src/telemetry.js` (before the `flush` function):
+
+```js
+export function captureWarning(message, context) {
+  if (!Sentry) return;
+  try {
+    Sentry.addBreadcrumb({ level: "warning", message, data: context });
+    Sentry.captureMessage(message, { level: "warning", extra: context });
+  } catch { /* telemetry must never break the deploy */ }
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/telemetry.js test/test.js
+git commit -m "feat(telemetry): add captureWarning helper for transient failures"
+```
+
+---
+
+### Task 2: Add error capture to `withSpan`
+
+**Files:**
+- Modify: `src/telemetry.js` — the `withSpan` function
+- Test: `test/test.js`
+
+**Note:** Line numbers in this task refer to the original file. Tasks 1-3 all modify `src/telemetry.js` sequentially, so use function names as anchors rather than line numbers.
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `test/test.js` — import `withSpan` and verify errors propagate correctly:
+
+```js
+import { withSpan } from "../src/telemetry.js";
+
+// ---------------------------------------------------------------------------
+// 7. withSpan error propagation
+// ---------------------------------------------------------------------------
+describe("withSpan", () => {
+  test("propagates errors from the callback", async () => {
+    await assert.rejects(
+      () => withSpan("test.op", "test span", {}, () => { throw new Error("span error"); }),
+      { message: "span error" }
+    );
+  });
+
+  test("returns the callback result on success", async () => {
+    const result = await withSpan("test.op", "test span", {}, () => "ok");
+    assert.strictEqual(result, "ok");
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it passes (baseline)**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: PASS — current `withSpan` already propagates errors in the no-Sentry path. This test locks in existing behavior before we change the implementation.
+
+- [ ] **Step 3: Modify `withSpan` to capture errors**
+
+Replace the `withSpan` function in `src/telemetry.js`. This is the **only** place that calls `captureException` for phase errors — `withDeploySpan` (Task 3) will NOT call `captureException` to avoid double-capture. The `deploy.phase` tag is set here so error events carry the correct phase for dashboard queries.
+
+```js
+export async function withSpan(op, description, attributes, fn) {
+  if (!Sentry) return fn();
+  return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
+    try {
+      return await fn();
+    } catch (error) {
+      span.setAttribute("error.message", error.message);
+      Sentry.setTag("deploy.phase", op);
+      Sentry.captureException(error);
+      error._sentryCaptured = true;
+      throw error;
+    }
+  });
+}
+```
+
+The `error._sentryCaptured = true` flag prevents `withDeploySpan` from capturing the same error a second time.
+
+- [ ] **Step 4: Run test to verify it still passes**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS — behavior unchanged in the no-Sentry path; the new try/catch only activates when Sentry is loaded.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/telemetry.js test/test.js
+git commit -m "feat(telemetry): capture exceptions and error attributes in withSpan"
+```
+
+---
+
+### Task 3: Add error capture and deploy tags to `withDeploySpan`
+
+**Files:**
+- Modify: `src/telemetry.js` — the `withDeploySpan` function
+- Test: `test/test.js`
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `test/test.js` — import `withDeploySpan`:
+
+```js
+import { withDeploySpan } from "../src/telemetry.js";
+
+// ---------------------------------------------------------------------------
+// 8. withDeploySpan error propagation
+// ---------------------------------------------------------------------------
+describe("withDeploySpan", () => {
+  test("propagates errors from the callback", async () => {
+    await assert.rejects(
+      () => withDeploySpan("test-domain", () => { throw new Error("deploy error"); }),
+      { message: "deploy error" }
+    );
+  });
+
+  test("returns the callback result on success", async () => {
+    const result = await withDeploySpan("test-domain", () => "deployed");
+    assert.strictEqual(result, "deployed");
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it passes (baseline)**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: PASS — locks in existing behavior.
+
+- [ ] **Step 3: Modify `withDeploySpan` to capture errors and set tags**
+
+Replace the `withDeploySpan` function in `src/telemetry.js`:
+
+```js
+export async function withDeploySpan(domain, fn) {
+  if (!Sentry) return fn();
+  const attrs = { ...getDeployAttributes(), "deploy.domain": domain };
+  try {
+    return await Sentry.startSpan({ op: "deploy", name: `deploy ${domain}`, attributes: attrs }, async (span) => {
+      Sentry.setTags({
+        "deploy.repo": attrs["deploy.repo"],
+        "deploy.branch": attrs["deploy.branch"],
+        "deploy.domain": domain,
+        "deploy.source": attrs["deploy.source"],
+      });
+      try {
+        return await fn();
+      } catch (error) {
+        span.setAttribute("deploy.status", "error");
+        span.setAttribute("deploy.error", error.message);
+        if (!error._sentryCaptured) {
+          Sentry.setTag("deploy.phase", "deploy");
+          Sentry.captureException(error);
+        }
+        throw error;
+      }
+    });
+  } finally {
+    await Sentry.flush(5000);
+  }
+}
+```
+
+Key points:
+- `Sentry.setTags` at span start ensures all error events within the deploy carry `deploy.repo`, `deploy.branch`, `deploy.domain`
+- **No double capture**: The `_sentryCaptured` check ensures errors already captured by an inner `withSpan` are not captured again. Only errors that bypass inner spans (e.g. code between spans) get captured here with `deploy.phase = "deploy"`.
+- The span still gets `deploy.status` and `deploy.error` attributes regardless — useful for trace view.
+- The outer `try/finally` with `flush` is unchanged.
+
+- [ ] **Step 4: Run test to verify it still passes**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/telemetry.js test/test.js
+git commit -m "feat(telemetry): capture exceptions and deploy tags in withDeploySpan"
+```
+
+---
+
+### Task 4: Add chunk retry warnings in deploy.js
+
+**Files:**
+- Modify: `src/deploy.js:20` (import)
+- Modify: `src/deploy.js:201-214` (chunk retry loop)
+
+- [ ] **Step 1: Add `captureWarning` to the import**
+
+In `src/deploy.js` line 20, change:
+
+```js
+import { initTelemetry, withSpan, withDeploySpan, setDeployAttribute, flush } from "./telemetry.js";
+```
+
+to:
+
+```js
+import { initTelemetry, withSpan, withDeploySpan, setDeployAttribute, captureWarning, flush } from "./telemetry.js";
+```
+
+- [ ] **Step 2: Add warning at initial batch failure detection**
+
+In `src/deploy.js`, inside the `for (const fail of failures)` loop body (after line 201), add a `captureWarning` call before the retry loop:
+
+```js
+      for (const fail of failures) {
+        captureWarning("Chunk upload failed, retrying", { chunkIndex: fail.index + 1, maxRetries: MAX_CHUNK_RETRIES, error: fail.error?.message?.slice(0, 200) });
+        let retried = false;
+```
+
+- [ ] **Step 3: Add warning on individual retry failures**
+
+In `src/deploy.js`, inside the retry catch block (after line 213), add:
+
+```js
+          } catch (e) {
+            captureWarning("Chunk retry failed", { chunkIndex: fail.index + 1, attempt, maxRetries: MAX_CHUNK_RETRIES, error: e.message?.slice(0, 200) });
+            console.log(`   Retry ${attempt} failed: ${e.message?.slice(0, 80)}`);
+          }
+```
+
+- [ ] **Step 4: Run existing tests to verify no regressions**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/deploy.js
+git commit -m "feat(telemetry): add transient failure warnings for chunk retries"
+```
+
+---
+
+### Task 5: Add RPC fallback warning in dotns.js
+
+**Files:**
+- Modify: `src/dotns.js:23` (import)
+- Modify: `src/dotns.js:319-323` (RPC fallback catch block)
+
+- [ ] **Step 1: Add `captureWarning` to the import**
+
+In `src/dotns.js` line 23, change:
+
+```js
+import { withSpan } from "./telemetry.js";
+```
+
+to:
+
+```js
+import { withSpan, captureWarning } from "./telemetry.js";
+```
+
+- [ ] **Step 2: Add warning in the RPC endpoint catch block**
+
+In `src/dotns.js`, inside the `connect()` catch block (after line 319), add the `captureWarning` call:
+
+```js
+      } catch (e) {
+        lastError = e;
+        captureWarning("DotNS RPC endpoint failed, trying next", { endpoint: rpc, error: e.message, remainingEndpoints: endpoints.length - endpoints.indexOf(rpc) - 1 });
+        console.log(`   Failed to connect to ${rpc}: ${e.message}`);
+        if (this.client) { try { this.client.destroy(); } catch {} this.client = null; }
+      }
+```
+
+- [ ] **Step 3: Run existing tests to verify no regressions**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/dotns.js
+git commit -m "feat(telemetry): add transient failure warning for DotNS RPC fallback"
+```
+
+---
+
+### Task 6: Close span coverage gap and renumber spans in dotns.js
+
+**Files:**
+- Modify: `src/dotns.js:528-529` (register method)
+
+- [ ] **Step 1: Wrap `getPriceAndValidate` in a span and renumber `finalize-registration`**
+
+In `src/dotns.js`, replace lines 528-529:
+
+```js
+      const pricing = await this.getPriceAndValidate(label);
+      await withSpan("deploy.dotns.finalize-registration", "2a-iii. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
+```
+
+with:
+
+```js
+      const pricing = await withSpan("deploy.dotns.price-validation", "2a-iii. price-validation", {}, () => this.getPriceAndValidate(label));
+      await withSpan("deploy.dotns.finalize-registration", "2a-iv. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
+```
+
+- [ ] **Step 2: Run existing tests to verify no regressions**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/dotns.js
+git commit -m "feat(telemetry): add price-validation span, renumber finalize to 2a-iv"
+```
+
+---
+
+### Task 7: Final verification
+
+- [ ] **Step 1: Run full test suite**
+
+Run: `BULLETIN_DEPLOY_TELEMETRY=0 node --test test/test.js`
+Expected: ALL PASS
+
+- [ ] **Step 2: Verify telemetry.js exports are consistent**
+
+Run: `node -e "import('./src/telemetry.js').then(m => console.log(Object.keys(m).sort().join(', ')))"`
+Expected: `captureWarning, flush, initTelemetry, setDeployAttribute, withDeploySpan, withSpan`
+
+- [ ] **Step 3: Commit all remaining changes (if any)**
+
+**Testing limitation note:** All tests run with Sentry disabled (the no-op path). The Sentry-active code paths (captureException, captureMessage, addBreadcrumb, setTags, setAttribute) are only exercised during real deploys. This is acceptable because the no-op guard (`if (!Sentry) return`) means tests verify that non-telemetry behavior is preserved, and the Sentry calls are straightforward SDK usage. Mock-based Sentry tests can be added as a follow-up if needed.
+
+---
+
+### Task 8: Dashboard widgets (manual)
+
+This task is performed in the Sentry web UI, not in code.
+
+**Dashboard:** `https://polkadot-community-foundation.sentry.io/dashboards/92523/`
+
+- [ ] **Step 1: Add "Failure rate over time" widget**
+
+Type: Line chart
+Dataset: Errors
+Query: `event.type:error`
+Y-axis: `count()`
+Group by: timestamp (hour)
+
+- [ ] **Step 2: Add "Failures by repo" widget**
+
+Type: Bar chart
+Dataset: Errors
+Query: `event.type:error`
+Y-axis: `count()`
+Group by: `deploy.repo` tag
+
+- [ ] **Step 3: Add "Failures by phase" widget**
+
+Type: Bar chart
+Dataset: Errors
+Query: `event.type:error`
+Y-axis: `count()`
+Group by: `deploy.phase` tag
+
+- [ ] **Step 4: Add "Failures by error type" widget**
+
+Type: Table
+Dataset: Errors
+Query: `event.type:error`
+Columns: `deploy.error`, `count()`, `last_seen()`
+
+- [ ] **Step 5: Add "Transient failure trends" widget**
+
+Type: Line chart
+Dataset: Errors
+Query: `level:warning`
+Y-axis: `count()`
+Group by: timestamp (day)
+
+- [ ] **Step 6: Add "Deploy success vs failure" widget**
+
+Type: Stacked area chart
+Dataset: Spans
+Query: `span.op:deploy`
+Y-axis: `count()`
+Group by: `span.status`

package/docs/superpowers/specs/2026-03-24-error-telemetry-design.md

@@ -0,0 +1,105 @@
+# Error Telemetry for bulletin-deploy
+
+**Date**: 2026-03-24
+**Status**: Approved
+**Trigger**: t3rminal deploy failed 6 times on 2026-03-23 with zero visibility in Sentry
+
+## Problem
+
+The telemetry module creates spans/traces for deploy phases, but:
+
+1. **No error events** — `Sentry.captureException()` is never called. Failures produce incomplete span trees but no Sentry Issues, so alerting is impossible.
+2. **No error context on spans** — When a span's callback throws, the span ends but carries no attributes describing what failed or why.
+3. **Span coverage gap** — `getPriceAndValidate` in `dotns.js` runs between the `wait-commitment-age` and `finalize-registration` spans with no span of its own. Last night's failure (DotNS v1.1.0 rejecting names with trailing hyphens) hit this exact gap.
+4. **Transient failures invisible** — Chunk retries, RPC fallbacks, and contract reverts that self-recover leave no trace. Flakiness trends are undetectable until they escalate to full failures.
+
+## Design
+
+### 1. Terminal error capture (telemetry.js)
+
+Modify `withSpan` and `withDeploySpan` to catch errors before re-throwing.
+
+**Critical implementation detail**: The try/catch + `captureException` must go **inside** the `Sentry.startSpan` callback, not outside it. The deploy span is only the active span within the callback scope — calling `captureException` outside would not associate the error event with the correct span/trace.
+
+**`withSpan(op, description, attributes, fn)`**:
+- Change the startSpan callback to intercept the `span` argument: `Sentry.startSpan({ ... }, async (span) => { ... })`
+- Inside the callback: try/catch around `fn()`
+- On error: `span.setAttribute("error.message", error.message)`, call `Sentry.captureException(error)`, re-throw
+- Sentry auto-sets span status to ERROR on throw (keep this behavior)
+
+**`withDeploySpan(domain, fn)`**:
+- Same pattern: try/catch goes **inside** the startSpan callback to access the span and active scope
+- On error: `span.setAttribute("deploy.status", "error")`, `span.setAttribute("deploy.error", error.message)`, call `Sentry.captureException(error)`, re-throw
+- Before `captureException`, call `Sentry.setTag("deploy.phase", span.op)` so the error event carries the phase for dashboard queries (span attributes don't auto-propagate to error events)
+- Set `Sentry.setTags` for `deploy.repo`, `deploy.branch`, `deploy.domain` in the scope at span start so all error events within the deploy carry these tags
+- The outer `try/finally` stays outside the startSpan callback for `Sentry.flush()`
+
+### 2. Transient failure capture
+
+New helper in telemetry.js:
+
+**`captureWarning(message, context)`**:
+- Calls `Sentry.addBreadcrumb({ level: "warning", message, data: context })` — attaches to the timeline of any subsequent error event
+- Calls `Sentry.captureMessage(message, { level: "warning", extra: context })` — creates a standalone Sentry Issue for the transient failure
+
+**Volume note**: Every transient failure creates a standalone Sentry Issue. Sentry deduplicates by message fingerprint, so repeated chunk retries with the same message collapse into one issue with multiple events. If volume becomes a concern, `captureMessage` can be removed and breadcrumbs alone retained (they still appear in the timeline of any terminal error).
+
+Call sites — **only at points where a failure is caught and retried**, not in generic methods:
+
+**deploy.js — chunk retry loop** (~line 201):
+- At the start of `for (const fail of failures)` loop body, when a chunk from the batch has failed and will be retried
+- Also inside the retry loop catch (~line 212) for subsequent retry failures
+- Context: `{ chunkIndex, attempt, maxRetries, error: error.message }`
+
+**dotns.js — RPC endpoint fallback** (~line 319-323):
+- When an RPC endpoint fails in `connect()` and the next endpoint will be tried
+- Context: `{ endpoint, error: error.message, remainingEndpoints }`
+
+**NOT in contractCall/contractTransaction generically** — those methods throw for both terminal and transient failures. Adding captureWarning there would duplicate errors already captured by `withSpan`. Only the specific retry/fallback sites above get captureWarning calls.
+
+### 3. Span coverage gap (dotns.js)
+
+Wrap `getPriceAndValidate` in its own span in the `register` method:
+
+```
+2a-i.   submit-commitment       (deploy.dotns.submit-commitment)
+2a-ii.  wait-commitment-age     (deploy.dotns.wait-commitment-age)
+2a-iii. price-validation        (deploy.dotns.price-validation)        <-- NEW
+2a-iv.  finalize-registration   (deploy.dotns.finalize-registration)   <-- renumbered
+```
+
+This closes the gap where last night's failure was invisible in the trace tree.
+
+### 4. Dashboard widgets
+
+Add to existing dashboard at `polkadot-community-foundation.sentry.io/dashboards/92523/`:
+
+| Widget | Type | Groups by | Purpose |
+|--------|------|-----------|---------|
+| Failure rate over time | Line chart | Error events by day/hour | Trend and cluster detection |
+| Failures by repo | Bar chart | `deploy.repo` tag | Which consuming repos hit failures most |
+| Failures by phase | Bar chart | `deploy.phase` tag on error events | Storage vs DotNS vs specific sub-phase |
+| Failures by error type | Table | `deploy.error` message | "Contract reverted" vs "timed out" vs "RPC failed" |
+| Transient failure trends | Line chart | Warning events over time | Flakiness early warning |
+| Deploy success vs failure | Stacked area | Span status (ok/error) over time | At-a-glance health |
+
+## Files changed
+
+| File | Change |
+|------|--------|
+| `src/telemetry.js` | Modify `withSpan`, `withDeploySpan`; add `captureWarning` |
+| `src/deploy.js` | Add `captureWarning` calls in chunk retry loop |
+| `src/dotns.js` | Add `captureWarning` calls in RPC fallback and contract errors; wrap `getPriceAndValidate` in span |
+
+## What this enables
+
+- **Alerting**: Alert rules on error events (any deploy failure), warning events (transient failure trends), specific error messages (contract behavior changes)
+- **Dashboards**: Failure rates, phase breakdown, repo breakdown, flakiness trends
+- **Trace diagnostics**: Error attributes on spans show what failed and why; breadcrumb timeline shows the full sequence of events leading to failure
+- **Coverage**: Both CI and local CLI paths go through `deploy()` -> `initTelemetry()` -> `withDeploySpan()`, so all changes apply to both
+
+## Out of scope
+
+- Custom Sentry metrics (span durations already cover performance)
+- Structured error types/codes (error messages are sufficient for now)
+- Retry logic changes (separate concern from observability)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "private": false,
   "repository": {
     "type": "git",

package/src/deploy.js

@@ -17,7 +17,7 @@ import { UnixFS } from "ipfs-unixfs";
 import { DotNS, fetchNonce, TX_TIMEOUT_MS } from "./dotns.js";
 import { cryptoWaitReady } from "@polkadot/util-crypto";
 import { derivePoolAccounts, fetchPoolAuthorizations, selectAccount, ensureAuthorized } from "./pool.js";
-import { initTelemetry, withSpan, withDeploySpan, setDeployAttribute, flush } from "./telemetry.js";
+import { initTelemetry, withSpan, withDeploySpan, setDeployAttribute, captureWarning, flush } from "./telemetry.js";
 
 const BULLETIN_RPC = process.env.BULLETIN_RPC || "wss://paseo-bulletin-rpc.polkadot.io";
 const POOL_SIZE = parseInt(process.env.BULLETIN_POOL_SIZE || "10", 10);
@@ -199,6 +199,7 @@ export async function storeChunkedContent(chunks, { client: existingClient, unsa
         .filter(Boolean);
 
       for (const fail of failures) {
+        captureWarning("Chunk upload failed, retrying", { chunkIndex: fail.index + 1, maxRetries: MAX_CHUNK_RETRIES, error: fail.error?.message?.slice(0, 200) });
         let retried = false;
         for (let attempt = 1; attempt <= MAX_CHUNK_RETRIES; attempt++) {
           console.log(`   Retrying chunk ${fail.index + 1} (attempt ${attempt}/${MAX_CHUNK_RETRIES})...`);
@@ -210,6 +211,7 @@ export async function storeChunkedContent(chunks, { client: existingClient, unsa
             retried = true;
             break;
           } catch (e) {
+            captureWarning("Chunk retry failed", { chunkIndex: fail.index + 1, attempt, maxRetries: MAX_CHUNK_RETRIES, error: e.message?.slice(0, 200) });
             console.log(`   Retry ${attempt} failed: ${e.message?.slice(0, 80)}`);
           }
         }

package/src/dotns.js

@@ -20,7 +20,7 @@ import {
   concatHex,
 } from "viem";
 import { CID } from "multiformats/cid";
-import { withSpan } from "./telemetry.js";
+import { withSpan, captureWarning } from "./telemetry.js";
 
 export const RPC_ENDPOINTS = [
   "wss://asset-hub-paseo.dotters.network",
@@ -160,7 +160,7 @@ export function computeDomainTokenId(label) {
   return BigInt(node);
 }
 export function countTrailingDigits(label) { let count = 0; for (let i = label.length - 1; i >= 0; i--) { const code = label.charCodeAt(i); if (code >= 48 && code <= 57) count++; else break; } return count; }
-export function stripTrailingDigits(label) { return label.replace(/\d+$/, ""); }
+export function stripTrailingDigits(label) { return label.replace(/\d+$/, "").replace(/-$/, ""); }
 
 export function validateDomainLabel(label) {
   if (!/^[a-z0-9-]{3,}$/.test(label)) throw new Error("Invalid domain label: must contain only lowercase letters, digits, and hyphens, min 3 chars");
@@ -318,6 +318,7 @@ export class DotNS {
         return this;
       } catch (e) {
         lastError = e;
+        captureWarning("DotNS RPC endpoint failed, trying next", { endpoint: rpc, error: e.message, remainingEndpoints: endpoints.length - endpoints.indexOf(rpc) - 1 });
         console.log(`   Failed to connect to ${rpc}: ${e.message}`);
         if (this.client) { try { this.client.destroy(); } catch {} this.client = null; }
       }
@@ -525,8 +526,8 @@ export class DotNS {
       const { commitment, registration } = await this.generateCommitment(label, reverse);
       await withSpan("deploy.dotns.submit-commitment", "2a-i. submit-commitment", {}, () => this.submitCommitment(commitment));
       await withSpan("deploy.dotns.wait-commitment-age", "2a-ii. wait-commitment-age", {}, () => this.waitForCommitmentAge());
-      const pricing = await this.getPriceAndValidate(label);
-      await withSpan("deploy.dotns.finalize-registration", "2a-iii. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
+      const pricing = await withSpan("deploy.dotns.price-validation", "2a-iii. price-validation", {}, () => this.getPriceAndValidate(label));
+      await withSpan("deploy.dotns.finalize-registration", "2a-iv. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
       await this.verifyOwnership(label);
       console.log(`\n   Registration complete!`);
       return { label, owner: this.evmAddress };

package/src/telemetry.js

@@ -2,6 +2,8 @@
 // Set BULLETIN_DEPLOY_TELEMETRY=0 to disable.
 
 import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 
 const DEFAULT_DSN = "https://e021c025d79c4c3ade2862a11f13c40b@o4509440811401216.ingest.de.sentry.io/4511093597405264";
 const DISABLED = process.env.BULLETIN_DEPLOY_TELEMETRY === "0";
@@ -25,10 +27,27 @@ export function initTelemetry() {
   });
 }
 
+function extractRepoSlug(url) {
+  return url.replace(/.*github\.com[:/]/, "").replace(/\.git$/, "");
+}
+
 function tryGitRemote() {
   try {
-    return execSync("git remote get-url origin", { encoding: "utf-8" }).trim().replace(/.*github\.com[:/]/, "").replace(/\.git$/, "");
-  } catch { return "unknown"; }
+    return extractRepoSlug(execSync("git remote get-url origin", { encoding: "utf-8" }).trim());
+  } catch { return undefined; }
+}
+
+function tryPackageJsonRepo() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8"));
+    const repo = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+    if (repo) return extractRepoSlug(repo);
+  } catch {}
+  return undefined;
+}
+
+export function resolveRepo(domain) {
+  return process.env.GITHUB_REPOSITORY || tryGitRemote() || tryPackageJsonRepo() || domain || "unknown";
 }
 
 function tryGitBranch() {
@@ -37,9 +56,9 @@ function tryGitBranch() {
   } catch { return "unknown"; }
 }
 
-function getDeployAttributes() {
+function getDeployAttributes(domain) {
   return {
-    "deploy.repo": process.env.GITHUB_REPOSITORY || tryGitRemote(),
+    "deploy.repo": resolveRepo(domain),
     "deploy.branch": process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || tryGitBranch(),
     "deploy.source": process.env.CI ? "ci" : "local",
     "deploy.pr": process.env.GITHUB_PR_NUMBER || undefined,
@@ -48,14 +67,42 @@ function getDeployAttributes() {
 
 export async function withSpan(op, description, attributes, fn) {
   if (!Sentry) return fn();
-  return Sentry.startSpan({ op, name: description, attributes }, fn);
+  return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
+    try {
+      return await fn();
+    } catch (error) {
+      span.setAttribute("error.message", error.message);
+      Sentry.setTag("deploy.phase", op);
+      Sentry.captureException(error);
+      error._sentryCaptured = true;
+      throw error;
+    }
+  });
 }
 
 export async function withDeploySpan(domain, fn) {
   if (!Sentry) return fn();
-  const attrs = { ...getDeployAttributes(), "deploy.domain": domain };
+  const attrs = { ...getDeployAttributes(domain), "deploy.domain": domain };
   try {
-    return await Sentry.startSpan({ op: "deploy", name: `deploy ${domain}`, attributes: attrs }, fn);
+    return await Sentry.startSpan({ op: "deploy", name: `deploy ${domain}`, attributes: attrs }, async (span) => {
+      Sentry.setTags({
+        "deploy.repo": attrs["deploy.repo"],
+        "deploy.branch": attrs["deploy.branch"],
+        "deploy.domain": domain,
+        "deploy.source": attrs["deploy.source"],
+      });
+      try {
+        return await fn();
+      } catch (error) {
+        span.setAttribute("deploy.status", "error");
+        span.setAttribute("deploy.error", error.message);
+        if (!error._sentryCaptured) {
+          Sentry.setTag("deploy.phase", "deploy");
+          Sentry.captureException(error);
+        }
+        throw error;
+      }
+    });
   } finally {
     await Sentry.flush(5000);
   }
@@ -67,6 +114,14 @@ export function setDeployAttribute(key, value) {
   if (span) span.setAttribute(key, value);
 }
 
+export function captureWarning(message, context) {
+  if (!Sentry) return;
+  try {
+    Sentry.addBreadcrumb({ level: "warning", message, data: context });
+    Sentry.captureMessage(message, { level: "warning", extra: context });
+  } catch { /* telemetry must never break the deploy */ }
+}
+
 export async function flush() {
   if (!Sentry) return;
   await Sentry.flush(5000);

package/test/test.js

@@ -1,7 +1,8 @@
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
 import { createCID, encodeContenthash } from "../src/deploy.js";
-import { validateDomainLabel, fetchNonce, TX_TIMEOUT_MS } from "../src/dotns.js";
+import { validateDomainLabel, stripTrailingDigits, fetchNonce, TX_TIMEOUT_MS } from "../src/dotns.js";
+import { captureWarning, withSpan, withDeploySpan, resolveRepo } from "../src/telemetry.js";
 
 // ---------------------------------------------------------------------------
 // 1. createCID
@@ -86,7 +87,28 @@ describe("validateDomainLabel", () => {
 });
 
 // ---------------------------------------------------------------------------
-// 4. fetchNonce timeout
+// 4. stripTrailingDigits
+// ---------------------------------------------------------------------------
+describe("stripTrailingDigits", () => {
+  test("strips trailing digits", () => {
+    assert.strictEqual(stripTrailingDigits("my-app00"), "my-app");
+  });
+
+  test("strips trailing hyphen after digits", () => {
+    assert.strictEqual(stripTrailingDigits("t3rminal-app-88-pr-80"), "t3rminal-app-88-pr");
+  });
+
+  test("handles no trailing digits", () => {
+    assert.strictEqual(stripTrailingDigits("my-app"), "my-app");
+  });
+
+  test("handles all digits suffix", () => {
+    assert.strictEqual(stripTrailingDigits("app-123"), "app");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 5. fetchNonce timeout
 // ---------------------------------------------------------------------------
 describe("fetchNonce", () => {
   test(
@@ -112,3 +134,91 @@ describe("TX_TIMEOUT_MS", () => {
     assert.strictEqual(TX_TIMEOUT_MS, 90_000);
   });
 });
+
+// ---------------------------------------------------------------------------
+// 6. resolveRepo fallback chain
+// ---------------------------------------------------------------------------
+describe("resolveRepo", () => {
+  function withEnv(env, cwd, fn) {
+    const prev = process.env.GITHUB_REPOSITORY;
+    const prevCwd = process.cwd();
+    if (env !== undefined) process.env.GITHUB_REPOSITORY = env;
+    else delete process.env.GITHUB_REPOSITORY;
+    if (cwd) process.chdir(cwd);
+    try { return fn(); }
+    finally {
+      if (cwd) process.chdir(prevCwd);
+      if (prev !== undefined) process.env.GITHUB_REPOSITORY = prev;
+      else delete process.env.GITHUB_REPOSITORY;
+    }
+  }
+
+  test("prefers GITHUB_REPOSITORY env var", () => {
+    withEnv("myorg/myrepo", null, () => {
+      assert.strictEqual(resolveRepo("some-domain"), "myorg/myrepo");
+    });
+  });
+
+  test("falls back to git remote when GITHUB_REPOSITORY is unset", () => {
+    withEnv(undefined, null, () => {
+      const result = resolveRepo("fallback-domain");
+      assert.ok(result !== "unknown", `expected a resolved repo, got: ${result}`);
+      assert.ok(result !== "fallback-domain", `should not fall through to domain when git works`);
+    });
+  });
+
+  test("falls back to domain when git and package.json are unavailable", () => {
+    withEnv(undefined, "/tmp", () => {
+      assert.strictEqual(resolveRepo("instagram-dapp"), "instagram-dapp");
+    });
+  });
+
+  test("returns 'unknown' only when everything fails", () => {
+    withEnv(undefined, "/tmp", () => {
+      assert.strictEqual(resolveRepo(undefined), "unknown");
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 7. captureWarning
+// ---------------------------------------------------------------------------
+describe("captureWarning", () => {
+  test("does not throw when Sentry is disabled", () => {
+    assert.doesNotThrow(() => captureWarning("test warning", { key: "value" }));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 8. withSpan error propagation
+// ---------------------------------------------------------------------------
+describe("withSpan", () => {
+  test("propagates errors from the callback", async () => {
+    await assert.rejects(
+      () => withSpan("test.op", "test span", {}, () => { throw new Error("span error"); }),
+      { message: "span error" }
+    );
+  });
+
+  test("returns the callback result on success", async () => {
+    const result = await withSpan("test.op", "test span", {}, () => "ok");
+    assert.strictEqual(result, "ok");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 9. withDeploySpan error propagation
+// ---------------------------------------------------------------------------
+describe("withDeploySpan", () => {
+  test("propagates errors from the callback", async () => {
+    await assert.rejects(
+      () => withDeploySpan("test-domain", () => { throw new Error("deploy error"); }),
+      { message: "deploy error" }
+    );
+  });
+
+  test("returns the callback result on success", async () => {
+    const result = await withDeploySpan("test-domain", () => "deployed");
+    assert.strictEqual(result, "deployed");
+  });
+});

package/workflows/deploy-on-pr.yml

@@ -65,6 +65,7 @@ jobs:
         env:
           MNEMONIC: ${{ secrets.DOTNS_MNEMONIC }}
           SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
           NODE_OPTIONS: '--max-old-space-size=8192'
 
       - name: Comment on PR