@tallyrow/safesignal 1.3.0 → 1.4.0

package/dist/framework-vue.mjs

@@ -0,0 +1,82 @@
+import { inject, onErrorCaptured } from 'vue';
+
+// src/framework-vue/index.ts
+var SOURCE_HANDLER = "vue-error-handler";
+var SOURCE_HOOK = "vue-use-log-error";
+var SOURCE_CAPTURED = "vue-error-captured";
+var loggerKey = /* @__PURE__ */ Symbol("safesignal.logger");
+function readName(obj) {
+  if (obj && typeof obj === "object") {
+    const name = obj.name;
+    if (typeof name === "string" && name.length > 0) return name;
+  }
+  return void 0;
+}
+function componentNameOf(instance) {
+  try {
+    if (!instance || typeof instance !== "object") return void 0;
+    const inst = instance;
+    return readName(inst.$options) ?? readName(inst.$?.type) ?? readName(inst.type);
+  } catch {
+    return void 0;
+  }
+}
+function emit(logger, source, message, error, extra, instance, info) {
+  if (!logger) return;
+  try {
+    const attributes = { "safesignal.source": source };
+    if (typeof info === "string" && info.length > 0) {
+      attributes["safesignal.vue.info"] = info;
+    }
+    const name = componentNameOf(instance);
+    if (name) attributes["safesignal.vue.componentName"] = name;
+    if (extra) {
+      for (const key of Object.keys(extra)) {
+        attributes[key] = extra[key];
+      }
+    }
+    logger.error(message, attributes, error);
+  } catch {
+  }
+}
+function createErrorHandler(logger) {
+  return (err, instance, info) => {
+    emit(logger, SOURCE_HANDLER, "Vue error", err, void 0, instance, info);
+  };
+}
+var safesignalErrorHandler = {
+  install(app, options) {
+    const { logger } = options;
+    app.config.errorHandler = createErrorHandler(logger);
+    app.provide(loggerKey, logger);
+  }
+};
+function useLogError(loggerOverride) {
+  const logger = loggerOverride ?? inject(loggerKey);
+  return (error, attributes) => {
+    emit(logger, SOURCE_HOOK, "Reported error", error, attributes);
+  };
+}
+function useErrorCapture(options = {}) {
+  const logger = options.logger ?? inject(loggerKey);
+  onErrorCaptured((err, instance, info) => {
+    emit(
+      logger,
+      SOURCE_CAPTURED,
+      "Vue captured error",
+      err,
+      void 0,
+      instance,
+      info
+    );
+    try {
+      options.onError?.(err, info);
+    } catch {
+    }
+    return options.propagate ? void 0 : false;
+  });
+}
+
+export { createErrorHandler, loggerKey, safesignalErrorHandler, useErrorCapture, useLogError };
+//# sourceMappingURL=framework-vue.mjs.map
+//# sourceMappingURL=framework-vue.mjs.map

package/dist/framework-vue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/framework-vue/index.ts"],"names":[],"mappings":"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","file":"framework-vue.mjs","sourcesContent":["/**\n * Vue error handling — the `./framework-vue` subpath.\n *\n * The **no-globals, Vue-native counterpart** to `./capture` (and the sibling of\n * `./framework-react`): an `app.config.errorHandler` adapter plus composables\n * that route Vue component-tree errors through a consumer-provided `Logger`'s\n * existing secure pipeline (sanitize → URL-scrub → redact → guard → transport)\n * by calling `logger.error(...)`. Where `./capture` is a single host-level\n * *global* install, this is explicit, per-app / per-subtree, and\n * side-effect-free — it patches nothing and attaches no global listeners.\n *\n * Surface:\n *   - `createErrorHandler(logger)` — a side-effect-free factory returning a\n *     handler for `app.config.errorHandler`.\n *   - `safesignalErrorHandler` — a thin Vue plugin that wires the handler AND\n *     `app.provide(loggerKey, logger)`.\n *   - `loggerKey` — the `InjectionKey<Logger>` by which the plugin provides, and\n *     the composables inject, the logger (the Vue parallel of React's context).\n *   - `useLogError(loggerOverride?)` — a stable manual-report callback for errors\n *     Vue's handler cannot catch (async/try-catch, native listeners).\n *   - `useErrorCapture(options?)` — a subtree boundary wrapping `onErrorCaptured`\n *     (parallel of React's `<LogErrorBoundary>`) that logs descendant errors and,\n *     by default, stops propagation so the app-level handler does not double-log.\n *\n * Properties (see `specs/020-vue-error-handler/contracts/framework-vue.md`):\n *   - Fail-closed: emits via `logger.error`, so messages / stacks / the Vue info\n *     string are redacted + sanitized (drop-on-failure) before any transport.\n *   - Fail-safe: a logging (or `onError`) throw is swallowed; the original error\n *     is never escalated and the app keeps running (Principle III).\n *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,\n *     no timers, no ambient reads (Principle VIII). Errors flow only through the\n *     resolved logger and Vue's own per-app / per-component error hooks.\n *   - Framework-neutral-preserving: `vue` is an externalized **peer** import, so\n *     the core entry and every other subpath stay Vue-free (Principle IV).\n *\n * The only intra-package `src/` import is **type-only** from `../api/types.js`;\n * the single runtime external is `vue` (the consumer-provided peer). No runtime\n * state is shared with the core — the helpers operate solely through the\n * passed/injected `Logger`.\n */\n\nimport {\n  type App,\n  type InjectionKey,\n  inject,\n  onErrorCaptured,\n  type Plugin,\n} from 'vue';\nimport type { Attributes, Logger } from '../api/types.js';\n\n/** `safesignal.source` marker for app-level (`app.config.errorHandler`) errors. */\nconst SOURCE_HANDLER = 'vue-error-handler';\n/** `safesignal.source` marker for errors reported via {@link useLogError}. */\nconst SOURCE_HOOK = 'vue-use-log-error';\n/** `safesignal.source` marker for subtree errors captured by {@link useErrorCapture}. */\nconst SOURCE_CAPTURED = 'vue-error-captured';\n\n/**\n * Vue injection key carrying the consumer's `Logger` for an app/subtree. When no\n * provider/override resolves a logger the helpers are a safe no-op (they never\n * mint a fallback logger, which would couple this bundle to the core runtime).\n * Vue-scoped, never a global registry.\n */\nexport const loggerKey: InjectionKey<Logger> = Symbol('safesignal.logger');\n\n/** The Vue app-level error-handler signature (matches `app.config.errorHandler`). */\nexport type VueErrorHandler = (\n  err: unknown,\n  instance: unknown,\n  info: string,\n) => void;\n\n/** Read a non-empty string `name` from an unknown object, else `undefined`. */\nfunction readName(obj: unknown): string | undefined {\n  if (obj && typeof obj === 'object') {\n    const name = (obj as { name?: unknown }).name;\n    if (typeof name === 'string' && name.length > 0) return name;\n  }\n  return undefined;\n}\n\n/**\n * Best-effort component name from a Vue instance (public or internal shape).\n * Wrapped + tolerant: returns `undefined` rather than throwing when the instance\n * is null, exotic, or nameless. Never reads props/state.\n */\nfunction componentNameOf(instance: unknown): string | undefined {\n  try {\n    if (!instance || typeof instance !== 'object') return undefined;\n    const inst = instance as {\n      $options?: unknown;\n      $?: { type?: unknown };\n      type?: unknown;\n    };\n    return (\n      readName(inst.$options) ?? readName(inst.$?.type) ?? readName(inst.type)\n    );\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Emit one `error`-level event through the resolved logger. Safe no-op when no\n * logger resolves; fail-safe — any throw in the logging path is swallowed so the\n * original error is never escalated.\n */\nfunction emit(\n  logger: Logger | undefined,\n  source: string,\n  message: string,\n  error: unknown,\n  extra?: Attributes,\n  instance?: unknown,\n  info?: string,\n): void {\n  if (!logger) return;\n  try {\n    const attributes: Attributes = { 'safesignal.source': source };\n    if (typeof info === 'string' && info.length > 0) {\n      attributes['safesignal.vue.info'] = info;\n    }\n    const name = componentNameOf(instance);\n    if (name) attributes['safesignal.vue.componentName'] = name;\n    if (extra) {\n      for (const key of Object.keys(extra)) {\n        attributes[key] = extra[key] as Attributes[string];\n      }\n    }\n    logger.error(message, attributes, error);\n  } catch {\n    // Fail-safe: a logging failure must never escalate the original error.\n  }\n}\n\n/**\n * Side-effect-free factory: given a `Logger`, returns a handler suitable for\n * `app.config.errorHandler`. Each invocation emits one `error`-level event\n * (`safesignal.source: 'vue-error-handler'`) via that logger; it attaches\n * nothing at creation and never throws.\n */\nexport function createErrorHandler(logger: Logger): VueErrorHandler {\n  return (err, instance, info) => {\n    emit(logger, SOURCE_HANDLER, 'Vue error', err, undefined, instance, info);\n  };\n}\n\n/** Options for the {@link safesignalErrorHandler} plugin. */\nexport interface SafesignalErrorHandlerOptions {\n  /** The consumer's configured `Logger`, used by the app handler and provided to descendants. */\n  logger: Logger;\n}\n\n/**\n * Vue plugin: `app.use(safesignalErrorHandler, { logger })` sets\n * `app.config.errorHandler = createErrorHandler(logger)` **and**\n * `app.provide(loggerKey, logger)`. No other side effects (no globals, no\n * timers, no listeners).\n */\nexport const safesignalErrorHandler: Plugin<SafesignalErrorHandlerOptions> = {\n  install(app: App, options: SafesignalErrorHandlerOptions): void {\n    const { logger } = options;\n    app.config.errorHandler = createErrorHandler(logger);\n    app.provide(loggerKey, logger);\n  },\n};\n\n/**\n * Returns a callback that logs an error through the resolved logger\n * (`loggerOverride` ?? injected {@link loggerKey}) as an `error`-level event —\n * for the errors a framework handler cannot catch (async/`Promise` callbacks,\n * `try/catch`, native `addEventListener`). Fail-safe; a **safe no-op** when no\n * logger resolves. Call this in `setup()`; the callback identity is stable for\n * the component's lifetime (Vue runs `setup` once).\n */\nexport function useLogError(\n  loggerOverride?: Logger,\n): (error: unknown, attributes?: Attributes) => void {\n  const logger = loggerOverride ?? inject(loggerKey);\n  return (error, attributes) => {\n    emit(logger, SOURCE_HOOK, 'Reported error', error, attributes);\n  };\n}\n\n/** Options for {@link useErrorCapture}. */\nexport interface UseErrorCaptureOptions {\n  /** Explicit logger override; falls back to the injected {@link loggerKey}. */\n  logger?: Logger;\n  /** Optional consumer hook, invoked fail-safe AFTER logging, with Vue's info string. */\n  onError?: (error: unknown, info: string) => void;\n  /** Keep propagating to ancestor/app handlers after logging. Default: false (stop). */\n  propagate?: boolean;\n}\n\n/**\n * Subtree boundary: registers `onErrorCaptured` in the calling component so a\n * descendant error is logged once via the resolved logger\n * (`safesignal.source: 'vue-error-captured'`). By **default it stops\n * propagation** (returns `false`) so the app-level handler does not also log it;\n * pass `{ propagate: true }` to keep it bubbling. The optional `onError` callback\n * is invoked fail-safe after logging. A safe no-op when no logger resolves.\n */\nexport function useErrorCapture(options: UseErrorCaptureOptions = {}): void {\n  const logger = options.logger ?? inject(loggerKey);\n  onErrorCaptured((err, instance, info) => {\n    emit(\n      logger,\n      SOURCE_CAPTURED,\n      'Vue captured error',\n      err,\n      undefined,\n      instance,\n      info,\n    );\n    try {\n      options.onError?.(err, info);\n    } catch {\n      // Fail-safe: a consumer onError that throws must not disrupt the app.\n    }\n    return options.propagate ? undefined : false;\n  });\n}\n"]}

package/dist/index.cjs

@@ -1,5 +1,121 @@
 'use strict';
 
+// src/internal/errors/internal-errors.ts
+var PACKAGE_ERROR_MARKER = /* @__PURE__ */ Symbol("frontend-logging-sdk/package-error");
+var PackageError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "PackageError";
+    this.code = code;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    if (options.transportName !== void 0) {
+      this.transportName = options.transportName;
+    }
+    Object.defineProperty(this, PACKAGE_ERROR_MARKER, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+};
+function isPackageError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value[PACKAGE_ERROR_MARKER] === true;
+}
+function wrapAsPackageError(code, message, cause, transportName) {
+  if (isPackageError(cause)) return cause;
+  const options = { cause };
+  if (transportName !== void 0) {
+    options.transportName = transportName;
+  }
+  return new PackageError(code, message, options);
+}
+function safeNotify(onInternalError, err) {
+  try {
+    onInternalError(err);
+  } catch {
+  }
+}
+
+// src/breadcrumbs/breadcrumb-buffer.ts
+function breadcrumbFail(onInternalError, err) {
+  safeNotify(
+    onInternalError,
+    wrapAsPackageError("breadcrumb_failed", "breadcrumb failed", err)
+  );
+}
+var DEFAULT_MAX_EVENTS = 20;
+var MAX_EVENTS_BOUND = 100;
+var BREADCRUMBS_KEY = "safesignal.breadcrumbs";
+function buildSnapshot(event) {
+  const snap = {
+    ts: event.timestamp,
+    level: event.level,
+    message: event.message
+  };
+  const app = event.context.application?.name;
+  if (app !== void 0) snap.app = app;
+  const mod = event.context.module?.name;
+  if (mod !== void 0) snap.module = mod;
+  const attrs = {};
+  let hasAttrs = false;
+  for (const key of Object.keys(event.attributes)) {
+    const value = event.attributes[key];
+    if (key === BREADCRUMBS_KEY || value === void 0) continue;
+    attrs[key] = value;
+    hasAttrs = true;
+  }
+  if (hasAttrs) snap.attributes = attrs;
+  return snap;
+}
+var BreadcrumbBuffer = class {
+  constructor(maxEvents) {
+    this.ring = [];
+    this.capacity = maxEvents;
+  }
+  /** Record a compact snapshot of a post-pipeline event; oldest evicted. */
+  record(event) {
+    this.ring.push(buildSnapshot(event));
+    if (this.ring.length > this.capacity) this.ring.shift();
+  }
+  /**
+   * Attach the current trail to an error event as `attributes[BREADCRUMBS_KEY]`
+   * (ordered oldest→newest). No-op when the buffer is empty (no placeholder).
+   */
+  attachTrailTo(event) {
+    if (this.ring.length === 0) return;
+    event.attributes[BREADCRUMBS_KEY] = this.ring.slice();
+  }
+};
+var MAX_CAUSE_DEPTH = 8;
+var CAUSES_KEY = "safesignal.errorCauses";
+function getCause(value) {
+  if (value !== null && typeof value === "object" && "cause" in value) {
+    return value.cause;
+  }
+  return void 0;
+}
+function extractCauseChain(value, maxDepth) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (value !== null && typeof value === "object") seen.add(value);
+  let current = getCause(value);
+  while (current !== void 0 && current !== null && chain.length < maxDepth) {
+    if (typeof current === "object") {
+      if (seen.has(current)) break;
+      seen.add(current);
+    }
+    chain.push(
+      current instanceof Error ? { name: current.name, message: current.message } : { name: "NonError", message: String(current) }
+    );
+    current = getCause(current);
+  }
+  return chain;
+}
+
 // src/context/context-merge.ts
 function mergeContexts(...sources) {
   const merged = {};
@@ -50,46 +166,6 @@ function isPlainAttributeObject(value) {
   return value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value);
 }
 
-// src/internal/errors/internal-errors.ts
-var PACKAGE_ERROR_MARKER = /* @__PURE__ */ Symbol("frontend-logging-sdk/package-error");
-var PackageError = class extends Error {
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "PackageError";
-    this.code = code;
-    if (options.cause !== void 0) {
-      this.cause = options.cause;
-    }
-    if (options.transportName !== void 0) {
-      this.transportName = options.transportName;
-    }
-    Object.defineProperty(this, PACKAGE_ERROR_MARKER, {
-      value: true,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-  }
-};
-function isPackageError(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return value[PACKAGE_ERROR_MARKER] === true;
-}
-function wrapAsPackageError(code, message, cause, transportName) {
-  if (isPackageError(cause)) return cause;
-  const options = { cause };
-  if (transportName !== void 0) {
-    options.transportName = transportName;
-  }
-  return new PackageError(code, message, options);
-}
-function safeNotify(onInternalError, err) {
-  try {
-    onInternalError(err);
-  } catch {
-  }
-}
-
 // src/pipeline/control-char-guard.ts
 var CONTROL_CHAR_CLASS = "[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u2028\\u2029]";
 var HAS_CONTROL_CHAR = new RegExp(CONTROL_CHAR_CLASS);
@@ -847,6 +923,13 @@ function dispatch(event, config) {
     if (current === null) return;
     current = controlCharGuard(current, config);
     if (current === null) return;
+    if (config.breadcrumbs !== void 0 && current.level === "error") {
+      try {
+        config.breadcrumbs.attachTrailTo(current);
+      } catch (err) {
+        breadcrumbFail(config.onInternalError, err);
+      }
+    }
     current = freezeInDev(current, config);
     if (current === null) return;
   } catch (err) {
@@ -869,6 +952,13 @@ function dispatch(event, config) {
     } catch {
     }
   }
+  if (config.breadcrumbs !== void 0) {
+    try {
+      config.breadcrumbs.record(current);
+    } catch (err) {
+      breadcrumbFail(config.onInternalError, err);
+    }
+  }
 }
 
 // src/pipeline/event-builder.ts
@@ -956,9 +1046,32 @@ function normalizeConfig(config) {
     transports,
     redactor: config.redactor,
     sanitizerLimits,
+    breadcrumbs: resolveBreadcrumbs(config.breadcrumbs, onInternalError),
+    normalizeStack: config.normalizeStack,
     onInternalError
   };
 }
+function resolveBreadcrumbs(option, onInternalError) {
+  if (!option) return void 0;
+  const requested = option === true ? void 0 : option.maxEvents;
+  if (requested === void 0 || !Number.isFinite(requested)) {
+    return new BreadcrumbBuffer(DEFAULT_MAX_EVENTS);
+  }
+  const maxEvents = Math.min(
+    MAX_EVENTS_BOUND,
+    Math.max(1, Math.floor(requested))
+  );
+  if (maxEvents !== requested) {
+    safeNotify(
+      onInternalError,
+      new PackageError(
+        "breadcrumbs_max_clamped",
+        `breadcrumbs.maxEvents clamped to ${maxEvents}`
+      )
+    );
+  }
+  return new BreadcrumbBuffer(maxEvents);
+}
 function resolveConfigLevel(level, environment) {
   if (level === void 0) {
     return defaultLevelForEnvironment(environment);
@@ -1236,6 +1349,33 @@ function makeLogger(options, chainedContexts) {
       context,
       errorValue
     });
+    if (cfg.breadcrumbs !== void 0 && level === "error" && errorValue !== void 0) {
+      try {
+        const causes = extractCauseChain(errorValue, MAX_CAUSE_DEPTH);
+        if (causes.length > 0) {
+          event.attributes[CAUSES_KEY] = causes;
+        }
+      } catch (err) {
+        breadcrumbFail(cfg.onInternalError, err);
+      }
+    }
+    if (cfg.normalizeStack !== void 0 && level === "error" && event.error?.stack !== void 0) {
+      try {
+        const frames = cfg.normalizeStack(event.error.stack);
+        if (frames !== null && frames.length > 0) {
+          event.attributes["safesignal.stack"] = frames;
+        }
+      } catch (err) {
+        safeNotify(
+          cfg.onInternalError,
+          wrapAsPackageError(
+            "stack_normalize_failed",
+            "stack normalize failed",
+            err
+          )
+        );
+      }
+    }
     dispatch(event, cfg);
   }
   return {