posthog-node 4.14.0 → 4.16.0

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 4.16.0 - 2025-05-01
+
+1. chore: improve flush event
+
+# 4.15.0 - 2025-04-30
+
+1. chore: add immediate-mode
+2. chore: better error logging when flushing events
+
 # 4.14.0 - 2025-04-24
 
 1. feat: Add super properties as a concept to the Node SDK

package/lib/index.cjs.js

@@ -22,7 +22,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var version = "4.14.0";
+var version = "4.16.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -278,6 +278,7 @@ const NEW_FLAGS_EXCLUDED_HASHES = new Set([
     'fc80b8e2',
     '75cc0998',
 ]);
+const STRING_FORMAT = 'utf8';
 function assert(truthyValue, message) {
     if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
         throw new Error(message);
@@ -1216,11 +1217,21 @@ const uuidv7 = () => uuidv7obj().toString();
 const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
 
 class PostHogFetchHttpError extends Error {
-    constructor(response) {
-        super('HTTP error while fetching PostHog: ' + response.status);
+    constructor(response, reqByteLength) {
+        super('HTTP error while fetching PostHog: status=' + response.status + ', reqByteLength=' + reqByteLength);
         this.response = response;
+        this.reqByteLength = reqByteLength;
         this.name = 'PostHogFetchHttpError';
     }
+    get status() {
+        return this.response.status;
+    }
+    get text() {
+        return this.response.text();
+    }
+    get json() {
+        return this.response.json();
+    }
 }
 class PostHogFetchNetworkError extends Error {
     constructor(error) {
@@ -1232,9 +1243,26 @@ class PostHogFetchNetworkError extends Error {
         this.name = 'PostHogFetchNetworkError';
     }
 }
+async function logFlushError(err) {
+    if (err instanceof PostHogFetchHttpError) {
+        let text = '';
+        try {
+            text = await err.text;
+        }
+        catch { }
+        console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
+    }
+    else {
+        console.error('Error while flushing PostHog', err);
+    }
+    return Promise.resolve();
+}
 function isPostHogFetchError(err) {
     return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
 }
+function isPostHogFetchContentTooLargeError(err) {
+    return typeof err === 'object' && err instanceof PostHogFetchHttpError && err.status === 413;
+}
 var QuotaLimitedFeature;
 (function (QuotaLimitedFeature) {
     QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
@@ -1243,6 +1271,7 @@ var QuotaLimitedFeature;
 class PostHogCoreStateless {
     constructor(apiKey, options) {
         this.flushPromise = null;
+        this.shutdownPromise = null;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -1365,12 +1394,26 @@ class PostHogCoreStateless {
             this.enqueue('identify', payload, options);
         });
     }
+    async identifyStatelessImmediate(distinctId, properties, options) {
+        const payload = {
+            ...this.buildPayload({
+                distinct_id: distinctId,
+                event: '$identify',
+                properties,
+            }),
+        };
+        await this.sendImmediate('identify', payload, options);
+    }
     captureStateless(distinctId, event, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
             this.enqueue('capture', payload, options);
         });
     }
+    async captureStatelessImmediate(distinctId, event, properties, options) {
+        const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
+        await this.sendImmediate('capture', payload, options);
+    }
     aliasStateless(alias, distinctId, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({
@@ -1385,6 +1428,18 @@ class PostHogCoreStateless {
             this.enqueue('alias', payload, options);
         });
     }
+    async aliasStatelessImmediate(alias, distinctId, properties, options) {
+        const payload = this.buildPayload({
+            event: '$create_alias',
+            distinct_id: distinctId,
+            properties: {
+                ...(properties || {}),
+                distinct_id: distinctId,
+                alias,
+            },
+        });
+        await this.sendImmediate('alias', payload, options);
+    }
     /***
      *** GROUPS
      ***/
@@ -1628,25 +1683,7 @@ class PostHogCoreStateless {
                 this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
                 return;
             }
-            const message = {
-                ..._message,
-                type: type,
-                library: this.getLibraryId(),
-                library_version: this.getLibraryVersion(),
-                timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
-                uuid: options?.uuid ? options.uuid : uuidv7(),
-            };
-            const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
-            if (addGeoipDisableProperty) {
-                if (!message.properties) {
-                    message.properties = {};
-                }
-                message['properties']['$geoip_disable'] = true;
-            }
-            if (message.distinctId) {
-                message.distinct_id = message.distinctId;
-                delete message.distinctId;
-            }
+            const message = this.prepareMessage(type, _message, options);
             const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
             if (queue.length >= this.maxQueueSize) {
                 queue.shift();
@@ -1664,6 +1701,73 @@ class PostHogCoreStateless {
             }
         });
     }
+    async sendImmediate(type, _message, options) {
+        if (this.disabled) {
+            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
+            return;
+        }
+        if (!this._isInitialized) {
+            await this._initPromise;
+        }
+        if (this.optedOut) {
+            this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
+            return;
+        }
+        const data = {
+            api_key: this.apiKey,
+            batch: [this.prepareMessage(type, _message, options)],
+            sent_at: currentISOTime(),
+        };
+        if (this.historicalMigration) {
+            data.historical_migration = true;
+        }
+        const payload = JSON.stringify(data);
+        const url = this.captureMode === 'form'
+            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+            : `${this.host}/batch/`;
+        const fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+            }
+            : {
+                method: 'POST',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        try {
+            await this.fetchWithRetry(url, fetchOptions);
+        }
+        catch (err) {
+            this._events.emit('error', err);
+            throw err;
+        }
+    }
+    prepareMessage(type, _message, options) {
+        const message = {
+            ..._message,
+            type: type,
+            library: this.getLibraryId(),
+            library_version: this.getLibraryVersion(),
+            timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+            uuid: options?.uuid ? options.uuid : uuidv7(),
+        };
+        const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+        if (addGeoipDisableProperty) {
+            if (!message.properties) {
+                message.properties = {};
+            }
+            message['properties']['$geoip_disable'] = true;
+        }
+        if (message.distinctId) {
+            message.distinct_id = message.distinctId;
+            delete message.distinctId;
+        }
+        return message;
+    }
     clearFlushTimer() {
         if (this._flushTimer) {
             clearTimeout(this._flushTimer);
@@ -1675,16 +1779,26 @@ class PostHogCoreStateless {
      * Avoids unnecessary promise errors
      */
     flushBackground() {
-        void this.flush().catch(() => { });
+        void this.flush().catch(async (err) => {
+            await logFlushError(err);
+        });
     }
     async flush() {
-        if (!this.flushPromise) {
-            this.flushPromise = this._flush().finally(() => {
+        // Wait for the current flush operation to finish (regardless of success or failure), then try to flush again.
+        // Use allSettled instead of finally to be defensive around flush throwing errors immediately rather than rejecting.
+        const nextFlushPromise = Promise.allSettled([this.flushPromise]).then(() => {
+            return this._flush();
+        });
+        this.flushPromise = nextFlushPromise;
+        void this.addPendingPromise(nextFlushPromise);
+        Promise.allSettled([nextFlushPromise]).then(() => {
+            // If there are no others waiting to flush, clear the promise.
+            // We don't strictly need to do this, but it could make debugging easier
+            if (this.flushPromise === nextFlushPromise) {
                 this.flushPromise = null;
-            });
-            this.addPendingPromise(this.flushPromise);
-        }
-        return this.flushPromise;
+            }
+        });
+        return nextFlushPromise;
     }
     getCustomHeaders() {
         // Don't set the user agent if we're not on a browser. The latest spec allows
@@ -1701,56 +1815,80 @@ class PostHogCoreStateless {
     async _flush() {
         this.clearFlushTimer();
         await this._initPromise;
-        const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        let queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
             return [];
         }
-        const items = queue.slice(0, this.maxBatchSize);
-        const messages = items.map((item) => item.message);
-        const persistQueueChange = () => {
-            const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-            this.setPersistedProperty(PostHogPersistedProperty.Queue, refreshedQueue.slice(items.length));
-        };
-        const data = {
-            api_key: this.apiKey,
-            batch: messages,
-            sent_at: currentISOTime(),
-        };
-        if (this.historicalMigration) {
-            data.historical_migration = true;
-        }
-        const payload = JSON.stringify(data);
-        const url = this.captureMode === 'form'
-            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
-            : `${this.host}/batch/`;
-        const fetchOptions = this.captureMode === 'form'
-            ? {
-                method: 'POST',
-                mode: 'no-cors',
-                credentials: 'omit',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+        const sentMessages = [];
+        const originalQueueLength = queue.length;
+        while (queue.length > 0 && sentMessages.length < originalQueueLength) {
+            const batchItems = queue.slice(0, this.maxBatchSize);
+            const batchMessages = batchItems.map((item) => item.message);
+            const persistQueueChange = () => {
+                const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                const newQueue = refreshedQueue.slice(batchItems.length);
+                this.setPersistedProperty(PostHogPersistedProperty.Queue, newQueue);
+                queue = newQueue;
+            };
+            const data = {
+                api_key: this.apiKey,
+                batch: batchMessages,
+                sent_at: currentISOTime(),
+            };
+            if (this.historicalMigration) {
+                data.historical_migration = true;
             }
-            : {
-                method: 'POST',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-                body: payload,
+            const payload = JSON.stringify(data);
+            const url = this.captureMode === 'form'
+                ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+                : `${this.host}/batch/`;
+            const fetchOptions = this.captureMode === 'form'
+                ? {
+                    method: 'POST',
+                    mode: 'no-cors',
+                    credentials: 'omit',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+                }
+                : {
+                    method: 'POST',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                    body: payload,
+                };
+            const retryOptions = {
+                retryCheck: (err) => {
+                    // don't automatically retry on 413 errors, we want to reduce the batch size first
+                    if (isPostHogFetchContentTooLargeError(err)) {
+                        return false;
+                    }
+                    // otherwise, retry on network errors
+                    return isPostHogFetchError(err);
+                },
             };
-        try {
-            await this.fetchWithRetry(url, fetchOptions);
-        }
-        catch (err) {
-            // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
-            // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
-            if (!(err instanceof PostHogFetchNetworkError)) {
-                persistQueueChange();
+            try {
+                await this.fetchWithRetry(url, fetchOptions, retryOptions);
             }
-            this._events.emit('error', err);
-            throw err;
+            catch (err) {
+                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}`));
+                    // do not persist the queue change, we want to retry the same batch
+                    continue;
+                }
+                // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
+                // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
+                if (!(err instanceof PostHogFetchNetworkError)) {
+                    persistQueueChange();
+                }
+                this._events.emit('error', err);
+                throw err;
+            }
+            persistQueueChange();
+            sentMessages.push(...batchMessages);
         }
-        persistQueueChange();
-        this._events.emit('flush', messages);
-        return messages;
+        this._events.emit('flush', sentMessages);
+        return sentMessages;
     }
     async fetchWithRetry(url, options, retryOptions, requestTimeout) {
         var _a;
@@ -1759,6 +1897,8 @@ class PostHogCoreStateless {
             setTimeout(() => ctrl.abort(), ms);
             return ctrl.signal;
         });
+        const body = options.body ? options.body : '';
+        const reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
         return await retriable(async () => {
             let res = null;
             try {
@@ -1776,12 +1916,12 @@ class PostHogCoreStateless {
             // https://developer.mozilla.org/en-US/docs/Web/API/Request/mode#no-cors
             const isNoCors = options.mode === 'no-cors';
             if (!isNoCors && (res.status < 200 || res.status >= 400)) {
-                throw new PostHogFetchHttpError(res);
+                throw new PostHogFetchHttpError(res, reqByteLength);
             }
             return res;
         }, { ...this._retryOptions, ...retryOptions });
     }
-    async shutdown(shutdownTimeoutMs = 30000) {
+    async _shutdown(shutdownTimeoutMs = 30000) {
         // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
         // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
         await this._initPromise;
@@ -1808,7 +1948,7 @@ class PostHogCoreStateless {
                 if (!isPostHogFetchError(e)) {
                     throw e;
                 }
-                this.logMsgIfDebug(() => console.error('Error while shutting down PostHog', e));
+                await logFlushError(e);
             }
         };
         return Promise.race([
@@ -1822,6 +1962,22 @@ class PostHogCoreStateless {
             doShutdown(),
         ]);
     }
+    /**
+     *  Call shutdown() once before the node process exits, so ensure that all events have been sent and all promises
+     *  have resolved. Do not use this function if you intend to keep using this PostHog instance after calling it.
+     * @param shutdownTimeoutMs
+     */
+    async shutdown(shutdownTimeoutMs = 30000) {
+        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'));
+        }
+        else {
+            this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
+                this.shutdownPromise = null;
+            });
+        }
+        return this.shutdownPromise;
+    }
 }
 
 class PostHogMemoryStorage {
@@ -3689,6 +3845,79 @@ class PostHog extends PostHogCoreStateless {
     });
     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.'));
+    }
+    const {
+      distinctId,
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    } = props;
+    const _capture = props => {
+      return super.captureStatelessImmediate(distinctId, event, props, {
+        timestamp,
+        disableGeoip,
+        uuid
+      });
+    };
+    const _getFlags = async (distinctId, groups, disableGeoip) => {
+      return (await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)).flags;
+    };
+    const capturePromise = Promise.resolve().then(async () => {
+      if (sendFeatureFlags) {
+        // If we are sending feature flags, we need to make sure we have the latest flags
+        // return await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)
+        return await _getFlags(distinctId, groups, disableGeoip);
+      }
+      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 {};
+      }
+      if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
+        // Otherwise we may as well check for the flags locally and include them if they are already loaded
+        const groupsWithStringValues = {};
+        for (const [key, value] of Object.entries(groups || {})) {
+          groupsWithStringValues[key] = String(value);
+        }
+        return await this.getAllFlags(distinctId, {
+          groups: groupsWithStringValues,
+          disableGeoip,
+          onlyEvaluateLocally: true
+        });
+      }
+      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
+      _capture({
+        ...additionalProperties,
+        ...properties,
+        $groups: groups
+      });
+    });
+    await capturePromise;
+  }
   identify({
     distinctId,
     properties,
@@ -3707,11 +3936,33 @@ class PostHog extends PostHogCoreStateless {
       disableGeoip
     });
   }
+  async identifyImmediate({
+    distinctId,
+    properties,
+    disableGeoip
+  }) {
+    // promote $set and $set_once to top level
+    const userPropsOnce = properties?.$set_once;
+    delete properties?.$set_once;
+    // if no $set is provided we assume all properties are $set
+    const userProps = properties?.$set || properties;
+    await super.identifyStatelessImmediate(distinctId, {
+      $set: userProps,
+      $set_once: userPropsOnce
+    }, {
+      disableGeoip
+    });
+  }
   alias(data) {
     super.aliasStateless(data.alias, data.distinctId, undefined, {
       disableGeoip: data.disableGeoip
     });
   }
+  async aliasImmediate(data) {
+    await super.aliasStatelessImmediate(data.alias, data.distinctId, undefined, {
+      disableGeoip: data.disableGeoip
+    });
+  }
   isLocalEvaluationReady() {
     return this.featureFlagsPoller?.isLocalEvaluationReady() ?? false;
   }
@@ -3918,9 +4169,9 @@ class PostHog extends PostHogCoreStateless {
   async reloadFeatureFlags() {
     await this.featureFlagsPoller?.loadFeatureFlags(true);
   }
-  async shutdown(shutdownTimeoutMs) {
+  async _shutdown(shutdownTimeoutMs) {
     this.featureFlagsPoller?.stopPoller();
-    return super.shutdown(shutdownTimeoutMs);
+    return super._shutdown(shutdownTimeoutMs);
   }
   addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
     const allPersonProperties = {