@vzn/vx-otel 0.0.652 → 0.0.653

package/README.md

@@ -96,12 +96,14 @@ otel({
   is counted, `-- <N arguments>`, never quoted, and a secret value
   before it is `***`), CI provider,
   host/os/arch, vx version, and `cicd.pipeline.result` (`success`, `failure`, or
-  `cancellation` for a run stopped with nothing failed); a red run sets
+  `cancellation` for a run stopped with nothing failed), and the counts:
+  `vx.run.aborted_count` the tasks the stop cut short, `vx.run.not_run_count`
+  the ones it reached first; a red run sets
   span status `ERROR`;
-- a child `vx.task` span per task — `cicd.pipeline.task.name`,
+- a child `vx.task` span per task (none for one the stop reached before it started) — `cicd.pipeline.task.name`,
   `cicd.pipeline.task.run.result` (the convention's enum: `success` for a
   run or a hit, `failure`, `timeout` (vx's own `timeout`, or a server's readiness wait), `skip`, `cancellation`), vx's own
-  status as `vx.task.status`, `vx.cache.source` (miss/local/remote, or none for a task that never ran),
+  status as `vx.task.status`, `vx.cache.source` (miss/local/remote, or none for a task that never ran or a failed hit whose restore threw),
   on a hit `vx.cache.restored` (`true` when it restored outputs, `false` when they were already up to date),
   `vx.task.hash`, duration, CPU ms, peak RSS, and on a skipped task its root
   blocker (`vx.task.blocked_by`) or, skipped for its `exec.platforms`, what it
@@ -140,7 +142,7 @@ otel({
   stage does, before the run lock, and that start is the
   `vx.run.started_at` every task's `vx.task.run_started_at` names.
 
-**Metrics per run**: `vx.tasks.total`, `vx.tasks.failed`,
+**Metrics per run**: `vx.tasks.total` (the terminal's total, not-run tasks included), `vx.tasks.failed`,
 `vx.tasks.cache_hits{source=local|remote}`, what those hits did to the disk as
 `vx.tasks.cache_restored{source=local|remote}` and `vx.tasks.cache_up_to_date`,
 and the `vx.run.duration_ms` and `vx.run.time_saved_ms` (what the hits'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-otel",
-  "version": "0.0.652",
+  "version": "0.0.653",
   "license": "MIT",
   "description": "OpenTelemetry exporter for vx — a telemetry plugin mapping runs to OTLP traces + metrics (CI/CD + VCS semantic conventions).",
   "keywords": [
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.652"
+    "@vzn/vx": "^0.0.653"
   },
   "repository": {
     "type": "git",

package/src/otlp.ts

@@ -116,6 +116,7 @@ const VX_ATTR = {
   runTaskCount: 'vx.run.task_count',
   runFailedCount: 'vx.run.failed_count',
   runAbortedCount: 'vx.run.aborted_count',
+  runNotRunCount: 'vx.run.not_run_count',
   runHitCount: 'vx.run.hit_count',
   runHitLocalCount: 'vx.run.hit_local_count',
   runHitRemoteCount: 'vx.run.hit_remote_count',
@@ -405,6 +406,7 @@ export function runSpanAttributes(run: RunContextRecord, summary?: RunSummaryRec
       intAttr(VX_ATTR.runTaskCount, summary.taskCount),
       intAttr(VX_ATTR.runFailedCount, summary.failedCount),
       intAttr(VX_ATTR.runAbortedCount, summary.abortedCount),
+      intAttr(VX_ATTR.runNotRunCount, summary.notRunCount ?? 0),
       intAttr(VX_ATTR.runHitCount, summary.hitCount),
       intAttr(VX_ATTR.runHitLocalCount, summary.hitLocalCount),
       intAttr(VX_ATTR.runHitRemoteCount, summary.hitRemoteCount),
@@ -428,11 +430,13 @@ export function runSpanAttributes(run: RunContextRecord, summary?: RunSummaryRec
 
 /**
  * `cicd.pipeline.result`, the task enum's run-level twin. A red run with
- * nothing failed and something aborted is a stopped one.
+ * nothing failed and something aborted or not run is a stopped one.
  */
 function pipelineResult(s: RunSummaryRecord): string {
   if (s.exitOk) return 'success'
-  return s.failedCount === 0 && s.abortedCount > 0 ? 'cancellation' : 'failure'
+  return s.failedCount === 0 && s.abortedCount + (s.notRunCount ?? 0) > 0
+    ? 'cancellation'
+    : 'failure'
 }
 
 /** The root span is ERROR when the run is red: UNSET read as a clean run. */

package/src/sink.ts

@@ -175,7 +175,7 @@ async function postOnce(
   )
   // Core's flush deadline ends the POST too: `timeoutMs` (15 s by
   // default) alone held the process that long after the run (item 1055).
-  const onDeadline = (): void => controller.abort()
+  const onDeadline = (): void => controller.abort(deadline?.reason)
   deadline?.addEventListener('abort', onDeadline, { once: true })
   try {
     let res: Response
@@ -210,7 +210,7 @@ async function postOnce(
     // (walked the adopter's path, 2026-09-20). The body is the
     // collector's own explanation, so a line of it rides the message.
     // quiet: the status alone still names the refusal
-    const text = await res.text().catch(() => '')
+    const text = await upTo(res, REPLY_BYTES).catch(() => '')
     if (res.status >= 300 && res.status < 400) {
       const location = res.headers.get('location')
       const to = location === null ? null : URL.parse(location, url)
@@ -234,6 +234,35 @@ async function postOnce(
   }
 }
 
+/**
+ * Room for a collector's error line or partial-success JSON: read whole,
+ * an endless 200 grew vx to 2.1 GB RSS within the flush deadline.
+ */
+const REPLY_BYTES = 64 * 1024
+
+/**
+ * A body's first `max` bytes as text, the rest cancelled unread
+ * (vx-history's and vx-cache's `upTo`).
+ */
+async function upTo(res: Response, max: number): Promise<string> {
+  const reader = res.body?.getReader()
+  if (reader === undefined) return ''
+  const parts: Uint8Array[] = []
+  let n = 0
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (done) break
+    parts.push(value)
+    n += value.byteLength
+    if (n > max) {
+      // quiet: the rest is unwanted; its cancel adds nothing
+      await reader.cancel().catch(() => {})
+      return Buffer.concat(parts).subarray(0, max).toString('utf8')
+    }
+  }
+  return Buffer.concat(parts).toString('utf8')
+}
+
 /**
  * A `Retry-After` in ms, or 0: seconds, or an HTTP date (RFC 9110), which
  * `Number()` read as NaN and the retry came at the default delay.