posthog-node 4.16.0 → 4.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-node",
-  "version": "4.16.0",
+  "version": "4.17.0",
   "description": "PostHog Node.js integration",
   "repository": {
     "type": "git",
@@ -19,8 +19,8 @@
     "email": "hey@posthog.com",
     "url": "https://posthog.com"
   },
-  "main": "lib/index.cjs.js",
-  "module": "lib/index.esm.js",
+  "main": "lib/node/index.cjs.js",
+  "module": "lib/node/index.esm.js",
   "types": "lib/index.d.ts",
   "dependencies": {
     "axios": "^1.8.2"
@@ -35,5 +35,32 @@
     "stats",
     "analysis",
     "funnels"
-  ]
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "edge": {
+        "import": "./lib/edge/index.esm.js",
+        "require": "./lib/edge/index.cjs.js",
+        "default": "./lib/edge/index.js"
+      },
+      "node": {
+        "import": "./lib/node/index.esm.js",
+        "require": "./lib/node/index.cjs.js",
+        "default": "./lib/node/index.js"
+      },
+      "edge-light": {
+        "import": "./lib/edge/index.esm.js",
+        "require": "./lib/edge/index.cjs.js",
+        "default": "./lib/edge/index.js"
+      },
+      "workerd": {
+        "import": "./lib/edge/index.esm.js",
+        "require": "./lib/edge/index.cjs.js",
+        "default": "./lib/edge/index.js"
+      },
+      "import": "./lib/node/index.esm.js",
+      "require": "./lib/node/index.cjs.js"
+    }
+  }
 }

package/src/{posthog-node.ts → client.ts}

@@ -2,43 +2,29 @@ import { version } from '../package.json'
 
 import {
   JsonType,
-  PostHogCoreOptions,
   PostHogCoreStateless,
   PostHogDecideResponse,
   PostHogFetchOptions,
   PostHogFetchResponse,
   PostHogFlagsAndPayloadsResponse,
   PostHogPersistedProperty,
-} from '../../posthog-core/src'
-import { PostHogMemoryStorage } from '../../posthog-core/src/storage-memory'
-import { EventMessage, GroupIdentifyMessage, IdentifyMessage, PostHogNodeV1 } from './types'
-import { FeatureFlagDetail, FeatureFlagValue } from '../../posthog-core/src/types'
-import { FeatureFlagsPoller } from './feature-flags'
+} from 'posthog-core'
+import { EventMessage, GroupIdentifyMessage, IdentifyMessage, PostHogNodeV1, PostHogOptions } from './types'
+import { FeatureFlagDetail, FeatureFlagValue } from 'posthog-core'
+import { FeatureFlagsPoller } from './extensions/feature-flags/feature-flags'
 import fetch from './fetch'
-import ErrorTracking from './error-tracking'
-import { getFeatureFlagValue } from 'posthog-core/src/featureFlagUtils'
-
-export type PostHogOptions = PostHogCoreOptions & {
-  persistence?: 'memory'
-  personalApiKey?: string
-  privacyMode?: boolean
-  enableExceptionAutocapture?: boolean
-  // The interval in milliseconds between polls for refreshing feature flag definitions. Defaults to 30 seconds.
-  featureFlagsPollingInterval?: number
-  // Maximum size of cache that deduplicates $feature_flag_called calls per user.
-  maxCacheSize?: number
-  fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
-}
+import ErrorTracking from './extensions/error-tracking'
+import { getFeatureFlagValue } from 'posthog-core'
+import { PostHogMemoryStorage } from './storage-memory'
 
 // Standard local evaluation rate limit is 600 per minute (10 per second),
 // so the fastest a poller should ever be set is 100ms.
-export const MINIMUM_POLLING_INTERVAL = 100
-export const THIRTY_SECONDS = 30 * 1000
-export const SIXTY_SECONDS = 60 * 1000
+const MINIMUM_POLLING_INTERVAL = 100
+const THIRTY_SECONDS = 30 * 1000
 const MAX_CACHE_SIZE = 50 * 1000
 
 // The actual exported Nodejs API.
-export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
+export abstract class PostHogBackendClient extends PostHogCoreStateless implements PostHogNodeV1 {
   private _memoryStorage = new PostHogMemoryStorage()
 
   private featureFlagsPoller?: FeatureFlagsPoller
@@ -97,10 +83,6 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
   fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
     return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options)
   }
-
-  getLibraryId(): string {
-    return 'posthog-node'
-  }
   getLibraryVersion(): string {
     return version
   }

package/src/entrypoints/index.edge.ts

@@ -0,0 +1,15 @@
+export * from '../exports'
+
+import ErrorTracking from '../extensions/error-tracking'
+
+import { PostHogBackendClient } from '../client'
+import { createStackParser } from '../extensions/error-tracking/stack-parser'
+
+ErrorTracking.stackParser = createStackParser()
+ErrorTracking.frameModifiers = []
+
+export class PostHog extends PostHogBackendClient {
+  getLibraryId(): string {
+    return 'posthog-edge'
+  }
+}

package/src/entrypoints/index.node.ts

@@ -0,0 +1,17 @@
+export * from '../exports'
+
+import { createGetModuleFromFilename } from '../extensions/error-tracking/get-module.node'
+import { addSourceContext } from '../extensions/error-tracking/context-lines.node'
+import ErrorTracking from '../extensions/error-tracking'
+
+import { PostHogBackendClient } from '../client'
+import { createStackParser } from '../extensions/error-tracking/stack-parser'
+
+ErrorTracking.stackParser = createStackParser(createGetModuleFromFilename())
+ErrorTracking.frameModifiers = [addSourceContext]
+
+export class PostHog extends PostHogBackendClient {
+  getLibraryId(): string {
+    return 'posthog-node'
+  }
+}

package/src/exports.ts

@@ -0,0 +1,3 @@
+export * from './extensions/sentry-integration'
+export * from './extensions/express'
+export * from './types'

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

@@ -1,7 +1,7 @@
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
 // Licensed under the MIT License
 
-import { EventHint } from 'posthog-node/src/extensions/error-tracking/types'
+import { EventHint } from './types'
 
 type ErrorHandler = { _posthogErrorHandler: boolean } & ((error: Error) => void)
 

package/src/extensions/error-tracking/{context-lines.ts → context-lines.node.ts}

@@ -3,31 +3,8 @@
 
 import { StackFrame } from './types'
 import { ReduceableCache } from './reduceable-cache'
-import { Lazy } from 'posthog-node/src/lazy'
-
-const nodeFs = new Lazy(async () => {
-  try {
-    return await import('fs')
-  } catch {
-    return undefined
-  }
-})
-
-export async function getNodeFs(): Promise<typeof import('fs') | undefined> {
-  return await nodeFs.getValue()
-}
-
-const nodeReadline = new Lazy(async () => {
-  try {
-    return await import('readline')
-  } catch {
-    return undefined
-  }
-})
-
-export async function getNodeReadline(): Promise<typeof import('readline') | undefined> {
-  return await nodeReadline.getValue()
-}
+import { createReadStream } from 'node:fs'
+import { createInterface } from 'node:readline'
 
 const LRU_FILE_CONTENTS_CACHE = new ReduceableCache<string, Record<number, string>>(25)
 const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache<string, 1>(20)
@@ -118,87 +95,77 @@ export async function addSourceContext(frames: StackFrame[]): Promise<StackFrame
  */
 function getContextLinesFromFile(path: string, ranges: ReadlineRange[], output: Record<number, string>): Promise<void> {
   return new Promise((resolve) => {
-    // KLUDGE: edge runtimes do not support node:fs or node:readline
-    // until we have separate packages for each environment this will skip
-    // trying to access the filesystem when not accessible
-    Promise.all([getNodeFs(), getNodeReadline()]).then(([nodeFs, nodeReadline]) => {
-      if (!nodeFs || !nodeReadline) {
-        resolve()
-        return
-      }
+    // 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 = createReadStream(path)
+    const lineReaded = createInterface({
+      input: stream,
+    })
 
-      // 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 = nodeFs.createReadStream(path)
-      const lineReaded = nodeReadline.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(): void {
-        stream.destroy()
-        resolve()
-      }
+    // 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(): void {
+      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(): void {
+      // 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()
+    }
 
-      // 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()
+    // 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
       }
-      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(): void {
-        // 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)
+      // !Warning: This mutates the cache by storing the snipped line into the cache.
+      output[lineNumber] = snipLine(line, 0)
 
-      lineReaded.on('line', (line) => {
-        lineNumber++
-        if (lineNumber < rangeStart) {
+      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
         }
-
-        // !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]
+        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]
+      }
     })
   })
 }

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

@@ -2,11 +2,19 @@
 // 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'
+import {
+  ErrorProperties,
+  EventHint,
+  Exception,
+  Mechanism,
+  StackFrame,
+  StackFrameModifierFn,
+  StackParser,
+} from './types'
 
 export async function propertiesFromUnknownInput(
   stackParser: StackParser,
+  frameModifiers: StackFrameModifierFn[],
   input: unknown,
   hint?: EventHint
 ): Promise<ErrorProperties> {
@@ -19,7 +27,7 @@ export async function propertiesFromUnknownInput(
   const errorList = getErrorList(mechanism, input, hint)
   const exceptionList = await Promise.all(
     errorList.map(async (error) => {
-      const exception = await exceptionFromError(stackParser, error)
+      const exception = await exceptionFromError(stackParser, frameModifiers, error)
       exception.value = exception.value || ''
       exception.type = exception.type || 'Error'
       exception.mechanism = mechanism
@@ -240,13 +248,22 @@ function serializeEventTarget(target: unknown): string {
 /**
  * Extracts stack frames from the error and builds an Exception
  */
-async function exceptionFromError(stackParser: StackParser, error: Error): Promise<Exception> {
+async function exceptionFromError(
+  stackParser: StackParser,
+  frameModifiers: StackFrameModifierFn[],
+  error: Error
+): Promise<Exception> {
   const exception: Exception = {
     type: error.name || error.constructor.name,
     value: error.message,
   }
 
-  const frames = await addSourceContext(parseStackFrames(stackParser, error))
+  let frames = parseStackFrames(stackParser, error)
+
+  for (const modifier of frameModifiers) {
+    frames = await modifier(frames)
+  }
+
   if (frames.length) {
     exception.stacktrace = { frames, type: 'raw' }
   }

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/{error-tracking.ts → extensions/error-tracking/index.ts}

@@ -1,19 +1,21 @@
-import { EventHint } from './extensions/error-tracking/types'
-import { addUncaughtExceptionListener, addUnhandledRejectionListener } from './extensions/error-tracking/autocapture'
-import { PostHog, PostHogOptions } from './posthog-node'
+import { EventHint, StackFrameModifierFn, StackParser } from './types'
+import { addUncaughtExceptionListener, addUnhandledRejectionListener } from './autocapture'
+import { PostHogBackendClient } from '../../client'
 import { uuidv7 } from 'posthog-core/src/vendor/uuidv7'
-import { propertiesFromUnknownInput } from './extensions/error-tracking/error-conversion'
-import { EventMessage } from './types'
-import { defaultStackParser } from './extensions/error-tracking/stack-trace'
+import { propertiesFromUnknownInput } from './error-conversion'
+import { EventMessage, PostHogOptions } from '../../types'
 
 const SHUTDOWN_TIMEOUT = 2000
 
 export default class ErrorTracking {
-  private client: PostHog
+  private client: PostHogBackendClient
   private _exceptionAutocaptureEnabled: boolean
 
+  static stackParser: StackParser
+  static frameModifiers: StackFrameModifierFn[]
+
   static async captureException(
-    client: PostHog,
+    client: PostHogBackendClient,
     error: unknown,
     hint: EventHint,
     distinctId?: string,
@@ -27,7 +29,7 @@ export default class ErrorTracking {
       properties.$process_person_profile = false
     }
 
-    const exceptionProperties = await propertiesFromUnknownInput(defaultStackParser, error, hint)
+    const exceptionProperties = await propertiesFromUnknownInput(this.stackParser, this.frameModifiers, error, hint)
 
     client.capture({
       event: '$exception',
@@ -39,7 +41,7 @@ export default class ErrorTracking {
     })
   }
 
-  constructor(client: PostHog, options: PostHogOptions) {
+  constructor(client: PostHogBackendClient, options: PostHogOptions) {
     this.client = client
     this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false
 

package/src/extensions/error-tracking/{stack-trace.ts → stack-parser.ts}

@@ -1,10 +1,7 @@
 // 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
+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.
@@ -37,7 +34,7 @@ const STACKTRACE_FRAME_LIMIT = 50
 const UNKNOWN_FUNCTION = '?'
 
 /** Node Stack line parser */
-export function node(getModule?: GetModuleFn): StackLineParserFn {
+function node(getModule?: GetModuleFn): StackLineParserFn {
   const FILENAME_MATCH = /^\s*[-]{4,}$/
   const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/
 
@@ -123,7 +120,7 @@ export function node(getModule?: GetModuleFn): StackLineParserFn {
 /**
  * Does this filename look like it's part of the app code?
  */
-export function filenameIsInApp(filename: string, isNative: boolean = false): boolean {
+function filenameIsInApp(filename: string, isNative: boolean = false): boolean {
   const isInternal =
     isNative ||
     (filename &&
@@ -147,66 +144,12 @@ function _parseIntOrUndefined(input: string | undefined): number | undefined {
   return parseInt(input || '', 10) || undefined
 }
 
-export function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {
+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 {
+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[] => {
@@ -248,7 +191,7 @@ export function createStackParser(...parsers: StackLineParser[]): StackParser {
   }
 }
 
-export function reverseAndStripFrames(stack: ReadonlyArray<StackFrame>): StackFrame[] {
+function reverseAndStripFrames(stack: ReadonlyArray<StackFrame>): StackFrame[] {
   if (!stack.length) {
     return []
   }

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

@@ -42,10 +42,14 @@ export interface Mechanism {
   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

package/src/extensions/express.ts

@@ -1,7 +1,7 @@
 import type * as http from 'node:http'
 import { uuidv7 } from 'posthog-core/src/vendor/uuidv7'
-import ErrorTracking from '../error-tracking'
-import { PostHog } from '../posthog-node'
+import ErrorTracking from './error-tracking'
+import { PostHogBackendClient } from '../client'
 
 type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
 
@@ -22,7 +22,7 @@ interface MiddlewareError extends Error {
 }
 
 export function setupExpressErrorHandler(
-  _posthog: PostHog,
+  _posthog: PostHogBackendClient,
   app: {
     use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown
   }