posthog-node 5.8.8 → 5.9.0

package/src/extensions/error-tracking/error-conversion.ts

@@ -0,0 +1,291 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import { getFilenameToChunkIdMap } from './chunk-ids'
+import { isError, isErrorEvent, isEvent, isPlainObject } from './type-checking'
+import {
+  ErrorProperties,
+  EventHint,
+  Exception,
+  Mechanism,
+  StackFrame,
+  StackFrameModifierFn,
+  StackParser,
+} from './types'
+
+export async function propertiesFromUnknownInput(
+  stackParser: StackParser,
+  frameModifiers: StackFrameModifierFn[],
+  input: unknown,
+  hint?: EventHint
+): Promise<ErrorProperties> {
+  const providedMechanism = hint && hint.mechanism
+  const mechanism = providedMechanism || {
+    handled: true,
+    type: 'generic',
+  }
+
+  const errorList = getErrorList(mechanism, input, hint)
+  const exceptionList = await Promise.all(
+    errorList.map(async (error) => {
+      const exception = await exceptionFromError(stackParser, frameModifiers, error)
+      exception.value = exception.value || ''
+      exception.type = exception.type || 'Error'
+      exception.mechanism = mechanism
+      return exception
+    })
+  )
+
+  const properties = { $exception_list: exceptionList }
+  return properties
+}
+
+// Flatten error causes into a list of errors
+// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+function getErrorList(mechanism: Mechanism, input: unknown, hint?: EventHint): Error[] {
+  const error = getError(mechanism, input, hint)
+  if (error.cause) {
+    return [error, ...getErrorList(mechanism, error.cause, hint)]
+  }
+  return [error]
+}
+
+function getError(mechanism: Mechanism, exception: unknown, hint?: EventHint): Error {
+  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 as string)
+  ex.message = `${exception}`
+
+  return ex
+}
+
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop]
+      if (isError(value)) {
+        return value
+      }
+    }
+  }
+
+  return undefined
+}
+
+function getMessageForObject(exception: Record<string, unknown>): string {
+  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: unknown): string | undefined | void {
+  try {
+    const prototype: unknown | null = 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: Record<string, unknown>, maxLength: number = 40): string {
+  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: string, max: number = 0): string {
+  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<V>(value: V):
+  | {
+      [ownProps: string]: unknown
+      type: string
+      target: string
+      currentTarget: string
+      detail?: unknown
+    }
+  | {
+      [ownProps: string]: unknown
+      message: string
+      name: string
+      stack?: string
+    }
+  | V {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value),
+    }
+  } else if (isEvent(value)) {
+    const newObj: {
+      [ownProps: string]: unknown
+      type: string
+      target: string
+      currentTarget: string
+      detail?: unknown
+    } = {
+      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: unknown): { [key: string]: unknown } {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps: { [key: string]: unknown } = {}
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = (obj as Record<string, unknown>)[property]
+      }
+    }
+    return extractedProps
+  } else {
+    return {}
+  }
+}
+
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target: unknown): string {
+  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: StackParser,
+  frameModifiers: StackFrameModifierFn[],
+  error: Error
+): Promise<Exception> {
+  const exception: Exception = {
+    type: error.name || error.constructor.name,
+    value: error.message,
+  }
+
+  let frames = parseStackFrames(stackParser, error)
+
+  for (const modifier of frameModifiers) {
+    frames = await modifier(frames)
+  }
+
+  if (frames.length) {
+    exception.stacktrace = { frames, type: 'raw' }
+  }
+
+  return exception
+}
+
+/**
+ * Extracts stack frames from the error.stack string
+ */
+function parseStackFrames(stackParser: StackParser, error: Error): StackFrame[] {
+  return applyChunkIds(stackParser(error.stack || '', 1), stackParser)
+}
+
+export function applyChunkIds(frames: StackFrame[], parser: StackParser): StackFrame[] {
+  const filenameChunkIdMap = getFilenameToChunkIdMap(parser)
+  frames.forEach((frame) => {
+    if (frame.filename && filenameChunkIdMap) {
+      frame.chunk_id = filenameChunkIdMap[frame.filename]
+    }
+  })
+
+  return frames
+}

package/src/extensions/error-tracking/get-module.node.ts

@@ -0,0 +1,57 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import { posix, sep, dirname } from 'path'
+
+/** Creates a function that gets the module name from a filename */
+export function createGetModuleFromFilename(
+  basePath: string = process.argv[1] ? dirname(process.argv[1]) : process.cwd(),
+  isWindows: boolean = sep === '\\'
+): (filename: string | undefined) => string | undefined {
+  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath
+
+  return (filename: string | undefined) => {
+    if (!filename) {
+      return
+    }
+
+    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename
+
+    // eslint-disable-next-line prefer-const
+    let { dir, base: file, ext } = 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: string): string {
+  return path
+    .replace(/^[A-Z]:/, '') // remove Windows-style prefix
+    .replace(/\\/g, '/') // replace all `\` instances with `/`
+}

package/src/extensions/error-tracking/index.ts

@@ -0,0 +1,103 @@
+import { EventHint, StackFrameModifierFn, StackParser } from './types'
+import { addUncaughtExceptionListener, addUnhandledRejectionListener } from './autocapture'
+import { PostHogBackendClient } from '../../client'
+import { uuidv7 } from '@posthog/core'
+import { propertiesFromUnknownInput } from './error-conversion'
+import { EventMessage, PostHogOptions } from '../../types'
+import type { Logger } from '@posthog/core'
+import { BucketedRateLimiter } from '@posthog/core'
+
+const SHUTDOWN_TIMEOUT = 2000
+
+export default class ErrorTracking {
+  private client: PostHogBackendClient
+  private _exceptionAutocaptureEnabled: boolean
+  private _rateLimiter: BucketedRateLimiter<string>
+  private _logger: Logger
+
+  static stackParser: StackParser
+  static frameModifiers: StackFrameModifierFn[]
+
+  constructor(client: PostHogBackendClient, options: PostHogOptions, _logger: Logger) {
+    this.client = client
+    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false
+    this._logger = _logger
+
+    // by default captures ten exceptions before rate limiting by exception type
+    // refills at a rate of one token / 10 second period
+    // e.g. will capture 1 exception rate limited exception every 10 seconds until burst ends
+    this._rateLimiter = new BucketedRateLimiter({
+      refillRate: 1,
+      bucketSize: 10,
+      refillInterval: 10000, // ten seconds in milliseconds
+      _logger: this._logger,
+    })
+
+    this.startAutocaptureIfEnabled()
+  }
+
+  static async buildEventMessage(
+    error: unknown,
+    hint: EventHint,
+    distinctId?: string,
+    additionalProperties?: Record<string | number, any>
+  ): Promise<EventMessage> {
+    const properties: EventMessage['properties'] = { ...additionalProperties }
+
+    // Given stateless nature of Node SDK we capture exceptions using personless processing when no
+    // user can be determined because a distinct_id is not provided e.g. exception autocapture
+    if (!distinctId) {
+      properties.$process_person_profile = false
+    }
+
+    const exceptionProperties = await propertiesFromUnknownInput(this.stackParser, this.frameModifiers, error, hint)
+
+    return {
+      event: '$exception',
+      distinctId: distinctId || uuidv7(),
+      properties: {
+        ...exceptionProperties,
+        ...properties,
+      },
+    }
+  }
+
+  private startAutocaptureIfEnabled(): void {
+    if (this.isEnabled()) {
+      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this))
+      addUnhandledRejectionListener(this.onException.bind(this))
+    }
+  }
+
+  private async onException(exception: unknown, hint: EventHint): Promise<void> {
+    this.client.addPendingPromise(
+      (async () => {
+        const eventMessage = await ErrorTracking.buildEventMessage(exception, hint)
+        const exceptionProperties = eventMessage.properties
+        const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? 'Exception'
+        const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType)
+        if (isRateLimited) {
+          this._logger.info('Skipping exception capture because of client rate limiting.', {
+            exception: exceptionType,
+          })
+          return
+        }
+        return this.client.capture(eventMessage)
+      })()
+    )
+  }
+
+  private async onFatalError(exception: Error): Promise<void> {
+    console.error(exception)
+    await this.client.shutdown(SHUTDOWN_TIMEOUT)
+    process.exit(1)
+  }
+
+  isEnabled(): boolean {
+    return !this.client.isDisabled && this._exceptionAutocaptureEnabled
+  }
+
+  shutdown(): void {
+    this._rateLimiter.stop()
+  }
+}

package/src/extensions/error-tracking/reduceable-cache.ts

@@ -0,0 +1,39 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+/** A simple Least Recently Used map */
+export class ReduceableCache<K, V> {
+  private readonly _cache: Map<K, V>
+
+  public constructor(private readonly _maxSize: number) {
+    this._cache = new Map<K, V>()
+  }
+
+  /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */
+  public get(key: K): V | undefined {
+    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 */
+  public set(key: K, value: V): void {
+    this._cache.set(key, value)
+  }
+
+  /** Remove an entry and return the entry if it was in the cache */
+  public reduce(): void {
+    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)
+      }
+    }
+  }
+}

package/src/extensions/error-tracking/stack-parser.ts

@@ -0,0 +1,212 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import { GetModuleFn, StackFrame, StackLineParser, StackLineParserFn, StackParser } from './types'
+
+// 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?: GetModuleFn): StackLineParserFn {
+  const FILENAME_MATCH = /^\s*[-]{4,}$/
+  const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/
+
+  return (line: string) => {
+    const lineMatch = line.match(FULL_MATCH)
+
+    if (lineMatch) {
+      let object: string | undefined
+      let method: string | undefined
+      let functionName: string | undefined
+      let typeName: string | undefined
+      let methodName: string | undefined
+
+      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: string, isNative: boolean = false): boolean {
+  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: string | undefined): number | undefined {
+  return parseInt(input || '', 10) || undefined
+}
+
+function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {
+  return [90, node(getModule)]
+}
+
+export function createStackParser(getModule?: GetModuleFn): StackParser {
+  const parsers = [nodeStackLineParser(getModule)]
+  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map((p) => p[1])
+
+  return (stack: string, skipFirstLines: number = 0): StackFrame[] => {
+    const frames: StackFrame[] = []
+    const lines = stack.split('\n')
+
+    for (let i = skipFirstLines; i < lines.length; i++) {
+      const line = lines[i] as string
+      // 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: ReadonlyArray<StackFrame>): StackFrame[] {
+  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: StackFrame[]): StackFrame {
+  return arr[arr.length - 1] || {}
+}