@rulemetric/hooks 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulemetric/hooks",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "publishConfig": {
     "access": "public"
   },

package/scripts/_post.sh

@@ -39,10 +39,13 @@ _rulemetric_post_event() {
     http_code=$(printf '%s' "$body" | tail -1)
     body=$(printf '%s' "$body" | sed '$d')
 
-    if [ "$http_code" = "200" ] || [ "$http_code" = "201" ]; then
+    # Any 2xx is success: the batched events route (Phase 2 admission control)
+    # returns 202 "buffered", the legacy path 200, session create 201.
+    case "$http_code" in 2??)
       [ -n "$hdr_file" ] && rm -f "$hdr_file"
       return 0
-    fi
+      ;;
+    esac
 
     # Transient (service busy / rate-limited / network) → retry unless this was
     # the last allowed attempt. Everything else (4xx) is permanent.
@@ -73,3 +76,68 @@ _rulemetric_post_event() {
   [ -n "$hdr_file" ] && rm -f "$hdr_file"
   return 1
 }
+
+# _rulemetric_send <method> <url> <auth_header> <payload> <log_tag> [max_time_s]
+# Method-aware sibling of _rulemetric_post_event for the session-END writes that
+# previously used a bare `curl -sf` and SILENTLY DROPPED on any failure — enrich
+# (PATCH), reimport (POST), derive-enrichment (POST). When the API fast-503s under
+# transient DB-pool load, those calls dropped, leaving sessions un-enriched / empty
+# (the "insights stuck at 06/30" cause). Same bounded 503/429/network retry +
+# capped Retry-After as _rulemetric_post_event; 4xx permanent; logs final failure.
+# Returns 0 on 2xx. `max_time_s` defaults to 4 (reimport passes 8 for large bodies).
+# `max_attempts` defaults to $_RM_POST_MAX_ATTEMPTS; the FOREGROUND reimport passes
+# 2 to cap its worst-case session-end tail-latency (it blocks the hook — see below).
+_rulemetric_send() {
+  local method="$1" url="$2" auth="$3" payload="$4" tag="$5" max_time="${6:-4}" max_attempts="${7:-$_RM_POST_MAX_ATTEMPTS}"
+  local attempt=1 http_code="000" body="" hdr_file retry_after sleep_s
+
+  hdr_file=$(mktemp "${TMPDIR:-/tmp}/rm-send.XXXXXX" 2>/dev/null || true)
+
+  while [ "$attempt" -le "$max_attempts" ]; do
+    if [ -n "$hdr_file" ]; then
+      body=$(curl -s --noproxy '*' --max-time "$max_time" -D "$hdr_file" -w '\n%{http_code}' \
+        -X "$method" "$url" -H "$auth" -H "Content-Type: application/json" \
+        -d "$payload" 2>&1) || true
+    else
+      body=$(curl -s --noproxy '*' --max-time "$max_time" -w '\n%{http_code}' \
+        -X "$method" "$url" -H "$auth" -H "Content-Type: application/json" \
+        -d "$payload" 2>&1) || true
+    fi
+    http_code=$(printf '%s' "$body" | tail -1)
+    body=$(printf '%s' "$body" | sed '$d')
+
+    # Any 2xx is success: the batched events route (Phase 2 admission control)
+    # returns 202 "buffered", the legacy path 200, session create 201.
+    case "$http_code" in 2??)
+      [ -n "$hdr_file" ] && rm -f "$hdr_file"
+      return 0
+      ;;
+    esac
+
+    if [ "$http_code" = "503" ] || [ "$http_code" = "429" ] || [ "$http_code" = "000" ]; then
+      if [ "$attempt" -lt "$max_attempts" ]; then
+        retry_after=""
+        if [ -n "$hdr_file" ]; then
+          retry_after=$(grep -i '^Retry-After:' "$hdr_file" 2>/dev/null | tail -1 | tr -dc '0-9' || true)
+        fi
+        if [ -n "$retry_after" ] && [ "$retry_after" -gt 0 ] 2>/dev/null; then
+          sleep_s="$retry_after"
+        else
+          sleep_s="$attempt"
+        fi
+        if [ "$sleep_s" -gt "$_RM_POST_RETRY_CAP_S" ] 2>/dev/null; then
+          sleep_s="$_RM_POST_RETRY_CAP_S"
+        fi
+        sleep "$sleep_s" 2>/dev/null || true
+        attempt=$((attempt + 1))
+        continue
+      fi
+    fi
+
+    break
+  done
+
+  _rulemetric_log "$tag" "error" "http_${http_code}_attempt_${attempt}: ${body}"
+  [ -n "$hdr_file" ] && rm -f "$hdr_file"
+  return 1
+}

package/scripts/post-retry.test.sh

@@ -32,7 +32,7 @@ trap cleanup EXIT
 # --- Stub server: counts requests, programmed by $MODE in a control file --------
 cat > "$WORK_ROOT/stub.py" <<'PY'
 import http.server, json, os, sys, threading
-mode = sys.argv[1]            # fail-once | always-503 | always-400
+mode = sys.argv[1]            # fail-once | always-503 | always-400 | always-202
 count_file = sys.argv[2]
 n = 0
 lock = threading.Lock()
@@ -50,6 +50,9 @@ class H(http.server.BaseHTTPRequestHandler):
         if mode == "always-503":
             self.send_response(503); self.send_header("Retry-After", "1"); self.end_headers()
             self.wfile.write(b'{"error":"busy"}'); return
+        if mode == "always-202":
+            self.send_response(202); self.end_headers()
+            self.wfile.write(b'{"buffered":true,"count":1,"durable":false}'); return
         # fail-once: 503 on first request, 200 thereafter
         if cur == 1:
             self.send_response(503); self.send_header("Retry-After", "1"); self.end_headers()
@@ -112,6 +115,18 @@ assert_eq "always-503: server saw exactly MAX_ATTEMPTS (3) requests" "3" "$(req_
 grep -q "http_503" "$LOG_FILE" && ok "always-503: logged an http_503 error" || fail "always-503: expected http_503 in log"
 stop_server
 
+# --- Test 4: batched-ingest 202 is SUCCESS (no retry, no error log) -----------
+# The Phase 2 batched events route returns 202 { buffered: true } instead of
+# 200 { recorded: true }; the helper must treat ANY 2xx as delivered.
+start_server always-202
+: > "$LOG_FILE"
+_rulemetric_post_event "http://127.0.0.1:$SERVER_PORT/events" "$AUTH" "$PAYLOAD" "test" 4
+rc=$?
+assert_eq "always-202: returns success (0) — buffered counts as delivered" "0" "$rc"
+assert_eq "always-202: server saw exactly 1 request (no retry)" "1" "$(req_count)"
+assert_eq "always-202: no error logged" "0" "$(wc -l < "$LOG_FILE" | tr -d ' ')"
+stop_server
+
 # --- Summary -----------------------------------------------------------------
 echo
 echo "Passed: $PASSES   Failed: $FAILURES"

package/scripts/session-end.sh

@@ -2,6 +2,11 @@
 # RuleMetric: Finalize session with full transcript import
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$SCRIPT_DIR/_log.sh" 2>/dev/null || _rulemetric_log() { :; }
+# Bounded retry-on-503 for the session-end writes (reimport/enrich/derive) so a
+# transient DB-pool wedge doesn't SILENTLY drop them (the "insights stuck" cause).
+# Log if the helper can't load (packaging regression) — otherwise the writes below
+# would hit `command not found` and degrade silently (backgrounded ones with NO log).
+source "$SCRIPT_DIR/_post.sh" 2>/dev/null || _rulemetric_log "session-end" "warn" "post_helper_unavailable"
 
 set -euo pipefail
 trap 'echo "rulemetric session-end failed at line $LINENO: $BASH_COMMAND" >&2; _rulemetric_log "session-end" "error" "line $LINENO: $BASH_COMMAND"; exit 1' ERR
@@ -41,10 +46,19 @@ fi
 # Try to reimport with full transcript, fall back to close
 if [ -n "$HOOK_TRANSCRIPT_PATH" ] && [ -f "$HOOK_TRANSCRIPT_PATH" ]; then
   CONTENT=$(cat "$HOOK_TRANSCRIPT_PATH")
-  curl -sf --noproxy '*' --max-time 8 -X POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/reimport" \
-    -H "$AUTH_HEADER" \
-    -H "Content-Type: application/json" \
-    -d "{\"content\":$(echo "$CONTENT" | jq -Rs .),\"tool\":\"$HOOK_TOOL\"}" \
+  REIMPORT_PAYLOAD="{\"content\":$(echo "$CONTENT" | jq -Rs .),\"tool\":\"$HOOK_TOOL\"}"
+  # Retry-on-503 (max-time 8 for the large transcript body); this is FOREGROUND and
+  # blocks the hook, so cap at 2 attempts (worst-case tail ~18s on a hard API hang,
+  # vs ~32s at 3) — the common fast-503 wedge still recovers in <1s. Fall back to
+  # close if it still fails after retries — a dropped reimport leaves the session EMPTY.
+  # NOTE: under headless `claude -p`, Claude Code's print-mode teardown cancels this
+  # hook ("SessionEnd hook … failed: Hook cancelled") regardless of whether this runs
+  # in the foreground or is backgrounded — verified 2026-07-05. It is a Claude Code
+  # print-mode behavior, not a capture failure (per-turn hooks still land events); do
+  # NOT try to "fix" it by detaching this call (adds no benefit, and headless is a
+  # deliberately-excluded capture vehicle).
+  _rulemetric_send POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/reimport" \
+    "$AUTH_HEADER" "$REIMPORT_PAYLOAD" "session-end-reimport" 8 2 \
     > /dev/null 2>&1 || {
     _rulemetric_log "session-end" "fallback" "reimport_failed"
     curl -sf --noproxy '*' --max-time 4 -X POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/close" \
@@ -127,18 +141,16 @@ except:
 " 2>/dev/null)
 
     if [ -n "$ENRICH_PAYLOAD" ]; then
-      (curl -sf --noproxy '*' --max-time 4 -X PATCH "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/enrich" \
-        -H "$AUTH_HEADER" \
-        -H "Content-Type: application/json" \
-        -d "$ENRICH_PAYLOAD" > /dev/null 2>&1) &
+      # Backgrounded retry-on-503 so a transient wedge doesn't drop enrichment
+      # (leaving insights stuck at the last-enriched session).
+      (_rulemetric_send PATCH "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/enrich" \
+        "$AUTH_HEADER" "$ENRICH_PAYLOAD" "session-end-enrich" > /dev/null 2>&1) &
     fi
   fi
 else
   # Non-Claude tools: derive enrichment from stored session events
-  (curl -sf --noproxy '*' --max-time 8 -X POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/derive-enrichment" \
-    -H "$AUTH_HEADER" \
-    -H "Content-Type: application/json" \
-    -d '{}' > /dev/null 2>&1) &
+  (_rulemetric_send POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/derive-enrichment" \
+    "$AUTH_HEADER" '{}' "session-end-derive" 8 > /dev/null 2>&1) &
 fi
 
 # ── Tail transcript for 429 rate-limit events ──