posthog-node 5.0.0-alpha.1 → 5.1.0

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

@@ -1,262 +0,0 @@
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-
-import { isError, isErrorEvent, isEvent, isPlainObject } from './type-checking'
-import { ErrorProperties, EventHint, Exception, Mechanism, StackFrame, StackParser } from './types'
-import { addSourceContext } from './context-lines'
-
-export async function propertiesFromUnknownInput(
-  stackParser: StackParser,
-  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, 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, error: Error): Promise<Exception> {
-  const exception: 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: StackParser, error: Error): StackFrame[] {
-  return stackParser(error.stack || '', 1)
-}

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

@@ -1,39 +0,0 @@
-// 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-trace.ts

@@ -1,269 +0,0 @@
-// 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'
-import { StackFrame, StackLineParser, StackLineParserFn, StackParser } from './types'
-
-type GetModuleFn = (filename: string | undefined) => string | undefined
-
-// 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 */
-export 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?
- */
-export 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
-}
-
-export function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {
-  return [90, node(getModule)]
-}
-
-export const defaultStackParser: StackParser = createStackParser(nodeStackLineParser(createGetModuleFromFilename()))
-
-/** 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 `/`
-}
-
-export function createStackParser(...parsers: StackLineParser[]): StackParser {
-  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)
-  }
-}
-
-export 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] || {}
-}

package/src/extensions/error-tracking/type-checking.ts

@@ -1,40 +0,0 @@
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-
-import { PolymorphicEvent } from './types'
-
-export function isEvent(candidate: unknown): candidate is PolymorphicEvent {
-  return typeof Event !== 'undefined' && isInstanceOf(candidate, Event)
-}
-
-export function isPlainObject(candidate: unknown): candidate is Record<string, unknown> {
-  return isBuiltin(candidate, 'Object')
-}
-
-export function isError(candidate: unknown): candidate is Error {
-  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)
-  }
-}
-
-export function isInstanceOf(candidate: unknown, base: any): boolean {
-  try {
-    return candidate instanceof base
-  } catch {
-    return false
-  }
-}
-
-export function isErrorEvent(event: unknown): boolean {
-  return isBuiltin(event, 'ErrorEvent')
-}
-
-export function isBuiltin(candidate: unknown, className: string): boolean {
-  return Object.prototype.toString.call(candidate) === `[object ${className}]`
-}

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

@@ -1,65 +0,0 @@
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-
-// levels originally copied from Sentry to work with the sentry integration
-// and to avoid relying on a frequently changing @sentry/types dependency
-// but provided as an array of literal types, so we can constrain the level below
-export const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const
-export declare type SeverityLevel = (typeof severityLevels)[number]
-
-export interface PolymorphicEvent {
-  [key: string]: unknown
-  readonly type: string
-  readonly target?: unknown
-  readonly currentTarget?: unknown
-}
-
-export interface EventHint {
-  mechanism?: Partial<Mechanism>
-  syntheticException?: Error | null
-}
-
-export interface ErrorProperties {
-  $exception_list: Exception[]
-  $exception_level?: SeverityLevel
-  $exception_DOMException_code?: string
-  $exception_personURL?: string
-}
-
-export interface Exception {
-  type?: string
-  value?: string
-  mechanism?: Mechanism
-  module?: string
-  thread_id?: number
-  stacktrace?: { frames?: StackFrame[]; type: 'raw' }
-}
-
-export interface Mechanism {
-  handled?: boolean
-  type?: string
-  source?: string
-  synthetic?: boolean
-}
-
-export type StackParser = (stack: string, skipFirstLines?: number) => StackFrame[]
-export type StackLineParserFn = (line: string) => StackFrame | undefined
-export type StackLineParser = [number, StackLineParserFn]
-
-export interface StackFrame {
-  platform: string
-  filename?: string
-  function?: string
-  module?: string
-  lineno?: number
-  colno?: number
-  abs_path?: string
-  context_line?: string
-  pre_context?: string[]
-  post_context?: string[]
-  in_app?: boolean
-  instruction_addr?: string
-  addr_mode?: string
-  vars?: { [key: string]: any }
-  debug_id?: string
-}