posthog-node 5.8.0 → 5.8.1

package/dist/node/index.cjs

@@ -318,7 +318,7 @@ function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
     });
     if (!calledFatalError && processWouldExit) {
       calledFatalError = true;
-      onFatalFn();
+      onFatalFn(error);
     }
   }, {
     _posthogErrorHandler: true
@@ -329,7 +329,7 @@ function addUncaughtExceptionListener(captureFn, onFatalFn) {
 }
 function addUnhandledRejectionListener(captureFn) {
   global.process.on('unhandledRejection', reason => {
-    captureFn(reason, {
+    return captureFn(reason, {
       mechanism: {
         type: 'onunhandledrejection',
         handled: false
@@ -346,8 +346,7 @@ let cachedFilenameChunkIds;
 function getFilenameToChunkIdMap(stackParser) {
   const chunkIdMap = globalThis._posthogChunkIds;
   if (!chunkIdMap) {
-    console.error('No chunk id map found');
-    return {};
+    return null;
   }
   const chunkIdKeys = Object.keys(chunkIdMap);
   if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) {
@@ -618,7 +617,7 @@ function parseStackFrames(stackParser, error) {
 function applyChunkIds(frames, parser) {
   const filenameChunkIdMap = getFilenameToChunkIdMap(parser);
   frames.forEach(frame => {
-    if (frame.filename) {
+    if (frame.filename && filenameChunkIdMap) {
       frame.chunk_id = filenameChunkIdMap[frame.filename];
     }
   });
@@ -647,6 +646,12 @@ function clampToRange(value, min, max, logger, fallbackValue) {
 }
 
 class BucketedRateLimiter {
+    stop() {
+        if (this._removeInterval) {
+            clearInterval(this._removeInterval);
+            this._removeInterval = void 0;
+        }
+    }
     constructor(_options){
         this._options = _options;
         this._buckets = {};
@@ -678,7 +683,7 @@ class BucketedRateLimiter {
         this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
         this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
         this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
-        setInterval(()=>{
+        this._removeInterval = setInterval(()=>{
             this._refillBuckets();
         }, this._refillInterval);
     }
@@ -692,6 +697,22 @@ function safeSetTimeout(fn, timeout) {
 
 const SHUTDOWN_TIMEOUT = 2000;
 class ErrorTracking {
+  constructor(client, options, _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, hint, distinctId, additionalProperties) {
     const properties = {
       ...additionalProperties
@@ -711,31 +732,16 @@ class ErrorTracking {
       }
     };
   }
-  constructor(client, options, _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();
-  }
   startAutocaptureIfEnabled() {
     if (this.isEnabled()) {
       addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
       addUnhandledRejectionListener(this.onException.bind(this));
     }
   }
-  onException(exception, hint) {
-    return ErrorTracking.buildEventMessage(exception, hint).then(msg => {
-      const exceptionProperties = msg.properties;
+  async onException(exception, hint) {
+    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) {
@@ -744,15 +750,20 @@ class ErrorTracking {
         });
         return;
       }
-      this.client.capture(msg);
-    });
+      return this.client.capture(eventMessage);
+    })());
   }
-  async onFatalError() {
+  async onFatalError(exception) {
+    console.error(exception);
     await this.client.shutdown(SHUTDOWN_TIMEOUT);
+    process.exit(1);
   }
   isEnabled() {
     return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
   }
+  shutdown() {
+    this._rateLimiter.stop();
+  }
 }
 
 function setupExpressErrorHandler(_posthog, app) {
@@ -1175,7 +1186,7 @@ function snipLine(line, colno) {
   return newLine;
 }
 
-var version = "5.8.0";
+var version = "5.8.1";
 
 /**
  * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
@@ -2140,146 +2151,43 @@ class PostHogBackendClient extends core.PostHogCoreStateless {
     if (typeof props === 'string') {
       this.logMsgIfDebug(() => console.warn('Called capture() with a string as the first argument when an object was expected.'));
     }
-    const {
-      distinctId,
-      event,
-      properties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    } = props;
-    // Run before_send if configured
-    const eventMessage = this._runBeforeSend({
+    this.addPendingPromise(this.prepareEventMessage(props).then(({
       distinctId,
       event,
       properties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    });
-    if (!eventMessage) {
-      return;
-    }
-    const _capture = props => {
-      super.captureStateless(eventMessage.distinctId, eventMessage.event, props, {
-        timestamp: eventMessage.timestamp,
-        disableGeoip: eventMessage.disableGeoip,
-        uuid: eventMessage.uuid
+      options
+    }) => {
+      return super.captureStateless(distinctId, event, properties, {
+        timestamp: options.timestamp,
+        disableGeoip: options.disableGeoip,
+        uuid: options.uuid
       });
-    };
-    // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
-    const capturePromise = Promise.resolve().then(async () => {
-      if (sendFeatureFlags) {
-        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
-        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
-        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
-      }
-      if (event === '$feature_flag_called') {
-        // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
-        return {};
-      }
-      return {};
-    }).then(flags => {
-      // Derive the relevant flag properties to add
-      const additionalProperties = {};
-      if (flags) {
-        for (const [feature, variant] of Object.entries(flags)) {
-          additionalProperties[`$feature/${feature}`] = variant;
-        }
+    }).catch(err => {
+      if (err) {
+        console.error(err);
       }
-      const activeFlags = Object.keys(flags || {}).filter(flag => flags?.[flag] !== false).sort();
-      if (activeFlags.length > 0) {
-        additionalProperties['$active_feature_flags'] = activeFlags;
-      }
-      return additionalProperties;
-    }).catch(() => {
-      // Something went wrong getting the flag info - we should capture the event anyways
-      return {};
-    }).then(additionalProperties => {
-      // No matter what - capture the event
-      _capture({
-        ...additionalProperties,
-        ...(eventMessage.properties || {}),
-        $groups: eventMessage.groups || groups
-      });
-    });
-    this.addPendingPromise(capturePromise);
+    }));
   }
   async captureImmediate(props) {
     if (typeof props === 'string') {
-      this.logMsgIfDebug(() => console.warn('Called capture() with a string as the first argument when an object was expected.'));
+      this.logMsgIfDebug(() => console.warn('Called captureImmediate() with a string as the first argument when an object was expected.'));
     }
-    const {
+    return this.addPendingPromise(this.prepareEventMessage(props).then(({
       distinctId,
       event,
       properties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    } = props;
-    // Run before_send if configured
-    const eventMessage = this._runBeforeSend({
-      distinctId,
-      event,
-      properties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    });
-    if (!eventMessage) {
-      return;
-    }
-    const _capture = props => {
-      return super.captureStatelessImmediate(eventMessage.distinctId, eventMessage.event, props, {
-        timestamp: eventMessage.timestamp,
-        disableGeoip: eventMessage.disableGeoip,
-        uuid: eventMessage.uuid
+      options
+    }) => {
+      return super.captureStatelessImmediate(distinctId, event, properties, {
+        timestamp: options.timestamp,
+        disableGeoip: options.disableGeoip,
+        uuid: options.uuid
       });
-    };
-    const capturePromise = Promise.resolve().then(async () => {
-      if (sendFeatureFlags) {
-        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
-        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
-        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
-      }
-      if (event === '$feature_flag_called') {
-        // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
-        return {};
-      }
-      return {};
-    }).then(flags => {
-      // Derive the relevant flag properties to add
-      const additionalProperties = {};
-      if (flags) {
-        for (const [feature, variant] of Object.entries(flags)) {
-          additionalProperties[`$feature/${feature}`] = variant;
-        }
+    }).catch(err => {
+      if (err) {
+        console.error(err);
       }
-      const activeFlags = Object.keys(flags || {}).filter(flag => flags?.[flag] !== false).sort();
-      if (activeFlags.length > 0) {
-        additionalProperties['$active_feature_flags'] = activeFlags;
-      }
-      return additionalProperties;
-    }).catch(() => {
-      // Something went wrong getting the flag info - we should capture the event anyways
-      return {};
-    }).then(additionalProperties => {
-      // No matter what - capture the event
-      _capture({
-        ...additionalProperties,
-        ...(eventMessage.properties || {}),
-        $groups: eventMessage.groups || groups
-      });
-    });
-    await capturePromise;
+    }));
   }
   identify({
     distinctId,
@@ -2549,6 +2457,7 @@ class PostHogBackendClient extends core.PostHogCoreStateless {
   }
   async _shutdown(shutdownTimeoutMs) {
     this.featureFlagsPoller?.stopPoller();
+    this.errorTracking.shutdown();
     return super._shutdown(shutdownTimeoutMs);
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -2567,7 +2476,7 @@ class PostHogBackendClient extends core.PostHogCoreStateless {
     let abortTimeout = null;
     if (this.options.requestTimeout && typeof this.options.requestTimeout === 'number') {
       const controller = new AbortController();
-      abortTimeout = safeSetTimeout(() => {
+      abortTimeout = core.safeSetTimeout(() => {
         controller.abort();
       }, this.options.requestTimeout);
       options.signal = controller.signal;
@@ -2676,18 +2585,88 @@ class PostHogBackendClient extends core.PostHogCoreStateless {
   }
   captureException(error, distinctId, additionalProperties) {
     const syntheticException = new Error('PostHog syntheticException');
-    ErrorTracking.buildEventMessage(error, {
+    this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
       syntheticException
-    }, distinctId, additionalProperties).then(msg => {
-      this.capture(msg);
-    });
+    }, distinctId, additionalProperties).then(msg => this.capture(msg)));
   }
   async captureExceptionImmediate(error, distinctId, additionalProperties) {
     const syntheticException = new Error('PostHog syntheticException');
-    const evtMsg = await ErrorTracking.buildEventMessage(error, {
+    this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
       syntheticException
-    }, distinctId, additionalProperties);
-    return await this.captureImmediate(evtMsg);
+    }, distinctId, additionalProperties).then(msg => this.captureImmediate(msg)));
+  }
+  async prepareEventMessage(props) {
+    const {
+      distinctId,
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    } = props;
+    // Run before_send if configured
+    const eventMessage = this._runBeforeSend({
+      distinctId,
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    });
+    if (!eventMessage) {
+      return Promise.reject(null);
+    }
+    // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
+    const eventProperties = await Promise.resolve().then(async () => {
+      if (sendFeatureFlags) {
+        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
+        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
+        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
+      }
+      if (event === '$feature_flag_called') {
+        // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
+        return {};
+      }
+      return {};
+    }).then(flags => {
+      // Derive the relevant flag properties to add
+      const additionalProperties = {};
+      if (flags) {
+        for (const [feature, variant] of Object.entries(flags)) {
+          additionalProperties[`$feature/${feature}`] = variant;
+        }
+      }
+      const activeFlags = Object.keys(flags || {}).filter(flag => flags?.[flag] !== false).sort();
+      if (activeFlags.length > 0) {
+        additionalProperties['$active_feature_flags'] = activeFlags;
+      }
+      return additionalProperties;
+    }).catch(() => {
+      // Something went wrong getting the flag info - we should capture the event anyways
+      return {};
+    }).then(additionalProperties => {
+      // No matter what - capture the event
+      const props = {
+        ...additionalProperties,
+        ...(eventMessage.properties || {}),
+        $groups: eventMessage.groups || groups
+      };
+      return props;
+    });
+    return {
+      distinctId: eventMessage.distinctId,
+      event: eventMessage.event,
+      properties: eventProperties,
+      options: {
+        timestamp: eventMessage.timestamp,
+        disableGeoip: eventMessage.disableGeoip,
+        uuid: eventMessage.uuid
+      }
+    };
   }
   _runBeforeSend(eventMessage) {
     const beforeSend = this.options.before_send;