posthog-node 4.17.1 → 4.18.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# Next
+
+## Added
+
+1. rotate session id if expired after 24 hours
+
+# 4.17.2 - 2025-05-22
+
+1. chore: improve event prop types
+2. fix: no throw in sendImmediate
+
 # 4.17.1 - 2025-05-02
 
 1. fix: fix imports for old node.js version

package/lib/edge/index.cjs

@@ -589,6 +589,47 @@ function addUnhandledRejectionListener(captureFn) {
   });
 }
 
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+let parsedStackResults;
+let lastKeysCount;
+let cachedFilenameChunkIds;
+function getFilenameToChunkIdMap(stackParser) {
+  const chunkIdMap = globalThis._posthogChunkIds;
+  if (!chunkIdMap) {
+    console.error('No chunk id map found');
+    return {};
+  }
+  const chunkIdKeys = Object.keys(chunkIdMap);
+  if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) {
+    return cachedFilenameChunkIds;
+  }
+  lastKeysCount = chunkIdKeys.length;
+  cachedFilenameChunkIds = chunkIdKeys.reduce((acc, stackKey) => {
+    if (!parsedStackResults) {
+      parsedStackResults = {};
+    }
+    const result = parsedStackResults[stackKey];
+    if (result) {
+      acc[result[0]] = result[1];
+    } else {
+      const parsedStack = stackParser(stackKey);
+      for (let i = parsedStack.length - 1; i >= 0; i--) {
+        const stackFrame = parsedStack[i];
+        const filename = stackFrame?.filename;
+        const chunkId = chunkIdMap[stackKey];
+        if (filename && chunkId) {
+          acc[filename] = chunkId;
+          parsedStackResults[stackKey] = [filename, chunkId];
+          break;
+        }
+      }
+    }
+    return acc;
+  }, {});
+  return cachedFilenameChunkIds;
+}
+
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
 // Licensed under the MIT License
 function isEvent(candidate) {
@@ -822,7 +863,16 @@ async function exceptionFromError(stackParser, frameModifiers, error) {
  * Extracts stack frames from the error.stack string
  */
 function parseStackFrames(stackParser, error) {
-  return stackParser(error.stack || '', 1);
+  return applyChunkIds(stackParser(error.stack || '', 1), stackParser);
+}
+function applyChunkIds(frames, parser) {
+  const filenameChunkIdMap = getFilenameToChunkIdMap(parser);
+  frames.forEach(frame => {
+    if (frame.filename) {
+      frame.chunk_id = filenameChunkIdMap[frame.filename];
+    }
+  });
+  return frames;
 }
 
 const SHUTDOWN_TIMEOUT = 2000;
@@ -885,7 +935,7 @@ function setupExpressErrorHandler(_posthog, app) {
   });
 }
 
-var version = "4.17.1";
+var version = "4.18.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -902,6 +952,7 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["Queue"] = "queue";
     PostHogPersistedProperty["OptedOut"] = "opted_out";
     PostHogPersistedProperty["SessionId"] = "session_id";
+    PostHogPersistedProperty["SessionStartTimestamp"] = "session_start_timestamp";
     PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
     PostHogPersistedProperty["PersonProperties"] = "person_properties";
     PostHogPersistedProperty["GroupProperties"] = "group_properties";
@@ -1216,6 +1267,9 @@ function isTokenInRollout(token, percentage = 0, excludedHashes) {
     const hashInt = parseInt(tokenHash, 16);
     const hashFloat = hashInt / 0xffffffff;
     return hashFloat < percentage;
+}
+function allSettled(promises) {
+    return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }))));
 }
 
 // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
@@ -1960,6 +2014,7 @@ class PostHogCoreStateless {
                 ...extraPayload,
             }),
         };
+        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Decide URL', url));
         // Don't retry /decide API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
@@ -2077,7 +2132,7 @@ class PostHogCoreStateless {
     async getSurveysStateless() {
         await this._initPromise;
         if (this.disableSurveys === true) {
-            this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Loading surveys is disabled.'));
             return [];
         }
         const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
@@ -2200,7 +2255,6 @@ class PostHogCoreStateless {
         }
         catch (err) {
             this._events.emit('error', err);
-            throw err;
         }
     }
     prepareMessage(type, _message, options) {
@@ -2240,15 +2294,38 @@ class PostHogCoreStateless {
             await logFlushError(err);
         });
     }
+    /**
+     * Flushes the queue
+     *
+     * This function will return a promise that will resolve when the flush is complete,
+     * or reject if there was an error (for example if the server or network is down).
+     *
+     * If there is already a flush in progress, this function will wait for that flush to complete.
+     *
+     * It's recommended to do error handling in the callback of the promise.
+     *
+     * @example
+     * posthog.flush().then(() => {
+     *   console.log('Flush complete')
+     * }).catch((err) => {
+     *   console.error('Flush failed', err)
+     * })
+     *
+     *
+     * @throws PostHogFetchHttpError
+     * @throws PostHogFetchNetworkError
+     * @throws Error
+     */
     async flush() {
         // 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(() => {
+        // Use a custom allSettled implementation to avoid issues with patching Promise on RN
+        const nextFlushPromise = allSettled([this.flushPromise]).then(() => {
             return this._flush();
         });
         this.flushPromise = nextFlushPromise;
         void this.addPendingPromise(nextFlushPromise);
-        Promise.allSettled([nextFlushPromise]).then(() => {
+        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) {
@@ -2274,7 +2351,7 @@ class PostHogCoreStateless {
         await this._initPromise;
         let queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
-            return [];
+            return;
         }
         const sentMessages = [];
         const originalQueueLength = queue.length;
@@ -2345,7 +2422,6 @@ class PostHogCoreStateless {
             sentMessages.push(...batchMessages);
         }
         this._events.emit('flush', sentMessages);
-        return sentMessages;
     }
     async fetchWithRetry(url, options, retryOptions, requestTimeout) {
         var _a;
@@ -2355,7 +2431,14 @@ class PostHogCoreStateless {
             return ctrl.signal;
         });
         const body = options.body ? options.body : '';
-        const reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
+        let reqByteLength = -1;
+        try {
+            reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
+        }
+        catch {
+            const encoded = new TextEncoder().encode(body);
+            reqByteLength = encoded.length;
+        }
         return await retriable(async () => {
             let res = null;
             try {
@@ -2901,12 +2984,12 @@ class FeatureFlagsPoller {
         case 200:
           {
             // Process successful response
-            const responseJson = await res.json();
+            const responseJson = (await res.json()) ?? {};
             if (!('flags' in responseJson)) {
               this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
               return;
             }
-            this.featureFlags = responseJson.flags || [];
+            this.featureFlags = responseJson.flags ?? [];
             this.featureFlagsByKey = this.featureFlags.reduce((acc, curr) => (acc[curr.key] = curr, acc), {});
             this.groupTypeMapping = responseJson.group_type_mapping || {};
             this.cohorts = responseJson.cohorts || {};