@secondlayer/subgraphs 7.4.0 → 7.5.0

package/dist/testing/index.js

@@ -203,7 +203,7 @@ import { createHash as createHash2 } from "node:crypto";
 // package.json
 var package_default = {
   name: "@secondlayer/subgraphs",
-  version: "7.4.0",
+  version: "7.5.0",
   description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
   license: "MIT",
   repository: {
@@ -263,7 +263,7 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@secondlayer/shared": "^13.3.0",
+    "@secondlayer/shared": "^13.4.0",
     "@secondlayer/stacks": "^6.4.0",
     "@secondlayer/verify": "^0.6.0",
     esbuild: "^0.28.2",
@@ -1535,7 +1535,7 @@ function sameValue(a, b) {
 
 // src/runtime/runner.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger4 } from "@secondlayer/shared/logger";
+import { logger as logger5 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
   deserializeCV as deserializeCV4,
@@ -1914,6 +1914,158 @@ function decodeEventData(data) {
   return data;
 }
 
+// src/runtime/error-groups.ts
+import { createHash as createHash3 } from "node:crypto";
+import { getTargetDb } from "@secondlayer/shared/db";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+import { sql as sql2 } from "kysely";
+var ERROR_GROUPS_CAP_PER_SUBGRAPH = 50;
+var MESSAGE_MAX_CHARS = 500;
+function normalizeMessage(message) {
+  return message.replace(/0x[0-9a-f]+/gi, "<hex>").replace(/(["'`])(?:(?!\1).)*\1/g, "<str>").replace(/\d+/g, "<n>");
+}
+function errorFingerprint(input) {
+  return createHash3("sha1").update([
+    input.sourceName,
+    input.eventType ?? "",
+    normalizeMessage(input.message),
+    input.frame ?? ""
+  ].join("|")).digest("hex");
+}
+function topFrame(err) {
+  if (!(err instanceof Error) || !err.stack)
+    return null;
+  for (const line of err.stack.split(`
+`).slice(1)) {
+    const match = /([^/\\\s()]+):(\d+):\d+\)?\s*$/.exec(line);
+    if (match)
+      return `${match[1]}:${match[2]}`;
+  }
+  return null;
+}
+var FLUSH_INTERVAL_MS = 5000;
+var MAX_PENDING_KEYS = 1000;
+var pending = new Map;
+var droppedKeys = 0;
+var flushTimer = null;
+function startFlusher() {
+  if (flushTimer)
+    return;
+  flushTimer = setInterval(() => {
+    flushHandlerErrors();
+  }, FLUSH_INTERVAL_MS);
+  flushTimer.unref();
+}
+async function flushHandlerErrors() {
+  if (pending.size === 0 && droppedKeys === 0)
+    return;
+  const batch = pending;
+  const dropped = droppedKeys;
+  pending = new Map;
+  droppedKeys = 0;
+  if (dropped > 0) {
+    logger3.warn("Handler error groups dropped: too many distinct errors", {
+      dropped,
+      cap: MAX_PENDING_KEYS
+    });
+  }
+  if (batch.size === 0)
+    return;
+  try {
+    const db = getTargetDb();
+    const subgraphs = new Set;
+    for (const group of batch.values()) {
+      subgraphs.add(group.subgraphName);
+      await db.insertInto("subgraph_error_groups").values({
+        subgraph_name: group.subgraphName,
+        fingerprint: group.fingerprint,
+        source_name: group.sourceName,
+        event_type: group.eventType,
+        message: group.message,
+        frame: group.frame,
+        count: group.count,
+        sample_tx_id: group.sampleTxId,
+        sample_block_height: group.sampleBlockHeight,
+        first_seen: group.firstSeenAt,
+        last_seen: group.lastSeenAt
+      }).onConflict((oc) => oc.columns(["subgraph_name", "fingerprint"]).doUpdateSet({
+        count: sql2`subgraph_error_groups.count + ${group.count}`,
+        last_seen: group.lastSeenAt,
+        sample_tx_id: group.sampleTxId,
+        sample_block_height: group.sampleBlockHeight
+      })).execute();
+    }
+    for (const subgraphName of subgraphs) {
+      await sql2`
+				DELETE FROM subgraph_error_groups
+				WHERE id IN (
+					SELECT id FROM subgraph_error_groups
+					WHERE subgraph_name = ${subgraphName}
+					ORDER BY last_seen DESC, id
+					OFFSET ${ERROR_GROUPS_CAP_PER_SUBGRAPH}
+				)
+			`.execute(db);
+    }
+  } catch (err) {
+    logger3.warn("Failed to flush handler error groups", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var recorderOverride = null;
+function recordHandlerError(input) {
+  try {
+    if (recorderOverride) {
+      recorderOverride(input).catch((err) => {
+        logger3.warn("Failed to record handler error group", {
+          subgraph: input.subgraphName,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return;
+    }
+    const message = (input.err instanceof Error ? input.err.message : String(input.err)).slice(0, MESSAGE_MAX_CHARS);
+    const frame = topFrame(input.err);
+    const fingerprint = errorFingerprint({
+      sourceName: input.sourceName,
+      eventType: input.eventType,
+      message,
+      frame
+    });
+    const key = `${input.subgraphName}|${fingerprint}`;
+    const now = new Date;
+    const existing = pending.get(key);
+    if (existing) {
+      existing.count++;
+      existing.sampleTxId = input.txId;
+      existing.sampleBlockHeight = input.blockHeight;
+      existing.lastSeenAt = now;
+    } else if (pending.size >= MAX_PENDING_KEYS) {
+      droppedKeys++;
+    } else {
+      pending.set(key, {
+        subgraphName: input.subgraphName,
+        fingerprint,
+        sourceName: input.sourceName,
+        eventType: input.eventType,
+        message,
+        frame,
+        count: 1,
+        sampleTxId: input.txId,
+        sampleBlockHeight: input.blockHeight,
+        firstSeenAt: now,
+        lastSeenAt: now
+      });
+    }
+    startFlusher();
+  } catch (err) {
+    logger3.warn("Failed to record handler error group", {
+      subgraph: input.subgraphName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
 // src/runtime/print-validate.ts
 var COLUMN_TYPES = new Set([
   "text",
@@ -2345,9 +2497,9 @@ function matchSources(sources, transactions, events, traitContracts = new Map, f
 }
 
 // src/runtime/violations.ts
-import { getTargetDb } from "@secondlayer/shared/db";
-import { logger as logger3 } from "@secondlayer/shared/logger";
-import { sql as sql2 } from "kysely";
+import { getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import { sql as sql3 } from "kysely";
 var VIOLATIONS_CAP_PER_SUBGRAPH = 100;
 function jsonSafe2(value) {
   if (typeof value === "bigint")
@@ -2367,7 +2519,7 @@ function jsonSafe2(value) {
 }
 async function defaultRecordPrintViolation(input) {
   try {
-    const db = getTargetDb();
+    const db = getTargetDb2();
     const sample = jsonSafe2(input.samplePayload);
     await db.insertInto("subgraph_violations").values({
       subgraph_name: input.subgraphName,
@@ -2377,7 +2529,7 @@ async function defaultRecordPrintViolation(input) {
       reason: input.reason,
       sample_payload: sample
     }).execute();
-    await sql2`
+    await sql3`
 			DELETE FROM subgraph_violations
 			WHERE id IN (
 				SELECT id FROM subgraph_violations
@@ -2387,7 +2539,7 @@ async function defaultRecordPrintViolation(input) {
 			)
 		`.execute(db);
   } catch (err) {
-    logger3.warn("Failed to record print violation", {
+    logger4.warn("Failed to record print violation", {
       subgraph: input.subgraphName,
       error: err instanceof Error ? err.message : String(err)
     });
@@ -2729,7 +2881,7 @@ async function runHandlers(subgraph, matched, ctx, opts) {
   units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || clockRank(a.event) - clockRank(b.event) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
   for (const { tx, event, sourceName } of units) {
     if (errors >= threshold) {
-      logger4.error("Subgraph error threshold reached, skipping remaining events", {
+      logger5.error("Subgraph error threshold reached, skipping remaining events", {
         subgraph: subgraph.name,
         errors,
         threshold
@@ -2744,7 +2896,7 @@ async function runHandlers(subgraph, matched, ctx, opts) {
     const filter = filterLookup.get(sourceName);
     const handler = subgraph.handlers[sourceName] ?? null;
     if (!handler) {
-      logger4.warn("No handler found for source", {
+      logger5.warn("No handler found for source", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id
@@ -2801,7 +2953,7 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
         if (!verdict.ok) {
           skipped++;
-          logger4.warn("Print payload does not match declared prints schema", {
+          logger5.warn("Print payload does not match declared prints schema", {
             subgraph: subgraph.name,
             sourceName,
             topic: printPayload.topic,
@@ -2829,7 +2981,15 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         throw err;
       ctx.rollbackTo(checkpoint);
       errors++;
-      logger4.error("Subgraph handler error", {
+      recordHandlerError({
+        subgraphName: subgraph.name,
+        sourceName,
+        eventType: event?.type ?? null,
+        txId: tx.tx_id,
+        blockHeight: ctx.block.height,
+        err
+      });
+      logger5.error("Subgraph handler error", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id,
@@ -3206,5 +3366,5 @@ export {
   toHandlerPayload
 };
 
-//# debugId=9370182C1798E38564756E2164756E21
+//# debugId=1C6775556709A2BD64756E2164756E21
 //# sourceMappingURL=index.js.map