posthog-node 4.4.0 → 4.5.0

package/lib/index.cjs.js

@@ -3,8 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var node_crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var node_readline = require('node:readline');
+var node_path = require('node:path');
 
-var version = "4.4.0";
+var version = "4.5.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -69,6 +72,9 @@ function safeSetTimeout(fn, timeout) {
     // We unref if available to prevent Node.js hanging on exit
     t?.unref && t?.unref();
     return t;
+}
+function getFetch() {
+    return typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
 }
 
 // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
@@ -1431,10 +1437,7 @@ class PostHogMemoryStorage {
  * This is currently solved by using the global fetch if available instead.
  * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
  */
-let _fetch =
-// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
-// @ts-ignore
-typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
+let _fetch = getFetch();
 if (!_fetch) {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const axios = require('axios');
@@ -2040,6 +2043,884 @@ function relativeDateParseForFeatureFlagMatching(value) {
   }
 }
 
+function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
+  let calledFatalError = false;
+  return Object.assign(error => {
+    // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not
+    // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust
+    // exit behaviour of the SDK accordingly:
+    // - If other listeners are attached, do not exit.
+    // - If the only listener attached is ours, exit.
+    const userProvidedListenersCount = global.process.listeners('uncaughtException').filter(listener => {
+      // There are 2 listeners we ignore:
+      return (
+        // as soon as we're using domains this listener is attached by node itself
+        listener.name !== 'domainUncaughtExceptionClear' &&
+        // the handler we register in this integration
+        listener._posthogErrorHandler !== true
+      );
+    }).length;
+    const processWouldExit = userProvidedListenersCount === 0;
+    captureFn(error, {
+      mechanism: {
+        type: 'onuncaughtexception',
+        handled: false
+      }
+    });
+    if (!calledFatalError && processWouldExit) {
+      calledFatalError = true;
+      onFatalFn();
+    }
+  }, {
+    _posthogErrorHandler: true
+  });
+}
+function addUncaughtExceptionListener(captureFn, onFatalFn) {
+  global.process.on('uncaughtException', makeUncaughtExceptionHandler(captureFn, onFatalFn));
+}
+function addUnhandledRejectionListener(captureFn) {
+  global.process.on('unhandledRejection', reason => {
+    captureFn(reason, {
+      mechanism: {
+        type: 'onunhandledrejection',
+        handled: false
+      }
+    });
+  });
+}
+
+function isEvent(candidate) {
+  return typeof Event !== 'undefined' && isInstanceOf(candidate, Event);
+}
+function isPlainObject(candidate) {
+  return isBuiltin(candidate, 'Object');
+}
+function isError(candidate) {
+  switch (Object.prototype.toString.call(candidate)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+    case '[object WebAssembly.Exception]':
+      return true;
+    default:
+      return isInstanceOf(candidate, Error);
+  }
+}
+function isInstanceOf(candidate, base) {
+  try {
+    return candidate instanceof base;
+  } catch {
+    return false;
+  }
+}
+function isErrorEvent(event) {
+  return isBuiltin(event, 'ErrorEvent');
+}
+function isBuiltin(candidate, className) {
+  return Object.prototype.toString.call(candidate) === `[object ${className}]`;
+}
+
+/** A simple Least Recently Used map */
+class ReduceableCache {
+  constructor(_maxSize) {
+    this._maxSize = _maxSize;
+    this._cache = new Map();
+  }
+  /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */
+  get(key) {
+    const value = this._cache.get(key);
+    if (value === undefined) {
+      return undefined;
+    }
+    // Remove and re-insert to update the order
+    this._cache.delete(key);
+    this._cache.set(key, value);
+    return value;
+  }
+  /** Insert an entry and evict an older entry if we've reached maxSize */
+  set(key, value) {
+    this._cache.set(key, value);
+  }
+  /** Remove an entry and return the entry if it was in the cache */
+  reduce() {
+    while (this._cache.size >= this._maxSize) {
+      const value = this._cache.keys().next().value;
+      if (value) {
+        // keys() returns an iterator in insertion order so keys().next() gives us the oldest key
+        this._cache.delete(value);
+      }
+    }
+  }
+}
+
+const LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+// Determines the upper bound of lineno/colno that we will attempt to read. Large colno values are likely to be
+// minified code while large lineno values are likely to be bundled code.
+// Exported for testing purposes.
+const MAX_CONTEXTLINES_COLNO = 1000;
+const MAX_CONTEXTLINES_LINENO = 10000;
+async function addSourceContext(frames) {
+  // keep a lookup map of which files we've already enqueued to read,
+  // so we don't enqueue the same file multiple times which would cause multiple i/o reads
+  const filesToLines = {};
+  // Maps preserve insertion order, so we iterate in reverse, starting at the
+  // outermost frame and closer to where the exception has occurred (poor mans priority)
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const frame = frames[i];
+    const filename = frame?.filename;
+    if (!frame || typeof filename !== 'string' || typeof frame.lineno !== 'number' || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) {
+      continue;
+    }
+    const filesToLinesOutput = filesToLines[filename];
+    if (!filesToLinesOutput) {
+      filesToLines[filename] = [];
+    }
+    filesToLines[filename].push(frame.lineno);
+  }
+  const files = Object.keys(filesToLines);
+  if (files.length == 0) {
+    return frames;
+  }
+  const readlinePromises = [];
+  for (const file of files) {
+    // If we failed to read this before, dont try reading it again.
+    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) {
+      continue;
+    }
+    const filesToLineRanges = filesToLines[file];
+    if (!filesToLineRanges) {
+      continue;
+    }
+    // Sort ranges so that they are sorted by line increasing order and match how the file is read.
+    filesToLineRanges.sort((a, b) => a - b);
+    // Check if the contents are already in the cache and if we can avoid reading the file again.
+    const ranges = makeLineReaderRanges(filesToLineRanges);
+    if (ranges.every(r => rangeExistsInContentCache(file, r))) {
+      continue;
+    }
+    const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
+    readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
+  }
+  // The promise rejections are caught in order to prevent them from short circuiting Promise.all
+  await Promise.all(readlinePromises).catch(() => {});
+  // Perform the same loop as above, but this time we can assume all files are in the cache
+  // and attempt to add source context to frames.
+  if (frames && frames.length > 0) {
+    addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
+  }
+  // Once we're finished processing an exception reduce the files held in the cache
+  // so that we don't indefinetly increase the size of this map
+  LRU_FILE_CONTENTS_CACHE.reduce();
+  return frames;
+}
+/**
+ * Extracts lines from a file and stores them in a cache.
+ */
+function getContextLinesFromFile(path, ranges, output) {
+  return new Promise(resolve => {
+    // It is important *not* to have any async code between createInterface and the 'line' event listener
+    // as it will cause the 'line' event to
+    // be emitted before the listener is attached.
+    const stream = node_fs.createReadStream(path);
+    const lineReaded = node_readline.createInterface({
+      input: stream
+    });
+    // We need to explicitly destroy the stream to prevent memory leaks,
+    // removing the listeners on the readline interface is not enough.
+    // See: https://github.com/nodejs/node/issues/9002 and https://github.com/getsentry/sentry-javascript/issues/14892
+    function destroyStreamAndResolve() {
+      stream.destroy();
+      resolve();
+    }
+    // Init at zero and increment at the start of the loop because lines are 1 indexed.
+    let lineNumber = 0;
+    let currentRangeIndex = 0;
+    const range = ranges[currentRangeIndex];
+    if (range === undefined) {
+      // We should never reach this point, but if we do, we should resolve the promise to prevent it from hanging.
+      destroyStreamAndResolve();
+      return;
+    }
+    let rangeStart = range[0];
+    let rangeEnd = range[1];
+    // We use this inside Promise.all, so we need to resolve the promise even if there is an error
+    // to prevent Promise.all from short circuiting the rest.
+    function onStreamError() {
+      // Mark file path as failed to read and prevent multiple read attempts.
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);
+      lineReaded.close();
+      lineReaded.removeAllListeners();
+      destroyStreamAndResolve();
+    }
+    // We need to handle the error event to prevent the process from crashing in < Node 16
+    // https://github.com/nodejs/node/pull/31603
+    stream.on('error', onStreamError);
+    lineReaded.on('error', onStreamError);
+    lineReaded.on('close', destroyStreamAndResolve);
+    lineReaded.on('line', line => {
+      lineNumber++;
+      if (lineNumber < rangeStart) {
+        return;
+      }
+      // !Warning: This mutates the cache by storing the snipped line into the cache.
+      output[lineNumber] = snipLine(line, 0);
+      if (lineNumber >= rangeEnd) {
+        if (currentRangeIndex === ranges.length - 1) {
+          // We need to close the file stream and remove listeners, else the reader will continue to run our listener;
+          lineReaded.close();
+          lineReaded.removeAllListeners();
+          return;
+        }
+        currentRangeIndex++;
+        const range = ranges[currentRangeIndex];
+        if (range === undefined) {
+          // This should never happen as it means we have a bug in the context.
+          lineReaded.close();
+          lineReaded.removeAllListeners();
+          return;
+        }
+        rangeStart = range[0];
+        rangeEnd = range[1];
+      }
+    });
+  });
+}
+/** Adds context lines to frames */
+function addSourceContextToFrames(frames, cache) {
+  for (const frame of frames) {
+    // Only add context if we have a filename and it hasn't already been added
+    if (frame.filename && frame.context_line === undefined && typeof frame.lineno === 'number') {
+      const contents = cache.get(frame.filename);
+      if (contents === undefined) {
+        continue;
+      }
+      addContextToFrame(frame.lineno, frame, contents);
+    }
+  }
+}
+/**
+ * Resolves context lines before and after the given line number and appends them to the frame;
+ */
+function addContextToFrame(lineno, frame, contents) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping.
+  // We already check for lineno before calling this, but since StackFrame lineno is optional, we check it again.
+  if (frame.lineno === undefined || contents === undefined) {
+    return;
+  }
+  frame.pre_context = [];
+  for (let i = makeRangeStart(lineno); i < lineno; i++) {
+    // We always expect the start context as line numbers cannot be negative. If we dont find a line, then
+    // something went wrong somewhere. Clear the context and return without adding any linecontext.
+    const line = contents[i];
+    if (line === undefined) {
+      clearLineContext(frame);
+      return;
+    }
+    frame.pre_context.push(line);
+  }
+  // We should always have the context line. If we dont, something went wrong, so we clear the context and return
+  // without adding any linecontext.
+  if (contents[lineno] === undefined) {
+    clearLineContext(frame);
+    return;
+  }
+  frame.context_line = contents[lineno];
+  const end = makeRangeEnd(lineno);
+  frame.post_context = [];
+  for (let i = lineno + 1; i <= end; i++) {
+    // Since we dont track when the file ends, we cant clear the context if we dont find a line as it could
+    // just be that we reached the end of the file.
+    const line = contents[i];
+    if (line === undefined) {
+      break;
+    }
+    frame.post_context.push(line);
+  }
+}
+/**
+ * Clears the context lines from a frame, used to reset a frame to its original state
+ * if we fail to resolve all context lines for it.
+ */
+function clearLineContext(frame) {
+  delete frame.pre_context;
+  delete frame.context_line;
+  delete frame.post_context;
+}
+/**
+ * Determines if context lines should be skipped for a file.
+ * - .min.(mjs|cjs|js) files are and not useful since they dont point to the original source
+ * - node: prefixed modules are part of the runtime and cannot be resolved to a file
+ * - data: skip json, wasm and inline js https://nodejs.org/api/esm.html#data-imports
+ */
+function shouldSkipContextLinesForFile(path) {
+  // Test the most common prefix and extension first. These are the ones we
+  // are most likely to see in user applications and are the ones we can break out of first.
+  return path.startsWith('node:') || path.endsWith('.min.js') || path.endsWith('.min.cjs') || path.endsWith('.min.mjs') || path.startsWith('data:');
+}
+/**
+ * Determines if we should skip contextlines based off the max lineno and colno values.
+ */
+function shouldSkipContextLinesForFrame(frame) {
+  if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO) {
+    return true;
+  }
+  if (frame.colno !== undefined && frame.colno > MAX_CONTEXTLINES_COLNO) {
+    return true;
+  }
+  return false;
+}
+/**
+ * Checks if we have all the contents that we need in the cache.
+ */
+function rangeExistsInContentCache(file, range) {
+  const contents = LRU_FILE_CONTENTS_CACHE.get(file);
+  if (contents === undefined) {
+    return false;
+  }
+  for (let i = range[0]; i <= range[1]; i++) {
+    if (contents[i] === undefined) {
+      return false;
+    }
+  }
+  return true;
+}
+/**
+ * Creates contiguous ranges of lines to read from a file. In the case where context lines overlap,
+ * the ranges are merged to create a single range.
+ */
+function makeLineReaderRanges(lines) {
+  if (!lines.length) {
+    return [];
+  }
+  let i = 0;
+  const line = lines[0];
+  if (typeof line !== 'number') {
+    return [];
+  }
+  let current = makeContextRange(line);
+  const out = [];
+  while (true) {
+    if (i === lines.length - 1) {
+      out.push(current);
+      break;
+    }
+    // If the next line falls into the current range, extend the current range to lineno + linecontext.
+    const next = lines[i + 1];
+    if (typeof next !== 'number') {
+      break;
+    }
+    if (next <= current[1]) {
+      current[1] = next + DEFAULT_LINES_OF_CONTEXT;
+    } else {
+      out.push(current);
+      current = makeContextRange(next);
+    }
+    i++;
+  }
+  return out;
+}
+// Determine start and end indices for context range (inclusive);
+function makeContextRange(line) {
+  return [makeRangeStart(line), makeRangeEnd(line)];
+}
+// Compute inclusive end context range
+function makeRangeStart(line) {
+  return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
+}
+// Compute inclusive start context range
+function makeRangeEnd(line) {
+  return line + DEFAULT_LINES_OF_CONTEXT;
+}
+/**
+ * Get or init map value
+ */
+function emplace(map, key, contents) {
+  const value = map.get(key);
+  if (value === undefined) {
+    map.set(key, contents);
+    return contents;
+  }
+  return value;
+}
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) {
+    return newLine;
+  }
+  if (colno > lineLength) {
+    colno = lineLength;
+  }
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) {
+    start = 0;
+  }
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) {
+    end = lineLength;
+  }
+  if (end === lineLength) {
+    start = Math.max(end - 140, 0);
+  }
+  newLine = newLine.slice(start, end);
+  if (start > 0) {
+    newLine = `...${newLine}`;
+  }
+  if (end < lineLength) {
+    newLine += '...';
+  }
+  return newLine;
+}
+
+/**
+ * based on the very wonderful MIT licensed Sentry SDK
+ */
+async function propertiesFromUnknownInput(stackParser, input, hint) {
+  const providedMechanism = hint && hint.mechanism;
+  const mechanism = providedMechanism || {
+    handled: true,
+    type: 'generic'
+  };
+  const error = getError(mechanism, input, hint);
+  const exception = await exceptionFromError(stackParser, error);
+  exception.value = exception.value || '';
+  exception.type = exception.type || 'Error';
+  exception.mechanism = mechanism;
+  const properties = {
+    $exception_list: [exception]
+  };
+  return properties;
+}
+function getError(mechanism, exception, hint) {
+  if (isError(exception)) {
+    return exception;
+  }
+  mechanism.synthetic = true;
+  if (isPlainObject(exception)) {
+    const errorFromProp = getErrorPropertyFromObject(exception);
+    if (errorFromProp) {
+      return errorFromProp;
+    }
+    const message = getMessageForObject(exception);
+    const ex = hint?.syntheticException || new Error(message);
+    ex.message = message;
+    return ex;
+  }
+  // This handles when someone does: `throw "something awesome";`
+  // We use synthesized Error here so we can extract a (rough) stack trace.
+  const ex = hint?.syntheticException || new Error(exception);
+  ex.message = `${exception}`;
+  return ex;
+}
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj) {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (value instanceof Error) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+function getMessageForObject(exception) {
+  if ('name' in exception && typeof exception.name === 'string') {
+    let message = `'${exception.name}' captured as exception`;
+    if ('message' in exception && typeof exception.message === 'string') {
+      message += ` with message '${exception.message}'`;
+    }
+    return message;
+  } else if ('message' in exception && typeof exception.message === 'string') {
+    return exception.message;
+  }
+  const keys = extractExceptionKeysForMessage(exception);
+  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before
+  // We still want to try to get a decent message for these cases
+  if (isErrorEvent(exception)) {
+    return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
+  }
+  const className = getObjectClassName(exception);
+  return `${className && className !== 'Object' ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
+}
+function getObjectClassName(obj) {
+  try {
+    const prototype = Object.getPrototypeOf(obj);
+    return prototype ? prototype.constructor.name : undefined;
+  } catch (e) {
+    // ignore errors here
+  }
+}
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+  const keys = Object.keys(convertToPlainObject(exception));
+  keys.sort();
+  const firstKey = keys[0];
+  if (!firstKey) {
+    return '[object has no keys]';
+  }
+  if (firstKey.length >= maxLength) {
+    return truncate(firstKey, maxLength);
+  }
+  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+    const serialized = keys.slice(0, includedKeys).join(', ');
+    if (serialized.length > maxLength) {
+      continue;
+    }
+    if (includedKeys === keys.length) {
+      return serialized;
+    }
+    return truncate(serialized, maxLength);
+  }
+  return '';
+}
+function truncate(str, max = 0) {
+  if (typeof str !== 'string' || max === 0) {
+    return str;
+  }
+  return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
+ *
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor
+ *  an Error.
+ */
+function convertToPlainObject(value) {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value)
+    };
+  } else if (isEvent(value)) {
+    const newObj = {
+      type: value.type,
+      target: serializeEventTarget(value.target),
+      currentTarget: serializeEventTarget(value.currentTarget),
+      ...getOwnProperties(value)
+    };
+    // TODO: figure out why this fails typing (I think CustomEvent is only supported in Node 19 onwards)
+    // if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
+    //   newObj.detail = (value as unknown as CustomEvent).detail
+    // }
+    return newObj;
+  } else {
+    return value;
+  }
+}
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps = {};
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = obj[property];
+      }
+    }
+    return extractedProps;
+  } else {
+    return {};
+  }
+}
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+  try {
+    return Object.prototype.toString.call(target);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+/**
+ * Extracts stack frames from the error and builds an Exception
+ */
+async function exceptionFromError(stackParser, error) {
+  const exception = {
+    type: error.name || error.constructor.name,
+    value: error.message
+  };
+  const frames = await addSourceContext(parseStackFrames(stackParser, error));
+  if (frames.length) {
+    exception.stacktrace = {
+      frames,
+      type: 'raw'
+    };
+  }
+  return exception;
+}
+/**
+ * Extracts stack frames from the error.stack string
+ */
+function parseStackFrames(stackParser, error) {
+  return stackParser(error.stack || '', 1);
+}
+
+// copied and adapted from https://github.com/getsentry/sentry-javascript/blob/41fef4b10f3a644179b77985f00f8696c908539f/packages/browser/src/stack-parsers.ts
+// This was originally forked from https://github.com/csnover/TraceKit, and was largely
+// re-written as part of raven - js.
+//
+// This code was later copied to the JavaScript mono - repo and further modified and
+// refactored over the years.
+// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files(the 'Software'), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify,
+// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies
+// or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STACKTRACE_FRAME_LIMIT = 50;
+const UNKNOWN_FUNCTION = '?';
+/** Node Stack line parser */
+function node(getModule) {
+  const FILENAME_MATCH = /^\s*[-]{4,}$/;
+  const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+  return line => {
+    const lineMatch = line.match(FULL_MATCH);
+    if (lineMatch) {
+      let object;
+      let method;
+      let functionName;
+      let typeName;
+      let methodName;
+      if (lineMatch[1]) {
+        functionName = lineMatch[1];
+        let methodStart = functionName.lastIndexOf('.');
+        if (functionName[methodStart - 1] === '.') {
+          methodStart--;
+        }
+        if (methodStart > 0) {
+          object = functionName.slice(0, methodStart);
+          method = functionName.slice(methodStart + 1);
+          const objectEnd = object.indexOf('.Module');
+          if (objectEnd > 0) {
+            functionName = functionName.slice(objectEnd + 1);
+            object = object.slice(0, objectEnd);
+          }
+        }
+        typeName = undefined;
+      }
+      if (method) {
+        typeName = object;
+        methodName = method;
+      }
+      if (method === '<anonymous>') {
+        methodName = undefined;
+        functionName = undefined;
+      }
+      if (functionName === undefined) {
+        methodName = methodName || UNKNOWN_FUNCTION;
+        functionName = typeName ? `${typeName}.${methodName}` : methodName;
+      }
+      let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];
+      const isNative = lineMatch[5] === 'native';
+      // If it's a Windows path, trim the leading slash so that `/C:/foo` becomes `C:/foo`
+      if (filename?.match(/\/[A-Z]:/)) {
+        filename = filename.slice(1);
+      }
+      if (!filename && lineMatch[5] && !isNative) {
+        filename = lineMatch[5];
+      }
+      return {
+        filename: filename ? decodeURI(filename) : undefined,
+        module: getModule ? getModule(filename) : undefined,
+        function: functionName,
+        lineno: _parseIntOrUndefined(lineMatch[3]),
+        colno: _parseIntOrUndefined(lineMatch[4]),
+        in_app: filenameIsInApp(filename || '', isNative),
+        platform: 'node:javascript'
+      };
+    }
+    if (line.match(FILENAME_MATCH)) {
+      return {
+        filename: line,
+        platform: 'node:javascript'
+      };
+    }
+    return undefined;
+  };
+}
+/**
+ * Does this filename look like it's part of the app code?
+ */
+function filenameIsInApp(filename, isNative = false) {
+  const isInternal = isNative || filename &&
+  // It's not internal if it's an absolute linux path
+  !filename.startsWith('/') &&
+  // It's not internal if it's an absolute windows path
+  !filename.match(/^[A-Z]:/) &&
+  // It's not internal if the path is starting with a dot
+  !filename.startsWith('.') &&
+  // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack
+  !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//); // Schema from: https://stackoverflow.com/a/3641782
+  // in_app is all that's not an internal Node function or a module within node_modules
+  // note that isNative appears to return true even for node core libraries
+  // see https://github.com/getsentry/raven-node/issues/176
+  return !isInternal && filename !== undefined && !filename.includes('node_modules/');
+}
+function _parseIntOrUndefined(input) {
+  return parseInt(input || '', 10) || undefined;
+}
+function nodeStackLineParser(getModule) {
+  return [90, node(getModule)];
+}
+const defaultStackParser = createStackParser(nodeStackLineParser(createGetModuleFromFilename()));
+/** Creates a function that gets the module name from a filename */
+function createGetModuleFromFilename(basePath = process.argv[1] ? node_path.dirname(process.argv[1]) : process.cwd(), isWindows = node_path.sep === '\\') {
+  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+  return filename => {
+    if (!filename) {
+      return;
+    }
+    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+    // eslint-disable-next-line prefer-const
+    let {
+      dir,
+      base: file,
+      ext
+    } = node_path.posix.parse(normalizedFilename);
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+      file = file.slice(0, ext.length * -1);
+    }
+    // The file name might be URI-encoded which we want to decode to
+    // the original file name.
+    const decodedFile = decodeURIComponent(file);
+    if (!dir) {
+      // No dirname whatsoever
+      dir = '.';
+    }
+    const n = dir.lastIndexOf('/node_modules');
+    if (n > -1) {
+      return `${dir.slice(n + 14).replace(/\//g, '.')}:${decodedFile}`;
+    }
+    // Let's see if it's a part of the main module
+    // To be a part of main module, it has to share the same base
+    if (dir.startsWith(normalizedBase)) {
+      const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+      return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+    }
+    return decodedFile;
+  };
+}
+/** normalizes Windows paths */
+function normalizeWindowsPath(path) {
+  return path.replace(/^[A-Z]:/, '') // remove Windows-style prefix
+  .replace(/\\/g, '/'); // replace all `\` instances with `/`
+}
+function createStackParser(...parsers) {
+  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
+  return (stack, skipFirstLines = 0) => {
+    const frames = [];
+    const lines = stack.split('\n');
+    for (let i = skipFirstLines; i < lines.length; i++) {
+      const line = lines[i];
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      if (line.length > 1024) {
+        continue;
+      }
+      // https://github.com/getsentry/sentry-javascript/issues/5459
+      // Remove webpack (error: *) wrappers
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+      // https://github.com/getsentry/sentry-javascript/issues/7813
+      // Skip Error: lines
+      if (cleanedLine.match(/\S*Error: /)) {
+        continue;
+      }
+      for (const parser of sortedParsers) {
+        const frame = parser(cleanedLine);
+        if (frame) {
+          frames.push(frame);
+          break;
+        }
+      }
+      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
+        break;
+      }
+    }
+    return reverseAndStripFrames(frames);
+  };
+}
+function reverseAndStripFrames(stack) {
+  if (!stack.length) {
+    return [];
+  }
+  const localStack = Array.from(stack);
+  localStack.reverse();
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({
+    ...frame,
+    filename: frame.filename || getLastStackFrame(localStack).filename,
+    function: frame.function || UNKNOWN_FUNCTION
+  }));
+}
+function getLastStackFrame(arr) {
+  return arr[arr.length - 1] || {};
+}
+
+const SHUTDOWN_TIMEOUT = 2000;
+class ErrorTracking {
+  static async captureException(client, error, distinctId, hint, additionalProperties) {
+    const properties = {
+      ...additionalProperties
+    };
+    if (!distinctId) {
+      properties.$process_person_profile = false;
+    }
+    const exceptionProperties = await propertiesFromUnknownInput(defaultStackParser, error, hint);
+    client.capture({
+      event: '$exception',
+      distinctId: distinctId || uuidv7(),
+      properties: {
+        ...exceptionProperties,
+        ...properties
+      }
+    });
+  }
+  constructor(client, options) {
+    this.client = client;
+    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
+    this.startAutocaptureIfEnabled();
+  }
+  startAutocaptureIfEnabled() {
+    if (this.isEnabled()) {
+      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
+      addUnhandledRejectionListener(this.onException.bind(this));
+    }
+  }
+  onException(exception, hint) {
+    // Given stateless nature of Node SDK we capture exceptions using personless processing
+    // when no user can be determined e.g. in the case of exception autocapture
+    ErrorTracking.captureException(this.client, exception, uuidv7(), hint, {
+      $process_person_profile: false
+    });
+  }
+  async onFatalError() {
+    await this.client.shutdown(SHUTDOWN_TIMEOUT);
+  }
+  isEnabled() {
+    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+  }
+}
+
 const THIRTY_SECONDS = 30 * 1000;
 const MAX_CACHE_SIZE = 50 * 1000;
 // The actual exported Nodejs API.
@@ -2062,6 +2943,7 @@ class PostHog extends PostHogCoreStateless {
         customHeaders: this.getCustomHeaders()
       });
     }
+    this.errorTracking = new ErrorTracking(this, options);
     this.distinctIdHasSentFlagCalls = {};
     this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
   }
@@ -2365,6 +3247,12 @@ class PostHog extends PostHogCoreStateless {
       allGroupProperties
     };
   }
+  captureException(error, distinctId, additionalProperties) {
+    const syntheticException = new Error('PostHog syntheticException');
+    ErrorTracking.captureException(this, error, distinctId, {
+      syntheticException
+    }, additionalProperties);
+  }
 }
 
 /**
@@ -2390,7 +3278,6 @@ class PostHog extends PostHogCoreStateless {
  * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
  * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
  */
-const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];
 const NAME = 'posthog-node';
 function createEventProcessor(_posthog, {
   organization,
@@ -2475,9 +3362,26 @@ class PostHogSentryIntegration {
 }
 PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';
 
+function setupExpressErrorHandler(_posthog, app) {
+  app.use((error, _, __, next) => {
+    const hint = {
+      mechanism: {
+        type: 'middleware',
+        handled: false
+      }
+    };
+    // Given stateless nature of Node SDK we capture exceptions using personless processing
+    // when no user can be determined e.g. in the case of exception autocapture
+    ErrorTracking.captureException(_posthog, error, uuidv7(), hint, {
+      $process_person_profile: false
+    });
+    next(error);
+  });
+}
+
 exports.PostHog = PostHog;
 exports.PostHogSentryIntegration = PostHogSentryIntegration;
 exports.createEventProcessor = createEventProcessor;
 exports.sentryIntegration = sentryIntegration;
-exports.severityLevels = severityLevels;
+exports.setupExpressErrorHandler = setupExpressErrorHandler;
 //# sourceMappingURL=index.cjs.js.map