@spunto/build 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spunto/build",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Spunto's shared Build engine — the devcontainer image protocol and VS Code extension registry clients, with no database, no HTTP framework and no UI.",
   "type": "module",
   "license": "MIT",

package/src/script/setup-script.ts

@@ -103,16 +103,6 @@ type CloneRepo = {
   branch?: string
 }
 
-/**
- * How a feature's entrypoint is started: without the OpenTelemetry variables the platform gives the
- * workload. An entrypoint is infrastructure — dockerd, containerd — and Docker instruments itself as
- * soon as `OTEL_EXPORTER_OTLP_ENDPOINT` exists: every internal gRPC call of a docker-in-docker
- * daemon became a span (~60 000 per quarter hour for three sandboxes, 2026-10-18), drowning the
- * project's own services in its organization's telemetry. The project's processes keep them.
- */
-export const ENTRYPOINT_WITHOUT_OTEL =
-  "env -u OTEL_EXPORTER_OTLP_ENDPOINT -u OTEL_EXPORTER_OTLP_TRACES_ENDPOINT -u OTEL_EXPORTER_OTLP_METRICS_ENDPOINT -u OTEL_EXPORTER_OTLP_LOGS_ENDPOINT -u OTEL_EXPORTER_OTLP_PROTOCOL -u OTEL_EXPORTER_OTLP_HEADERS -u OTEL_RESOURCE_ATTRIBUTES -u OTEL_SERVICE_NAME"
-
 /**
  * Branch actually checked out for a repo: the worker-level choice (made at creation, applies to
  * every repo of the project) wins over the project-level default carried by the repository itself.
@@ -1150,7 +1140,7 @@ export function buildSetupScript(params: SetupScriptParams): { script: string }
       "  while IFS= read -r _ep; do",
       '    if [ -f "$_ep" ]; then',
       '      echo "Starting entrypoint: $_ep"',
-      '      ' + ENTRYPOINT_WITHOUT_OTEL + ' "$_ep" &',
+      '      "$_ep" &',
       "    fi",
       "  done < " + FEATURE_ENTRYPOINTS_FILE,
       "fi",
@@ -1316,7 +1306,7 @@ export function buildStartScript(params: StartScriptParams): { script: string; h
     "  while IFS= read -r _ep; do",
     '    if [ -f "$_ep" ]; then',
     '      echo "Starting entrypoint: $_ep"',
-    '      ' + ENTRYPOINT_WITHOUT_OTEL + ' "$_ep" &',
+    '      "$_ep" &',
     "    fi",
     "  done < " + FEATURE_ENTRYPOINTS_FILE,
     "fi",
@@ -1490,12 +1480,12 @@ export function buildStartScript(params: StartScriptParams): { script: string; h
 // The functions below power the *new* model where the agent (not the container) drives setup:
 // `buildContainerScript` is the passive CMD (serve code-server + stay alive, no setup, no status
 // machinery), and `buildSetupPlan` returns the ordered phases the agent execs one by one, each
-// wrapped in a native OTel span. The legacy `buildWorkerScript`/`buildSetupScript`/`buildStartScript`
+// wrapped in its own try/catch. The legacy `buildWorkerScript`/`buildSetupScript`/`buildStartScript`
 // above are left untouched — the runner picks the path by flag, defaulting to legacy. See RFC 0017.
 
-/** One setup phase the agent execs via `docker exec`, wrapped in a native OTel span. */
+/** One setup phase the agent execs via `docker exec`. */
 export type SetupPhase = {
-  /** Timing-key / span-suffix (`setup.<id>`) and the phase's short identity. */
+  /** Timing key and the phase's short identity. */
   id: "credentials" | "shell" | "dotfiles" | "skills" | "clone" | "postCreate" | "postStart"
   /** Human label for logs. */
   label: string
@@ -1510,7 +1500,7 @@ export type SetupPhase = {
 
 // The passive container CMD. Same "serve + stay alive" blocks as buildStartScript (SSH, feature
 // entrypoints, env persistence, extensions, code-server settings + restart loop) — MINUS the setup
-// status machinery, the lifecycle commands and any OTLP/timing emission (the agent owns all of that
+// status machinery, the lifecycle commands and any timing emission (the agent owns all of that
 // now). Ends by signalling readiness (`.mp-container-up`) then `wait`. Blocks are duplicated from
 // buildStartScript on purpose: the legacy path stays byte-identical (prod default) until it's
 // deleted once WORKER_SETUP_ORCHESTRATOR=agent becomes the default. See RFC 0017 §2.1.
@@ -1569,7 +1559,7 @@ export function buildContainerScript(params: StartScriptParams): { script: strin
     "  while IFS= read -r _ep; do",
     '    if [ -f "$_ep" ]; then',
     '      echo "Starting entrypoint: $_ep"',
-    '      ' + ENTRYPOINT_WITHOUT_OTEL + ' "$_ep" &',
+    '      "$_ep" &',
     "    fi",
     "  done < " + FEATURE_ENTRYPOINTS_FILE,
     "fi",
@@ -1724,9 +1714,6 @@ export function buildWorkerScript(params: {
     "  local now; now=\"$(_mp_now)\"",
     "  if [ -s \"$_MP_TFILE\" ]; then printf ',' >> \"$_MP_TFILE\"; fi",
     "  printf '\"%s\":%s' \"$1\" \"$now\" >> \"$_MP_TFILE\" || true",
-    // Native OTel: emit this phase transition as a real OTLP span through the node
-    // collector (|| true + suspends set -e inside the fn — telemetry never breaks setup).
-    "  _mp_span_on_stamp \"$1\" \"$now\" || true",
     "}",
     // mp-status.json lives in the home dir (persistent volume), not /tmp — when a
     // DinD feature starts dockerd in the background, /tmp's mount visibility can
@@ -1743,70 +1730,14 @@ export function buildWorkerScript(params: {
     "  printf '%s' \"$j\" > " + workerStatusPath("/home/vscode") + " || true",
     "}",
     "",
-    // ── Native OTel setup spans (emitted by this script, not backdated in the API) ──
-    // Each phase is emitted as a real OTLP span to the node agent's collector (the
-    // auto-injected OTEL_EXPORTER_OTLP_ENDPOINT); the agent forwards to /otlp where org.id
-    // /node.id are stamped server-side. MP_SETUP_TRACEPARENT (the job.worker.spawn span,
-    // injected by the runner) gives the traceId + parent span, so the whole `worker.setup`
-    // subtree nests under the spawn trace. No trace context (or no curl) → silently skipped.
-    "MP_TRACE_ID=''; MP_JOB_SPAN=''",
-    "if [ -n \"${MP_SETUP_TRACEPARENT:-}\" ]; then",
-    "  MP_TRACE_ID=$(printf '%s' \"$MP_SETUP_TRACEPARENT\" | cut -d- -f2)",
-    "  MP_JOB_SPAN=$(printf '%s' \"$MP_SETUP_TRACEPARENT\" | cut -d- -f3)",
-    "fi",
-    "MP_SETUP_SPAN=''; MP_SETUP_START=''; MP_PREV_PHASE=''; MP_PREV_TS=''",
     // Failure-trap state. _MP_DONE flips to 1 once setup+start reach `ready` (see buildStartScript),
     // disarming _mp_fail so a normal container stop / code-server hiccup after ready never looks like
     // a setup failure. _MP_LAST holds the most recent status JSON (set by _mp) for the error re-emit.
     "_MP_DONE=0; _MP_LAST=''",
-    "_mp_rand_id() { od -An -tx1 -N8 /dev/urandom 2>/dev/null | tr -d ' \\n'; }",
-    "_mp_phase_span_name() {",
-    "  case \"$1\" in",
-    "    initializing) echo 'setup.initialize' ;;",
-    "    credentials) echo 'setup.credentials' ;;",
-    "    shell) echo 'setup.shell' ;;",
-    "    cloning) echo 'setup.clone' ;;",
-    "    postCreate) echo 'setup.postCreate' ;;",
-    "    postStart) echo 'setup.postStart' ;;",
-    "    *) echo \"setup.$1\" ;;",
-    "  esac",
-    "}",
-    // Emit one OTLP/HTTP JSON span, backgrounded + short timeout so it never adds latency
-    // to (or blocks) the setup path. Args: name start_ms end_ms span_id parent_span_id phase.
-    "_mp_span_emit() {",
-    "  if [ -z \"$MP_TRACE_ID\" ] || [ -z \"${OTEL_EXPORTER_OTLP_ENDPOINT:-}\" ]; then return 0; fi",
-    "  if ! command -v curl >/dev/null 2>&1; then return 0; fi",
-    // Optional $7 = error message and $8 = exit code turn this into a native ERROR span
-    // (OTel status code 2 + a setup.exit_code attribute) — that's what makes a failed
-    // clone/postCreate/postStart show up red in the waterfall instead of as a hole.
-    "  local name=\"$1\" s_ns=$(( $2 * 1000000 )) e_ns=$(( $3 * 1000000 )) sid=\"$4\" pid=\"$5\" phase=\"$6\" errmsg=\"${7:-}\" ecode=\"${8:-}\" dur=$(( $3 - $2 )) attrs='' status=''",
-    "  if [ -n \"$phase\" ]; then attrs=\"{\\\"key\\\":\\\"setup.phase\\\",\\\"value\\\":{\\\"stringValue\\\":\\\"$phase\\\"}},{\\\"key\\\":\\\"setup.duration_ms\\\",\\\"value\\\":{\\\"intValue\\\":\\\"$dur\\\"}}\"; fi",
-    "  if [ -n \"$ecode\" ]; then [ -n \"$attrs\" ] && attrs=\"$attrs,\"; attrs=\"${attrs}{\\\"key\\\":\\\"setup.exit_code\\\",\\\"value\\\":{\\\"intValue\\\":\\\"$ecode\\\"}}\"; fi",
-    "  if [ -n \"$errmsg\" ]; then status=\",\\\"status\\\":{\\\"code\\\":2,\\\"message\\\":\\\"$errmsg\\\"}\"; fi",
-    "  local body=\"{\\\"resourceSpans\\\":[{\\\"resource\\\":{\\\"attributes\\\":[{\\\"key\\\":\\\"service.name\\\",\\\"value\\\":{\\\"stringValue\\\":\\\"spunto-worker\\\"}},{\\\"key\\\":\\\"spunto.worker.slug\\\",\\\"value\\\":{\\\"stringValue\\\":\\\"${WORKER_SLUG:-}\\\"}}]},\\\"scopeSpans\\\":[{\\\"scope\\\":{\\\"name\\\":\\\"spunto.setup\\\"},\\\"spans\\\":[{\\\"traceId\\\":\\\"$MP_TRACE_ID\\\",\\\"spanId\\\":\\\"$sid\\\",\\\"parentSpanId\\\":\\\"$pid\\\",\\\"name\\\":\\\"$name\\\",\\\"kind\\\":1,\\\"startTimeUnixNano\\\":\\\"$s_ns\\\",\\\"endTimeUnixNano\\\":\\\"$e_ns\\\",\\\"attributes\\\":[$attrs]$status}]}]}]}\"",
-    "  ( curl -s -m 3 -o /dev/null -X POST \"$OTEL_EXPORTER_OTLP_ENDPOINT/v1/traces\" -H 'Content-Type: application/json' -d \"$body\" || true ) &",
-    "}",
-    // Called on each new phase stamp. The first stamp opens the `worker.setup` window; every
-    // later stamp closes the previous phase as a child span; `ready` also emits the parent.
-    "_mp_span_on_stamp() {",
-    "  if [ -z \"$MP_TRACE_ID\" ]; then return 0; fi",
-    "  local key=\"$1\" now=\"$2\"",
-    "  if [ -z \"$MP_SETUP_SPAN\" ]; then",
-    "    MP_SETUP_SPAN=$(_mp_rand_id); MP_SETUP_START=\"$now\"; MP_PREV_PHASE=\"$key\"; MP_PREV_TS=\"$now\"; return 0",
-    "  fi",
-    "  _mp_span_emit \"$(_mp_phase_span_name \"$MP_PREV_PHASE\")\" \"$MP_PREV_TS\" \"$now\" \"$(_mp_rand_id)\" \"$MP_SETUP_SPAN\" \"$MP_PREV_PHASE\"",
-    "  if [ \"$key\" = ready ]; then",
-    "    _mp_span_emit 'worker.setup' \"$MP_SETUP_START\" \"$now\" \"$MP_SETUP_SPAN\" \"$MP_JOB_SPAN\" ''",
-    "  else",
-    "    MP_PREV_PHASE=\"$key\"; MP_PREV_TS=\"$now\"",
-    "  fi",
-    "}",
-    // ── Native error spans on setup failure (the direct goal of this refactor) ──
+    // ── Setup failure trap ──
     // set -e makes any uncaught failure abort the CMD; before PR #115 that just left the worker
-    // stuck at its last status with a hole in the trace. This EXIT trap turns that same failure
-    // into: (1) a real OTLP span in ERROR (status code 2 + exit code + the in-flight phase), so the
-    // failing clone/postCreate/postStart shows up red under worker.setup, and (2) a phase=error
-    // status write so the API poller flips the worker to `error` with a message. It fires only on a
+    // stuck at its last status. This EXIT trap turns that same failure into a phase=error status
+    // write so the API poller flips the worker to `error` with a message. It fires only on a
     // non-zero exit and only before `ready` (_MP_DONE guards the normal path); the short sleep lets
     // the 1.5s poll read the error status before the container exits.
     "_mp_fail() {",
@@ -1816,26 +1747,13 @@ export function buildWorkerScript(params: {
     "  [ \"$_MP_DONE\" = 1 ] && return 0",
     "  [ \"$code\" = 0 ] && return 0",
     "  _MP_DONE=1",
-    "  local phase now msg j",
-    "  phase=\"$MP_PREV_PHASE\"",
-    "  [ -z \"$phase\" ] && phase=$(printf '%s' \"$_MP_LAST\" | sed -n 's/.*\"phase\":\"\\([^\"]*\\)\".*/\\1/p')",
+    "  local phase msg j",
+    "  phase=$(printf '%s' \"$_MP_LAST\" | sed -n 's/.*\"phase\":\"\\([^\"]*\\)\".*/\\1/p')",
     "  [ -z \"$phase\" ] && phase=initializing",
-    "  now=\"$(_mp_now)\"",
     // A phase that knows *why* it failed (e.g. a clone on a branch that doesn't exist) sets
     // MP_FAIL_MSG before exiting, so the UI shows that instead of the generic phase message.
     "  msg=\"${MP_FAIL_MSG:-setup phase $phase failed (exit $code)}\"",
     "  echo \"[setup] ✗ $msg\" >&2",
-    // Best-effort error spans: close the failing phase (child of worker.setup) then worker.setup
-    // itself in ERROR. On a restart (postStart failure) the setup window was never opened, so emit
-    // a single worker.setup error span under the job span instead.
-    "  if [ -n \"$MP_TRACE_ID\" ]; then",
-    "    if [ -n \"$MP_SETUP_SPAN\" ]; then",
-    "      _mp_span_emit \"$(_mp_phase_span_name \"$phase\")\" \"${MP_PREV_TS:-$now}\" \"$now\" \"$(_mp_rand_id)\" \"$MP_SETUP_SPAN\" \"$phase\" \"$msg\" \"$code\"",
-    "      _mp_span_emit 'worker.setup' \"${MP_SETUP_START:-$now}\" \"$now\" \"$MP_SETUP_SPAN\" \"$MP_JOB_SPAN\" '' \"$msg\" \"$code\"",
-    "    else",
-    "      _mp_span_emit 'worker.setup' \"${MP_PREV_TS:-$now}\" \"$now\" \"$(_mp_rand_id)\" \"$MP_JOB_SPAN\" \"$phase\" \"$msg\" \"$code\"",
-    "    fi",
-    "  fi",
     // Flip .mp-status.json to phase=error (preserving the rest) so monitorSetup surfaces it.
     "  j=\"$_MP_LAST\"",
     "  if [ -n \"$j\" ]; then",
@@ -1865,10 +1783,10 @@ export function buildWorkerScript(params: {
 
 // ─── buildSetupPlan (RFC 0017) ─────────────────────────────────────────────────
 //
-// The ordered phases the agent execs one by one (each in its own `docker exec` + OTel span) when
+// The ordered phases the agent execs one by one (each in its own `docker exec`) when
 // WORKER_SETUP_ORCHESTRATOR=agent. Reuses the exact bash blocks from buildSetupScript/buildStartScript
-// (clone strategies, oh-my-zsh, dotfiles, lifecycle) MINUS the `_mp`/`_mp_stamp`/OTLP machinery — the
-// agent owns status + spans now. Each phase carries the SetupStatus to persist at its start/end
+// (clone strategies, oh-my-zsh, dotfiles, lifecycle) MINUS the `_mp`/`_mp_stamp` machinery — the
+// agent owns status now. Each phase carries the SetupStatus to persist at its start/end
 // (mirrors the legacy `mkStatus(...)` writes) so the DB/UI progression is identical. See RFC 0017 §2.2.
 
 export function buildSetupPlan(params: SetupScriptParams): {