@posthog/core 1.2.2 → 1.2.4

package/src/logger.ts

@@ -0,0 +1,58 @@
+import { Logger } from './types'
+
+// We want to make sure to get the original console methods as soon as possible
+type ConsoleLike = {
+  log: (...args: any[]) => void
+  warn: (...args: any[]) => void
+  error: (...args: any[]) => void
+  debug: (...args: any[]) => void
+}
+
+function createConsole(consoleLike: ConsoleLike = console): ConsoleLike {
+  const lockedMethods = {
+    log: consoleLike.log.bind(consoleLike),
+    warn: consoleLike.warn.bind(consoleLike),
+    error: consoleLike.error.bind(consoleLike),
+    debug: consoleLike.debug.bind(consoleLike),
+  }
+  return lockedMethods
+}
+
+export const _createLogger = (
+  prefix: string,
+  maybeCall: (fn: () => void) => void,
+  consoleLike: ConsoleLike
+): Logger => {
+  function _log(level: 'log' | 'warn' | 'error', ...args: any[]) {
+    maybeCall(() => {
+      const consoleMethod = consoleLike[level]
+      consoleMethod(prefix, ...args)
+    })
+  }
+
+  const logger: Logger = {
+    info: (...args: any[]) => {
+      _log('log', ...args)
+    },
+
+    warn: (...args: any[]) => {
+      _log('warn', ...args)
+    },
+
+    error: (...args: any[]) => {
+      _log('error', ...args)
+    },
+
+    critical: (...args: any[]) => {
+      // Critical errors are always logged to the console
+      consoleLike['error'](prefix, ...args)
+    },
+
+    createLogger: (additionalPrefix: string) => _createLogger(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike),
+  }
+  return logger
+}
+
+export function createLogger(prefix: string, maybeCall: (fn: () => void) => void) {
+  return _createLogger(prefix, maybeCall, createConsole())
+}

package/src/posthog-core-stateless.ts

@@ -1,6 +1,7 @@
 import { SimpleEventEmitter } from './eventemitter'
 import { getFeatureFlagValue, normalizeFlagsResponse } from './featureFlagUtils'
 import { gzipCompress, isGzipSupported } from './gzip'
+import { createLogger } from './logger'
 import {
   PostHogFlagsResponse,
   PostHogCoreOptions,
@@ -18,6 +19,7 @@ import {
   PostHogFetchOptions,
   PostHogPersistedProperty,
   PostHogQueueItem,
+  Logger,
 } from './types'
 import {
   allSettled,
@@ -127,6 +129,7 @@ export abstract class PostHogCoreStateless {
   protected _initPromise: Promise<void>
   protected _isInitialized: boolean = false
   protected _remoteConfigResponsePromise?: Promise<PostHogRemoteConfig | undefined>
+  protected _logger: Logger
 
   // Abstract methods to be overridden by implementations
   abstract fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>
@@ -138,34 +141,35 @@ export abstract class PostHogCoreStateless {
   abstract getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined
   abstract setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void
 
-  constructor(apiKey: string, options?: PostHogCoreOptions) {
+  constructor(apiKey: string, options: PostHogCoreOptions = {}) {
     assert(apiKey, "You must pass your PostHog project's api key.")
 
     this.apiKey = apiKey
-    this.host = removeTrailingSlash(options?.host || 'https://us.i.posthog.com')
-    this.flushAt = options?.flushAt ? Math.max(options?.flushAt, 1) : 20
-    this.maxBatchSize = Math.max(this.flushAt, options?.maxBatchSize ?? 100)
-    this.maxQueueSize = Math.max(this.flushAt, options?.maxQueueSize ?? 1000)
-    this.flushInterval = options?.flushInterval ?? 10000
-    this.preloadFeatureFlags = options?.preloadFeatureFlags ?? true
+    this.host = removeTrailingSlash(options.host || 'https://us.i.posthog.com')
+    this.flushAt = options.flushAt ? Math.max(options.flushAt, 1) : 20
+    this.maxBatchSize = Math.max(this.flushAt, options.maxBatchSize ?? 100)
+    this.maxQueueSize = Math.max(this.flushAt, options.maxQueueSize ?? 1000)
+    this.flushInterval = options.flushInterval ?? 10000
+    this.preloadFeatureFlags = options.preloadFeatureFlags ?? true
     // If enable is explicitly set to false we override the optout
-    this.defaultOptIn = options?.defaultOptIn ?? true
-    this.disableSurveys = options?.disableSurveys ?? false
+    this.defaultOptIn = options.defaultOptIn ?? true
+    this.disableSurveys = options.disableSurveys ?? false
 
     this._retryOptions = {
-      retryCount: options?.fetchRetryCount ?? 3,
-      retryDelay: options?.fetchRetryDelay ?? 3000, // 3 seconds
+      retryCount: options.fetchRetryCount ?? 3,
+      retryDelay: options.fetchRetryDelay ?? 3000, // 3 seconds
       retryCheck: isPostHogFetchError,
     }
-    this.requestTimeout = options?.requestTimeout ?? 10000 // 10 seconds
-    this.featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 3000 // 3 seconds
-    this.remoteConfigRequestTimeoutMs = options?.remoteConfigRequestTimeoutMs ?? 3000 // 3 seconds
-    this.disableGeoip = options?.disableGeoip ?? true
-    this.disabled = options?.disabled ?? false
+    this.requestTimeout = options.requestTimeout ?? 10000 // 10 seconds
+    this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3000 // 3 seconds
+    this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3000 // 3 seconds
+    this.disableGeoip = options.disableGeoip ?? true
+    this.disabled = options.disabled ?? false
     this.historicalMigration = options?.historicalMigration ?? false
     // Init promise allows the derived class to block calls until it is ready
     this._initPromise = Promise.resolve()
     this._isInitialized = true
+    this._logger = createLogger('[PostHog]', this.logMsgIfDebug.bind(this))
     this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false)
   }
 
@@ -177,7 +181,7 @@ export abstract class PostHogCoreStateless {
 
   protected wrap(fn: () => void): void {
     if (this.disabled) {
-      this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'))
+      this._logger.warn('The client is disabled')
       return
     }
 
@@ -245,7 +249,7 @@ export abstract class PostHogCoreStateless {
     this.removeDebugCallback?.()
 
     if (enabled) {
-      const removeDebugCallback = this.on('*', (event, payload) => console.log('PostHog Debug', event, payload))
+      const removeDebugCallback = this.on('*', (event, payload) => this._logger.info(event, payload))
       this.removeDebugCallback = () => {
         removeDebugCallback()
         this.removeDebugCallback = undefined
@@ -429,7 +433,7 @@ export abstract class PostHogCoreStateless {
     return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.remoteConfigRequestTimeoutMs)
       .then((response) => response.json() as Promise<PostHogRemoteConfig>)
       .catch((error) => {
-        this.logMsgIfDebug(() => console.error('Remote config could not be loaded', error))
+        this._logger.error('Remote config could not be loaded', error)
         this._events.emit('error', error)
         return undefined
       })
@@ -462,7 +466,7 @@ export abstract class PostHogCoreStateless {
       }),
     }
 
-    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Flags URL', url))
+    this._logger.info('Flags URL', url)
 
     // Don't retry /flags API calls
     return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
@@ -731,7 +735,7 @@ export abstract class PostHogCoreStateless {
     await this._initPromise
 
     if (this.disableSurveys === true) {
-      this.logMsgIfDebug(() => console.log('PostHog Debug', 'Loading surveys is disabled.'))
+      this._logger.info('Loading surveys is disabled.')
       return []
     }
 
@@ -746,7 +750,7 @@ export abstract class PostHogCoreStateless {
         if (response.status !== 200 || !response.json) {
           const msg = `Surveys API could not be loaded: ${response.status}`
           const error = new Error(msg)
-          this.logMsgIfDebug(() => console.error(error))
+          this._logger.error(error)
 
           this._events.emit('error', new Error(msg))
           return undefined
@@ -755,7 +759,7 @@ export abstract class PostHogCoreStateless {
         return response.json() as Promise<SurveyResponse>
       })
       .catch((error) => {
-        this.logMsgIfDebug(() => console.error('Surveys API could not be loaded', error))
+        this._logger.error('Surveys API could not be loaded', error)
 
         this._events.emit('error', error)
         return undefined
@@ -764,7 +768,7 @@ export abstract class PostHogCoreStateless {
     const newSurveys = response?.surveys
 
     if (newSurveys) {
-      this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from API: ', JSON.stringify(newSurveys)))
+      this._logger.info('Surveys fetched from API: ', JSON.stringify(newSurveys))
     }
 
     return newSurveys ?? []
@@ -819,7 +823,7 @@ export abstract class PostHogCoreStateless {
 
       if (queue.length >= this.maxQueueSize) {
         queue.shift()
-        this.logMsgIfDebug(() => console.info('Queue is full, the oldest event is dropped.'))
+        this._logger.info('Queue is full, the oldest event is dropped.')
       }
 
       queue.push({ message })
@@ -840,7 +844,7 @@ export abstract class PostHogCoreStateless {
 
   protected async sendImmediate(type: string, _message: any, options?: PostHogCaptureOptions): Promise<void> {
     if (this.disabled) {
-      this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'))
+      this._logger.warn('The client is disabled')
       return
     }
 
@@ -1057,10 +1061,8 @@ export abstract class PostHogCoreStateless {
         if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
           // if we get a 413 error, we want to reduce the batch size and try again
           this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2))
-          this.logMsgIfDebug(() =>
-            console.warn(
-              `Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`
-            )
+          this._logger.warn(
+            `Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`
           )
           // do not persist the queue change, we want to retry the same batch
           continue
@@ -1177,7 +1179,7 @@ export abstract class PostHogCoreStateless {
     return Promise.race([
       new Promise<void>((_, reject) => {
         safeSetTimeout(() => {
-          this.logMsgIfDebug(() => console.error('Timed out while shutting down PostHog'))
+          this._logger.error('Timed out while shutting down PostHog')
           hasTimedOut = true
           reject('Timeout while shutting down PostHog. Some events may not have been sent.')
         }, shutdownTimeoutMs)
@@ -1211,10 +1213,8 @@ export abstract class PostHogCoreStateless {
    */
   async shutdown(shutdownTimeoutMs: number = 30000): Promise<void> {
     if (this.shutdownPromise) {
-      this.logMsgIfDebug(() =>
-        console.warn(
-          'shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup'
-        )
+      this._logger.warn(
+        'shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup'
       )
     } else {
       this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {

package/src/posthog-core.ts

@@ -462,13 +462,11 @@ export abstract class PostHogCore extends PostHogCoreStateless {
     const sessionReplay = response?.sessionRecording
     if (sessionReplay) {
       this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay)
-      this.logMsgIfDebug(() =>
-        console.log('PostHog Debug', `Session replay config from ${source}: `, JSON.stringify(sessionReplay))
-      )
+      this._logger.info(`Session replay config from ${source}: `, JSON.stringify(sessionReplay))
     } else if (typeof sessionReplay === 'boolean' && sessionReplay === false) {
       // if session replay is disabled, we don't need to cache it
       // we need to check for this because the response might be undefined (/flags does not return sessionRecording yet)
-      this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay config from ${source} disabled.`))
+      this._logger.info(`Session replay config from ${source} disabled.`)
       this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null)
     }
   }
@@ -480,16 +478,14 @@ export abstract class PostHogCore extends PostHogCoreStateless {
           PostHogPersistedProperty.RemoteConfig
         )
 
-        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached remote config: ', JSON.stringify(remoteConfig)))
+        this._logger.info('Cached remote config: ', JSON.stringify(remoteConfig))
 
         return super.getRemoteConfig().then((response) => {
           if (response) {
             const remoteConfigWithoutSurveys = { ...response }
             delete remoteConfigWithoutSurveys.surveys
 
-            this.logMsgIfDebug(() =>
-              console.log('PostHog Debug', 'Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys))
-            )
+            this._logger.info('Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys))
 
             if (this.disableSurveys === false) {
               const surveys = response.surveys
@@ -498,12 +494,10 @@ export abstract class PostHogCore extends PostHogCoreStateless {
 
               if (!Array.isArray(surveys)) {
                 // If surveys is not an array, it means there are no surveys (its a boolean instead)
-                this.logMsgIfDebug(() => console.log('PostHog Debug', 'There are no surveys.'))
+                this._logger.info('There are no surveys.')
                 hasSurveys = false
               } else {
-                this.logMsgIfDebug(() =>
-                  console.log('PostHog Debug', 'Surveys fetched from remote config: ', JSON.stringify(surveys))
-                )
+                this._logger.info('Surveys fetched from remote config: ', JSON.stringify(surveys))
               }
 
               if (hasSurveys) {
@@ -530,7 +524,7 @@ export abstract class PostHogCore extends PostHogCoreStateless {
               // resetting flags to empty object
               this.setKnownFeatureFlagDetails({ flags: {} })
 
-              this.logMsgIfDebug(() => console.warn('Remote config has no feature flags, will not load feature flags.'))
+              this._logger.warn('Remote config has no feature flags, will not load feature flags.')
             } else if (this.preloadFeatureFlags !== false) {
               this.reloadFeatureFlags()
             }
@@ -592,9 +586,7 @@ export abstract class PostHogCore extends PostHogCoreStateless {
           if (res.errorsWhileComputingFlags) {
             // if not all flags were computed, we upsert flags instead of replacing them
             const currentFlagDetails = this.getKnownFeatureFlagDetails()
-            this.logMsgIfDebug(() =>
-              console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlagDetails))
-            )
+            this._logger.info('Cached feature flags: ', JSON.stringify(currentFlagDetails))
 
             newFeatureFlagDetails = {
               ...res,
@@ -823,7 +815,7 @@ export abstract class PostHogCore extends PostHogCoreStateless {
       .catch((e) => {
         options?.cb?.(e, undefined)
         if (!options?.cb) {
-          this.logMsgIfDebug(() => console.log('PostHog Debug', 'Error reloading feature flags', e))
+          this._logger.info('Error reloading feature flags', e)
         }
       })
   }

package/src/process/index.ts

@@ -0,0 +1 @@
+export * from './spawn-local'

package/src/process/spawn-local.ts

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process'
+import { resolveBinaryPath } from './utils'
+
+export async function spawnLocal(
+  binaryName: string,
+  args: string[],
+  options: {
+    env: NodeJS.ProcessEnv
+    stdio: 'inherit' | 'ignore'
+    // We start traversing the file system tree from this directory and we go up until we find the binary
+    resolveFrom: string
+    cwd: string
+    onBinaryFound: (binaryLocation: string) => void
+  }
+): Promise<void> {
+  let binaryLocation
+  try {
+    binaryLocation = resolveBinaryPath(options.env.PATH ?? '', options.resolveFrom, binaryName)
+    options.onBinaryFound(binaryLocation)
+  } catch (e) {
+    console.error(e)
+    throw new Error(
+      `Binary ${binaryName} not found. Make sure postinstall script was allowed if it installs the binary`
+    )
+  }
+
+  const child = spawn(binaryLocation, [...args], {
+    shell: true,
+    stdio: options?.stdio ?? 'inherit',
+    env: options.env,
+    cwd: options.cwd,
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(`Command failed with code ${code}`))
+      }
+    })
+
+    child.on('error', (error) => {
+      reject(error)
+    })
+  })
+}

package/src/process/utils.spec.ts

@@ -0,0 +1,11 @@
+import { buildLocalBinaryPaths } from './utils'
+
+describe('buildLocalBinaryPaths', () => {
+  it('generates possible binary locations', () => {
+    const cwd = '/home/user'
+    const result = buildLocalBinaryPaths(cwd)
+    expect(result.includes('/home/user/node_modules/.bin')).toBe(true)
+    expect(result.includes('/home/node_modules/.bin')).toBe(true)
+    expect(result.includes('/node_modules/.bin')).toBe(true)
+  })
+})

package/src/process/utils.ts

@@ -0,0 +1,41 @@
+import path from 'node:path'
+import fs from 'node:fs'
+
+const getLocalPaths = (startPath: string): string[] => {
+  const paths: string[] = []
+  let currentPath = startPath
+
+  while (true) {
+    paths.push(currentPath)
+    const parentPath = path.resolve(currentPath, '..')
+
+    // If we've reached the root directory, stop
+    if (parentPath === currentPath) {
+      break
+    }
+
+    currentPath = parentPath
+  }
+
+  return paths
+}
+
+export const buildLocalBinaryPaths = (cwd: string): string[] => {
+  const localPaths = getLocalPaths(path.resolve(cwd)).map((localPath: string) =>
+    path.join(localPath, 'node_modules/.bin')
+  )
+  return localPaths
+}
+
+export function resolveBinaryPath(envPath: string, cwd: string, binName: string): string {
+  const envLocations = envPath.split(path.delimiter)
+  const localLocations = buildLocalBinaryPaths(cwd)
+  const directories = [...new Set([...localLocations, ...envLocations])]
+  for (const directory of directories) {
+    const binaryPath = path.join(directory, binName)
+    if (fs.existsSync(binaryPath)) {
+      return binaryPath
+    }
+  }
+  throw new Error(`Binary ${binName} not found`)
+}

package/src/testing/test-utils.ts

@@ -36,12 +36,10 @@ export const delay = (ms: number): Promise<void> => {
 
 export const createMockLogger = (): Logger => {
   return {
-    _log: jest.fn(),
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    critical: jest.fn(),
-    uninitializedWarning: jest.fn(),
+    info: jest.fn((...args) => console.log(...args)),
+    warn: jest.fn((...args) => console.warn(...args)),
+    error: jest.fn((...args) => console.error(...args)),
+    critical: jest.fn((...args) => console.error(...args)),
     createLogger: createMockLogger,
   }
 }

package/src/types.ts

@@ -509,12 +509,10 @@ export type ActionStepType = {
 }
 
 export type Logger = {
-  _log: (level: 'log' | 'warn' | 'error', ...args: any[]) => void
   info: (...args: any[]) => void
   warn: (...args: any[]) => void
   error: (...args: any[]) => void
   critical: (...args: any[]) => void
-  uninitializedWarning: (methodName: string) => void
   createLogger: (prefix: string) => Logger
 }