posthog-node 5.8.8 → 5.9.0

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

@@ -0,0 +1,40 @@
+// 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

@@ -0,0 +1,71 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import { JsonType } from '@posthog/core'
+
+// 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 GetModuleFn = (filename: string | undefined) => string | undefined
+
+export type StackParser = (stack: string, skipFirstLines?: number) => StackFrame[]
+export type StackLineParserFn = (line: string) => StackFrame | undefined
+export type StackLineParser = [number, StackLineParserFn]
+
+export type StackFrameModifierFn = (frames: StackFrame[]) => Promise<StackFrame[]>
+
+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]: JsonType }
+  chunk_id?: string
+}

package/src/extensions/express.ts

@@ -0,0 +1,39 @@
+import type * as http from 'node:http'
+import { uuidv7 } from '@posthog/core'
+import ErrorTracking from './error-tracking'
+import { PostHogBackendClient } from '../client'
+
+type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
+
+type ExpressErrorMiddleware = (
+  error: MiddlewareError,
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  next: (error: MiddlewareError) => void
+) => void
+
+interface MiddlewareError extends Error {
+  status?: number | string
+  statusCode?: number | string
+  status_code?: number | string
+  output?: {
+    statusCode?: number | string
+  }
+}
+
+export function setupExpressErrorHandler(
+  _posthog: PostHogBackendClient,
+  app: {
+    use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown
+  }
+): void {
+  app.use((error: MiddlewareError, _, __, next: (error: MiddlewareError) => void): void => {
+    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.buildEventMessage(error, hint, uuidv7(), { $process_person_profile: false }).then((msg) =>
+      _posthog.capture(msg)
+    )
+    next(error)
+  })
+}

package/src/extensions/feature-flags/crypto-helpers.ts

@@ -0,0 +1,36 @@
+/// <reference lib="dom" />
+import { Lazy } from './lazy'
+
+const nodeCrypto = new Lazy(async () => {
+  try {
+    return await import('crypto')
+  } catch {
+    return undefined
+  }
+})
+
+export async function getNodeCrypto(): Promise<typeof import('crypto') | undefined> {
+  return await nodeCrypto.getValue()
+}
+
+const webCrypto = new Lazy(async (): Promise<SubtleCrypto | undefined> => {
+  if (typeof globalThis.crypto?.subtle !== 'undefined') {
+    return globalThis.crypto.subtle
+  }
+
+  try {
+    // Node.js: use built-in webcrypto and assign it if needed
+    const crypto = await nodeCrypto.getValue()
+    if (crypto?.webcrypto?.subtle) {
+      return crypto.webcrypto.subtle as SubtleCrypto
+    }
+  } catch {
+    // Ignore if not available
+  }
+
+  return undefined
+})
+
+export async function getWebCrypto(): Promise<SubtleCrypto | undefined> {
+  return await webCrypto.getValue()
+}

package/src/extensions/feature-flags/crypto.ts

@@ -0,0 +1,22 @@
+/// <reference lib="dom" />
+
+import { getNodeCrypto, getWebCrypto } from './crypto-helpers'
+
+export async function hashSHA1(text: string): Promise<string> {
+  // Try Node.js crypto first
+  const nodeCrypto = await getNodeCrypto()
+  if (nodeCrypto) {
+    return nodeCrypto.createHash('sha1').update(text).digest('hex')
+  }
+
+  const webCrypto = await getWebCrypto()
+
+  // Fall back to Web Crypto API
+  if (webCrypto) {
+    const hashBuffer = await webCrypto.digest('SHA-1', new TextEncoder().encode(text))
+    const hashArray = Array.from(new Uint8Array(hashBuffer))
+    return hashArray.map((byte) => byte.toString(16).padStart(2, '0')).join('')
+  }
+
+  throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API')
+}