posthog-node 3.0.0 → 3.1.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 3.1.1 - 2023-04-26
+
+1. Replace crypto library with pure-js rusha library which makes posthog-node work with Cloudflare Workers in Next.js edge runtime.
+
+# 3.1.0 - 2023-04-19
+
+1. Some small fixes to incorrect types
+2. Fixed fetch compatibility by aligning error handling
+3. Added two errors: PostHogFetchHttpError (non-2xx status) and PostHogFetchNetworkError (fetch network error)
+4. Added .on('error', (err) => void)
+5. shutdownAsync now ignores fetch errors. They should be handled with .on('error', ...) from now on.
+
 # 3.0.0 - 2023-04-14
 
 Breaking change:
@@ -12,7 +24,7 @@ To restore previous behaviour, you can set the default to False like so:
 ```javascript
 const posthog = new PostHog(PH_API_KEY, {
   host: PH_HOST,
-  disableGeoip: false
+  disableGeoip: false,
 })
 ```
 
@@ -23,10 +35,12 @@ const posthog = new PostHog(PH_API_KEY, {
 # 2.5.4 - 2023-02-27
 
 1. Fix error log for local evaluation of feature flags (InconclusiveMatchError(s)) to only show during debug mode.
+
 # 2.5.3 - 2023-02-21
 
 1. Allow passing in a distinctId to `groupIdentify()`.
 2. Fix a bug with active feature flags on capture events, where non-active flags would be added to the list as well.
+
 # 2.5.2 - 2023-02-17
 
 1. Fix issue where properties passed to `.identify` were not set correctly

package/lib/index.cjs.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var crypto = require('crypto');
+var rusha = require('rusha');
 var axios = require('axios');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -163,7 +163,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "3.0.0";
+var version = "3.1.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -201,29 +201,31 @@ function retriable(fn, props) {
                     i = 0;
                     _d.label = 1;
                 case 1:
-                    if (!(i < retryCount + 1)) return [3 /*break*/, 8];
-                    _d.label = 2;
+                    if (!(i < retryCount + 1)) return [3 /*break*/, 7];
+                    if (!(i > 0)) return [3 /*break*/, 3];
+                    // don't wait when it's the last try
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, retryDelay); })];
                 case 2:
-                    _d.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, fn()];
+                    // don't wait when it's the last try
+                    _d.sent();
+                    _d.label = 3;
                 case 3:
+                    _d.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, fn()];
+                case 4:
                     res = _d.sent();
                     return [2 /*return*/, res];
-                case 4:
+                case 5:
                     e_1 = _d.sent();
                     lastError = e_1;
                     if (!retryCheck(e_1)) {
                         throw e_1;
                     }
-                    return [3 /*break*/, 5];
-                case 5: return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, retryDelay); })];
+                    return [3 /*break*/, 6];
                 case 6:
-                    _d.sent();
-                    _d.label = 7;
-                case 7:
                     i++;
                     return [3 /*break*/, 1];
-                case 8: throw lastError;
+                case 7: throw lastError;
             }
         });
     });
@@ -722,6 +724,29 @@ var SimpleEventEmitter = /** @class */ (function () {
     return SimpleEventEmitter;
 }());
 
+var PostHogFetchHttpError = /** @class */ (function (_super) {
+    __extends(PostHogFetchHttpError, _super);
+    function PostHogFetchHttpError(response) {
+        var _this = _super.call(this, 'HTTP error while fetching PostHog: ' + response.status) || this;
+        _this.response = response;
+        _this.name = 'PostHogFetchHttpError';
+        return _this;
+    }
+    return PostHogFetchHttpError;
+}(Error));
+var PostHogFetchNetworkError = /** @class */ (function (_super) {
+    __extends(PostHogFetchNetworkError, _super);
+    function PostHogFetchNetworkError(error) {
+        var _this = _super.call(this, 'Network error while fetching PostHog', error instanceof Error ? { cause: error } : {}) || this;
+        _this.error = error;
+        _this.name = 'PostHogFetchNetworkError';
+        return _this;
+    }
+    return PostHogFetchNetworkError;
+}(Error));
+function isPostHogFetchError(err) {
+    return typeof err === 'object' && (err.name === 'PostHogFetchHttpError' || err.name === 'PostHogFetchNetworkError');
+}
 var PostHogCoreStateless = /** @class */ (function () {
     function PostHogCoreStateless(apiKey, options) {
         var _a, _b, _c, _d, _e;
@@ -741,6 +766,7 @@ var PostHogCoreStateless = /** @class */ (function () {
         this._retryOptions = {
             retryCount: (_b = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _b !== void 0 ? _b : 3,
             retryDelay: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _c !== void 0 ? _c : 3000,
+            retryCheck: isPostHogFetchError,
         };
         this.requestTimeout = (_d = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _d !== void 0 ? _d : 10000; // 10 seconds
         this.disableGeoip = (_e = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _e !== void 0 ? _e : true;
@@ -1033,6 +1059,9 @@ var PostHogCoreStateless = /** @class */ (function () {
         };
         var promiseUUID = generateUUID();
         var done = function (err) {
+            if (err) {
+                _this._events.emit('error', err);
+            }
             callback === null || callback === void 0 ? void 0 : callback(err, messages);
             // remove promise from pendingPromises
             delete _this.pendingPromises[promiseUUID];
@@ -1065,10 +1094,6 @@ var PostHogCoreStateless = /** @class */ (function () {
         requestPromise
             .then(function () { return done(); })
             .catch(function (err) {
-            if (err.response) {
-                var error = new Error(err.response.statusText);
-                return done(error);
-            }
             done(err);
         });
     };
@@ -1078,30 +1103,72 @@ var PostHogCoreStateless = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_c) {
-                (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
-                    var ctrl = new AbortController();
-                    setTimeout(function () { return ctrl.abort(); }, ms);
-                    return ctrl.signal;
-                });
-                return [2 /*return*/, retriable(function () {
-                        return _this.fetch(url, __assign({ signal: AbortSignal.timeout(_this.requestTimeout) }, options));
-                    }, retryOptions || this._retryOptions)];
+                switch (_c.label) {
+                    case 0:
+                        (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
+                            var ctrl = new AbortController();
+                            setTimeout(function () { return ctrl.abort(); }, ms);
+                            return ctrl.signal;
+                        });
+                        return [4 /*yield*/, retriable(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var res, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            res = null;
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.trys.push([1, 3, , 4]);
+                                            return [4 /*yield*/, this.fetch(url, __assign({ signal: AbortSignal.timeout(this.requestTimeout) }, options))];
+                                        case 2:
+                                            res = _a.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            e_1 = _a.sent();
+                                            // fetch will only throw on network errors or on timeouts
+                                            throw new PostHogFetchNetworkError(e_1);
+                                        case 4:
+                                            if (res.status < 200 || res.status >= 400) {
+                                                throw new PostHogFetchHttpError(res);
+                                            }
+                                            return [2 /*return*/, res];
+                                    }
+                                });
+                            }); }, __assign(__assign({}, this._retryOptions), retryOptions))];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
             });
         });
     };
     PostHogCoreStateless.prototype.shutdownAsync = function () {
         return __awaiter(this, void 0, void 0, function () {
+            var e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         clearTimeout(this._flushTimer);
-                        return [4 /*yield*/, this.flushAsync()];
+                        _a.label = 1;
                     case 1:
-                        _a.sent();
-                        return [4 /*yield*/, Promise.allSettled(Object.values(this.pendingPromises))];
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.flushAsync()];
                     case 2:
                         _a.sent();
-                        return [2 /*return*/];
+                        return [4 /*yield*/, Promise.all(Object.values(this.pendingPromises).map(function (x) {
+                                return x.catch(function () {
+                                    // ignore errors as we are shutting down and can't deal with them anyways.
+                                });
+                            }))];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_2 = _a.sent();
+                        if (!isPostHogFetchError(e_2)) {
+                            throw e_2;
+                        }
+                        console.error('Error while shutting down PostHog', e_2);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
                 }
             });
         });
@@ -1122,12 +1189,6 @@ var PostHogCoreStateless = /** @class */ (function () {
         _this.flagCallReported = {};
         _this.sendFeatureFlagEvent = (_b = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _b !== void 0 ? _b : true;
         _this._sessionExpirationTimeSeconds = (_c = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _c !== void 0 ? _c : 1800; // 30 minutes
-        // NOTE: It is important we don't initiate anything in the constructor as some async IO may still be underway on the parent
-        if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
-            safeSetTimeout(function () {
-                _this.reloadFeatureFlags();
-            }, 1);
-        }
         return _this;
     }
     PostHogCore.prototype.setupBootstrap = function (options) {
@@ -1242,9 +1303,7 @@ var PostHogCoreStateless = /** @class */ (function () {
             // We keep the AnonymousId to be used by decide calls and identify to link the previousId
             this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
             this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
-            if (this.getFeatureFlags()) {
-                this.reloadFeatureFlags();
-            }
+            this.reloadFeatureFlags();
         }
         _super.prototype.identifyStateless.call(this, distinctId, allProperties, options);
         return this;
@@ -1284,7 +1343,7 @@ var PostHogCoreStateless = /** @class */ (function () {
         this.register({
             $groups: __assign(__assign({}, existingGroups), groups),
         });
-        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; }) && this.getFeatureFlags()) {
+        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; })) {
             this.reloadFeatureFlags();
         }
         return this;
@@ -1545,7 +1604,11 @@ var fetch = function (url, options) {
             headers: options.headers,
             method: options.method.toLowerCase(),
             data: options.body,
-            signal: options.signal
+            signal: options.signal,
+            // fetch only throws on network errors, not on HTTP errors
+            validateStatus: function () {
+              return true;
+            }
           })];
 
         case 1:
@@ -1555,10 +1618,22 @@ var fetch = function (url, options) {
           , {
             status: res.status,
             text: function () {
-              return res.data;
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2
+                  /*return*/
+                  , res.data];
+                });
+              });
             },
             json: function () {
-              return res.data;
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2
+                  /*return*/
+                  , res.data];
+                });
+              });
             }
           }];
       }
@@ -2178,7 +2253,7 @@ function () {
 
           case 3:
             err_2 = _a.sent();
-            throw new Error("Request failed with error: ".concat(err_2));
+            throw err_2;
 
           case 4:
             clearTimeout(abortTimeout);
@@ -2209,9 +2284,10 @@ function () {
 function _hash(key, distinctId, salt) {
   if (salt === void 0) {
     salt = '';
-  }
+  } // rusha is a fast sha1 implementation in pure javascript
+
 
-  var sha1Hash = crypto.createHash('sha1');
+  var sha1Hash = rusha.createHash();
   sha1Hash.update("".concat(key, ".").concat(distinctId).concat(salt));
   return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE;
 }