autotel-subscribers 27.0.1 → 28.0.0

package/dist/factories.cjs

@@ -12,6 +12,7 @@ var https = require('https');
 var buffer = require('buffer');
 var util = require('util');
 var crypto2 = require('crypto');
+var slowRedact = require('slow-redact');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -40,6 +41,7 @@ var http__namespace = /*#__PURE__*/_interopNamespace(http);
 var https__namespace = /*#__PURE__*/_interopNamespace(https);
 var util__namespace = /*#__PURE__*/_interopNamespace(util);
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
+var slowRedact__default = /*#__PURE__*/_interopDefault(slowRedact);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -13855,7 +13857,70 @@ var EventSubscriber = class {
   }
 };
 
-// src/posthog.ts
+// src/posthog-error-formatter.ts
+var MAX_CAUSE_DEPTH = 5;
+function formatExceptionForPostHog(exceptionList, platform = "web:javascript", redactor) {
+  return {
+    $exception_list: exceptionList.map((ex) => ({
+      type: ex.type,
+      value: redactor ? redactor(ex.value) : ex.value,
+      mechanism: ex.mechanism,
+      stacktrace: {
+        frames: (ex.stacktrace?.frames || []).map((frame) => ({
+          ...frame,
+          abs_path: frame.abs_path && redactor ? redactor(frame.abs_path) : frame.abs_path,
+          platform
+        }))
+      }
+    }))
+  };
+}
+function errorToExceptionList(input, redactor) {
+  const error = input instanceof Error ? input : new Error(
+    input === null || input === void 0 ? "Unknown error" : String(input)
+  );
+  const records = [];
+  let current = error;
+  let depth = 0;
+  while (current && depth < MAX_CAUSE_DEPTH) {
+    const value = current.message || "Unknown error";
+    const frames = current.stack ? parseStackBasic(current.stack) : void 0;
+    records.push({
+      type: current.name || "Error",
+      value: redactor ? redactor(value) : value,
+      mechanism: { type: "manual", handled: true },
+      stacktrace: frames ? {
+        frames: redactor ? frames.map((f) => ({
+          ...f,
+          abs_path: f.abs_path ? redactor(f.abs_path) : f.abs_path
+        })) : frames
+      } : void 0
+    });
+    current = current.cause instanceof Error ? current.cause : void 0;
+    depth++;
+  }
+  return records.toReversed();
+}
+function parseStackBasic(stack) {
+  const lines = stack.split("\n");
+  const frames = [];
+  const re = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/;
+  for (const line of lines) {
+    const match = line.trim().match(re);
+    if (match) {
+      const [, fn, absPath, lineStr, colStr] = match;
+      frames.push({
+        function: fn || void 0,
+        abs_path: absPath,
+        filename: absPath.split("/").pop() || absPath,
+        lineno: Number.parseInt(lineStr, 10),
+        colno: Number.parseInt(colStr, 10),
+        in_app: !absPath.includes("node_modules")
+      });
+    }
+  }
+  return frames;
+}
 var PostHogSubscriber = class extends EventSubscriber {
   name = "PostHogSubscriber";
   version = "2.0.0";
@@ -13864,6 +13929,8 @@ var PostHogSubscriber = class extends EventSubscriber {
   initPromise = null;
   /** True when using browser's window.posthog (different API signature) */
   isBrowserClient = false;
+  pathRedactor = null;
+  stringRedactor = null;
   constructor(config) {
     super();
     if (config.serverless) {
@@ -13885,6 +13952,15 @@ var PostHogSubscriber = class extends EventSubscriber {
       filterUndefinedValues: true,
       ...config
     };
+    if (this.config.redactPaths && this.config.redactPaths.length > 0) {
+      this.pathRedactor = slowRedact__default.default({
+        paths: this.config.redactPaths,
+        serialize: false
+      });
+    }
+    if (this.config.stringRedactor) {
+      this.stringRedactor = this.config.stringRedactor;
+    }
     if (this.enabled) {
       this.initPromise = this.initialize();
     }
@@ -13944,6 +14020,50 @@ var PostHogSubscriber = class extends EventSubscriber {
   extractDistinctId(attributes) {
     return attributes?.userId || attributes?.user_id || "anonymous";
   }
+  redactProperties(properties) {
+    let result = properties;
+    if (this.pathRedactor) {
+      result = this.pathRedactor(properties);
+    }
+    if (this.stringRedactor) {
+      result = this.redactStringValues(result);
+    }
+    return result;
+  }
+  redactStringValues(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === "string") {
+        result[key] = this.stringRedactor(value);
+      } else if (Array.isArray(value)) {
+        result[key] = this.redactArray(value);
+      } else if (value !== null && typeof value === "object") {
+        result[key] = this.redactStringValues(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  redactArray(arr) {
+    return arr.map((item) => {
+      if (typeof item === "string") {
+        return this.stringRedactor(item);
+      } else if (Array.isArray(item)) {
+        return this.redactArray(item);
+      } else if (item !== null && typeof item === "object") {
+        return this.redactStringValues(item);
+      }
+      return item;
+    });
+  }
+  /**
+   * Set the string redactor. Called by autotel init() when attributeRedactor is configured.
+   * Can also be called manually.
+   */
+  setStringRedactor(redactor) {
+    this.stringRedactor = redactor;
+  }
   /**
    * Send payload to PostHog
    *
@@ -13995,14 +14115,39 @@ var PostHogSubscriber = class extends EventSubscriber {
         properties.$linked_trace_ids = payload.autotel.linked_trace_ids;
       }
     }
+    const redactedProperties = this.redactProperties(properties);
+    if (payload.attributes?.["exception.list"]) {
+      try {
+        const exceptionList = JSON.parse(payload.attributes["exception.list"]);
+        const formatted = formatExceptionForPostHog(
+          exceptionList,
+          void 0,
+          this.stringRedactor ?? void 0
+        );
+        const exceptionProperties = {
+          ...redactedProperties,
+          ...formatted
+        };
+        if (this.isBrowserClient) {
+          this.posthog?.capture("$exception", exceptionProperties);
+        } else {
+          this.posthog?.capture({
+            distinctId: this.extractDistinctId(filteredAttributes),
+            event: "$exception",
+            properties: exceptionProperties
+          });
+        }
+      } catch {
+      }
+    }
     const distinctId = this.extractDistinctId(filteredAttributes);
     if (this.isBrowserClient) {
-      this.posthog?.capture(payload.name, properties);
+      this.posthog?.capture(payload.name, redactedProperties);
     } else {
       const capturePayload = {
         distinctId,
         event: payload.name,
-        properties
+        properties: redactedProperties
       };
       if (filteredAttributes?.groups) {
         capturePayload.groups = filteredAttributes.groups;
@@ -14211,6 +14356,36 @@ var PostHogSubscriber = class extends EventSubscriber {
     }
     await this.trackEvent(name, eventAttributes);
   }
+  /**
+   * Capture an exception and send to PostHog error tracking.
+   *
+   * If using browser client (window.posthog), delegates to its captureException.
+   * Otherwise, formats and sends via posthog-node capture API.
+   */
+  async captureException(error, options) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    try {
+      if (this.isBrowserClient) {
+        const browserProps = options?.additionalProperties ? this.redactProperties(options.additionalProperties) : void 0;
+        this.posthog?.captureException?.(error, browserProps);
+        return;
+      }
+      const exceptionList = errorToExceptionList(error, this.stringRedactor ?? void 0);
+      const formatted = formatExceptionForPostHog(exceptionList, "node:javascript", this.stringRedactor ?? void 0);
+      const properties = {
+        ...formatted,
+        ...options?.additionalProperties
+      };
+      this.posthog?.capture({
+        distinctId: options?.distinctId || "anonymous",
+        event: "$exception",
+        properties: this.redactProperties(properties)
+      });
+    } catch (error_) {
+      this.config.onError?.(error_);
+    }
+  }
   /**
    * Flush pending events and clean up resources
    */